From 36f99156fd140f1ef58c7763f88b5bca18926b15 Mon Sep 17 00:00:00 2001 From: Andrey Uskov Date: Wed, 9 Dec 2020 17:33:09 +0300 Subject: [PATCH 001/196] IC of sealed classes Supported case then children of sealed classes could be declared anywhere in a module. If list of classes implementing sealing class changes the sealed class and all its inheritors should be recompiled (now sealed class should be compiled together with children in order to calculate all possible inheritors at compile time) and and invalidated (as they could have when operators). --- .../incremental/AbstractIncrementalCache.kt | 20 +++++++- .../kotlin/incremental/ChangesCollector.kt | 35 +++++++++++-- .../kotlin/incremental/IncrementalJvmCache.kt | 2 + .../jetbrains/kotlin/incremental/buildUtil.kt | 38 +++++++++++++- .../incremental/protoDifferenceUtils.kt | 20 ++++++-- .../incremental/storage/ClassAttributesMap.kt | 51 +++++++++++++++++++ .../incremental/IncrementalCompilerRunner.kt | 6 ++- .../IncrementalJsCompilerRunner.kt | 2 +- .../IncrementalJvmCompilerRunner.kt | 2 +- .../AbstractProtoComparisonTest.kt | 2 + .../kotlin/jps/build/KotlinBuilder.kt | 25 +++++++-- 11 files changed, 183 insertions(+), 20 deletions(-) create mode 100644 build-common/src/org/jetbrains/kotlin/incremental/storage/ClassAttributesMap.kt diff --git a/build-common/src/org/jetbrains/kotlin/incremental/AbstractIncrementalCache.kt b/build-common/src/org/jetbrains/kotlin/incremental/AbstractIncrementalCache.kt index fedb2949dc8..337c09af52b 100644 --- a/build-common/src/org/jetbrains/kotlin/incremental/AbstractIncrementalCache.kt +++ b/build-common/src/org/jetbrains/kotlin/incremental/AbstractIncrementalCache.kt @@ -19,6 +19,7 @@ package org.jetbrains.kotlin.incremental import com.intellij.util.io.EnumeratorStringDescriptor import org.jetbrains.kotlin.incremental.storage.* import org.jetbrains.kotlin.metadata.ProtoBuf +import org.jetbrains.kotlin.metadata.deserialization.Flags import org.jetbrains.kotlin.metadata.deserialization.NameResolver import org.jetbrains.kotlin.metadata.deserialization.TypeTable import org.jetbrains.kotlin.metadata.deserialization.supertypes @@ -34,12 +35,15 @@ interface IncrementalCacheCommon { val thisWithDependentCaches: Iterable> fun classesFqNamesBySources(files: Iterable): Collection fun getSubtypesOf(className: FqName): Sequence + fun getSupertypesOf(className: FqName): Sequence fun getSourceFileIfClass(fqName: FqName): File? fun markDirty(removedAndCompiledSources: Collection) fun clearCacheForRemovedClasses(changesCollector: ChangesCollector) fun getComplementaryFilesRecursive(dirtyFiles: Collection): Collection fun updateComplementaryFiles(dirtyFiles: Collection, expectActualTracker: ExpectActualTrackerImpl) fun dump(): String + + fun isSealed(className: FqName): Boolean? } /** @@ -50,6 +54,7 @@ abstract class AbstractIncrementalCache( protected val pathConverter: FileToPathConverter ) : BasicMapsOwner(workingDir), IncrementalCacheCommon { companion object { + private val CLASS_ATTRIBUTES = "class-attributes" private val SUBTYPES = "subtypes" private val SUPERTYPES = "supertypes" private val CLASS_FQ_NAME_TO_SOURCE = "class-fq-name-to-source" @@ -71,6 +76,7 @@ abstract class AbstractIncrementalCache( result } + internal val classAttributesMap = registerMap(ClassAttributesMap(CLASS_ATTRIBUTES.storageFile)) private val subtypesMap = registerMap(SubtypesMap(SUBTYPES.storageFile)) private val supertypesMap = registerMap(SupertypesMap(SUPERTYPES.storageFile)) protected val classFqNameToSourceMap = registerMap(ClassFqNameToSourceMap(CLASS_FQ_NAME_TO_SOURCE.storageFile, pathConverter)) @@ -90,6 +96,14 @@ abstract class AbstractIncrementalCache( override fun getSubtypesOf(className: FqName): Sequence = subtypesMap[className].asSequence() + override fun getSupertypesOf(className: FqName): Sequence { + return supertypesMap[className].asSequence() + } + + override fun isSealed(className: FqName): Boolean? { + return classAttributesMap[className]?.isSealed + } + override fun getSourceFileIfClass(fqName: FqName): File? = classFqNameToSourceMap[fqName] @@ -118,6 +132,7 @@ abstract class AbstractIncrementalCache( supertypesMap[child] = parents classFqNameToSourceMap[child] = srcFile + classAttributesMap[child] = ICClassesAttributes(ProtoBuf.Modality.SEALED == Flags.MODALITY.get(proto.flags)) } protected fun removeAllFromClassStorage(removedClasses: Collection, changesCollector: ChangesCollector) { @@ -152,7 +167,10 @@ abstract class AbstractIncrementalCache( } } - removedFqNames.forEach { classFqNameToSourceMap.remove(it) } + removedFqNames.forEach { + classFqNameToSourceMap.remove(it) + classAttributesMap.remove(it) + } } protected class ClassFqNameToSourceMap( diff --git a/build-common/src/org/jetbrains/kotlin/incremental/ChangesCollector.kt b/build-common/src/org/jetbrains/kotlin/incremental/ChangesCollector.kt index bf66f3a8e74..90499179685 100644 --- a/build-common/src/org/jetbrains/kotlin/incremental/ChangesCollector.kt +++ b/build-common/src/org/jetbrains/kotlin/incremental/ChangesCollector.kt @@ -19,12 +19,14 @@ package org.jetbrains.kotlin.incremental import org.jetbrains.kotlin.metadata.ProtoBuf import org.jetbrains.kotlin.metadata.deserialization.Flags import org.jetbrains.kotlin.metadata.deserialization.NameResolver +import org.jetbrains.kotlin.metadata.deserialization.supertypes import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.protobuf.MessageLite import org.jetbrains.kotlin.serialization.deserialization.getClassId class ChangesCollector { private val removedMembers = hashMapOf>() + private val changedParents = hashMapOf>() private val changedMembers = hashMapOf>() private val areSubclassesAffected = hashMapOf() @@ -47,6 +49,10 @@ class ChangesCollector { changes.add(ChangeInfo.SignatureChanged(fqName, areSubclassesAffected)) } + for ((fqName, changedParents) in changedParents) { + changes.add(ChangeInfo.ParentsChanged(fqName, changedParents)) + } + return changes } @@ -79,12 +85,12 @@ class ChangesCollector { } if (oldData == null) { - newData!!.collectAll(isRemoved = false, collectAllMembersForNewClass = collectAllMembersForNewClass) + newData!!.collectAll(isRemoved = false, isAdded = true, collectAllMembersForNewClass = collectAllMembersForNewClass) return } if (newData == null) { - oldData.collectAll(isRemoved = true) + oldData.collectAll(isRemoved = true, isAdded = false) return } @@ -98,6 +104,7 @@ class ChangesCollector { collectSignature(oldData, diff.areSubclassesAffected) } collectChangedMembers(fqName, diff.changedMembersNames) + addChangedParents(fqName, diff.changedSupertypes) } is PackagePartProtoData -> { collectSignature(oldData, areSubclassesAffected = true) @@ -121,10 +128,11 @@ class ChangesCollector { private fun T.getNonPrivateNames(nameResolver: NameResolver, vararg members: T.() -> List): Set = members.flatMap { this.it().filterNot { it.isPrivate }.names(nameResolver) }.toSet() - private fun ProtoData.collectAll(isRemoved: Boolean, collectAllMembersForNewClass: Boolean = false) = + //TODO remember all sealed parent classes + private fun ProtoData.collectAll(isRemoved: Boolean, isAdded: Boolean, collectAllMembersForNewClass: Boolean = false) = when (this) { is PackagePartProtoData -> collectAllFromPackage(isRemoved) - is ClassProtoData -> collectAllFromClass(isRemoved, collectAllMembersForNewClass) + is ClassProtoData -> collectAllFromClass(isRemoved, isAdded, collectAllMembersForNewClass) } private fun PackagePartProtoData.collectAllFromPackage(isRemoved: Boolean) { @@ -143,7 +151,7 @@ class ChangesCollector { } } - private fun ClassProtoData.collectAllFromClass(isRemoved: Boolean, collectAllMembersForNewClass: Boolean = false) { + private fun ClassProtoData.collectAllFromClass(isRemoved: Boolean, isAdded: Boolean, collectAllMembersForNewClass: Boolean = false) { val classFqName = nameResolver.getClassId(proto.fqName).asSingleFqName() val kind = Flags.CLASS_KIND.get(proto.flags) @@ -162,6 +170,23 @@ class ChangesCollector { collectSignature(classFqName, areSubclassesAffected = true) } + + if (isRemoved || isAdded) { + collectChangedParents(classFqName, proto.supertypeList) + } + } + + private fun addChangedParents(fqName: FqName, parents: Collection) { + if (parents.isNotEmpty()) { + changedParents.getOrPut(fqName) { HashSet() }.addAll(parents) + } + } + + private fun ClassProtoData.collectChangedParents(fqName: FqName, parents: Collection) { + val changedParentsFqNames = parents.map { type -> + nameResolver.getClassId(type.className).asSingleFqName() + } + addChangedParents(fqName, changedParentsFqNames) } private fun ClassProtoData.getNonPrivateMemberNames(): Set { diff --git a/build-common/src/org/jetbrains/kotlin/incremental/IncrementalJvmCache.kt b/build-common/src/org/jetbrains/kotlin/incremental/IncrementalJvmCache.kt index 29e89f95de9..c5f01e1824b 100644 --- a/build-common/src/org/jetbrains/kotlin/incremental/IncrementalJvmCache.kt +++ b/build-common/src/org/jetbrains/kotlin/incremental/IncrementalJvmCache.kt @@ -145,6 +145,7 @@ open class IncrementalJvmCache( } protoMap.remove(className, changesCollector) classFqNameToSourceMap.remove(className.fqNameForClassNameWithoutDollars) + classAttributesMap.remove(className.fqNameForClassNameWithoutDollars) internalNameToSource.remove(className.internalName) // TODO NO_CHANGES? (delegates only) @@ -568,6 +569,7 @@ sealed class ChangeInfo(val fqName: FqName) { class SignatureChanged(fqName: FqName, val areSubclassesAffected: Boolean) : ChangeInfo(fqName) + class ParentsChanged(fqName: FqName, val parentsChanged: Collection) : ChangeInfo(fqName) protected open fun toStringProperties(): String = "fqName = $fqName" diff --git a/build-common/src/org/jetbrains/kotlin/incremental/buildUtil.kt b/build-common/src/org/jetbrains/kotlin/incremental/buildUtil.kt index 745453842f6..cf215b95ab5 100644 --- a/build-common/src/org/jetbrains/kotlin/incremental/buildUtil.kt +++ b/build-common/src/org/jetbrains/kotlin/incremental/buildUtil.kt @@ -136,7 +136,8 @@ fun LookupStorage.update( data class DirtyData( val dirtyLookupSymbols: Collection = emptyList(), - val dirtyClassesFqNames: Collection = emptyList() + val dirtyClassesFqNames: Collection = emptyList(), + val dirtyClassesFqNamesForceRecompile: Collection = emptyList() ) fun ChangesCollector.getDirtyData( @@ -146,6 +147,9 @@ fun ChangesCollector.getDirtyData( val dirtyLookupSymbols = HashSet() val dirtyClassesFqNames = HashSet() + val sealedParents = HashMap>() + val notSealedParents = HashSet() + for (change in changes()) { reporter.reportVerbose { "Process $change" } @@ -170,10 +174,35 @@ fun ChangesCollector.getDirtyData( } fqNames.mapTo(dirtyLookupSymbols) { LookupSymbol(SAM_LOOKUP_NAME.asString(), it.asString()) } + } else if (change is ChangeInfo.ParentsChanged) { + fun FqName.isSealed(): Boolean { + if (notSealedParents.contains(this)) return false + if (sealedParents.containsKey(this)) return true + return isSealed(this, caches).also { sealed -> + if (sealed) { + sealedParents[this] = HashSet() + } else { + notSealedParents.add(this) + } + } + } + change.parentsChanged.forEach { parent -> + if (parent.isSealed()) { + sealedParents.getOrPut(parent) { HashSet() }.add(change.fqName) + } + } } } - return DirtyData(dirtyLookupSymbols, dirtyClassesFqNames) + val forceRecompile = HashSet().apply { + addAll(sealedParents.keys) + //we should recompile all inheritors with parent sealed class: add known subtypes + addAll(sealedParents.keys.flatMap { withSubtypes(it, caches) }) + //we should recompile all inheritors with parent sealed class: add new subtypes + addAll(sealedParents.values.flatten()) + } + + return DirtyData(dirtyLookupSymbols, dirtyClassesFqNames, forceRecompile) } fun mapLookupSymbolsToFiles( @@ -217,6 +246,11 @@ fun mapClassesFqNamesToFiles( return fqNameToAffectedFiles.values.flattenTo(HashSet()) } +fun isSealed( + fqName: FqName, + caches: Iterable +): Boolean = caches.any { it.isSealed(fqName) ?: false } + fun withSubtypes( typeFqName: FqName, caches: Iterable diff --git a/build-common/src/org/jetbrains/kotlin/incremental/protoDifferenceUtils.kt b/build-common/src/org/jetbrains/kotlin/incremental/protoDifferenceUtils.kt index 9b84e4857fb..8af998ce9c7 100644 --- a/build-common/src/org/jetbrains/kotlin/incremental/protoDifferenceUtils.kt +++ b/build-common/src/org/jetbrains/kotlin/incremental/protoDifferenceUtils.kt @@ -28,12 +28,14 @@ import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.protobuf.MessageLite import org.jetbrains.kotlin.serialization.deserialization.ProtoEnumFlags import org.jetbrains.kotlin.serialization.deserialization.descriptorVisibility +import org.jetbrains.kotlin.serialization.deserialization.getClassId import java.util.* data class Difference( val isClassAffected: Boolean = false, val areSubclassesAffected: Boolean = false, - val changedMembersNames: Set = emptySet() + val changedMembersNames: Set = emptySet(), + val changedSupertypes: Set = emptySet() ) sealed class ProtoData @@ -187,6 +189,7 @@ class DifferenceCalculatorForClass( var isClassAffected = false var areSubclassesAffected = false + val changedSupertypes = HashSet() val names = hashSetOf() val classIsSealed = newProto.isSealed && oldProto.isSealed @@ -247,12 +250,21 @@ class DifferenceCalculatorForClass( ProtoBufClassKind.FLAGS, ProtoBufClassKind.FQ_NAME, ProtoBufClassKind.TYPE_PARAMETER_LIST, - ProtoBufClassKind.SUPERTYPE_LIST, - ProtoBufClassKind.SUPERTYPE_ID_LIST, ProtoBufClassKind.JS_EXT_CLASS_ANNOTATION_LIST -> { isClassAffected = true areSubclassesAffected = true } + + ProtoBufClassKind.SUPERTYPE_LIST, + ProtoBufClassKind.SUPERTYPE_ID_LIST -> { + isClassAffected = true + areSubclassesAffected = true + + val oldSupertypes = oldProto.supertypeList.map { oldNameResolver.getClassId(it.className).asSingleFqName() } + val newSupertypes = newProto.supertypeList.map { newNameResolver.getClassId(it.className).asSingleFqName() } + val changed = (oldSupertypes union newSupertypes) subtract (oldSupertypes intersect newSupertypes) + changedSupertypes.addAll(changed) + } ProtoBufClassKind.JVM_EXT_CLASS_MODULE_NAME, ProtoBufClassKind.JS_EXT_CLASS_CONTAINING_FILE_ID -> { // TODO @@ -281,7 +293,7 @@ class DifferenceCalculatorForClass( } } - return Difference(isClassAffected, areSubclassesAffected, names) + return Difference(isClassAffected, areSubclassesAffected, names, changedSupertypes) } } diff --git a/build-common/src/org/jetbrains/kotlin/incremental/storage/ClassAttributesMap.kt b/build-common/src/org/jetbrains/kotlin/incremental/storage/ClassAttributesMap.kt new file mode 100644 index 00000000000..7b853709576 --- /dev/null +++ b/build-common/src/org/jetbrains/kotlin/incremental/storage/ClassAttributesMap.kt @@ -0,0 +1,51 @@ +/* + * Copyright 2010-2015 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.incremental.storage + +import com.intellij.util.io.DataExternalizer +import org.jetbrains.kotlin.name.FqName +import java.io.DataInput +import java.io.DataOutput +import java.io.File + +internal data class ICClassesAttributes(val isSealed: Boolean) + +internal object ICClassesAttributesExternalizer : DataExternalizer { + override fun read(input: DataInput): ICClassesAttributes { + return ICClassesAttributes(input.readBoolean()) + } + + override fun save(output: DataOutput, value: ICClassesAttributes) { + output.writeBoolean(value.isSealed) + } +} + +internal open class ClassAttributesMap( + storageFile: File +) : BasicStringMap(storageFile, ICClassesAttributesExternalizer) { + override fun dumpValue(value: ICClassesAttributes): String = value.toString() + + operator fun set(key: FqName, value: ICClassesAttributes) { + storage[key.asString()] = value + } + + operator fun get(key: FqName): ICClassesAttributes? = storage[key.asString()] + + fun remove(key: FqName) { + storage.remove(key.asString()) + } +} diff --git a/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalCompilerRunner.kt b/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalCompilerRunner.kt index ecdbf02d6b2..450e25eb3d3 100644 --- a/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalCompilerRunner.kt +++ b/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalCompilerRunner.kt @@ -310,9 +310,10 @@ abstract class IncrementalCompilerRunner< } if (compilationMode is CompilationMode.Rebuild) break - val (dirtyLookupSymbols, dirtyClassFqNames) = changesCollector.getDirtyData(listOf(caches.platformCache), reporter) + val (dirtyLookupSymbols, dirtyClassFqNames, forceRecompile) = changesCollector.getDirtyData(listOf(caches.platformCache), reporter) val compiledInThisIterationSet = sourcesToCompile.toHashSet() + val forceToRecompileFiles = mapClassesFqNamesToFiles(listOf(caches.platformCache), forceRecompile, reporter) with(dirtySources) { clear() addAll(mapLookupSymbolsToFiles(caches.lookupCache, dirtyLookupSymbols, reporter, excludes = compiledInThisIterationSet)) @@ -324,6 +325,9 @@ abstract class IncrementalCompilerRunner< excludes = compiledInThisIterationSet ) ) + if (!compiledInThisIterationSet.containsAll(forceToRecompileFiles)) { + addAll(forceToRecompileFiles) + } } buildDirtyLookupSymbols.addAll(dirtyLookupSymbols) diff --git a/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalJsCompilerRunner.kt b/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalJsCompilerRunner.kt index 09c17ebfd2f..963fa236ddd 100644 --- a/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalJsCompilerRunner.kt +++ b/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalJsCompilerRunner.kt @@ -125,7 +125,7 @@ class IncrementalJsCompilerRunner( val removedClassesChanges = getRemovedClassesChanges(caches, changedFiles) dirtyFiles.addByDirtySymbols(removedClassesChanges.dirtyLookupSymbols) dirtyFiles.addByDirtyClasses(removedClassesChanges.dirtyClassesFqNames) - + dirtyFiles.addByDirtyClasses(removedClassesChanges.dirtyClassesFqNamesForceRecompile) return CompilationMode.Incremental(dirtyFiles) } diff --git a/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalJvmCompilerRunner.kt b/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalJvmCompilerRunner.kt index c85f8e6d573..9c5da3b4972 100644 --- a/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalJvmCompilerRunner.kt +++ b/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalJvmCompilerRunner.kt @@ -227,7 +227,7 @@ class IncrementalJvmCompilerRunner( dirtyFiles.addByDirtySymbols(androidLayoutChanges) dirtyFiles.addByDirtySymbols(removedClassesChanges.dirtyLookupSymbols) dirtyFiles.addByDirtyClasses(removedClassesChanges.dirtyClassesFqNames) - + dirtyFiles.addByDirtyClasses(removedClassesChanges.dirtyClassesFqNamesForceRecompile) return CompilationMode.Incremental(dirtyFiles) } diff --git a/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/incremental/AbstractProtoComparisonTest.kt b/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/incremental/AbstractProtoComparisonTest.kt index 4065354f67c..da16372d4c1 100644 --- a/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/incremental/AbstractProtoComparisonTest.kt +++ b/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/incremental/AbstractProtoComparisonTest.kt @@ -90,6 +90,8 @@ abstract class AbstractProtoComparisonTest : TestWithWorkingDir() { when (it) { is ChangeInfo.SignatureChanged -> "CLASS_SIGNATURE" is ChangeInfo.MembersChanged -> "MEMBERS\n ${it.names.sorted()}" + is ChangeInfo.ParentsChanged -> "PARENTS\n ${it.parentsChanged.map { it.asString()}.sorted()}" + } }.sorted() diff --git a/jps-plugin/src/org/jetbrains/kotlin/jps/build/KotlinBuilder.kt b/jps-plugin/src/org/jetbrains/kotlin/jps/build/KotlinBuilder.kt index d0b97301a60..04afe480d2c 100644 --- a/jps-plugin/src/org/jetbrains/kotlin/jps/build/KotlinBuilder.kt +++ b/jps-plugin/src/org/jetbrains/kotlin/jps/build/KotlinBuilder.kt @@ -250,7 +250,7 @@ class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR) { removedClasses.forEach { changesCollector.collectSignature(FqName(it), areSubclassesAffected = true) } val affectedByRemovedClasses = changesCollector.getDirtyFiles(incrementalCaches.values, kotlinContext.lookupStorageManager) - fsOperations.markFilesForCurrentRound(affectedByRemovedClasses) + fsOperations.markFilesForCurrentRound(affectedByRemovedClasses.dirtyFiles + affectedByRemovedClasses.forceRecompileTogether) } override fun chunkBuildFinished(context: CompileContext, chunk: ModuleChunk) { @@ -695,21 +695,36 @@ private fun ChangesCollector.processChangesUsingLookups( reporter.reportVerbose { "Start processing changes" } val dirtyFiles = getDirtyFiles(allCaches, lookupStorageManager) - fsOperations.markInChunkOrDependents(dirtyFiles.asIterable(), excludeFiles = compiledFiles) + // if list of inheritors of sealed class has changed it should be recompiled with all the inheritors + // Here we have a small optimization. Do not recompile the bunch if ALL these files were recompiled during the previous round. + val excludeFiles = if (compiledFiles.containsAll(dirtyFiles.forceRecompileTogether)) + compiledFiles + else + compiledFiles.minus(dirtyFiles.forceRecompileTogether) + fsOperations.markInChunkOrDependents( + (dirtyFiles.dirtyFiles + dirtyFiles.forceRecompileTogether).asIterable(), + excludeFiles = excludeFiles + ) reporter.reportVerbose { "End of processing changes" } } +data class FilesToRecompile(val dirtyFiles: Set, val forceRecompileTogether: Set) + private fun ChangesCollector.getDirtyFiles( caches: Iterable, lookupStorageManager: JpsLookupStorageManager -): Set { +): FilesToRecompile { val reporter = JpsICReporter() - val (dirtyLookupSymbols, dirtyClassFqNames) = getDirtyData(caches, reporter) + val (dirtyLookupSymbols, dirtyClassFqNames, forceRecompile) = getDirtyData(caches, reporter) val dirtyFilesFromLookups = lookupStorageManager.withLookupStorage { mapLookupSymbolsToFiles(it, dirtyLookupSymbols, reporter) } - return dirtyFilesFromLookups + mapClassesFqNamesToFiles(caches, dirtyClassFqNames, reporter) + return FilesToRecompile( + dirtyFilesFromLookups + mapClassesFqNamesToFiles(caches, dirtyClassFqNames, reporter), + mapClassesFqNamesToFiles(caches, forceRecompile, reporter) + ) + } private fun getLookupTracker(project: JpsProject, representativeTarget: KotlinModuleBuildTarget<*>): LookupTracker { From 2e607335dbdbe18f9513bd7721f690212c799079 Mon Sep 17 00:00:00 2001 From: Andrey Uskov Date: Wed, 9 Dec 2020 17:33:51 +0300 Subject: [PATCH 002/196] Add tests for incremental compilation of sealed interfaces --- .../incremental/BuildDiffsStorageTest.kt | 2 +- ...rementalJsCompilerRunnerTestGenerated.java | 25 ++++++++++++ ...erRunnerWithMetadataOnlyTestGenerated.java | 25 ++++++++++++ ...ntalJsKlibCompilerRunnerTestGenerated.java | 25 ++++++++++++ ...WithScopeExpansionRunnerTestGenerated.java | 27 +++++++++++++ ...ementalJvmCompilerRunnerTestGenerated.java | 25 ++++++++++++ ...ementalJvmCompilerRunnerTestGenerated.java | 25 ++++++++++++ .../build/IncrementalJvmJpsTestGenerated.java | 25 ++++++++++++ .../classFlagsChanged/result-js.out | 12 ++++-- .../classFlagsChanged/result.out | 12 ++++-- .../classWithSuperTypeListChanged/result.out | 3 +- .../nestedClassSignatureChanged/result.out | 3 +- .../sealedClassImplAdded/result.out | 3 +- .../sealedClassImplRemoved/result.out | 3 +- .../sealedClassNestedImplAdded/result.out | 3 +- .../sealedClassNestedImplAddedDeep/result.out | 3 +- .../sealedClassNestedImplRemoved/result.out | 3 +- .../expected-kotlin-caches.txt | 3 ++ .../class/expected-kotlin-caches.txt | 1 + .../expected-kotlin-caches.txt | 1 + .../sealedClassesAddImplements/A.kt | 3 ++ .../sealedClassesAddImplements/B.kt | 3 ++ .../sealedClassesAddImplements/B.kt.new | 3 ++ .../sealedClassesAddImplements/Base.kt | 3 ++ .../sealedClassesAddImplements/args.txt | 1 + .../sealedClassesAddImplements/build.log | 28 +++++++++++++ .../sealedClassesAddImplements.jsklib.mute | 1 + .../sealedClassesAddImplements/С.kt | 3 ++ .../pureKotlin/sealedClassesAddInheritor/A.kt | 3 ++ .../pureKotlin/sealedClassesAddInheritor/B.kt | 3 ++ .../sealedClassesAddInheritor/Base.kt | 3 ++ .../sealedClassesAddInheritor/C.kt.new | 3 ++ .../sealedClassesAddInheritor/args.txt | 1 + .../sealedClassesAddInheritor/build.log | 27 +++++++++++++ .../sealedClassesAddInheritor.jsklib.mute | 1 + .../sealedClassesRemoveImplements/A.kt | 3 ++ .../sealedClassesRemoveImplements/B.kt | 3 ++ .../sealedClassesRemoveImplements/B.kt.new | 4 ++ .../sealedClassesRemoveImplements/Base.kt | 3 ++ .../BaseUsage.kt | 5 +++ .../sealedClassesRemoveImplements/args.txt | 1 + .../sealedClassesRemoveImplements/build.log | 39 +++++++++++++++++++ .../sealedClassesRemoveImplements.jsklib.mute | 1 + .../sealedClassesRemoveInheritor/A.kt | 3 ++ .../sealedClassesRemoveInheritor/B.kt | 3 ++ .../sealedClassesRemoveInheritor/B.kt.delete | 0 .../sealedClassesRemoveInheritor/Base.kt | 3 ++ .../sealedClassesRemoveInheritor/BaseUsage.kt | 5 +++ .../sealedClassesRemoveInheritor/args.txt | 1 + .../sealedClassesRemoveInheritor/build.log | 35 +++++++++++++++++ .../sealedClassesRemoveInheritor.jsklib.mute | 1 + .../pureKotlin/sealedClassesUseSwitch/A.kt | 3 ++ .../pureKotlin/sealedClassesUseSwitch/B.kt | 3 ++ .../pureKotlin/sealedClassesUseSwitch/Base.kt | 3 ++ .../sealedClassesUseSwitch/C.kt.new | 3 ++ .../pureKotlin/sealedClassesUseSwitch/D.kt | 5 +++ .../pureKotlin/sealedClassesUseSwitch/E.kt | 4 ++ .../sealedClassesUseSwitch/args.txt | 1 + .../sealedClassesUseSwitch/build.log | 38 ++++++++++++++++++ .../sealedClassesUseSwitch.jsklib.mute | 1 + 60 files changed, 470 insertions(+), 16 deletions(-) create mode 100644 jps-plugin/testData/incremental/pureKotlin/sealedClassesAddImplements/A.kt create mode 100644 jps-plugin/testData/incremental/pureKotlin/sealedClassesAddImplements/B.kt create mode 100644 jps-plugin/testData/incremental/pureKotlin/sealedClassesAddImplements/B.kt.new create mode 100644 jps-plugin/testData/incremental/pureKotlin/sealedClassesAddImplements/Base.kt create mode 100644 jps-plugin/testData/incremental/pureKotlin/sealedClassesAddImplements/args.txt create mode 100644 jps-plugin/testData/incremental/pureKotlin/sealedClassesAddImplements/build.log create mode 100644 jps-plugin/testData/incremental/pureKotlin/sealedClassesAddImplements/sealedClassesAddImplements.jsklib.mute create mode 100644 jps-plugin/testData/incremental/pureKotlin/sealedClassesAddImplements/С.kt create mode 100644 jps-plugin/testData/incremental/pureKotlin/sealedClassesAddInheritor/A.kt create mode 100644 jps-plugin/testData/incremental/pureKotlin/sealedClassesAddInheritor/B.kt create mode 100644 jps-plugin/testData/incremental/pureKotlin/sealedClassesAddInheritor/Base.kt create mode 100644 jps-plugin/testData/incremental/pureKotlin/sealedClassesAddInheritor/C.kt.new create mode 100644 jps-plugin/testData/incremental/pureKotlin/sealedClassesAddInheritor/args.txt create mode 100644 jps-plugin/testData/incremental/pureKotlin/sealedClassesAddInheritor/build.log create mode 100644 jps-plugin/testData/incremental/pureKotlin/sealedClassesAddInheritor/sealedClassesAddInheritor.jsklib.mute create mode 100644 jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveImplements/A.kt create mode 100644 jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveImplements/B.kt create mode 100644 jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveImplements/B.kt.new create mode 100644 jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveImplements/Base.kt create mode 100644 jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveImplements/BaseUsage.kt create mode 100644 jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveImplements/args.txt create mode 100644 jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveImplements/build.log create mode 100644 jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveImplements/sealedClassesRemoveImplements.jsklib.mute create mode 100644 jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveInheritor/A.kt create mode 100644 jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveInheritor/B.kt create mode 100644 jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveInheritor/B.kt.delete create mode 100644 jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveInheritor/Base.kt create mode 100644 jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveInheritor/BaseUsage.kt create mode 100644 jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveInheritor/args.txt create mode 100644 jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveInheritor/build.log create mode 100644 jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveInheritor/sealedClassesRemoveInheritor.jsklib.mute create mode 100644 jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/A.kt create mode 100644 jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/B.kt create mode 100644 jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/Base.kt create mode 100644 jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/C.kt.new create mode 100644 jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/D.kt create mode 100644 jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/E.kt create mode 100644 jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/args.txt create mode 100644 jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/build.log create mode 100644 jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/sealedClassesUseSwitch.jsklib.mute diff --git a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/BuildDiffsStorageTest.kt b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/BuildDiffsStorageTest.kt index 90afd6eae67..0b80724f435 100644 --- a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/BuildDiffsStorageTest.kt +++ b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/BuildDiffsStorageTest.kt @@ -46,7 +46,7 @@ class BuildDiffsStorageTest { val diff = BuildDifference(100, true, DirtyData(lookupSymbols, fqNames)) val diffs = BuildDiffsStorage(listOf(diff)) Assert.assertEquals( - "BuildDiffsStorage(buildDiffs=[BuildDifference(ts=100, isIncremental=true, dirtyData=DirtyData(dirtyLookupSymbols=[LookupSymbol(name=foo, scope=bar)], dirtyClassesFqNames=[fizz.Buzz]))])", + "BuildDiffsStorage(buildDiffs=[BuildDifference(ts=100, isIncremental=true, dirtyData=DirtyData(dirtyLookupSymbols=[LookupSymbol(name=foo, scope=bar)], dirtyClassesFqNames=[fizz.Buzz], dirtyClassesFqNamesForceRecompile=[]))])", diffs.toString() ) } diff --git a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsCompilerRunnerTestGenerated.java b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsCompilerRunnerTestGenerated.java index 77389396c57..b3db196aac5 100644 --- a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsCompilerRunnerTestGenerated.java +++ b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsCompilerRunnerTestGenerated.java @@ -570,6 +570,31 @@ public class IncrementalJsCompilerRunnerTestGenerated extends AbstractIncrementa runTest("jps-plugin/testData/incremental/pureKotlin/returnTypeChanged/"); } + @TestMetadata("sealedClassesAddImplements") + public void testSealedClassesAddImplements() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/sealedClassesAddImplements/"); + } + + @TestMetadata("sealedClassesAddInheritor") + public void testSealedClassesAddInheritor() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/sealedClassesAddInheritor/"); + } + + @TestMetadata("sealedClassesRemoveImplements") + public void testSealedClassesRemoveImplements() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveImplements/"); + } + + @TestMetadata("sealedClassesRemoveInheritor") + public void testSealedClassesRemoveInheritor() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveInheritor/"); + } + + @TestMetadata("sealedClassesUseSwitch") + public void testSealedClassesUseSwitch() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/"); + } + @TestMetadata("secondaryConstructorInlined") public void testSecondaryConstructorInlined() throws Exception { runTest("jps-plugin/testData/incremental/pureKotlin/secondaryConstructorInlined/"); diff --git a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsCompilerRunnerWithMetadataOnlyTestGenerated.java b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsCompilerRunnerWithMetadataOnlyTestGenerated.java index 8ffd5078d1b..510e72b96cc 100644 --- a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsCompilerRunnerWithMetadataOnlyTestGenerated.java +++ b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsCompilerRunnerWithMetadataOnlyTestGenerated.java @@ -570,6 +570,31 @@ public class IncrementalJsCompilerRunnerWithMetadataOnlyTestGenerated extends Ab runTest("jps-plugin/testData/incremental/pureKotlin/returnTypeChanged/"); } + @TestMetadata("sealedClassesAddImplements") + public void testSealedClassesAddImplements() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/sealedClassesAddImplements/"); + } + + @TestMetadata("sealedClassesAddInheritor") + public void testSealedClassesAddInheritor() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/sealedClassesAddInheritor/"); + } + + @TestMetadata("sealedClassesRemoveImplements") + public void testSealedClassesRemoveImplements() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveImplements/"); + } + + @TestMetadata("sealedClassesRemoveInheritor") + public void testSealedClassesRemoveInheritor() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveInheritor/"); + } + + @TestMetadata("sealedClassesUseSwitch") + public void testSealedClassesUseSwitch() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/"); + } + @TestMetadata("secondaryConstructorInlined") public void testSecondaryConstructorInlined() throws Exception { runTest("jps-plugin/testData/incremental/pureKotlin/secondaryConstructorInlined/"); diff --git a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsKlibCompilerRunnerTestGenerated.java b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsKlibCompilerRunnerTestGenerated.java index a209b922641..f9b1a487a46 100644 --- a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsKlibCompilerRunnerTestGenerated.java +++ b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsKlibCompilerRunnerTestGenerated.java @@ -572,6 +572,31 @@ public class IncrementalJsKlibCompilerRunnerTestGenerated extends AbstractIncrem runTest("jps-plugin/testData/incremental/pureKotlin/returnTypeChanged/"); } + @TestMetadata("sealedClassesAddImplements") + public void testSealedClassesAddImplements() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/sealedClassesAddImplements/"); + } + + @TestMetadata("sealedClassesAddInheritor") + public void testSealedClassesAddInheritor() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/sealedClassesAddInheritor/"); + } + + @TestMetadata("sealedClassesRemoveImplements") + public void testSealedClassesRemoveImplements() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveImplements/"); + } + + @TestMetadata("sealedClassesRemoveInheritor") + public void testSealedClassesRemoveInheritor() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveInheritor/"); + } + + @TestMetadata("sealedClassesUseSwitch") + public void testSealedClassesUseSwitch() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/"); + } + @TestMetadata("secondaryConstructorInlined") public void testSecondaryConstructorInlined() throws Exception { runTest("jps-plugin/testData/incremental/pureKotlin/secondaryConstructorInlined/"); diff --git a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsKlibCompilerWithScopeExpansionRunnerTestGenerated.java b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsKlibCompilerWithScopeExpansionRunnerTestGenerated.java index ea168c53f62..4e71e9f4dc3 100644 --- a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsKlibCompilerWithScopeExpansionRunnerTestGenerated.java +++ b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsKlibCompilerWithScopeExpansionRunnerTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.incremental; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.MuteExtraSuffix; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -19,6 +20,7 @@ import java.util.regex.Pattern; @RunWith(JUnit3RunnerWithInners.class) public class IncrementalJsKlibCompilerWithScopeExpansionRunnerTestGenerated extends AbstractIncrementalJsKlibCompilerWithScopeExpansionRunnerTest { @TestMetadata("jps-plugin/testData/incremental/pureKotlin") + @MuteExtraSuffix(".jsklib") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) public static class PureKotlin extends AbstractIncrementalJsKlibCompilerWithScopeExpansionRunnerTest { @@ -570,6 +572,31 @@ public class IncrementalJsKlibCompilerWithScopeExpansionRunnerTestGenerated exte runTest("jps-plugin/testData/incremental/pureKotlin/returnTypeChanged/"); } + @TestMetadata("sealedClassesAddImplements") + public void testSealedClassesAddImplements() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/sealedClassesAddImplements/"); + } + + @TestMetadata("sealedClassesAddInheritor") + public void testSealedClassesAddInheritor() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/sealedClassesAddInheritor/"); + } + + @TestMetadata("sealedClassesRemoveImplements") + public void testSealedClassesRemoveImplements() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveImplements/"); + } + + @TestMetadata("sealedClassesRemoveInheritor") + public void testSealedClassesRemoveInheritor() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveInheritor/"); + } + + @TestMetadata("sealedClassesUseSwitch") + public void testSealedClassesUseSwitch() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/"); + } + @TestMetadata("secondaryConstructorInlined") public void testSecondaryConstructorInlined() throws Exception { runTest("jps-plugin/testData/incremental/pureKotlin/secondaryConstructorInlined/"); diff --git a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJvmCompilerRunnerTestGenerated.java b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJvmCompilerRunnerTestGenerated.java index f9084401e4d..ba32279d9cb 100644 --- a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJvmCompilerRunnerTestGenerated.java +++ b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJvmCompilerRunnerTestGenerated.java @@ -571,6 +571,31 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement runTest("jps-plugin/testData/incremental/pureKotlin/returnTypeChanged/"); } + @TestMetadata("sealedClassesAddImplements") + public void testSealedClassesAddImplements() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/sealedClassesAddImplements/"); + } + + @TestMetadata("sealedClassesAddInheritor") + public void testSealedClassesAddInheritor() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/sealedClassesAddInheritor/"); + } + + @TestMetadata("sealedClassesRemoveImplements") + public void testSealedClassesRemoveImplements() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveImplements/"); + } + + @TestMetadata("sealedClassesRemoveInheritor") + public void testSealedClassesRemoveInheritor() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveInheritor/"); + } + + @TestMetadata("sealedClassesUseSwitch") + public void testSealedClassesUseSwitch() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/"); + } + @TestMetadata("secondaryConstructorInlined") public void testSecondaryConstructorInlined() throws Exception { runTest("jps-plugin/testData/incremental/pureKotlin/secondaryConstructorInlined/"); diff --git a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IrIncrementalJvmCompilerRunnerTestGenerated.java b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IrIncrementalJvmCompilerRunnerTestGenerated.java index f08e1497aca..71389f82926 100644 --- a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IrIncrementalJvmCompilerRunnerTestGenerated.java +++ b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IrIncrementalJvmCompilerRunnerTestGenerated.java @@ -571,6 +571,31 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre runTest("jps-plugin/testData/incremental/pureKotlin/returnTypeChanged/"); } + @TestMetadata("sealedClassesAddImplements") + public void testSealedClassesAddImplements() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/sealedClassesAddImplements/"); + } + + @TestMetadata("sealedClassesAddInheritor") + public void testSealedClassesAddInheritor() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/sealedClassesAddInheritor/"); + } + + @TestMetadata("sealedClassesRemoveImplements") + public void testSealedClassesRemoveImplements() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveImplements/"); + } + + @TestMetadata("sealedClassesRemoveInheritor") + public void testSealedClassesRemoveInheritor() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveInheritor/"); + } + + @TestMetadata("sealedClassesUseSwitch") + public void testSealedClassesUseSwitch() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/"); + } + @TestMetadata("secondaryConstructorInlined") public void testSecondaryConstructorInlined() throws Exception { runTest("jps-plugin/testData/incremental/pureKotlin/secondaryConstructorInlined/"); diff --git a/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/IncrementalJvmJpsTestGenerated.java b/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/IncrementalJvmJpsTestGenerated.java index 8c4310c99cf..d0ce519c09c 100644 --- a/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/IncrementalJvmJpsTestGenerated.java +++ b/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/IncrementalJvmJpsTestGenerated.java @@ -1239,6 +1239,31 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes runTest("jps-plugin/testData/incremental/pureKotlin/returnTypeChanged/"); } + @TestMetadata("sealedClassesAddImplements") + public void testSealedClassesAddImplements() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/sealedClassesAddImplements/"); + } + + @TestMetadata("sealedClassesAddInheritor") + public void testSealedClassesAddInheritor() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/sealedClassesAddInheritor/"); + } + + @TestMetadata("sealedClassesRemoveImplements") + public void testSealedClassesRemoveImplements() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveImplements/"); + } + + @TestMetadata("sealedClassesRemoveInheritor") + public void testSealedClassesRemoveInheritor() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveInheritor/"); + } + + @TestMetadata("sealedClassesUseSwitch") + public void testSealedClassesUseSwitch() throws Exception { + runTest("jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/"); + } + @TestMetadata("secondaryConstructorInlined") public void testSecondaryConstructorInlined() throws Exception { runTest("jps-plugin/testData/incremental/pureKotlin/secondaryConstructorInlined/"); diff --git a/jps-plugin/testData/comparison/classSignatureChange/classFlagsChanged/result-js.out b/jps-plugin/testData/comparison/classSignatureChange/classFlagsChanged/result-js.out index 6fcbece9a43..95f7d8309bc 100644 --- a/jps-plugin/testData/comparison/classSignatureChange/classFlagsChanged/result-js.out +++ b/jps-plugin/testData/comparison/classSignatureChange/classFlagsChanged/result-js.out @@ -3,9 +3,11 @@ CHANGES in test/AbstractFlagAdded: CLASS_SIGNATURE PROTO DIFFERENCE in test/AbstractFlagRemoved: FLAGS CHANGES in test/AbstractFlagRemoved: CLASS_SIGNATURE PROTO DIFFERENCE in test/AnnotationFlagAdded: FLAGS, SUPERTYPE_LIST -CHANGES in test/AnnotationFlagAdded: CLASS_SIGNATURE +CHANGES in test/AnnotationFlagAdded: CLASS_SIGNATURE, PARENTS + [kotlin.Annotation, kotlin.Any] PROTO DIFFERENCE in test/AnnotationFlagRemoved: FLAGS, SUPERTYPE_LIST -CHANGES in test/AnnotationFlagRemoved: CLASS_SIGNATURE +CHANGES in test/AnnotationFlagRemoved: CLASS_SIGNATURE, PARENTS + [kotlin.Annotation, kotlin.Any] PROTO DIFFERENCE in test/DataFlagAdded: FLAGS, FUNCTION_LIST CHANGES in test/DataFlagAdded: CLASS_SIGNATURE, MEMBERS [component1, copy, equals, hashCode, toString] @@ -13,9 +15,11 @@ PROTO DIFFERENCE in test/DataFlagRemoved: FLAGS, FUNCTION_LIST CHANGES in test/DataFlagRemoved: CLASS_SIGNATURE, MEMBERS [component1, copy, equals, hashCode, toString] PROTO DIFFERENCE in test/EnumFlagAdded: CONSTRUCTOR_LIST, FLAGS, SUPERTYPE_LIST -CHANGES in test/EnumFlagAdded: CLASS_SIGNATURE +CHANGES in test/EnumFlagAdded: CLASS_SIGNATURE, PARENTS + [kotlin.Any, kotlin.Enum] PROTO DIFFERENCE in test/EnumFlagRemoved: CONSTRUCTOR_LIST, FLAGS, SUPERTYPE_LIST -CHANGES in test/EnumFlagRemoved: CLASS_SIGNATURE +CHANGES in test/EnumFlagRemoved: CLASS_SIGNATURE, PARENTS + [kotlin.Any, kotlin.Enum] PROTO DIFFERENCE in test/InnerClassHolder.InnerFlagAdded: FLAGS CHANGES in test/InnerClassHolder.InnerFlagAdded: CLASS_SIGNATURE PROTO DIFFERENCE in test/InnerClassHolder.InnerFlagRemoved: FLAGS diff --git a/jps-plugin/testData/comparison/classSignatureChange/classFlagsChanged/result.out b/jps-plugin/testData/comparison/classSignatureChange/classFlagsChanged/result.out index 9dbebfba115..f00772bb93a 100644 --- a/jps-plugin/testData/comparison/classSignatureChange/classFlagsChanged/result.out +++ b/jps-plugin/testData/comparison/classSignatureChange/classFlagsChanged/result.out @@ -3,9 +3,11 @@ CHANGES in test/AbstractFlagAdded: CLASS_SIGNATURE PROTO DIFFERENCE in test/AbstractFlagRemoved: FLAGS CHANGES in test/AbstractFlagRemoved: CLASS_SIGNATURE PROTO DIFFERENCE in test/AnnotationFlagAdded: CONSTRUCTOR_LIST, FLAGS, SUPERTYPE_LIST -CHANGES in test/AnnotationFlagAdded: CLASS_SIGNATURE +CHANGES in test/AnnotationFlagAdded: CLASS_SIGNATURE, PARENTS + [kotlin.Annotation, kotlin.Any] PROTO DIFFERENCE in test/AnnotationFlagRemoved: CONSTRUCTOR_LIST, FLAGS, SUPERTYPE_LIST -CHANGES in test/AnnotationFlagRemoved: CLASS_SIGNATURE +CHANGES in test/AnnotationFlagRemoved: CLASS_SIGNATURE, PARENTS + [kotlin.Annotation, kotlin.Any] PROTO DIFFERENCE in test/DataFlagAdded: FLAGS, FUNCTION_LIST CHANGES in test/DataFlagAdded: CLASS_SIGNATURE, MEMBERS [component1, copy, equals, hashCode, toString] @@ -13,9 +15,11 @@ PROTO DIFFERENCE in test/DataFlagRemoved: FLAGS, FUNCTION_LIST CHANGES in test/DataFlagRemoved: CLASS_SIGNATURE, MEMBERS [component1, copy, equals, hashCode, toString] PROTO DIFFERENCE in test/EnumFlagAdded: CONSTRUCTOR_LIST, FLAGS, SUPERTYPE_LIST -CHANGES in test/EnumFlagAdded: CLASS_SIGNATURE +CHANGES in test/EnumFlagAdded: CLASS_SIGNATURE, PARENTS + [kotlin.Any, kotlin.Enum] PROTO DIFFERENCE in test/EnumFlagRemoved: CONSTRUCTOR_LIST, FLAGS, SUPERTYPE_LIST -CHANGES in test/EnumFlagRemoved: CLASS_SIGNATURE +CHANGES in test/EnumFlagRemoved: CLASS_SIGNATURE, PARENTS + [kotlin.Any, kotlin.Enum] PROTO DIFFERENCE in test/InnerClassHolder.InnerFlagAdded: CONSTRUCTOR_LIST, FLAGS CHANGES in test/InnerClassHolder.InnerFlagAdded: CLASS_SIGNATURE PROTO DIFFERENCE in test/InnerClassHolder.InnerFlagRemoved: CONSTRUCTOR_LIST, FLAGS diff --git a/jps-plugin/testData/comparison/classSignatureChange/classWithSuperTypeListChanged/result.out b/jps-plugin/testData/comparison/classSignatureChange/classWithSuperTypeListChanged/result.out index e57a591aafe..b1c4bef6ae7 100644 --- a/jps-plugin/testData/comparison/classSignatureChange/classWithSuperTypeListChanged/result.out +++ b/jps-plugin/testData/comparison/classSignatureChange/classWithSuperTypeListChanged/result.out @@ -1,2 +1,3 @@ PROTO DIFFERENCE in test/ClassWithSuperTypeListChanged: SUPERTYPE_LIST -CHANGES in test/ClassWithSuperTypeListChanged: CLASS_SIGNATURE +CHANGES in test/ClassWithSuperTypeListChanged: CLASS_SIGNATURE, PARENTS + [kotlin.Any, kotlin.Throwable] diff --git a/jps-plugin/testData/comparison/classSignatureChange/nestedClassSignatureChanged/result.out b/jps-plugin/testData/comparison/classSignatureChange/nestedClassSignatureChanged/result.out index 51e6416c9e4..d6e8eed1c39 100644 --- a/jps-plugin/testData/comparison/classSignatureChange/nestedClassSignatureChanged/result.out +++ b/jps-plugin/testData/comparison/classSignatureChange/nestedClassSignatureChanged/result.out @@ -1,2 +1,3 @@ PROTO DIFFERENCE in test/Base.Nested1.Nested2: SUPERTYPE_LIST -CHANGES in test/Base.Nested1.Nested2: CLASS_SIGNATURE +CHANGES in test/Base.Nested1.Nested2: CLASS_SIGNATURE, PARENTS + [kotlin.Any, test.Base] diff --git a/jps-plugin/testData/comparison/classSignatureChange/sealedClassImplAdded/result.out b/jps-plugin/testData/comparison/classSignatureChange/sealedClassImplAdded/result.out index 027ee98b281..9c70f14d0aa 100644 --- a/jps-plugin/testData/comparison/classSignatureChange/sealedClassImplAdded/result.out +++ b/jps-plugin/testData/comparison/classSignatureChange/sealedClassImplAdded/result.out @@ -4,4 +4,5 @@ CHANGES in test/Base1: CLASS_SIGNATURE PROTO DIFFERENCE in test/Base2: SEALED_SUBCLASS_FQ_NAME_LIST CHANGES in test/Base2: CLASS_SIGNATURE PROTO DIFFERENCE in test/Impl22: SUPERTYPE_LIST -CHANGES in test/Impl22: CLASS_SIGNATURE +CHANGES in test/Impl22: CLASS_SIGNATURE, PARENTS + [kotlin.Any, test.Base2] diff --git a/jps-plugin/testData/comparison/classSignatureChange/sealedClassImplRemoved/result.out b/jps-plugin/testData/comparison/classSignatureChange/sealedClassImplRemoved/result.out index 07cefb49155..2fa142e3f9b 100644 --- a/jps-plugin/testData/comparison/classSignatureChange/sealedClassImplRemoved/result.out +++ b/jps-plugin/testData/comparison/classSignatureChange/sealedClassImplRemoved/result.out @@ -4,4 +4,5 @@ CHANGES in test/Base1: CLASS_SIGNATURE PROTO DIFFERENCE in test/Base2: SEALED_SUBCLASS_FQ_NAME_LIST CHANGES in test/Base2: CLASS_SIGNATURE PROTO DIFFERENCE in test/Impl22: SUPERTYPE_LIST -CHANGES in test/Impl22: CLASS_SIGNATURE +CHANGES in test/Impl22: CLASS_SIGNATURE, PARENTS + [kotlin.Any, test.Base2] diff --git a/jps-plugin/testData/comparison/classSignatureChange/sealedClassNestedImplAdded/result.out b/jps-plugin/testData/comparison/classSignatureChange/sealedClassNestedImplAdded/result.out index c7661b6ed2c..e64c6353c17 100644 --- a/jps-plugin/testData/comparison/classSignatureChange/sealedClassNestedImplAdded/result.out +++ b/jps-plugin/testData/comparison/classSignatureChange/sealedClassNestedImplAdded/result.out @@ -5,4 +5,5 @@ CHANGES in test/Base1: CLASS_SIGNATURE, MEMBERS PROTO DIFFERENCE in test/Base2: SEALED_SUBCLASS_FQ_NAME_LIST CHANGES in test/Base2: CLASS_SIGNATURE PROTO DIFFERENCE in test/Base2.Nested2: SUPERTYPE_LIST -CHANGES in test/Base2.Nested2: CLASS_SIGNATURE +CHANGES in test/Base2.Nested2: CLASS_SIGNATURE, PARENTS + [kotlin.Any, test.Base2] diff --git a/jps-plugin/testData/comparison/classSignatureChange/sealedClassNestedImplAddedDeep/result.out b/jps-plugin/testData/comparison/classSignatureChange/sealedClassNestedImplAddedDeep/result.out index 3363b854df1..24ddda10d1c 100644 --- a/jps-plugin/testData/comparison/classSignatureChange/sealedClassNestedImplAddedDeep/result.out +++ b/jps-plugin/testData/comparison/classSignatureChange/sealedClassNestedImplAddedDeep/result.out @@ -9,4 +9,5 @@ CHANGES in test/Base2.Nested1: CLASS_SIGNATURE, MEMBERS PROTO DIFFERENCE in test/Base3.Nested1: SEALED_SUBCLASS_FQ_NAME_LIST CHANGES in test/Base3.Nested1: CLASS_SIGNATURE PROTO DIFFERENCE in test/Base3.Nested1.Nested2: SUPERTYPE_LIST -CHANGES in test/Base3.Nested1.Nested2: CLASS_SIGNATURE +CHANGES in test/Base3.Nested1.Nested2: CLASS_SIGNATURE, PARENTS + [kotlin.Any, test.Base3.Nested1] diff --git a/jps-plugin/testData/comparison/classSignatureChange/sealedClassNestedImplRemoved/result.out b/jps-plugin/testData/comparison/classSignatureChange/sealedClassNestedImplRemoved/result.out index 87fa076f273..c3d77972774 100644 --- a/jps-plugin/testData/comparison/classSignatureChange/sealedClassNestedImplRemoved/result.out +++ b/jps-plugin/testData/comparison/classSignatureChange/sealedClassNestedImplRemoved/result.out @@ -5,4 +5,5 @@ CHANGES in test/Base1: CLASS_SIGNATURE, MEMBERS PROTO DIFFERENCE in test/Base2: SEALED_SUBCLASS_FQ_NAME_LIST CHANGES in test/Base2: CLASS_SIGNATURE PROTO DIFFERENCE in test/Base2.Nested2: SUPERTYPE_LIST -CHANGES in test/Base2.Nested2: CLASS_SIGNATURE +CHANGES in test/Base2.Nested2: CLASS_SIGNATURE, PARENTS + [kotlin.Any, test.Base2] diff --git a/jps-plugin/testData/incremental/changeIncrementalOption/incrementalOffOn/expected-kotlin-caches.txt b/jps-plugin/testData/incremental/changeIncrementalOption/incrementalOffOn/expected-kotlin-caches.txt index afaffa21b44..d44fbba4050 100644 --- a/jps-plugin/testData/incremental/changeIncrementalOption/incrementalOffOn/expected-kotlin-caches.txt +++ b/jps-plugin/testData/incremental/changeIncrementalOption/incrementalOffOn/expected-kotlin-caches.txt @@ -7,6 +7,7 @@ kotlin-data-container Module 'module1' production format-version.txt jvm-build-meta-info.txt + class-attributes.tab class-fq-name-to-source.tab internal-name-to-source.tab proto.tab @@ -24,6 +25,7 @@ Module 'module2' tests Module 'module3' production format-version.txt jvm-build-meta-info.txt + class-attributes.tab class-fq-name-to-source.tab internal-name-to-source.tab proto.tab @@ -32,6 +34,7 @@ Module 'module3' tests Module 'module4' production format-version.txt jvm-build-meta-info.txt + class-attributes.tab class-fq-name-to-source.tab internal-name-to-source.tab proto.tab diff --git a/jps-plugin/testData/incremental/lazyKotlinCaches/class/expected-kotlin-caches.txt b/jps-plugin/testData/incremental/lazyKotlinCaches/class/expected-kotlin-caches.txt index f49b588520e..1572f363a50 100644 --- a/jps-plugin/testData/incremental/lazyKotlinCaches/class/expected-kotlin-caches.txt +++ b/jps-plugin/testData/incremental/lazyKotlinCaches/class/expected-kotlin-caches.txt @@ -7,6 +7,7 @@ kotlin-data-container Module 'module' production format-version.txt jvm-build-meta-info.txt + class-attributes.tab class-fq-name-to-source.tab internal-name-to-source.tab proto.tab diff --git a/jps-plugin/testData/incremental/lazyKotlinCaches/classInheritance/expected-kotlin-caches.txt b/jps-plugin/testData/incremental/lazyKotlinCaches/classInheritance/expected-kotlin-caches.txt index b4e54efb164..6ece0df56da 100644 --- a/jps-plugin/testData/incremental/lazyKotlinCaches/classInheritance/expected-kotlin-caches.txt +++ b/jps-plugin/testData/incremental/lazyKotlinCaches/classInheritance/expected-kotlin-caches.txt @@ -7,6 +7,7 @@ kotlin-data-container Module 'module' production format-version.txt jvm-build-meta-info.txt + class-attributes.tab class-fq-name-to-source.tab internal-name-to-source.tab proto.tab diff --git a/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddImplements/A.kt b/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddImplements/A.kt new file mode 100644 index 00000000000..e41a06d2875 --- /dev/null +++ b/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddImplements/A.kt @@ -0,0 +1,3 @@ +package test + +interface A : Base diff --git a/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddImplements/B.kt b/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddImplements/B.kt new file mode 100644 index 00000000000..324aaa75684 --- /dev/null +++ b/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddImplements/B.kt @@ -0,0 +1,3 @@ +package test + +interface B diff --git a/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddImplements/B.kt.new b/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddImplements/B.kt.new new file mode 100644 index 00000000000..cdc33c843df --- /dev/null +++ b/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddImplements/B.kt.new @@ -0,0 +1,3 @@ +package test + +interface B : Base diff --git a/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddImplements/Base.kt b/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddImplements/Base.kt new file mode 100644 index 00000000000..4e5675b150a --- /dev/null +++ b/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddImplements/Base.kt @@ -0,0 +1,3 @@ +package test + +sealed interface Base diff --git a/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddImplements/args.txt b/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddImplements/args.txt new file mode 100644 index 00000000000..56ea44cbedd --- /dev/null +++ b/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddImplements/args.txt @@ -0,0 +1 @@ +-XXLanguage:+FreedomForSealedClasses -XXLanguage:+SealedInterfaces diff --git a/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddImplements/build.log b/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddImplements/build.log new file mode 100644 index 00000000000..2b7405353a6 --- /dev/null +++ b/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddImplements/build.log @@ -0,0 +1,28 @@ +================ Step #1 ================= + +Cleaning output files: + out/production/module/META-INF/module.kotlin_module + out/production/module/test/B.class +End of files +Compiling files: + src/B.kt +End of files +Marked as dirty by Kotlin: + src/A.kt + src/B.kt + src/Base.kt +Exit code: ADDITIONAL_PASS_REQUIRED +------------------------------------------ +Cleaning output files: + out/production/module/META-INF/module.kotlin_module + out/production/module/test/A.class + out/production/module/test/B.class + out/production/module/test/Base.class +End of files +Compiling files: + src/A.kt + src/B.kt + src/Base.kt +End of files +Exit code: OK +------------------------------------------ diff --git a/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddImplements/sealedClassesAddImplements.jsklib.mute b/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddImplements/sealedClassesAddImplements.jsklib.mute new file mode 100644 index 00000000000..45f4097dd42 --- /dev/null +++ b/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddImplements/sealedClassesAddImplements.jsklib.mute @@ -0,0 +1 @@ +IC of sealed interfaces are not supported in JS diff --git a/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddImplements/С.kt b/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddImplements/С.kt new file mode 100644 index 00000000000..755dfbd73d4 --- /dev/null +++ b/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddImplements/С.kt @@ -0,0 +1,3 @@ +package test + +interface С diff --git a/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddInheritor/A.kt b/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddInheritor/A.kt new file mode 100644 index 00000000000..e41a06d2875 --- /dev/null +++ b/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddInheritor/A.kt @@ -0,0 +1,3 @@ +package test + +interface A : Base diff --git a/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddInheritor/B.kt b/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddInheritor/B.kt new file mode 100644 index 00000000000..cdc33c843df --- /dev/null +++ b/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddInheritor/B.kt @@ -0,0 +1,3 @@ +package test + +interface B : Base diff --git a/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddInheritor/Base.kt b/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddInheritor/Base.kt new file mode 100644 index 00000000000..4e5675b150a --- /dev/null +++ b/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddInheritor/Base.kt @@ -0,0 +1,3 @@ +package test + +sealed interface Base diff --git a/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddInheritor/C.kt.new b/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddInheritor/C.kt.new new file mode 100644 index 00000000000..da276aa99da --- /dev/null +++ b/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddInheritor/C.kt.new @@ -0,0 +1,3 @@ +package test + +interface C : Base diff --git a/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddInheritor/args.txt b/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddInheritor/args.txt new file mode 100644 index 00000000000..56ea44cbedd --- /dev/null +++ b/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddInheritor/args.txt @@ -0,0 +1 @@ +-XXLanguage:+FreedomForSealedClasses -XXLanguage:+SealedInterfaces diff --git a/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddInheritor/build.log b/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddInheritor/build.log new file mode 100644 index 00000000000..59554ef9cfa --- /dev/null +++ b/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddInheritor/build.log @@ -0,0 +1,27 @@ +================ Step #1 ================= + +Compiling files: + src/C.kt +End of files +Marked as dirty by Kotlin: + src/A.kt + src/B.kt + src/Base.kt + src/C.kt +Exit code: ADDITIONAL_PASS_REQUIRED +------------------------------------------ +Cleaning output files: + out/production/module/META-INF/module.kotlin_module + out/production/module/test/A.class + out/production/module/test/B.class + out/production/module/test/Base.class + out/production/module/test/C.class +End of files +Compiling files: + src/A.kt + src/B.kt + src/Base.kt + src/C.kt +End of files +Exit code: OK +------------------------------------------ diff --git a/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddInheritor/sealedClassesAddInheritor.jsklib.mute b/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddInheritor/sealedClassesAddInheritor.jsklib.mute new file mode 100644 index 00000000000..45f4097dd42 --- /dev/null +++ b/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddInheritor/sealedClassesAddInheritor.jsklib.mute @@ -0,0 +1 @@ +IC of sealed interfaces are not supported in JS diff --git a/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveImplements/A.kt b/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveImplements/A.kt new file mode 100644 index 00000000000..e41a06d2875 --- /dev/null +++ b/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveImplements/A.kt @@ -0,0 +1,3 @@ +package test + +interface A : Base diff --git a/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveImplements/B.kt b/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveImplements/B.kt new file mode 100644 index 00000000000..cdc33c843df --- /dev/null +++ b/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveImplements/B.kt @@ -0,0 +1,3 @@ +package test + +interface B : Base diff --git a/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveImplements/B.kt.new b/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveImplements/B.kt.new new file mode 100644 index 00000000000..25bf4d005ba --- /dev/null +++ b/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveImplements/B.kt.new @@ -0,0 +1,4 @@ +package test + +interface B + diff --git a/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveImplements/Base.kt b/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveImplements/Base.kt new file mode 100644 index 00000000000..4e5675b150a --- /dev/null +++ b/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveImplements/Base.kt @@ -0,0 +1,3 @@ +package test + +sealed interface Base diff --git a/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveImplements/BaseUsage.kt b/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveImplements/BaseUsage.kt new file mode 100644 index 00000000000..f2533e11978 --- /dev/null +++ b/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveImplements/BaseUsage.kt @@ -0,0 +1,5 @@ +package test + +class C { + lateinit var base: Base +} diff --git a/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveImplements/args.txt b/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveImplements/args.txt new file mode 100644 index 00000000000..56ea44cbedd --- /dev/null +++ b/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveImplements/args.txt @@ -0,0 +1 @@ +-XXLanguage:+FreedomForSealedClasses -XXLanguage:+SealedInterfaces diff --git a/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveImplements/build.log b/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveImplements/build.log new file mode 100644 index 00000000000..379d4b734e1 --- /dev/null +++ b/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveImplements/build.log @@ -0,0 +1,39 @@ +================ Step #1 ================= + +Cleaning output files: + out/production/module/META-INF/module.kotlin_module + out/production/module/test/B.class +End of files +Compiling files: + src/B.kt +End of files +Marked as dirty by Kotlin: + src/A.kt + src/B.kt + src/Base.kt +Exit code: ADDITIONAL_PASS_REQUIRED +------------------------------------------ +Cleaning output files: + out/production/module/META-INF/module.kotlin_module + out/production/module/test/A.class + out/production/module/test/B.class + out/production/module/test/Base.class +End of files +Compiling files: + src/A.kt + src/B.kt + src/Base.kt +End of files +Marked as dirty by Kotlin: + src/BaseUsage.kt +Exit code: ADDITIONAL_PASS_REQUIRED +------------------------------------------ +Cleaning output files: + out/production/module/META-INF/module.kotlin_module + out/production/module/test/C.class +End of files +Compiling files: + src/BaseUsage.kt +End of files +Exit code: OK +------------------------------------------ diff --git a/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveImplements/sealedClassesRemoveImplements.jsklib.mute b/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveImplements/sealedClassesRemoveImplements.jsklib.mute new file mode 100644 index 00000000000..45f4097dd42 --- /dev/null +++ b/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveImplements/sealedClassesRemoveImplements.jsklib.mute @@ -0,0 +1 @@ +IC of sealed interfaces are not supported in JS diff --git a/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveInheritor/A.kt b/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveInheritor/A.kt new file mode 100644 index 00000000000..e41a06d2875 --- /dev/null +++ b/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveInheritor/A.kt @@ -0,0 +1,3 @@ +package test + +interface A : Base diff --git a/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveInheritor/B.kt b/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveInheritor/B.kt new file mode 100644 index 00000000000..cdc33c843df --- /dev/null +++ b/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveInheritor/B.kt @@ -0,0 +1,3 @@ +package test + +interface B : Base diff --git a/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveInheritor/B.kt.delete b/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveInheritor/B.kt.delete new file mode 100644 index 00000000000..e69de29bb2d diff --git a/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveInheritor/Base.kt b/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveInheritor/Base.kt new file mode 100644 index 00000000000..4e5675b150a --- /dev/null +++ b/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveInheritor/Base.kt @@ -0,0 +1,3 @@ +package test + +sealed interface Base diff --git a/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveInheritor/BaseUsage.kt b/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveInheritor/BaseUsage.kt new file mode 100644 index 00000000000..f2533e11978 --- /dev/null +++ b/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveInheritor/BaseUsage.kt @@ -0,0 +1,5 @@ +package test + +class C { + lateinit var base: Base +} diff --git a/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveInheritor/args.txt b/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveInheritor/args.txt new file mode 100644 index 00000000000..56ea44cbedd --- /dev/null +++ b/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveInheritor/args.txt @@ -0,0 +1 @@ +-XXLanguage:+FreedomForSealedClasses -XXLanguage:+SealedInterfaces diff --git a/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveInheritor/build.log b/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveInheritor/build.log new file mode 100644 index 00000000000..cb874b1df7b --- /dev/null +++ b/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveInheritor/build.log @@ -0,0 +1,35 @@ +================ Step #1 ================= + +Cleaning output files: + out/production/module/META-INF/module.kotlin_module + out/production/module/test/B.class +End of files +Compiling files: +End of files +Marked as dirty by Kotlin: + src/A.kt + src/Base.kt +Exit code: ADDITIONAL_PASS_REQUIRED +------------------------------------------ +Cleaning output files: + out/production/module/META-INF/module.kotlin_module + out/production/module/test/A.class + out/production/module/test/Base.class +End of files +Compiling files: + src/A.kt + src/Base.kt +End of files +Marked as dirty by Kotlin: + src/BaseUsage.kt +Exit code: ADDITIONAL_PASS_REQUIRED +------------------------------------------ +Cleaning output files: + out/production/module/META-INF/module.kotlin_module + out/production/module/test/C.class +End of files +Compiling files: + src/BaseUsage.kt +End of files +Exit code: OK +------------------------------------------ diff --git a/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveInheritor/sealedClassesRemoveInheritor.jsklib.mute b/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveInheritor/sealedClassesRemoveInheritor.jsklib.mute new file mode 100644 index 00000000000..45f4097dd42 --- /dev/null +++ b/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveInheritor/sealedClassesRemoveInheritor.jsklib.mute @@ -0,0 +1 @@ +IC of sealed interfaces are not supported in JS diff --git a/jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/A.kt b/jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/A.kt new file mode 100644 index 00000000000..e41a06d2875 --- /dev/null +++ b/jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/A.kt @@ -0,0 +1,3 @@ +package test + +interface A : Base diff --git a/jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/B.kt b/jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/B.kt new file mode 100644 index 00000000000..cdc33c843df --- /dev/null +++ b/jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/B.kt @@ -0,0 +1,3 @@ +package test + +interface B : Base diff --git a/jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/Base.kt b/jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/Base.kt new file mode 100644 index 00000000000..4e5675b150a --- /dev/null +++ b/jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/Base.kt @@ -0,0 +1,3 @@ +package test + +sealed interface Base diff --git a/jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/C.kt.new b/jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/C.kt.new new file mode 100644 index 00000000000..da276aa99da --- /dev/null +++ b/jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/C.kt.new @@ -0,0 +1,3 @@ +package test + +interface C : Base diff --git a/jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/D.kt b/jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/D.kt new file mode 100644 index 00000000000..71237657cd9 --- /dev/null +++ b/jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/D.kt @@ -0,0 +1,5 @@ +package test + +class D { + lateinit var x: Base +} diff --git a/jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/E.kt b/jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/E.kt new file mode 100644 index 00000000000..7a1c3583390 --- /dev/null +++ b/jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/E.kt @@ -0,0 +1,4 @@ +package test + +class E { +} diff --git a/jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/args.txt b/jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/args.txt new file mode 100644 index 00000000000..56ea44cbedd --- /dev/null +++ b/jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/args.txt @@ -0,0 +1 @@ +-XXLanguage:+FreedomForSealedClasses -XXLanguage:+SealedInterfaces diff --git a/jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/build.log b/jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/build.log new file mode 100644 index 00000000000..d1581952b1f --- /dev/null +++ b/jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/build.log @@ -0,0 +1,38 @@ +================ Step #1 ================= + +Compiling files: + src/C.kt +End of files +Marked as dirty by Kotlin: + src/A.kt + src/B.kt + src/Base.kt + src/C.kt +Exit code: ADDITIONAL_PASS_REQUIRED +------------------------------------------ +Cleaning output files: + out/production/module/META-INF/module.kotlin_module + out/production/module/test/A.class + out/production/module/test/B.class + out/production/module/test/Base.class + out/production/module/test/C.class +End of files +Compiling files: + src/A.kt + src/B.kt + src/Base.kt + src/C.kt +End of files +Marked as dirty by Kotlin: + src/D.kt +Exit code: ADDITIONAL_PASS_REQUIRED +------------------------------------------ +Cleaning output files: + out/production/module/META-INF/module.kotlin_module + out/production/module/test/D.class +End of files +Compiling files: + src/D.kt +End of files +Exit code: OK +------------------------------------------ diff --git a/jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/sealedClassesUseSwitch.jsklib.mute b/jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/sealedClassesUseSwitch.jsklib.mute new file mode 100644 index 00000000000..45f4097dd42 --- /dev/null +++ b/jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/sealedClassesUseSwitch.jsklib.mute @@ -0,0 +1 @@ +IC of sealed interfaces are not supported in JS From af95b8d1fe868be8f120a7a4b15d46a9e45fb487 Mon Sep 17 00:00:00 2001 From: Andrey Uskov Date: Sun, 13 Dec 2020 10:50:27 +0300 Subject: [PATCH 003/196] Add explicit path sensitivity for InspectClassesForMultiModuleIC Gradle uses PathSensitivity.ABSOLUTE by default, so this change just explicitly specifies it in order to avoid warnings. #KT-43895 Fixed --- .../kotlin/gradle/tasks/InspectClassesForMultiModuleIC.kt | 2 ++ 1 file changed, 2 insertions(+) diff --git a/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/tasks/InspectClassesForMultiModuleIC.kt b/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/tasks/InspectClassesForMultiModuleIC.kt index ce8025d80ac..5763773a1d1 100644 --- a/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/tasks/InspectClassesForMultiModuleIC.kt +++ b/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/tasks/InspectClassesForMultiModuleIC.kt @@ -31,6 +31,7 @@ internal open class InspectClassesForMultiModuleIC : DefaultTask() { (project.kotlinExtension as KotlinSingleJavaTargetExtension).target.defaultArtifactClassesListFile.get() } + @get:PathSensitive(PathSensitivity.ABSOLUTE) @get:InputFiles internal val sourceSetOutputClassesDir by lazy { project.convention.findPlugin(JavaPluginConvention::class.java)?.sourceSets?.findByName(sourceSetName)?.output?.classesDirs @@ -50,6 +51,7 @@ internal open class InspectClassesForMultiModuleIC : DefaultTask() { internal val objects = project.objects @Suppress("MemberVisibilityCanBePrivate") + @get:PathSensitive(PathSensitivity.ABSOLUTE) @get:InputFiles internal val classFiles: FileCollection get() { From 275a02ce88e44f144bbb5f0718cfb223cd429051 Mon Sep 17 00:00:00 2001 From: Andrey Uskov Date: Thu, 12 Nov 2020 17:25:18 +0300 Subject: [PATCH 004/196] Fix synchronization when working with IC caches IC caches could be modified and read from different threads. In JPS builder these threads are RMI worker (invoked from Compiler Daemon) and JPS worker thread. Proper synchronization fixes cases when caches could become broken. #KT-42265 Fixed #KT-42194 Fixed #KT-42265 Fixed #KT-42937 Fixed --- .../kotlin/incremental/AbstractIncrementalCache.kt | 4 ++-- .../kotlin/incremental/IncrementalJvmCache.kt | 11 +++++++++++ .../kotlin/incremental/storage/BasicMapsOwner.kt | 3 +++ .../kotlin/incremental/storage/CachingLazyStorage.kt | 7 +++++-- .../kotlin/incremental/storage/ClassOneToManyMap.kt | 12 ++++++++---- .../incremental/storage/NonCachingLazyStorage.kt | 12 +++++++----- .../kotlin/incremental/IncrementalCachesManager.kt | 11 ++++++++++- .../kotlin/incremental/IncrementalCompilerRunner.kt | 10 +++++++--- .../kotlin/incremental/snapshots/FileSnapshotMap.kt | 1 + .../incremental/storage/SourceToOutputFilesMap.kt | 2 ++ 10 files changed, 56 insertions(+), 17 deletions(-) diff --git a/build-common/src/org/jetbrains/kotlin/incremental/AbstractIncrementalCache.kt b/build-common/src/org/jetbrains/kotlin/incremental/AbstractIncrementalCache.kt index 337c09af52b..c768fa3a8cb 100644 --- a/build-common/src/org/jetbrains/kotlin/incremental/AbstractIncrementalCache.kt +++ b/build-common/src/org/jetbrains/kotlin/incremental/AbstractIncrementalCache.kt @@ -176,8 +176,8 @@ abstract class AbstractIncrementalCache( protected class ClassFqNameToSourceMap( storageFile: File, private val pathConverter: FileToPathConverter - ) : - BasicStringMap(storageFile, EnumeratorStringDescriptor(), PathStringDescriptor) { + ) : BasicStringMap(storageFile, EnumeratorStringDescriptor(), PathStringDescriptor) { + operator fun set(fqName: FqName, sourceFile: File) { storage[fqName.asString()] = pathConverter.toPath(sourceFile) } diff --git a/build-common/src/org/jetbrains/kotlin/incremental/IncrementalJvmCache.kt b/build-common/src/org/jetbrains/kotlin/incremental/IncrementalJvmCache.kt index c5f01e1824b..84d75a417d6 100644 --- a/build-common/src/org/jetbrains/kotlin/incremental/IncrementalJvmCache.kt +++ b/build-common/src/org/jetbrains/kotlin/incremental/IncrementalJvmCache.kt @@ -272,6 +272,7 @@ open class IncrementalJvmCache( private inner class ProtoMap(storageFile: File) : BasicStringMap(storageFile, ProtoMapValueExternalizer) { + @Synchronized fun process(kotlinClass: LocalFileKotlinClass, changesCollector: ChangesCollector) { return put(kotlinClass, changesCollector) } @@ -283,10 +284,12 @@ open class IncrementalJvmCache( // from files compiled during last round. // However there is no need to compare old and new data in this case // (also that would fail with exception). + @Synchronized fun storeModuleMapping(className: JvmClassName, bytes: ByteArray) { storage[className.internalName] = ProtoMapValue(isPackageFacade = false, bytes = bytes, strings = emptyArray()) } + @Synchronized private fun put(kotlinClass: LocalFileKotlinClass, changesCollector: ChangesCollector) { val header = kotlinClass.classHeader @@ -309,6 +312,7 @@ open class IncrementalJvmCache( operator fun get(className: JvmClassName): ProtoMapValue? = storage[className.internalName] + @Synchronized fun remove(className: JvmClassName, changesCollector: ChangesCollector) { val key = className.internalName val oldValue = storage[key] ?: return @@ -325,6 +329,8 @@ open class IncrementalJvmCache( private inner class JavaSourcesProtoMap(storageFile: File) : BasicStringMap(storageFile, JavaClassProtoMapValueExternalizer) { + + @Synchronized fun process(jvmClassName: JvmClassName, newData: SerializedJavaClass, changesCollector: ChangesCollector) { val key = jvmClassName.internalName val oldData = storage[key] @@ -336,6 +342,7 @@ open class IncrementalJvmCache( ) } + @Synchronized fun remove(className: JvmClassName, changesCollector: ChangesCollector) { val key = className.internalName val oldValue = storage[key] ?: return @@ -375,6 +382,7 @@ open class IncrementalJvmCache( operator fun contains(className: JvmClassName): Boolean = className.internalName in storage + @Synchronized fun process(kotlinClass: LocalFileKotlinClass, changesCollector: ChangesCollector) { val key = kotlinClass.className.internalName val oldMap = storage[key] ?: emptyMap() @@ -391,6 +399,7 @@ open class IncrementalJvmCache( } } + @Synchronized fun remove(className: JvmClassName) { storage.remove(className.internalName) } @@ -523,6 +532,7 @@ open class IncrementalJvmCache( return result } + @Synchronized fun process(kotlinClass: LocalFileKotlinClass, changesCollector: ChangesCollector) { val key = kotlinClass.className.internalName val oldMap = storage[key] ?: emptyMap() @@ -548,6 +558,7 @@ open class IncrementalJvmCache( private fun functionNameBySignature(signature: String): String = signature.substringBefore("(") + @Synchronized fun remove(className: JvmClassName) { storage.remove(className.internalName) } diff --git a/build-common/src/org/jetbrains/kotlin/incremental/storage/BasicMapsOwner.kt b/build-common/src/org/jetbrains/kotlin/incremental/storage/BasicMapsOwner.kt index 571f26bb968..57d90607c4f 100644 --- a/build-common/src/org/jetbrains/kotlin/incremental/storage/BasicMapsOwner.kt +++ b/build-common/src/org/jetbrains/kotlin/incremental/storage/BasicMapsOwner.kt @@ -30,6 +30,7 @@ open class BasicMapsOwner(val cachesDir: File) { protected val String.storageFile: File get() = File(cachesDir, this + "." + CACHE_EXTENSION) + @Synchronized protected fun > registerMap(map: M): M { maps.add(map) return map @@ -47,6 +48,7 @@ open class BasicMapsOwner(val cachesDir: File) { forEachMapSafe("flush") { it.flush(memoryCachesOnly) } } + @Synchronized private fun forEachMapSafe(actionName: String, action: (BasicMap<*, *>) -> Unit) { val actionExceptions = LinkedHashMap() maps.forEach { @@ -66,5 +68,6 @@ open class BasicMapsOwner(val cachesDir: File) { } @TestOnly + @Synchronized fun dump(): String = maps.joinToString("\n\n") { it.dump() } } \ No newline at end of file diff --git a/build-common/src/org/jetbrains/kotlin/incremental/storage/CachingLazyStorage.kt b/build-common/src/org/jetbrains/kotlin/incremental/storage/CachingLazyStorage.kt index 360a4e517b1..7e4a25c2ada 100644 --- a/build-common/src/org/jetbrains/kotlin/incremental/storage/CachingLazyStorage.kt +++ b/build-common/src/org/jetbrains/kotlin/incremental/storage/CachingLazyStorage.kt @@ -17,9 +17,11 @@ package org.jetbrains.kotlin.incremental.storage import com.intellij.util.io.DataExternalizer +import com.intellij.util.io.IOUtil import com.intellij.util.io.KeyDescriptor import com.intellij.util.io.PersistentHashMap import java.io.File +import java.io.IOException /** @@ -30,7 +32,6 @@ class CachingLazyStorage( private val keyDescriptor: KeyDescriptor, private val valueExternalizer: DataExternalizer ) : LazyStorage { - @Volatile private var storage: PersistentHashMap? = null @Synchronized @@ -80,8 +81,10 @@ class CachingLazyStorage( try { storage?.close() } finally { - PersistentHashMap.deleteFilesStartingWith(storageFile) storage = null + if (!IOUtil.deleteAllFilesStartingWith(storageFile)) { + throw IOException("Could not delete internal storage: ${storageFile.absolutePath}") + } } } diff --git a/build-common/src/org/jetbrains/kotlin/incremental/storage/ClassOneToManyMap.kt b/build-common/src/org/jetbrains/kotlin/incremental/storage/ClassOneToManyMap.kt index 6549c96224a..f06524591b6 100644 --- a/build-common/src/org/jetbrains/kotlin/incremental/storage/ClassOneToManyMap.kt +++ b/build-common/src/org/jetbrains/kotlin/incremental/storage/ClassOneToManyMap.kt @@ -20,18 +20,18 @@ import org.jetbrains.kotlin.incremental.dumpCollection import org.jetbrains.kotlin.name.FqName import java.io.File -internal open class ClassOneToManyMap( - storageFile: File -) : BasicStringMap>(storageFile, StringCollectionExternalizer) { +internal open class ClassOneToManyMap(storageFile: File) : BasicStringMap>(storageFile, StringCollectionExternalizer) { override fun dumpValue(value: Collection): String = value.dumpCollection() + @Synchronized fun add(key: FqName, value: FqName) { storage.append(key.asString(), listOf(value.asString())) } operator fun get(key: FqName): Collection = - storage[key.asString()]?.map(::FqName) ?: setOf() + storage[key.asString()]?.map(::FqName) ?: setOf() + @Synchronized operator fun set(key: FqName, values: Collection) { if (values.isEmpty()) { remove(key) @@ -41,10 +41,14 @@ internal open class ClassOneToManyMap( storage[key.asString()] = values.map(FqName::asString) } + @Synchronized fun remove(key: FqName) { storage.remove(key.asString()) } + // Access to caches could be done from multiple threads (e.g. JPS worker and RMI). The underlying collection is already synchronized, + // thus we need synchronization of this method and all modification methods. + @Synchronized fun removeValues(key: FqName, removed: Set) { val notRemoved = this[key].filter { it !in removed } this[key] = notRemoved diff --git a/build-common/src/org/jetbrains/kotlin/incremental/storage/NonCachingLazyStorage.kt b/build-common/src/org/jetbrains/kotlin/incremental/storage/NonCachingLazyStorage.kt index 614426e0b1e..755ea8262ec 100644 --- a/build-common/src/org/jetbrains/kotlin/incremental/storage/NonCachingLazyStorage.kt +++ b/build-common/src/org/jetbrains/kotlin/incremental/storage/NonCachingLazyStorage.kt @@ -17,9 +17,11 @@ package org.jetbrains.kotlin.incremental.storage import com.intellij.util.io.DataExternalizer +import com.intellij.util.io.IOUtil import com.intellij.util.io.KeyDescriptor import com.intellij.util.io.PersistentHashMap import java.io.File +import java.io.IOException class NonCachingLazyStorage( @@ -27,7 +29,6 @@ class NonCachingLazyStorage( private val keyDescriptor: KeyDescriptor, private val valueExternalizer: DataExternalizer ) : LazyStorage { - @Volatile private var storage: PersistentHashMap? = null @Synchronized @@ -76,11 +77,12 @@ class NonCachingLazyStorage( override fun clean() { try { storage?.close() - } catch (ignored: Throwable) { + } finally { + storage = null + if (!IOUtil.deleteAllFilesStartingWith(storageFile)) { + throw IOException("Could not delete internal storage: ${storageFile.absolutePath}") + } } - - PersistentHashMap.deleteFilesStartingWith(storageFile) - storage = null } @Synchronized diff --git a/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalCachesManager.kt b/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalCachesManager.kt index c529463ac24..83c8bb1f881 100644 --- a/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalCachesManager.kt +++ b/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalCachesManager.kt @@ -30,7 +30,12 @@ abstract class IncrementalCachesManager() + + var isClosed = false + + @Synchronized protected fun T.registerCache() { + assert(!isClosed) { "Attempted to add new cache into closed storage." } caches.add(this) } @@ -41,9 +46,12 @@ abstract class IncrementalCachesManager(storageF override fun dumpValue(value: FileSnapshot): String = value.toString() + @Synchronized fun compareAndUpdate(newFiles: Iterable): ChangedFiles.Known { val snapshotProvider = SimpleFileSnapshotProviderImpl() val newOrModified = ArrayList() diff --git a/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/storage/SourceToOutputFilesMap.kt b/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/storage/SourceToOutputFilesMap.kt index 18448f56799..28032db9d44 100644 --- a/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/storage/SourceToOutputFilesMap.kt +++ b/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/storage/SourceToOutputFilesMap.kt @@ -12,6 +12,7 @@ class SourceToOutputFilesMap( storageFile: File ) : BasicStringMap>(storageFile, PathStringDescriptor, StringCollectionExternalizer) { + @Synchronized operator fun set(sourceFile: File, outputFiles: Collection) { storage[sourceFile.absolutePath] = outputFiles.map { it.absolutePath } } @@ -22,6 +23,7 @@ class SourceToOutputFilesMap( override fun dumpValue(value: Collection) = value.dumpCollection() + @Synchronized fun remove(file: File): Collection = get(file).also { storage.remove(file.absolutePath) } } \ No newline at end of file From 7bdd7ce6b8027033255f92349993eefc6f8435e9 Mon Sep 17 00:00:00 2001 From: Andrey Uskov Date: Thu, 19 Nov 2020 23:16:30 +0300 Subject: [PATCH 005/196] Reformat DirtyClassesMap --- .../kotlin/incremental/storage/DirtyClassesMaps.kt | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/build-common/src/org/jetbrains/kotlin/incremental/storage/DirtyClassesMaps.kt b/build-common/src/org/jetbrains/kotlin/incremental/storage/DirtyClassesMaps.kt index 5a158e3bea5..a6673385706 100644 --- a/build-common/src/org/jetbrains/kotlin/incremental/storage/DirtyClassesMaps.kt +++ b/build-common/src/org/jetbrains/kotlin/incremental/storage/DirtyClassesMaps.kt @@ -25,8 +25,7 @@ internal class DirtyClassesJvmNameMap(storageFile: File) : AbstractDirtyClassesM internal class DirtyClassesFqNameMap(storageFile: File) : AbstractDirtyClassesMap(FqNameTransformer, storageFile) internal abstract class AbstractDirtyClassesMap( - private val nameTransformer: NameTransformer, - storageFile: File + private val nameTransformer: NameTransformer, storageFile: File ) : BasicStringMap(storageFile, BooleanDataDescriptor.INSTANCE) { fun markDirty(className: Name) { storage[nameTransformer.asString(className)] = true @@ -37,10 +36,10 @@ internal abstract class AbstractDirtyClassesMap( } fun getDirtyOutputClasses(): Collection = - storage.keys.map { nameTransformer.asName(it) } + storage.keys.map { nameTransformer.asName(it) } fun isDirty(className: Name): Boolean = - storage.contains(nameTransformer.asString(className)) + storage.contains(nameTransformer.asString(className)) override fun dumpValue(value: Boolean) = "" } From 9be7221efdac17d25b3cecea859de59cab3d955e Mon Sep 17 00:00:00 2001 From: Andrey Uskov Date: Sun, 13 Dec 2020 11:24:56 +0300 Subject: [PATCH 006/196] Clear IC caches if they were not properly closed --- .../incremental/IncrementalCompilerRunner.kt | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalCompilerRunner.kt b/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalCompilerRunner.kt index f8d44d2b79e..6d5b1c0d6a2 100644 --- a/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalCompilerRunner.kt +++ b/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalCompilerRunner.kt @@ -98,10 +98,9 @@ abstract class IncrementalCompilerRunner< val allKotlinFiles = allSourceFiles.filter { it.isKotlinFile(kotlinSourceFilesExtensions) } return compileIncrementally(args, caches, allKotlinFiles, CompilationMode.Rebuild(reason), messageCollector) } - // attempt IC - // if OK or failed compilation - return - // internal error - clear - // failed to close - clear + + // If compilation has crashed or we failed to close caches we have to clear them + var cachesMayBeCorrupted = true return try { val changedFiles = providedChangedFiles ?: caches.inputsCache.sourceSnapshotMap.compareAndUpdate(allSourceFiles) val compilationMode = sourcesToCompile(caches, changedFiles, args, messageCollector) @@ -116,12 +115,18 @@ abstract class IncrementalCompilerRunner< } if (!caches.close(flush = true)) throw RuntimeException("Could not flush caches") - + // Here we should analyze exit code of compiler. E.g. compiler failure should lead to caches rebuild, + // but now JsKlib compiler reports invalid exit code. + cachesMayBeCorrupted = false return exitCode } catch (e: Exception) { // todo: catch only cache corruption // todo: warn? reporter.report { "Rebuilding because of possible caches corruption: $e" } rebuild(BuildAttribute.CACHE_CORRUPTION) + } finally { + if (cachesMayBeCorrupted) { + clearLocalStateOnRebuild(args) + } } } From 0a2269cccbe559f4051a99584d0e76efdb2dc893 Mon Sep 17 00:00:00 2001 From: Andrey Uskov Date: Sun, 13 Dec 2020 11:40:46 +0300 Subject: [PATCH 007/196] Fixed out-of-process compiler execution if project directy is absent If project directory does not exist and out-of-process execution is used the file with compiler arguments should be created in project directory (if exists) or in temp directory. #KT-43740 Fixed --- .../org/jetbrains/kotlin/compilerRunner/reportUtils.kt | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/compilerRunner/reportUtils.kt b/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/compilerRunner/reportUtils.kt index 0a5ea37eeae..db4d36918d6 100644 --- a/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/compilerRunner/reportUtils.kt +++ b/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/compilerRunner/reportUtils.kt @@ -126,8 +126,12 @@ internal fun runToolInSeparateProcess( } private fun writeArgumentsToFile(directory: File, argsArray: Array): File { - val compilerOptions = - Files.createTempFile(directory.toPath(), LocalDateTime.now().format(DateTimeFormatter.BASIC_ISO_DATE) + "_", ".compiler.options").toFile() + val prefix = LocalDateTime.now().format(DateTimeFormatter.BASIC_ISO_DATE) + "_" + val suffix = ".compiler.options" + val compilerOptions = if (directory.exists()) + Files.createTempFile(directory.toPath(), prefix, suffix).toFile() + else + Files.createTempFile(prefix, suffix).toFile() compilerOptions.deleteOnExit() compilerOptions.writeText(argsArray.joinToString(" ") { "\"${StringEscapeUtils.escapeJava(it)}\"" }) return compilerOptions From 55b0775565ffa38eb7c392ccb63ac60b1b0cfb62 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Mon, 14 Dec 2020 10:42:24 +0300 Subject: [PATCH 008/196] [FE] Call SealedClassInheritorsProvider only for sealed classes --- .../resolve/lazy/descriptors/LazyClassDescriptor.java | 10 +++++++++- .../kotlin/resolve/SealedClassInheritorsProvider.kt | 3 +++ .../commonizer/builder/CommonizedClassDescriptor.kt | 6 +++++- 3 files changed, 17 insertions(+), 2 deletions(-) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java index d6d9790b64a..737e48b10e4 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java @@ -54,6 +54,7 @@ import java.util.Collection; import java.util.Collections; import java.util.List; +import static kotlin.collections.CollectionsKt.emptyList; import static kotlin.collections.CollectionsKt.firstOrNull; import static org.jetbrains.kotlin.descriptors.DescriptorVisibilities.PRIVATE; import static org.jetbrains.kotlin.descriptors.DescriptorVisibilities.PUBLIC; @@ -270,7 +271,14 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes ); boolean freedomForSealedInterfacesSupported = c.getLanguageVersionSettings().supportsFeature(LanguageFeature.AllowSealedInheritorsInDifferentFilesOfSamePackage); - this.sealedSubclasses = storageManager.createLazyValue(() -> c.getSealedClassInheritorsProvider().computeSealedSubclasses(this, freedomForSealedInterfacesSupported)); + this.sealedSubclasses = + storageManager.createLazyValue(() -> { + if (getModality() == Modality.SEALED) { + return c.getSealedClassInheritorsProvider().computeSealedSubclasses(this, freedomForSealedInterfacesSupported); + } else { + return Collections.emptyList(); + } + }); } private static boolean isIllegalInner(@NotNull DeclarationDescriptor descriptor) { diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/SealedClassInheritorsProvider.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/SealedClassInheritorsProvider.kt index 7f663f6f0d2..0927584612e 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/resolve/SealedClassInheritorsProvider.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/SealedClassInheritorsProvider.kt @@ -13,6 +13,9 @@ import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter import org.jetbrains.kotlin.resolve.scopes.MemberScope abstract class SealedClassInheritorsProvider { + /** + * This method may be called by compiler only for classes/interfaces with sealed modality + */ abstract fun computeSealedSubclasses( sealedClass: ClassDescriptor, freedomForSealedInterfacesSupported: Boolean diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/builder/CommonizedClassDescriptor.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/builder/CommonizedClassDescriptor.kt index 9cc4543f360..3404c4cd519 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/builder/CommonizedClassDescriptor.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/builder/CommonizedClassDescriptor.kt @@ -54,7 +54,11 @@ class CommonizedClassDescriptor( private val typeConstructor = CommonizedClassTypeConstructor(targetComponents, cirSupertypes) private val sealedSubclasses = targetComponents.storageManager.createLazyValue { // TODO: pass proper language version settings - SealedClassInheritorsProviderImpl.computeSealedSubclasses(this, freedomForSealedInterfacesSupported = false) + if (modality == Modality.SEALED) { + SealedClassInheritorsProviderImpl.computeSealedSubclasses(this, freedomForSealedInterfacesSupported = false) + } else { + emptyList() + } } private val declaredTypeParametersAndTypeParameterResolver = targetComponents.storageManager.createLazyValue { From 0a3f3bef51eebd55c66249d17d5ba47b6ded896d Mon Sep 17 00:00:00 2001 From: Ilya Goncharov Date: Thu, 10 Dec 2020 15:43:41 +0300 Subject: [PATCH 009/196] [Gradle, JS]Process error output and rethrow errors and warns to console ^KT-43869 fixed --- .../internal/TeamCityMessageCommonClient.kt | 16 ++++++-- .../jetbrains/kotlin/gradle/internal/exec.kt | 8 ++-- .../targets/js/webpack/KotlinWebpackRunner.kt | 38 +++++++++++-------- 3 files changed, 39 insertions(+), 23 deletions(-) diff --git a/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/internal/TeamCityMessageCommonClient.kt b/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/internal/TeamCityMessageCommonClient.kt index 1ef8b70d4e6..e43dccccd0e 100644 --- a/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/internal/TeamCityMessageCommonClient.kt +++ b/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/internal/TeamCityMessageCommonClient.kt @@ -14,6 +14,7 @@ import org.jetbrains.kotlin.gradle.utils.clearAnsiColor import java.text.ParseException class TeamCityMessageCommonClient( + internal val clientType: LogType, internal val log: Logger ) : ServiceMessageParserCallback { @@ -43,9 +44,12 @@ class TeamCityMessageCommonClient( afterMessage = true } - internal fun testFailedMessage(): String { - return errors - .joinToString("\n") + internal fun testFailedMessage(): String? { + return if (errors.isNotEmpty()) + errors + .joinToString("\n") + else + null } private fun printMessage(text: String, type: LogType?) { @@ -74,6 +78,10 @@ class TeamCityMessageCommonClient( } override fun regularText(text: String) { - printMessage(text, LogType.DEBUG) + if (clientType == LogType.ERROR || clientType == LogType.WARN) { + printMessage(text, clientType) + } else { + printMessage(text, LogType.DEBUG) + } } } \ No newline at end of file diff --git a/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/internal/exec.kt b/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/internal/exec.kt index 5cd9218efee..c2cc1834c84 100644 --- a/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/internal/exec.kt +++ b/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/internal/exec.kt @@ -71,19 +71,21 @@ internal fun Project.execWithProgress(description: String, readStdErr: Boolean = internal fun Project.execWithErrorLogger( description: String, - body: (ExecAction, ProgressLogger) -> TeamCityMessageCommonClient + body: (ExecAction, ProgressLogger) -> Pair ): ExecResult { this as ProjectInternal val exec = services.get(ExecActionFactory::class.java).newExecAction() return project!!.operation(description) { progress(description) - val client = body(exec, this) + val (standardClient, errorClient) = body(exec, this) exec.isIgnoreExitValue = true val result = exec.execute() if (result.exitValue != 0) { error( - client.testFailedMessage() + errorClient.testFailedMessage() + ?: standardClient.testFailedMessage() + ?: "Error occurred. See log for details." ) } result diff --git a/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/targets/js/webpack/KotlinWebpackRunner.kt b/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/targets/js/webpack/KotlinWebpackRunner.kt index 5ab35d23639..d39cccd7ccb 100644 --- a/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/targets/js/webpack/KotlinWebpackRunner.kt +++ b/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/targets/js/webpack/KotlinWebpackRunner.kt @@ -9,6 +9,7 @@ import org.gradle.internal.logging.progress.ProgressLogger import org.gradle.process.ExecSpec import org.gradle.process.internal.ExecHandle import org.gradle.process.internal.ExecHandleFactory +import org.jetbrains.kotlin.gradle.internal.LogType import org.jetbrains.kotlin.gradle.internal.TeamCityMessageCommonClient import org.jetbrains.kotlin.gradle.internal.execWithErrorLogger import org.jetbrains.kotlin.gradle.internal.testing.TCServiceMessageOutputStreamHandler @@ -25,29 +26,29 @@ internal data class KotlinWebpackRunner( val config: KotlinWebpackConfig ) { fun execute() = npmProject.project.execWithErrorLogger("webpack") { execAction, progressLogger -> - val client = configureClient(progressLogger) - client.apply { - configureExec( - execAction, - client - ) - } + configureExec( + execAction, + progressLogger + ) } fun start(): ExecHandle { val execFactory = execHandleFactory.newExec() configureExec( execFactory, - configureClient(null) + null ) val exec = execFactory.build() exec.start() return exec } - private fun configureClient(progressLogger: ProgressLogger?): TeamCityMessageCommonClient { + private fun configureClient( + clientType: LogType, + progressLogger: ProgressLogger? + ): TeamCityMessageCommonClient { val logger = npmProject.project.logger - return TeamCityMessageCommonClient(logger) + return TeamCityMessageCommonClient(clientType, logger) .apply { if (progressLogger != null) { this.progressLogger = progressLogger @@ -57,21 +58,24 @@ internal data class KotlinWebpackRunner( private fun configureExec( execFactory: ExecSpec, - client: TeamCityMessageCommonClient - ) { + progressLogger: ProgressLogger? + ): Pair { check(config.entry?.isFile == true) { "${this}: Entry file not existed \"${config.entry}\"" } + val standardClient = configureClient(LogType.LOG, progressLogger) execFactory.standardOutput = TCServiceMessageOutputStreamHandler( - client = client, + client = standardClient, onException = { }, - logger = client.log + logger = standardClient.log ) + + val errorClient = configureClient(LogType.ERROR, progressLogger) execFactory.errorOutput = TCServiceMessageOutputStreamHandler( - client = client, + client = errorClient, onException = { }, - logger = client.log + logger = errorClient.log ) config.save(configFile) @@ -89,5 +93,7 @@ internal data class KotlinWebpackRunner( nodeArgs, args ) + + return standardClient to errorClient } } \ No newline at end of file From 28168bf230a434c79fb96faa4cee8dd4930f47bd Mon Sep 17 00:00:00 2001 From: Ilya Gorbunov Date: Thu, 12 Nov 2020 05:10:29 +0300 Subject: [PATCH 010/196] Correctly implement specialized MutableEntrySet.contains KT-41278 This is a workaround for the problem KT-43321. Introduce an intermediate abstract set specialized for Map.Entry elements and implement 'contains(Map.Entry)' method there. Then inherit that intermediate set in entrysets of JS HashMap, JS LinkedHashMap, JVM MapBuilder, that are specialized for MutableMap.MutableEntry elements, so that no override of 'contains' is required anymore. This allows to avoid incorrect special 'contains' bridge being generated that otherwise rejects all arguments except ones of MutableEntry type. --- .../kotlin/collections/AbstractMutableMap.kt | 6 +++ .../js/src/kotlin/collections/HashMap.kt | 9 +++-- .../src/kotlin/collections/LinkedHashMap.kt | 9 +++-- .../kotlin/collections/builders/MapBuilder.kt | 10 ++++- libraries/stdlib/test/collections/MapTest.kt | 37 +++++++++++++++++++ 5 files changed, 61 insertions(+), 10 deletions(-) diff --git a/libraries/stdlib/js/src/kotlin/collections/AbstractMutableMap.kt b/libraries/stdlib/js/src/kotlin/collections/AbstractMutableMap.kt index 5fca74d9397..f705221f119 100644 --- a/libraries/stdlib/js/src/kotlin/collections/AbstractMutableMap.kt +++ b/libraries/stdlib/js/src/kotlin/collections/AbstractMutableMap.kt @@ -46,6 +46,12 @@ public actual abstract class AbstractMutableMap protected actual construct } + // intermediate abstract class to workaround KT-43321 + internal abstract class AbstractEntrySet, K, V> : AbstractMutableSet() { + final override fun contains(element: E): Boolean = containsEntry(element) + abstract fun containsEntry(element: Map.Entry): Boolean + } + actual override fun clear() { entries.clear() } diff --git a/libraries/stdlib/js/src/kotlin/collections/HashMap.kt b/libraries/stdlib/js/src/kotlin/collections/HashMap.kt index 8cbdd4d17e9..c372f056592 100644 --- a/libraries/stdlib/js/src/kotlin/collections/HashMap.kt +++ b/libraries/stdlib/js/src/kotlin/collections/HashMap.kt @@ -1,7 +1,8 @@ /* - * Copyright 2010-2018 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ + /* * Based on GWT AbstractHashMap * Copyright 2008 Google Inc. @@ -20,14 +21,14 @@ import kotlin.collections.MutableMap.MutableEntry // have to make sure mutating methods check `checkIsMutable`. public actual open class HashMap : AbstractMutableMap, MutableMap { - private inner class EntrySet : AbstractMutableSet>() { + private inner class EntrySet : AbstractEntrySet, K, V>() { override fun add(element: MutableEntry): Boolean = throw UnsupportedOperationException("Add is not supported on entries") override fun clear() { this@HashMap.clear() } - override operator fun contains(element: MutableEntry): Boolean = containsEntry(element) + override fun containsEntry(element: Map.Entry): Boolean = this@HashMap.containsEntry(element) override operator fun iterator(): MutableIterator> = internalMap.iterator() @@ -121,4 +122,4 @@ public actual open class HashMap : AbstractMutableMap, MutableMap stringMapOf(vararg pairs: Pair): HashMap { return HashMap(InternalStringMap(EqualityComparator.HashCode)).apply { putAll(pairs) } -} \ No newline at end of file +} diff --git a/libraries/stdlib/js/src/kotlin/collections/LinkedHashMap.kt b/libraries/stdlib/js/src/kotlin/collections/LinkedHashMap.kt index 67057019bb6..a626e23b37d 100644 --- a/libraries/stdlib/js/src/kotlin/collections/LinkedHashMap.kt +++ b/libraries/stdlib/js/src/kotlin/collections/LinkedHashMap.kt @@ -1,7 +1,8 @@ /* - * Copyright 2010-2018 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ + /* * Based on GWT LinkedHashMap * Copyright 2008 Google Inc. @@ -40,7 +41,7 @@ public actual open class LinkedHashMap : HashMap, MutableMap { } } - private inner class EntrySet : AbstractMutableSet>() { + private inner class EntrySet : AbstractEntrySet, K, V>() { private inner class EntryIterator : MutableIterator> { // The last entry that was returned from this iterator. @@ -85,7 +86,7 @@ public actual open class LinkedHashMap : HashMap, MutableMap { this@LinkedHashMap.clear() } - override operator fun contains(element: MutableEntry): Boolean = containsEntry(element) + override fun containsEntry(element: Map.Entry): Boolean = this@LinkedHashMap.containsEntry(element) override operator fun iterator(): MutableIterator> = EntryIterator() @@ -275,4 +276,4 @@ public actual open class LinkedHashMap : HashMap, MutableMap { */ public fun linkedStringMapOf(vararg pairs: Pair): LinkedHashMap { return LinkedHashMap(stringMapOf()).apply { putAll(pairs) } -} \ No newline at end of file +} diff --git a/libraries/stdlib/jvm/src/kotlin/collections/builders/MapBuilder.kt b/libraries/stdlib/jvm/src/kotlin/collections/builders/MapBuilder.kt index 01c04cb6c30..16f5ffff796 100644 --- a/libraries/stdlib/jvm/src/kotlin/collections/builders/MapBuilder.kt +++ b/libraries/stdlib/jvm/src/kotlin/collections/builders/MapBuilder.kt @@ -595,13 +595,19 @@ internal class MapBuilderValues internal constructor( } } +// intermediate abstract class to workaround KT-43321 +internal abstract class AbstractMapBuilderEntrySet, K, V> : AbstractMutableSet() { + final override fun contains(element: E): Boolean = containsEntry(element) + abstract fun containsEntry(element: Map.Entry): Boolean +} + internal class MapBuilderEntries internal constructor( val backing: MapBuilder -) : MutableSet>, AbstractMutableSet>() { +) : AbstractMapBuilderEntrySet, K, V>() { override val size: Int get() = backing.size override fun isEmpty(): Boolean = backing.isEmpty() - override fun contains(element: MutableMap.MutableEntry): Boolean = backing.containsEntry(element) + override fun containsEntry(element: Map.Entry): Boolean = backing.containsEntry(element) override fun clear() = backing.clear() override fun add(element: MutableMap.MutableEntry): Boolean = throw UnsupportedOperationException() override fun addAll(elements: Collection>): Boolean = throw UnsupportedOperationException() diff --git a/libraries/stdlib/test/collections/MapTest.kt b/libraries/stdlib/test/collections/MapTest.kt index 7aa0347205e..e9c614c1fd8 100644 --- a/libraries/stdlib/test/collections/MapTest.kt +++ b/libraries/stdlib/test/collections/MapTest.kt @@ -400,6 +400,43 @@ class MapTest { assertEquals(3, filteredByValue["b"]) } + @Test + fun entriesCovariantContains() { + // Based on https://youtrack.jetbrains.com/issue/KT-42428. + fun doTest(implName: String, map: Map, key: String, value: Int) { + class SimpleEntry(override val key: K, override val value: V) : Map.Entry { + override fun toString(): String = "$key=$value" + override fun hashCode(): Int = key.hashCode() xor value.hashCode() + override fun equals(other: Any?): Boolean = + other is Map.Entry<*, *> && key == other.key && value == other.value + } + + val mapDescription = "$implName: ${map::class}" + + assertTrue(map.keys.contains(key), mapDescription) + assertEquals(value, map[key], mapDescription) + // This one requires special efforts to make it work this way. + // map.entries can in fact be `MutableSet`, + // which [contains] method takes [MutableEntry], so the compiler may generate special bridge + // returning false for values that aren't [MutableEntry] (including [SimpleEntry]). + assertTrue(map.entries.contains(SimpleEntry(key, value)), mapDescription) + assertTrue(map.entries.toSet().contains(SimpleEntry(key, value)), mapDescription) + } + + val mapLetterToIndex = ('a'..'z').mapIndexed { i, c -> "$c" to i }.toMap() + doTest("default read-only", mapLetterToIndex, "h", 7) + doTest("default mutable", mapLetterToIndex.toMutableMap(), "b", 1) + doTest("HashMap", mapLetterToIndex.toMap(HashMap()), "c", 2) + doTest("LinkedHashMap", mapLetterToIndex.toMap(LinkedHashMap()), "d", 3) + + val builtMap = buildMap { + putAll(mapLetterToIndex) + doTest("MapBuilder", this, "z", 25) + } + doTest("built Map", builtMap, "y", 24) + } + + fun testPlusAssign(doPlusAssign: (MutableMap) -> Unit) { val map = hashMapOf("a" to 1, "b" to 2) doPlusAssign(map) From 51e8d782b0c2eb93db4e1f4a2fe6028e998ef84a Mon Sep 17 00:00:00 2001 From: Svyatoslav Kuzmich Date: Tue, 8 Dec 2020 15:53:15 +0300 Subject: [PATCH 011/196] [Wasm] Support packed integer class fields --- .../backend/wasm/ir2wasm/BodyGenerator.kt | 19 ++++++++++++++++--- .../wasm/ir2wasm/DeclarationGenerator.kt | 2 +- .../backend/wasm/ir2wasm/TypeTransformer.kt | 13 +++++++++++++ .../wasm/ir2wasm/WasmBaseCodegenContext.kt | 2 ++ .../ir2wasm/WasmModuleCodegenContextImpl.kt | 4 ++++ .../src/org/jetbrains/kotlin/wasm/ir/Types.kt | 2 +- 6 files changed, 37 insertions(+), 5 deletions(-) diff --git a/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/BodyGenerator.kt b/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/BodyGenerator.kt index 22cd4da8aa2..bcbfb912fb1 100644 --- a/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/BodyGenerator.kt +++ b/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/BodyGenerator.kt @@ -77,9 +77,22 @@ class BodyGenerator(val context: WasmFunctionCodegenContext) : IrElementVisitorV } private fun generateInstanceFieldAccess(field: IrField) { - body.buildStructGet( - context.referenceGcType(field.parentAsClass.symbol), - context.getStructFieldRef(field) + val opcode = when (field.type) { + irBuiltIns.charType -> + WasmOp.STRUCT_GET_U + + irBuiltIns.booleanType, + irBuiltIns.byteType, + irBuiltIns.shortType -> + WasmOp.STRUCT_GET_S + + else -> WasmOp.STRUCT_GET + } + + body.buildInstr( + opcode, + WasmImmediate.GcType(context.referenceGcType(field.parentAsClass.symbol)), + WasmImmediate.StructFieldIdx(context.getStructFieldRef(field)) ) } diff --git a/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/DeclarationGenerator.kt b/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/DeclarationGenerator.kt index ffa99ad0679..081bb9e3e02 100644 --- a/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/DeclarationGenerator.kt +++ b/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/DeclarationGenerator.kt @@ -194,7 +194,7 @@ class DeclarationGenerator(val context: WasmModuleCodegenContext) : IrElementVis fields = declaration.allFields(irBuiltIns).map { WasmStructFieldDeclaration( name = it.name.toString(), - type = context.transformType(it.type), + type = context.transformFieldType(it.type), isMutable = true ) } diff --git a/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/TypeTransformer.kt b/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/TypeTransformer.kt index d20a35ef1bd..17c75b6fedc 100644 --- a/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/TypeTransformer.kt +++ b/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/TypeTransformer.kt @@ -51,6 +51,19 @@ class WasmTypeTransformer( fun IrType.toBoxedInlineClassType(): WasmType = toWasmGcRefType() + fun IrType.toWasmFieldType(): WasmType = + when (this) { + builtIns.booleanType, + builtIns.byteType -> + WasmI8 + + builtIns.shortType, + builtIns.charType -> + WasmI16 + + else -> toWasmValueType() + } + fun IrType.toWasmValueType(): WasmType = when (this) { builtIns.booleanType, diff --git a/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/WasmBaseCodegenContext.kt b/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/WasmBaseCodegenContext.kt index 341cc0dd9f8..7ee75aa1182 100644 --- a/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/WasmBaseCodegenContext.kt +++ b/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/WasmBaseCodegenContext.kt @@ -34,6 +34,8 @@ interface WasmBaseCodegenContext { fun referenceStringLiteral(string: String): WasmSymbol fun transformType(irType: IrType): WasmType + fun transformFieldType(irType: IrType): WasmType + fun transformBoxedType(irType: IrType): WasmType fun transformValueParameterType(irValueParameter: IrValueParameter): WasmType fun transformResultType(irType: IrType): WasmType? diff --git a/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/WasmModuleCodegenContextImpl.kt b/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/WasmModuleCodegenContextImpl.kt index c6796576178..33ab9a8b5b3 100644 --- a/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/WasmModuleCodegenContextImpl.kt +++ b/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/WasmModuleCodegenContextImpl.kt @@ -33,6 +33,10 @@ class WasmModuleCodegenContextImpl( return with(typeTransformer) { irType.toWasmValueType() } } + override fun transformFieldType(irType: IrType): WasmType { + return with(typeTransformer) { irType.toWasmFieldType() } + } + override fun transformBoxedType(irType: IrType): WasmType { return with(typeTransformer) { irType.toBoxedInlineClassType() } } diff --git a/wasm/wasm.ir/src/org/jetbrains/kotlin/wasm/ir/Types.kt b/wasm/wasm.ir/src/org/jetbrains/kotlin/wasm/ir/Types.kt index 4ba81b2ed90..02e5a5277d2 100644 --- a/wasm/wasm.ir/src/org/jetbrains/kotlin/wasm/ir/Types.kt +++ b/wasm/wasm.ir/src/org/jetbrains/kotlin/wasm/ir/Types.kt @@ -21,7 +21,7 @@ object WasmF32 : WasmType("f32", -0x3) object WasmF64 : WasmType("f64", -0x4) object WasmV128 : WasmType("v128", -0x5) object WasmI8 : WasmType("i8", -0x6) -object WasmI16 : WasmType("i8", -0x7) +object WasmI16 : WasmType("i16", -0x7) object WasmFuncRef : WasmType("funcref", -0x10) object WasmExternRef : WasmType("externref", -0x11) object WasmAnyRef : WasmType("anyref", -0x12) From d37271bf358be842540e8bec1847795450720def Mon Sep 17 00:00:00 2001 From: Svyatoslav Kuzmich Date: Sat, 12 Dec 2020 16:26:21 +0300 Subject: [PATCH 012/196] [Wasm] Support packed integer array elements --- .../wasm/ir2wasm/DeclarationGenerator.kt | 2 +- .../stdlib/wasm/builtins/kotlin/Arrays.kt | 16 +++--- .../stdlib/wasm/src/generated/_WasmArrays.kt | 50 +++++++++---------- .../src/generators/GenerateWasmOps.kt | 32 ++++++++++-- 4 files changed, 61 insertions(+), 39 deletions(-) diff --git a/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/DeclarationGenerator.kt b/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/DeclarationGenerator.kt index 081bb9e3e02..e673b667423 100644 --- a/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/DeclarationGenerator.kt +++ b/compiler/ir/backend.wasm/src/org/jetbrains/kotlin/backend/wasm/ir2wasm/DeclarationGenerator.kt @@ -176,7 +176,7 @@ class DeclarationGenerator(val context: WasmModuleCodegenContext) : IrElementVis nameStr, WasmStructFieldDeclaration( name = "field", - type = context.transformType(wasmArrayAnnotation.type), + type = context.transformFieldType(wasmArrayAnnotation.type), isMutable = true ) ) diff --git a/libraries/stdlib/wasm/builtins/kotlin/Arrays.kt b/libraries/stdlib/wasm/builtins/kotlin/Arrays.kt index 1bbf8ae056c..6126576f0ff 100644 --- a/libraries/stdlib/wasm/builtins/kotlin/Arrays.kt +++ b/libraries/stdlib/wasm/builtins/kotlin/Arrays.kt @@ -35,17 +35,17 @@ internal fun byteArrayIterator(array: ByteArray) = object : ByteIterator() { public class CharArray(size: Int) { - private var storage = WasmShortArray(size) + private var storage = WasmCharArray(size) public constructor(size: Int, init: (Int) -> Char) : this(size) { - storage.fill(size) { init(it).toShort() } + storage.fill(size) { init(it) } } public operator fun get(index: Int): Char = - storage.get(index).toChar() + storage.get(index) public operator fun set(index: Int, value: Char) { - storage.set(index, value.toShort()) + storage.set(index, value) } public val size: Int @@ -200,17 +200,17 @@ internal fun doubleArrayIterator(array: DoubleArray) = object : DoubleIterator() public class BooleanArray(size: Int) { - private var storage = WasmBooleanArray(size) + private var storage = WasmByteArray(size) public constructor(size: Int, init: (Int) -> Boolean) : this(size) { - storage.fill(size, init) + storage.fill(size) { init(it).toInt().reinterpretAsByte() } } public operator fun get(index: Int): Boolean = - storage.get(index) + storage.get(index).reinterpretAsInt().reinterpretAsBoolean() public operator fun set(index: Int, value: Boolean) { - storage.set(index, value) + storage.set(index, value.toInt().reinterpretAsByte()) } public val size: Int diff --git a/libraries/stdlib/wasm/src/generated/_WasmArrays.kt b/libraries/stdlib/wasm/src/generated/_WasmArrays.kt index ec59a1e957f..b50a47da571 100644 --- a/libraries/stdlib/wasm/src/generated/_WasmArrays.kt +++ b/libraries/stdlib/wasm/src/generated/_WasmArrays.kt @@ -33,32 +33,9 @@ internal inline fun WasmAnyArray.fill(size: Int, init: (Int) -> Any?) { } } -@WasmArrayOf(Boolean::class, isNullable = false) -internal class WasmBooleanArray(size: Int) { - @WasmOp(WasmOp.ARRAY_GET) - fun get(index: Int): Boolean = - implementedAsIntrinsic - - @WasmOp(WasmOp.ARRAY_SET) - fun set(index: Int, value: Boolean): Unit = - implementedAsIntrinsic - - @WasmOp(WasmOp.ARRAY_LEN) - fun len(): Int = - implementedAsIntrinsic -} - -internal inline fun WasmBooleanArray.fill(size: Int, init: (Int) -> Boolean) { - var i = 0 - while (i < size) { - set(i, init(i)) - i++ - } -} - @WasmArrayOf(Byte::class, isNullable = false) internal class WasmByteArray(size: Int) { - @WasmOp(WasmOp.ARRAY_GET) + @WasmOp(WasmOp.ARRAY_GET_S) fun get(index: Int): Byte = implementedAsIntrinsic @@ -79,9 +56,32 @@ internal inline fun WasmByteArray.fill(size: Int, init: (Int) -> Byte) { } } +@WasmArrayOf(Char::class, isNullable = false) +internal class WasmCharArray(size: Int) { + @WasmOp(WasmOp.ARRAY_GET_U) + fun get(index: Int): Char = + implementedAsIntrinsic + + @WasmOp(WasmOp.ARRAY_SET) + fun set(index: Int, value: Char): Unit = + implementedAsIntrinsic + + @WasmOp(WasmOp.ARRAY_LEN) + fun len(): Int = + implementedAsIntrinsic +} + +internal inline fun WasmCharArray.fill(size: Int, init: (Int) -> Char) { + var i = 0 + while (i < size) { + set(i, init(i)) + i++ + } +} + @WasmArrayOf(Short::class, isNullable = false) internal class WasmShortArray(size: Int) { - @WasmOp(WasmOp.ARRAY_GET) + @WasmOp(WasmOp.ARRAY_GET_S) fun get(index: Int): Short = implementedAsIntrinsic diff --git a/libraries/tools/kotlin-stdlib-gen/src/generators/GenerateWasmOps.kt b/libraries/tools/kotlin-stdlib-gen/src/generators/GenerateWasmOps.kt index 350f73fa400..604436b6721 100644 --- a/libraries/tools/kotlin-stdlib-gen/src/generators/GenerateWasmOps.kt +++ b/libraries/tools/kotlin-stdlib-gen/src/generators/GenerateWasmOps.kt @@ -9,6 +9,7 @@ import org.jetbrains.kotlin.wasm.ir.WasmOp import templates.COMMON_AUTOGENERATED_WARNING import templates.COPYRIGHT_NOTICE import templates.PrimitiveType +import templates.isUnsigned import java.io.File import java.io.FileWriter @@ -56,20 +57,41 @@ fun generateWasmArrays(targetDir: File) { writer.generateStandardWasmInternalHeader() writer.appendLine(wasmArrayForType("Any", true)) - writer.appendLine(wasmArrayForType("Boolean", false)) - PrimitiveType.numericPrimitives.sortedBy { it.capacity }.forEach { primitive -> - writer.appendLine(wasmArrayForType(primitive.name, false)) + PrimitiveType.descendingByDomainCapacity.reversed().forEach { primitive -> + val isPacked = primitive in setOf( + PrimitiveType.Byte, + PrimitiveType.Short, + PrimitiveType.Char, + ) + val isUnsigned = primitive.isUnsigned() || primitive == PrimitiveType.Char + + writer.appendLine( + wasmArrayForType( + primitive.name, + false, isPacked, isUnsigned + ) + ) } } } -fun wasmArrayForType(klass: String, isNullable: Boolean): String { +fun wasmArrayForType( + klass: String, + isNullable: Boolean, + isPacked: Boolean = false, + isUnsigned: Boolean = false, +): String { val type = klass + if (isNullable) "?" else "" val name = "Wasm${klass}Array" + val getSuffix = when { + isPacked && isUnsigned -> "_U" + isPacked && !isUnsigned -> "_S" + else -> "" + } return """ @WasmArrayOf($klass::class, isNullable = $isNullable) internal class $name(size: Int) { - @WasmOp(WasmOp.ARRAY_GET) + @WasmOp(WasmOp.ARRAY_GET${getSuffix}) fun get(index: Int): $type = implementedAsIntrinsic From 7efc95705ab2abeaec1c2b5975c280231e9a4d20 Mon Sep 17 00:00:00 2001 From: Svyatoslav Kuzmich Date: Fri, 11 Dec 2020 22:34:01 +0300 Subject: [PATCH 013/196] [Wasm] Publish stdlib klib to maven --- libraries/stdlib/wasm/build.gradle.kts | 1 - libraries/stdlib/wasm/publish/build.gradle.kts | 11 +++++++++++ settings.gradle | 2 ++ 3 files changed, 13 insertions(+), 1 deletion(-) create mode 100644 libraries/stdlib/wasm/publish/build.gradle.kts diff --git a/libraries/stdlib/wasm/build.gradle.kts b/libraries/stdlib/wasm/build.gradle.kts index e25ee1640b9..5de782a3139 100644 --- a/libraries/stdlib/wasm/build.gradle.kts +++ b/libraries/stdlib/wasm/build.gradle.kts @@ -1,7 +1,6 @@ import org.jetbrains.kotlin.gradle.dsl.KotlinCompile plugins { - `maven-publish` kotlin("multiplatform") } diff --git a/libraries/stdlib/wasm/publish/build.gradle.kts b/libraries/stdlib/wasm/publish/build.gradle.kts new file mode 100644 index 00000000000..0480de65bc9 --- /dev/null +++ b/libraries/stdlib/wasm/publish/build.gradle.kts @@ -0,0 +1,11 @@ +description = "Kotlin Standard Library for experimental WebAssembly platform" + +// Using separate project to publish a single klib from multiplatform build + +publish { + artifactId = "kotlin-stdlib-wasm" + pom.packaging = "klib" + artifact(tasks.getByPath(":kotlin-stdlib-wasm:jsJar")) { + extension = "klib" + } +} diff --git a/settings.gradle b/settings.gradle index f0b59c44a99..bc420b33a01 100644 --- a/settings.gradle +++ b/settings.gradle @@ -399,6 +399,7 @@ if (buildProperties.inJpsBuildIdeaSync) { ":kotlin-stdlib-js-ir", ":kotlin-stdlib-js-ir-minimal-for-test", ":kotlin-stdlib-wasm", + ":kotlin-stdlib-wasm-publish", ":kotlin-stdlib-jdk7", ":kotlin-stdlib-jdk8", ":kotlin-stdlib:samples", @@ -417,6 +418,7 @@ if (buildProperties.inJpsBuildIdeaSync) { project(':kotlin-stdlib-js').projectDir = "$rootDir/libraries/stdlib/js-v1" as File project(':kotlin-stdlib-js-ir').projectDir = "$rootDir/libraries/stdlib/js-ir" as File project(':kotlin-stdlib-wasm').projectDir = "$rootDir/libraries/stdlib/wasm" as File + project(':kotlin-stdlib-wasm-publish').projectDir = "$rootDir/libraries/stdlib/wasm/publish" as File project(':kotlin-stdlib-js-ir-minimal-for-test').projectDir = "$rootDir/libraries/stdlib/js-ir-minimal-for-test" as File project(':kotlin-stdlib-jdk7').projectDir = "$rootDir/libraries/stdlib/jdk7" as File project(':kotlin-stdlib-jdk8').projectDir = "$rootDir/libraries/stdlib/jdk8" as File From 32cc95a3b0ca7fb2579588f5f2bfc4177c599762 Mon Sep 17 00:00:00 2001 From: Shagen Ogandzhanian Date: Mon, 14 Dec 2020 14:49:22 +0100 Subject: [PATCH 014/196] [JS IR] Skip export annotations while generating default stubs --- .../kotlin/backend/common/ir/IrUtils.kt | 10 ++++++++- .../lower/DefaultArgumentStubGenerator.kt | 21 ++++++++++++------- .../backend/js/export/ExportModelGenerator.kt | 4 ++-- .../lower/JsDefaultArgumentStubGenerator.kt | 7 +++++++ .../org/jetbrains/kotlin/ir/util/IrUtils.kt | 6 +++--- 5 files changed, 35 insertions(+), 13 deletions(-) diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/IrUtils.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/IrUtils.kt index ea220ef45aa..49487090bcd 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/IrUtils.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/IrUtils.kt @@ -235,8 +235,16 @@ private fun IrTypeParameter.copySuperTypesFrom(source: IrTypeParameter, srcToDst } } +fun IrAnnotationContainer.copyAnnotations(): List { + return annotations.map { it.deepCopyWithSymbols(this as? IrDeclarationParent) } +} + +fun IrAnnotationContainer.copyAnnotationsWhen(filter: IrConstructorCall.() -> Boolean): List { + return annotations.mapNotNull { if (it.filter()) it.deepCopyWithSymbols(this as? IrDeclarationParent) else null } +} + fun IrMutableAnnotationContainer.copyAnnotationsFrom(source: IrAnnotationContainer) { - annotations += source.annotations.map { it.deepCopyWithSymbols(this as? IrDeclarationParent) } + annotations += source.copyAnnotations() } fun makeTypeParameterSubstitutionMap( diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/DefaultArgumentStubGenerator.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/DefaultArgumentStubGenerator.kt index 0c3139c8558..52d2af0ce25 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/DefaultArgumentStubGenerator.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/lower/DefaultArgumentStubGenerator.kt @@ -50,6 +50,8 @@ open class DefaultArgumentStubGenerator( return null } + open protected fun IrFunction.resolveAnnotations() = copyAnnotations() + private fun lower(irFunction: IrFunction): List? { val newIrFunction = irFunction.generateDefaultsFunction( @@ -58,7 +60,8 @@ open class DefaultArgumentStubGenerator( skipExternalMethods, forceSetOverrideSymbols, defaultArgumentStubVisibility(irFunction), - useConstructorMarker(irFunction) + useConstructorMarker(irFunction), + irFunction.resolveAnnotations() ) ?: return null if (newIrFunction.isFakeOverride) { return listOf(irFunction, newIrFunction) @@ -384,7 +387,8 @@ open class DefaultParameterInjector( skipExternalMethods, forceSetOverrideSymbols, defaultArgumentStubVisibility(declaration), - useConstructorMarker(declaration) + useConstructorMarker(declaration), + emptyList() ) ?: return null log { "$declaration -> $stubFunction" } @@ -485,7 +489,8 @@ private fun IrFunction.generateDefaultsFunction( skipExternalMethods: Boolean, forceSetOverrideSymbols: Boolean, visibility: DescriptorVisibility, - useConstructorMarker: Boolean + useConstructorMarker: Boolean, + copiedAnnotations: List ): IrFunction? { if (skipInlineMethods && isInline) return null if (skipExternalMethods && isExternalOrInheritedFromExternal()) return null @@ -495,7 +500,7 @@ private fun IrFunction.generateDefaultsFunction( // If this is an override of a function with default arguments, produce a fake override of a default stub. if (overriddenSymbols.any { it.owner.findBaseFunctionWithDefaultArguments(skipInlineMethods, skipExternalMethods) != null }) return generateDefaultsFunctionImpl( - context, IrDeclarationOrigin.FAKE_OVERRIDE, visibility, true, useConstructorMarker + context, IrDeclarationOrigin.FAKE_OVERRIDE, visibility, copiedAnnotations, true, useConstructorMarker ).also { defaultsFunction -> context.mapping.defaultArgumentsDispatchFunction[this] = defaultsFunction context.mapping.defaultArgumentsOriginalFunction[defaultsFunction] = this @@ -508,7 +513,8 @@ private fun IrFunction.generateDefaultsFunction( skipExternalMethods, forceSetOverrideSymbols, visibility, - useConstructorMarker + useConstructorMarker, + it.owner.copyAnnotations() )?.symbol as IrSimpleFunctionSymbol? } } @@ -526,7 +532,7 @@ private fun IrFunction.generateDefaultsFunction( // binaries, it's way too late to fix it. Hence the workaround. if (valueParameters.any { it.defaultValue != null }) { return generateDefaultsFunctionImpl( - context, IrDeclarationOrigin.FUNCTION_FOR_DEFAULT_PARAMETER, visibility, false, useConstructorMarker + context, IrDeclarationOrigin.FUNCTION_FOR_DEFAULT_PARAMETER, visibility, copiedAnnotations, false, useConstructorMarker ).also { context.mapping.defaultArgumentsDispatchFunction[this] = it context.mapping.defaultArgumentsOriginalFunction[it] = this @@ -539,6 +545,7 @@ private fun IrFunction.generateDefaultsFunctionImpl( context: CommonBackendContext, newOrigin: IrDeclarationOrigin, newVisibility: DescriptorVisibility, + copiedAnnotations: List, isFakeOverride: Boolean, useConstructorMarker: Boolean ): IrFunction { @@ -601,7 +608,7 @@ private fun IrFunction.generateDefaultsFunctionImpl( } // TODO some annotations are needed (e.g. @JvmStatic), others need different values (e.g. @JvmName), the rest are redundant. - newFunction.copyAnnotationsFrom(this) + newFunction.annotations += copiedAnnotations return newFunction } diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/export/ExportModelGenerator.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/export/ExportModelGenerator.kt index 1bb08d7037c..dd5b3acf711 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/export/ExportModelGenerator.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/export/ExportModelGenerator.kt @@ -326,8 +326,8 @@ class ExportModelGenerator(val context: JsIrBackendContext) { return Exportability.NotNeeded if (function.origin == IrDeclarationOrigin.BRIDGE || function.origin == JsLoweredDeclarationOrigin.BRIDGE_TO_EXTERNAL_FUNCTION || - function.origin == IrDeclarationOrigin.FUNCTION_FOR_DEFAULT_PARAMETER || - function.origin == JsLoweredDeclarationOrigin.OBJECT_GET_INSTANCE_FUNCTION + function.origin == JsLoweredDeclarationOrigin.OBJECT_GET_INSTANCE_FUNCTION || + function.origin == IrDeclarationOrigin.FUNCTION_FOR_DEFAULT_PARAMETER ) { return Exportability.NotNeeded } diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/JsDefaultArgumentStubGenerator.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/JsDefaultArgumentStubGenerator.kt index 82623bd231c..4fb8a7189ff 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/JsDefaultArgumentStubGenerator.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/JsDefaultArgumentStubGenerator.kt @@ -7,10 +7,12 @@ package org.jetbrains.kotlin.ir.backend.js.lower import org.jetbrains.kotlin.backend.common.BodyLoweringPass import org.jetbrains.kotlin.backend.common.deepCopyWithVariables +import org.jetbrains.kotlin.backend.common.ir.copyAnnotationsWhen import org.jetbrains.kotlin.backend.common.ir.isOverridableOrOverrides import org.jetbrains.kotlin.backend.common.lower.DefaultArgumentStubGenerator import org.jetbrains.kotlin.backend.common.lower.DEFAULT_DISPATCH_CALL import org.jetbrains.kotlin.ir.backend.js.JsIrBackendContext +import org.jetbrains.kotlin.ir.backend.js.utils.JsAnnotations import org.jetbrains.kotlin.ir.builders.IrBlockBodyBuilder import org.jetbrains.kotlin.ir.builders.irCall import org.jetbrains.kotlin.ir.builders.irGet @@ -20,6 +22,7 @@ import org.jetbrains.kotlin.ir.expressions.* import org.jetbrains.kotlin.ir.expressions.impl.IrCallImpl import org.jetbrains.kotlin.ir.expressions.impl.IrFunctionReferenceImpl import org.jetbrains.kotlin.ir.util.deepCopyWithSymbols +import org.jetbrains.kotlin.ir.util.isAnnotation import org.jetbrains.kotlin.ir.util.patchDeclarationParents import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid import org.jetbrains.kotlin.ir.visitors.transformChildrenVoid @@ -29,6 +32,10 @@ class JsDefaultArgumentStubGenerator(override val context: JsIrBackendContext) : override fun needSpecialDispatch(irFunction: IrSimpleFunction) = irFunction.isOverridableOrOverrides + override fun IrFunction.resolveAnnotations(): List = copyAnnotationsWhen { + !(isAnnotation(JsAnnotations.jsExportFqn) || isAnnotation(JsAnnotations.jsNameFqn)) + } + override fun IrBlockBodyBuilder.generateHandleCall( handlerDeclaration: IrValueParameter, oldIrFunction: IrFunction, diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IrUtils.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IrUtils.kt index d9c8cc74742..f095109368b 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IrUtils.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IrUtils.kt @@ -279,10 +279,10 @@ tailrec fun IrElement.getPackageFragment(): IrPackageFragment? { } } +fun IrConstructorCall.isAnnotation(name: FqName) = symbol.owner.parentAsClass.fqNameWhenAvailable == name + fun IrAnnotationContainer.getAnnotation(name: FqName): IrConstructorCall? = - annotations.find { - it.symbol.owner.parentAsClass.fqNameWhenAvailable == name - } + annotations.find { it.isAnnotation(name) } fun IrAnnotationContainer.hasAnnotation(name: FqName) = annotations.any { From b3d8c4a0fc03442fc5ad97db4309dcc00c4c986d Mon Sep 17 00:00:00 2001 From: Svyatoslav Kuzmich Date: Mon, 14 Dec 2020 17:29:42 +0300 Subject: [PATCH 015/196] [JS IR] Apply missing property for all tests tasks like jsIrTest and quickTest --- js/js.tests/build.gradle.kts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/js/js.tests/build.gradle.kts b/js/js.tests/build.gradle.kts index f7f39642891..1f8ef786ba8 100644 --- a/js/js.tests/build.gradle.kts +++ b/js/js.tests/build.gradle.kts @@ -224,6 +224,7 @@ fun Test.setUpBoxTests() { systemProperty("kotlin.ant.launcher.class", "org.apache.tools.ant.Main") } + systemProperty("kotlin.js.test.root.out.dir", "$buildDir/") systemProperty("overwrite.output", findProperty("overwrite.output") ?: "false") val prefixForPpropertiesToForward = "fd." @@ -247,7 +248,6 @@ projectTest(parallel = true) { inputs.dir(rootDir.resolve("libraries/stdlib/api/js")) inputs.dir(rootDir.resolve("libraries/stdlib/api/js-v1")) - systemProperty("kotlin.js.test.root.out.dir", "$buildDir/") outputs.dir("$buildDir/out") outputs.dir("$buildDir/out-min") outputs.dir("$buildDir/out-pir") From c094d77794a890b997a32c959acccbc0a037fd6a Mon Sep 17 00:00:00 2001 From: Svyatoslav Scherbina Date: Wed, 9 Dec 2020 18:13:47 +0300 Subject: [PATCH 016/196] Fix DeepRecursiveFunction in worker on Native Add `@SharedImmutable` to `UNDEFINED_RESULT` top-level property. --- libraries/stdlib/src/kotlin/util/DeepRecursive.kt | 2 ++ 1 file changed, 2 insertions(+) diff --git a/libraries/stdlib/src/kotlin/util/DeepRecursive.kt b/libraries/stdlib/src/kotlin/util/DeepRecursive.kt index 1302739c0e8..0417b7bbc9c 100644 --- a/libraries/stdlib/src/kotlin/util/DeepRecursive.kt +++ b/libraries/stdlib/src/kotlin/util/DeepRecursive.kt @@ -7,6 +7,7 @@ package kotlin import kotlin.coroutines.* import kotlin.coroutines.intrinsics.* +import kotlin.native.concurrent.SharedImmutable /** * Defines deep recursive function that keeps its stack on the heap, @@ -124,6 +125,7 @@ public sealed class DeepRecursiveScope { @ExperimentalStdlibApi private typealias DeepRecursiveFunctionBlock = suspend DeepRecursiveScope<*, *>.(Any?) -> Any? +@SharedImmutable private val UNDEFINED_RESULT = Result.success(COROUTINE_SUSPENDED) @Suppress("UNCHECKED_CAST") From 8f4e4a4d404b386e5420583b15c3e738d89c119e Mon Sep 17 00:00:00 2001 From: Ilya Gorbunov Date: Fri, 11 Dec 2020 13:53:47 +0300 Subject: [PATCH 017/196] Specify common sources for stdlib test compilation tasks Some multiplatform tests are compiled in single-platform projects: - in kotlin-stdlib-jdk7 - in kotlin-stdlib-jdk8 - in kotlin-stdlib-js-ir. The latter is technically MPP but with a single platform, so its common sources are not considered as common. Pass information about common sources to test compilation tasks in order to use OptionalExpectation annotations there. Co-authored-by: Svyatoslav Scherbina --- libraries/stdlib/jdk7/build.gradle | 1 + libraries/stdlib/jdk8/build.gradle | 1 + libraries/stdlib/js-ir/build.gradle.kts | 9 +++++++++ 3 files changed, 11 insertions(+) diff --git a/libraries/stdlib/jdk7/build.gradle b/libraries/stdlib/jdk7/build.gradle index 1e56622188d..361e0fda382 100644 --- a/libraries/stdlib/jdk7/build.gradle +++ b/libraries/stdlib/jdk7/build.gradle @@ -90,6 +90,7 @@ compileTestKotlin { "-Xopt-in=kotlin.ExperimentalUnsignedTypes", "-Xopt-in=kotlin.ExperimentalStdlibApi", "-Xopt-in=kotlin.io.path.ExperimentalPathApi", + "-Xcommon-sources=${fileTree('../test').join(',')}", ] } diff --git a/libraries/stdlib/jdk8/build.gradle b/libraries/stdlib/jdk8/build.gradle index e59fbc30e3b..a5e45269b44 100644 --- a/libraries/stdlib/jdk8/build.gradle +++ b/libraries/stdlib/jdk8/build.gradle @@ -82,6 +82,7 @@ compileTestKotlin { "-Xopt-in=kotlin.ExperimentalUnsignedTypes", "-Xopt-in=kotlin.ExperimentalStdlibApi", "-Xopt-in=kotlin.io.path.ExperimentalPathApi", + "-Xcommon-sources=${fileTree('../test').join(',')}", ] } diff --git a/libraries/stdlib/js-ir/build.gradle.kts b/libraries/stdlib/js-ir/build.gradle.kts index 47ee64c00ba..1d0629ebff2 100644 --- a/libraries/stdlib/js-ir/build.gradle.kts +++ b/libraries/stdlib/js-ir/build.gradle.kts @@ -149,6 +149,15 @@ val compileKotlinJs by tasks.existing(KotlinCompile::class) { kotlinOptions.freeCompilerArgs += "-Xir-module-name=kotlin" } + +val compileTestKotlinJs by tasks.existing(KotlinCompile::class) { + doFirst { + // Note: common test sources are copied to the actual source directory by commonMainSources task, + // so can't do this at configuration time: + kotlinOptions.freeCompilerArgs += "-Xcommon-sources=${kotlin.sourceSets["commonTest"].kotlin.joinToString(",")}" + } +} + val packFullRuntimeKLib by tasks.registering(Jar::class) { dependsOn(compileKotlinJs) from(buildDir.resolve("classes/kotlin/js/main")) From 0f4173cdfa62217e0ca2f580bd3a4832f4fc3813 Mon Sep 17 00:00:00 2001 From: Svyatoslav Scherbina Date: Thu, 10 Dec 2020 12:09:35 +0300 Subject: [PATCH 018/196] Fix running stdlib tests in worker on Native Add `@SharedImmutable` or `@ThreadLocal` where required. --- libraries/stdlib/test/OrderingTest.kt | 2 ++ .../delegation/PropertyReferenceTest.kt | 23 +++++++++++++++++++ libraries/stdlib/test/random/RandomTest.kt | 2 ++ libraries/stdlib/test/text/StringTest.kt | 2 ++ libraries/stdlib/test/time/DurationTest.kt | 3 +++ 5 files changed, 32 insertions(+) diff --git a/libraries/stdlib/test/OrderingTest.kt b/libraries/stdlib/test/OrderingTest.kt index c32fa1e3576..727a16d2d11 100644 --- a/libraries/stdlib/test/OrderingTest.kt +++ b/libraries/stdlib/test/OrderingTest.kt @@ -5,6 +5,7 @@ package test.comparisons +import kotlin.native.concurrent.SharedImmutable import kotlin.test.* data class Item(val name: String, val rating: Int) : Comparable { @@ -13,6 +14,7 @@ data class Item(val name: String, val rating: Int) : Comparable { } } +@SharedImmutable val STRING_CASE_INSENSITIVE_ORDER: Comparator = compareBy { it: String -> it.toUpperCase() }.thenBy { it.toLowerCase() }.thenBy { it } diff --git a/libraries/stdlib/test/properties/delegation/PropertyReferenceTest.kt b/libraries/stdlib/test/properties/delegation/PropertyReferenceTest.kt index d3d2e69c85e..cb4db8ce7e3 100644 --- a/libraries/stdlib/test/properties/delegation/PropertyReferenceTest.kt +++ b/libraries/stdlib/test/properties/delegation/PropertyReferenceTest.kt @@ -8,6 +8,7 @@ package test.properties.delegation.references import kotlin.reflect.* import kotlin.test.* import kotlin.internal.* +import kotlin.native.concurrent.ThreadLocal import kotlin.random.* open class Data(val stringVal: String, var intVar: Int, var builderVar: StringBuilder = StringBuilder("default")) @@ -16,25 +17,33 @@ var Data.displacedVar: Int get() = intVar + 2 set(value) { intVar = value - 2 } +@ThreadLocal val data = Data("bound string", 42) val topVal: Double get() = 3.14 +@ThreadLocal var topVar: ULong = 0xFFFFUL // top-level properties // val to bound val +@ThreadLocal val tlValBoundVal by data::stringVal // val to bound var +@ThreadLocal val tlValBoundVar by data::intVar // var to bound var +@ThreadLocal var tlVarBoundVar by data::intVar // val to top-level val +@ThreadLocal val tlValTopLevelVal by ::topVal // val to top-level var +@ThreadLocal val tlValTopLevelVar by ::topVar // var to top-level var +@ThreadLocal var tlVarTopLevelVar by ::topVar // member properties @@ -73,36 +82,50 @@ class DataExt : Data("member string", -1) { // extension properties // val to bound val +@ThreadLocal val Data.extValBoundVal by data::stringVal // val to bound var +@ThreadLocal val Data.extValBoundVar by data::intVar // var to bound var +@ThreadLocal var Data.extVarBoundVar by data::intVar // val to top-level val +@ThreadLocal val Data.extValTopLevelVal by ::topVal // val to top-level var +@ThreadLocal val Data.extValTopLevelVar by ::topVar // var to top-level var +@ThreadLocal var Data.extVarTopLevelVar by ::topVar // val to member val +@ThreadLocal val Data.extValMemberVal by Data::stringVal // val to member var +@ThreadLocal val Data.extValMemberVar by Data::intVar // var to member var +@ThreadLocal var Data.extVarMemberVar by Data::intVar // val to extension val +@ThreadLocal val Data.extValExtVal by Data::formattedVal // val to extension var +@ThreadLocal val Data.extValExtVar by Data::displacedVar // var to extension var +@ThreadLocal var Data.extVarExtVar by Data::displacedVar // covariance +@ThreadLocal val covariantVal: Number by ::topVal +@ThreadLocal val Data.extCovariantVal: CharSequence by Data::builderVar diff --git a/libraries/stdlib/test/random/RandomTest.kt b/libraries/stdlib/test/random/RandomTest.kt index 1729c3f5b19..1960e4dca6a 100644 --- a/libraries/stdlib/test/random/RandomTest.kt +++ b/libraries/stdlib/test/random/RandomTest.kt @@ -6,6 +6,7 @@ package test.random import kotlin.math.* +import kotlin.native.concurrent.ThreadLocal import kotlin.random.* import kotlin.test.* @@ -566,6 +567,7 @@ class DefaultRandomSmokeTest : RandomSmokeTest() { override val subject: Random get() = Random } +@ThreadLocal private val seededRandomSmokeTestSubject = Random(Random.nextInt().also { println("Seed: $it") }) class SeededRandomSmokeTest : RandomSmokeTest() { diff --git a/libraries/stdlib/test/text/StringTest.kt b/libraries/stdlib/test/text/StringTest.kt index 9046fb492b5..5d0665a237c 100644 --- a/libraries/stdlib/test/text/StringTest.kt +++ b/libraries/stdlib/test/text/StringTest.kt @@ -11,6 +11,7 @@ import test.collections.behaviors.iteratorBehavior import test.collections.behaviors.setBehavior import test.collections.compare import kotlin.math.sign +import kotlin.native.concurrent.SharedImmutable import kotlin.random.Random @@ -18,6 +19,7 @@ fun createString(content: String): CharSequence = content fun createStringBuilder(content: String): CharSequence = StringBuilder((content as Any).toString()) // required for Rhino JS +@SharedImmutable val charSequenceBuilders = listOf(::createString, ::createStringBuilder) fun withOneCharSequenceArg(f: ((String) -> CharSequence) -> Unit) { diff --git a/libraries/stdlib/test/time/DurationTest.kt b/libraries/stdlib/test/time/DurationTest.kt index 4c423a31c07..7edbc449226 100644 --- a/libraries/stdlib/test/time/DurationTest.kt +++ b/libraries/stdlib/test/time/DurationTest.kt @@ -8,11 +8,14 @@ package test.time import test.numbers.assertAlmostEquals import test.* +import kotlin.native.concurrent.SharedImmutable import kotlin.test.* import kotlin.time.* import kotlin.random.* +@SharedImmutable private val expectStorageUnit = DurationUnit.NANOSECONDS +@SharedImmutable private val units = DurationUnit.values() class DurationTest { From 45112a3c11e1def5c9a5a200c38a632c7a1a62b6 Mon Sep 17 00:00:00 2001 From: Igor Yakovlev Date: Mon, 14 Dec 2020 15:38:09 +0300 Subject: [PATCH 019/196] [ULC] Fix invalid positive inheritor for self checking Fixed #KT-43824 --- .../asJava/classes/KtLightClassForSourceDeclaration.kt | 7 ++++--- .../caches/lightClasses/IdeLightClassInheritanceHelper.kt | 1 + .../kotlin/idea/caches/lightClasses/KtFakeLightClass.kt | 7 +++++++ .../kotlin/asJava/KotlinLightClassInheritorTest.kt | 8 ++++++-- 4 files changed, 18 insertions(+), 5 deletions(-) diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/KtLightClassForSourceDeclaration.kt b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/KtLightClassForSourceDeclaration.kt index 97b528802dc..bb844689d7f 100644 --- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/KtLightClassForSourceDeclaration.kt +++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/KtLightClassForSourceDeclaration.kt @@ -264,11 +264,11 @@ abstract class KtLightClassForSourceDeclaration( override fun isValid(): Boolean = classOrObject.isValid override fun isInheritor(baseClass: PsiClass, checkDeep: Boolean): Boolean { + if (manager.areElementsEquivalent(baseClass, this)) return false LightClassInheritanceHelper.getService(project).isInheritor(this, baseClass, checkDeep).ifSure { return it } val qualifiedName: String? = if (baseClass is KtLightClassForSourceDeclaration) { - val baseDescriptor = baseClass.getDescriptor() - if (baseDescriptor != null) DescriptorUtils.getFqName(baseDescriptor).asString() else null + baseClass.getDescriptor()?.let(DescriptorUtils::getFqName)?.asString() } else { baseClass.qualifiedName } @@ -276,7 +276,8 @@ abstract class KtLightClassForSourceDeclaration( val thisDescriptor = getDescriptor() return if (qualifiedName != null && thisDescriptor != null) { - checkSuperTypeByFQName(thisDescriptor, qualifiedName, checkDeep) + qualifiedName != DescriptorUtils.getFqName(thisDescriptor).asString() && + checkSuperTypeByFQName(thisDescriptor, qualifiedName, checkDeep) } else { InheritanceImplUtil.isInheritor(this, baseClass, checkDeep) } diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/lightClasses/IdeLightClassInheritanceHelper.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/lightClasses/IdeLightClassInheritanceHelper.kt index 3714177d6f0..aa32f79ed16 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/lightClasses/IdeLightClassInheritanceHelper.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/lightClasses/IdeLightClassInheritanceHelper.kt @@ -36,6 +36,7 @@ class IdeLightClassInheritanceHelper : LightClassInheritanceHelper { checkDeep: Boolean ): ImpreciseResolveResult { if (baseClass.project.isInDumbMode()) return NO_MATCH + if (lightClass.manager.areElementsEquivalent(baseClass, lightClass)) return NO_MATCH val classOrObject = lightClass.kotlinOrigin ?: return UNSURE val entries = classOrObject.superTypeListEntries diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/lightClasses/KtFakeLightClass.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/lightClasses/KtFakeLightClass.kt index 9ef7293221e..ab6e1f6416f 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/lightClasses/KtFakeLightClass.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/lightClasses/KtFakeLightClass.kt @@ -12,6 +12,7 @@ import com.intellij.psi.impl.PsiClassImplUtil import com.intellij.psi.impl.light.AbstractLightClass import com.intellij.psi.impl.light.LightMethod import com.intellij.util.IncorrectOperationException +import org.jetbrains.kotlin.asJava.ImpreciseResolveResult import org.jetbrains.kotlin.asJava.classes.KtLightClass import org.jetbrains.kotlin.asJava.classes.LightClassInheritanceHelper import org.jetbrains.kotlin.asJava.elements.KtLightElement @@ -48,11 +49,17 @@ class KtFakeLightClass(override val kotlinOrigin: KtClassOrObject) : override fun getUseScope() = kotlinOrigin.useScope override fun isInheritor(baseClass: PsiClass, checkDeep: Boolean): Boolean { + if (manager.areElementsEquivalent(baseClass, this)) return false LightClassInheritanceHelper.getService(project).isInheritor(this, baseClass, checkDeep).ifSure { return it } val baseKtClass = (baseClass as? KtLightClass)?.kotlinOrigin ?: return false val baseDescriptor = baseKtClass.resolveToDescriptorIfAny() ?: return false val thisDescriptor = kotlinOrigin.resolveToDescriptorIfAny() ?: return false + + val thisFqName = DescriptorUtils.getFqName(thisDescriptor).asString() + val baseFqName = DescriptorUtils.getFqName(baseDescriptor).asString() + if (thisFqName == baseFqName) return false + return if (checkDeep) DescriptorUtils.isSubclass(thisDescriptor, baseDescriptor) else diff --git a/idea/tests/org/jetbrains/kotlin/asJava/KotlinLightClassInheritorTest.kt b/idea/tests/org/jetbrains/kotlin/asJava/KotlinLightClassInheritorTest.kt index f1b3f9afbdf..b1e7f7a9489 100644 --- a/idea/tests/org/jetbrains/kotlin/asJava/KotlinLightClassInheritorTest.kt +++ b/idea/tests/org/jetbrains/kotlin/asJava/KotlinLightClassInheritorTest.kt @@ -38,12 +38,16 @@ class KotlinLightClassInheritorTest : KotlinLightCodeInsightFixtureTestCase() { doTestInheritorByText("abstract class A : List", "java.lang.Object", true) } - private fun doTestInheritorByText(text: String, superQName: String, checkDeep: Boolean) { + fun testClassOnSelfDeep() { + doTestInheritorByText("class A", "A", checkDeep = true, result = false) + } + + private fun doTestInheritorByText(text: String, superQName: String, checkDeep: Boolean, result: Boolean = true) { val file = myFixture.configureByText("A.kt", text) as KtFile val jetClass = file.declarations.filterIsInstance().single() val psiClass = KotlinAsJavaSupport.getInstance(project).getLightClass(jetClass)!! val baseClass = JavaPsiFacade.getInstance(project).findClass(superQName, GlobalSearchScope.allScope(project))!! - Assert.assertTrue(psiClass.isInheritor(baseClass, checkDeep)) + Assert.assertEquals(psiClass.isInheritor(baseClass, checkDeep), result) } override fun getProjectDescriptor(): LightProjectDescriptor = KotlinLightProjectDescriptor.INSTANCE From 010a2901322637580902d15b9c75f36bec43db2e Mon Sep 17 00:00:00 2001 From: Igor Yakovlev Date: Mon, 14 Dec 2020 23:53:19 +0300 Subject: [PATCH 020/196] [LC] Fix for light classes equivalence --- .../kotlin/asJava/classes/KtLightClassForFacade.kt | 6 +++--- .../kotlin/asJava/classes/KtLightClassForScript.kt | 8 +++++--- .../classes/KtLightClassForSourceDeclaration.kt | 11 +++++------ 3 files changed, 13 insertions(+), 12 deletions(-) diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/KtLightClassForFacade.kt b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/KtLightClassForFacade.kt index b89c7b2623b..dce4f2006dc 100644 --- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/KtLightClassForFacade.kt +++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/KtLightClassForFacade.kt @@ -190,9 +190,9 @@ open class KtLightClassForFacade constructor( override fun getNavigationElement() = firstFileInFacade - override fun isEquivalentTo(another: PsiElement?): Boolean { - return another is KtLightClassForFacade && Comparing.equal(another.qualifiedName, qualifiedName) - } + override fun isEquivalentTo(another: PsiElement?): Boolean = + equals(another) || + (another is KtLightClassForFacade && another.facadeClassFqName == facadeClassFqName) override fun getElementIcon(flags: Int): Icon? = throw UnsupportedOperationException("This should be done by JetIconProvider") diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/KtLightClassForScript.kt b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/KtLightClassForScript.kt index 9892fbc5cfa..832f6562297 100644 --- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/KtLightClassForScript.kt +++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/KtLightClassForScript.kt @@ -123,9 +123,11 @@ open class KtLightClassForScript(val script: KtScript) : KtLazyLightClass(script override fun getNavigationElement() = script override fun isEquivalentTo(another: PsiElement?): Boolean = - another is PsiClass && Comparing.equal(another.qualifiedName, qualifiedName) + equals(another) || + (another is KtLightClassForScript && fqName == another.fqName) - override fun getElementIcon(flags: Int): Icon? = throw UnsupportedOperationException("This should be done by JetIconProvider") + override fun getElementIcon(flags: Int): Icon? = + throw UnsupportedOperationException("This should be done by JetIconProvider") override val originKind: LightClassOriginKind get() = LightClassOriginKind.SOURCE @@ -174,7 +176,7 @@ open class KtLightClassForScript(val script: KtScript) : KtLazyLightClass(script return false } - val lightClass = other as KtLightClassForScript + val lightClass = other as? KtLightClassForScript ?: return false if (this === other) return true if (this.hashCode != lightClass.hashCode) return false diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/KtLightClassForSourceDeclaration.kt b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/KtLightClassForSourceDeclaration.kt index bb844689d7f..e568c6c74b6 100644 --- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/KtLightClassForSourceDeclaration.kt +++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/KtLightClassForSourceDeclaration.kt @@ -152,14 +152,13 @@ abstract class KtLightClassForSourceDeclaration( override fun getNavigationElement(): PsiElement = classOrObject - override fun isEquivalentTo(another: PsiElement?): Boolean { - return kotlinOrigin.isEquivalentTo(another) || - another is KtLightClassForSourceDeclaration && Comparing.equal(another.qualifiedName, qualifiedName) - } + override fun isEquivalentTo(another: PsiElement?): Boolean = + kotlinOrigin.isEquivalentTo(another) || + equals(another) || + (qualifiedName != null && another is KtLightClassForSourceDeclaration && qualifiedName == another.qualifiedName) - override fun getElementIcon(flags: Int): Icon? { + override fun getElementIcon(flags: Int): Icon? = throw UnsupportedOperationException("This should be done by JetIconProvider") - } override fun equals(other: Any?): Boolean { if (this === other) return true From 6e9ac6b333875e3daf2f0c4f6ca253312c3bf01b Mon Sep 17 00:00:00 2001 From: Dmitriy Dolovov Date: Mon, 14 Dec 2020 09:33:39 +0300 Subject: [PATCH 021/196] [Commonizer] Internal tool for tracking memory usage --- .../utils/CommonizerMemoryTracker.kt | 100 ++++++++++++++++++ 1 file changed, 100 insertions(+) create mode 100644 native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/utils/CommonizerMemoryTracker.kt diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/utils/CommonizerMemoryTracker.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/utils/CommonizerMemoryTracker.kt new file mode 100644 index 00000000000..68caab6b916 --- /dev/null +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/utils/CommonizerMemoryTracker.kt @@ -0,0 +1,100 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.descriptors.commonizer.utils + +import java.io.Writer +import java.util.concurrent.atomic.AtomicReference + +/** + * Internal tool for tracking the memory used by the commonizer. + */ +@Suppress("unused") +internal object CommonizerMemoryTracker { + private class CommonizerMemoryTrackerRunner( + phaseName: String, + private val intervalMillis: Long, + private val forceGC: Boolean, + private val writerFactory: () -> Writer + ) : Thread("CommonizerMemoryTrackerRunner") { + private val runtime = Runtime.getRuntime() + private val phaseName = AtomicReference(phaseName) + + fun updatePhase(phaseName: String) { + this.phaseName.set(phaseName) + } + + override fun run() { + writerFactory().use { writer -> + writer.writeHeader() + + val startTime = System.currentTimeMillis() + + try { + while (!interrupted()) { + if (forceGC) { + runtime.gc() + } + + val currentTime = System.currentTimeMillis() - startTime + + val free = runtime.freeMemory() + val total = runtime.totalMemory() + val used = total - free + val max = runtime.maxMemory() + + writer.writeRow(currentTime, phaseName.get(), used, free, total, max) + + sleep(intervalMillis) + } + } catch (_: InterruptedException) { + // do nothing, just leave the loop + } + } + } + } + + private val activeRunner = AtomicReference() + + fun startTracking(phaseName: String, intervalMillis: Long, forceGC: Boolean) { + val runner = CommonizerMemoryTrackerRunner(phaseName, intervalMillis, forceGC) { + System.out.writer() // TODO: add ability to supply custom writer here + } + + check(activeRunner.compareAndSet(null, runner)) { "There is another active runner" } + + runner.start() + } + + fun updatePhase(phaseName: String) { + activeRunner.get()?.updatePhase(phaseName) ?: error("No active runner") + } + + fun stopTracking() { + val runner = activeRunner.getAndSet(null) ?: error("No active runner") + runner.interrupt() + } + + private fun Writer.writeHeader() { + write("time;phase;used;free;total;max\n") + } + + private fun Writer.writeRow(time: Long, phaseName: String, used: Long, free: Long, total: Long, max: Long) { + fun Long.toMBs() = (this / 1024 / 1024).toString() + + write(time.toString()) + write(";") + write(phaseName) + write(";") + write(used.toMBs()) + write(";") + write(free.toMBs()) + write(";") + write(total.toMBs()) + write(";") + write(max.toMBs()) + write("\n") + } +} From f7ade2b0b847f2e4a9d0d335e69cc7d5d6200ada Mon Sep 17 00:00:00 2001 From: Jinseong Jeon Date: Thu, 10 Dec 2020 22:16:31 -0800 Subject: [PATCH 022/196] FIR2IR: introduce implicit casts for extension receivers --- .../generators/CallAndReferenceGenerator.kt | 14 ++++++++++++-- ...abilityAssertionOnInlineFunExtensionReceiver.kt | 1 - ...ityAssertionOnPrivateMemberExtensionReceiver.kt | 1 - ...icitNotNullInDestructuringAssignment.fir.kt.txt | 2 +- ...mplicitNotNullInDestructuringAssignment.fir.txt | 3 ++- ...NullabilityInDestructuringAssignment.fir.kt.txt | 2 +- ...cedNullabilityInDestructuringAssignment.fir.txt | 3 ++- ...labilityAssertionOnExtensionReceiver.fir.kt.txt | 4 ++-- ...nullabilityAssertionOnExtensionReceiver.fir.txt | 6 ++++-- 9 files changed, 24 insertions(+), 12 deletions(-) diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt index 671e8c62eda..35353eda734 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt @@ -5,7 +5,6 @@ package org.jetbrains.kotlin.fir.backend.generators -import org.jetbrains.kotlin.descriptors.Visibilities import org.jetbrains.kotlin.fir.FirFakeSourceElementKind import org.jetbrains.kotlin.fir.backend.* import org.jetbrains.kotlin.fir.declarations.* @@ -720,7 +719,18 @@ class CallAndReferenceGenerator( dispatchReceiver = qualifiedAccess.findIrDispatchReceiver(explicitReceiverExpression) } if (ownerFunction?.extensionReceiverParameter != null) { - extensionReceiver = qualifiedAccess.findIrExtensionReceiver(explicitReceiverExpression) + extensionReceiver = qualifiedAccess.findIrExtensionReceiver(explicitReceiverExpression)?.let { + ((qualifiedAccess.calleeReference as FirResolvedNamedReference) + .resolvedSymbol.fir as? FirCallableMemberDeclaration)?.receiverTypeRef?.let { receiverType -> + with(visitor.implicitCastInserter) { + it.cast( + qualifiedAccess.extensionReceiver, + qualifiedAccess.extensionReceiver.typeRef, + receiverType + ) + } + } ?: it + } } this } diff --git a/compiler/testData/codegen/box/javaInterop/notNullAssertions/nullabilityAssertionOnInlineFunExtensionReceiver.kt b/compiler/testData/codegen/box/javaInterop/notNullAssertions/nullabilityAssertionOnInlineFunExtensionReceiver.kt index dcdeeb29810..61e9b7eb70c 100644 --- a/compiler/testData/codegen/box/javaInterop/notNullAssertions/nullabilityAssertionOnInlineFunExtensionReceiver.kt +++ b/compiler/testData/codegen/box/javaInterop/notNullAssertions/nullabilityAssertionOnInlineFunExtensionReceiver.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR // TARGET_BACKEND: JVM // WITH_RUNTIME // FILE: test.kt diff --git a/compiler/testData/codegen/box/javaInterop/notNullAssertions/nullabilityAssertionOnPrivateMemberExtensionReceiver.kt b/compiler/testData/codegen/box/javaInterop/notNullAssertions/nullabilityAssertionOnPrivateMemberExtensionReceiver.kt index 194a9c5b8c6..5b1bb29e249 100644 --- a/compiler/testData/codegen/box/javaInterop/notNullAssertions/nullabilityAssertionOnPrivateMemberExtensionReceiver.kt +++ b/compiler/testData/codegen/box/javaInterop/notNullAssertions/nullabilityAssertionOnPrivateMemberExtensionReceiver.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR // TARGET_BACKEND: JVM // WITH_RUNTIME // FILE: test.kt diff --git a/compiler/testData/ir/irText/expressions/implicitNotNullInDestructuringAssignment.fir.kt.txt b/compiler/testData/ir/irText/expressions/implicitNotNullInDestructuringAssignment.fir.kt.txt index e4947d8c8b7..677ce14ca8c 100644 --- a/compiler/testData/ir/irText/expressions/implicitNotNullInDestructuringAssignment.fir.kt.txt +++ b/compiler/testData/ir/irText/expressions/implicitNotNullInDestructuringAssignment.fir.kt.txt @@ -9,5 +9,5 @@ private operator fun J.component2(): Int { fun test() { val : J? = j() val a: Int = .component1() - val b: Int = .component2() + val b: Int = /*!! J */.component2() } diff --git a/compiler/testData/ir/irText/expressions/implicitNotNullInDestructuringAssignment.fir.txt b/compiler/testData/ir/irText/expressions/implicitNotNullInDestructuringAssignment.fir.txt index 2d59e98bfae..69675bd72a9 100644 --- a/compiler/testData/ir/irText/expressions/implicitNotNullInDestructuringAssignment.fir.txt +++ b/compiler/testData/ir/irText/expressions/implicitNotNullInDestructuringAssignment.fir.txt @@ -18,4 +18,5 @@ FILE fqName: fileName:/implicitNotNullInDestructuringAssignment.kt $receiver: GET_VAR 'val tmp_0: .J? [val] declared in .test' type=.J? origin=null VAR name:b type:kotlin.Int [val] CALL 'private final fun component2 (): kotlin.Int [operator] declared in ' type=kotlin.Int origin=null - $receiver: GET_VAR 'val tmp_0: .J? [val] declared in .test' type=.J? origin=null + $receiver: TYPE_OP type=.J origin=IMPLICIT_NOTNULL typeOperand=.J + GET_VAR 'val tmp_0: .J? [val] declared in .test' type=.J? origin=null diff --git a/compiler/testData/ir/irText/types/nullChecks/enhancedNullabilityInDestructuringAssignment.fir.kt.txt b/compiler/testData/ir/irText/types/nullChecks/enhancedNullabilityInDestructuringAssignment.fir.kt.txt index e9c15dc1d1e..6434991f23f 100644 --- a/compiler/testData/ir/irText/types/nullChecks/enhancedNullabilityInDestructuringAssignment.fir.kt.txt +++ b/compiler/testData/ir/irText/types/nullChecks/enhancedNullabilityInDestructuringAssignment.fir.kt.txt @@ -80,7 +80,7 @@ fun test3() { } fun test4() { - val : IndexedValue = listOfNotNull().withIndex().first>() + val : IndexedValue = listOfNotNull() /*!! List */.withIndex().first>() val x: Int = .component1() val y: P? = .component2() use(x = x, y = y /*!! P */) diff --git a/compiler/testData/ir/irText/types/nullChecks/enhancedNullabilityInDestructuringAssignment.fir.txt b/compiler/testData/ir/irText/types/nullChecks/enhancedNullabilityInDestructuringAssignment.fir.txt index 2fb5458168d..71b5565933a 100644 --- a/compiler/testData/ir/irText/types/nullChecks/enhancedNullabilityInDestructuringAssignment.fir.txt +++ b/compiler/testData/ir/irText/types/nullChecks/enhancedNullabilityInDestructuringAssignment.fir.txt @@ -179,7 +179,8 @@ FILE fqName: fileName:/enhancedNullabilityInDestructuringAssignment.kt : kotlin.collections.IndexedValue<.P?> $receiver: CALL 'public final fun withIndex (): kotlin.collections.Iterable> declared in kotlin.collections' type=kotlin.collections.Iterable.P?>> origin=null : .P? - $receiver: CALL 'public open fun listOfNotNull (): kotlin.collections.List<.P?>? declared in .J' type=kotlin.collections.List<.P?>? origin=null + $receiver: TYPE_OP type=kotlin.collections.List<.P?> origin=IMPLICIT_NOTNULL typeOperand=kotlin.collections.List<.P?> + CALL 'public open fun listOfNotNull (): kotlin.collections.List<.P?>? declared in .J' type=kotlin.collections.List<.P?>? origin=null VAR name:x type:kotlin.Int [val] CALL 'public final fun component1 (): kotlin.Int [operator] declared in kotlin.collections.IndexedValue' type=kotlin.Int origin=null $this: GET_VAR 'val tmp_3: kotlin.collections.IndexedValue<.P?> [val] declared in .test4' type=kotlin.collections.IndexedValue<.P?> origin=null diff --git a/compiler/testData/ir/irText/types/nullChecks/nullabilityAssertionOnExtensionReceiver.fir.kt.txt b/compiler/testData/ir/irText/types/nullChecks/nullabilityAssertionOnExtensionReceiver.fir.kt.txt index df7c948dfc6..13b5113cbc9 100644 --- a/compiler/testData/ir/irText/types/nullChecks/nullabilityAssertionOnExtensionReceiver.fir.kt.txt +++ b/compiler/testData/ir/irText/types/nullChecks/nullabilityAssertionOnExtensionReceiver.fir.kt.txt @@ -14,9 +14,9 @@ class C { } fun testExt() { - s().extension() + s() /*!! String */.extension() } fun C.testMemberExt() { - (, s()).memberExtension() + (, s() /*!! String */).memberExtension() } diff --git a/compiler/testData/ir/irText/types/nullChecks/nullabilityAssertionOnExtensionReceiver.fir.txt b/compiler/testData/ir/irText/types/nullChecks/nullabilityAssertionOnExtensionReceiver.fir.txt index 5606e1b25d3..e9ca8d32ba0 100644 --- a/compiler/testData/ir/irText/types/nullChecks/nullabilityAssertionOnExtensionReceiver.fir.txt +++ b/compiler/testData/ir/irText/types/nullChecks/nullabilityAssertionOnExtensionReceiver.fir.txt @@ -28,10 +28,12 @@ FILE fqName: fileName:/nullabilityAssertionOnExtensionReceiver.kt FUN name:testExt visibility:public modality:FINAL <> () returnType:kotlin.Unit BLOCK_BODY CALL 'public final fun extension (): kotlin.Unit declared in ' type=kotlin.Unit origin=null - $receiver: CALL 'public open fun s (): kotlin.String? declared in .J' type=kotlin.String? origin=null + $receiver: TYPE_OP type=kotlin.String origin=IMPLICIT_NOTNULL typeOperand=kotlin.String + CALL 'public open fun s (): kotlin.String? declared in .J' type=kotlin.String? origin=null FUN name:testMemberExt visibility:public modality:FINAL <> ($receiver:.C) returnType:kotlin.Unit $receiver: VALUE_PARAMETER name: type:.C BLOCK_BODY CALL 'public final fun memberExtension (): kotlin.Unit declared in .C' type=kotlin.Unit origin=null $this: GET_VAR ': .C declared in .testMemberExt' type=.C origin=null - $receiver: CALL 'public open fun s (): kotlin.String? declared in .J' type=kotlin.String? origin=null + $receiver: TYPE_OP type=kotlin.String origin=IMPLICIT_NOTNULL typeOperand=kotlin.String + CALL 'public open fun s (): kotlin.String? declared in .J' type=kotlin.String? origin=null From 12cfba9ca966af1b371a89c72e8262f18677b86c Mon Sep 17 00:00:00 2001 From: Jinseong Jeon Date: Fri, 11 Dec 2020 10:43:47 -0800 Subject: [PATCH 023/196] FIR BB: remove stale test ignoring tags in old language versions Since bf06d381 (move old Java nullability assertion tests...), these tests aren't used by (Fir|Ir)BlackBoxCodegenTest anymore. --- .../incWithNullabilityAssertionOnExtensionReceiver_lv11.kt | 1 - .../nullabilityAssertionOnExtensionReceiver_lv11.kt | 1 - 2 files changed, 2 deletions(-) diff --git a/compiler/testData/codegen/box/oldLanguageVersions/javaInterop/notNullAssertions/incWithNullabilityAssertionOnExtensionReceiver_lv11.kt b/compiler/testData/codegen/box/oldLanguageVersions/javaInterop/notNullAssertions/incWithNullabilityAssertionOnExtensionReceiver_lv11.kt index ecbfa827ac1..2b480ab26ea 100644 --- a/compiler/testData/codegen/box/oldLanguageVersions/javaInterop/notNullAssertions/incWithNullabilityAssertionOnExtensionReceiver_lv11.kt +++ b/compiler/testData/codegen/box/oldLanguageVersions/javaInterop/notNullAssertions/incWithNullabilityAssertionOnExtensionReceiver_lv11.kt @@ -1,5 +1,4 @@ // !LANGUAGE: -NullabilityAssertionOnExtensionReceiver -// IGNORE_BACKEND_FIR: JVM_IR // TARGET_BACKEND: JVM // FILE: test.kt // WITH_RUNTIME diff --git a/compiler/testData/codegen/box/oldLanguageVersions/javaInterop/notNullAssertions/nullabilityAssertionOnExtensionReceiver_lv11.kt b/compiler/testData/codegen/box/oldLanguageVersions/javaInterop/notNullAssertions/nullabilityAssertionOnExtensionReceiver_lv11.kt index c7359c86c38..8751d513e31 100644 --- a/compiler/testData/codegen/box/oldLanguageVersions/javaInterop/notNullAssertions/nullabilityAssertionOnExtensionReceiver_lv11.kt +++ b/compiler/testData/codegen/box/oldLanguageVersions/javaInterop/notNullAssertions/nullabilityAssertionOnExtensionReceiver_lv11.kt @@ -1,5 +1,4 @@ // !LANGUAGE: -NullabilityAssertionOnExtensionReceiver -// IGNORE_BACKEND_FIR: JVM_IR // TARGET_BACKEND: JVM // WITH_RUNTIME // FILE: test.kt From b0f6461fa9fee792ec7d9d295eb97e567a987691 Mon Sep 17 00:00:00 2001 From: Dmitry Petrov Date: Mon, 14 Dec 2020 11:53:13 +0300 Subject: [PATCH 024/196] JVM_IR KT-42020 special IdSignature for some fake override members --- ...mpileKotlinAgainstKotlinTestGenerated.java | 5 + .../ir/FirBlackBoxCodegenTestGenerated.java | 5 + .../kotlin/fir/Fir2IrTextTestGenerated.java | 5 + .../jetbrains/kotlin/ir/util/IdSignature.kt | 58 +++ .../signature/IdSignatureBuilder.kt | 28 +- .../serialization/JvmIdSignatureDescriptor.kt | 78 ++- .../box/ir/clashingFakeOverrideSignatures.kt | 29 ++ .../signatureClash.kt | 1 - .../clashingFakeOverrideSignatures.kt | 33 ++ .../clashingFakeOverrideSignatures.fir.txt | 474 ++++++++++++++++++ .../classes/clashingFakeOverrideSignatures.kt | 67 +++ .../clashingFakeOverrideSignatures.kt.txt | 172 +++++++ .../clashingFakeOverrideSignatures.txt | 474 ++++++++++++++++++ .../kotlin/ir/AbstractIrGeneratorTestCase.kt | 38 +- .../codegen/BlackBoxCodegenTestGenerated.java | 5 + ...mpileKotlinAgainstKotlinTestGenerated.java | 5 + .../LightAnalysisModeTestGenerated.java | 5 + .../ir/IrBlackBoxCodegenTestGenerated.java | 5 + ...mpileKotlinAgainstKotlinTestGenerated.java | 5 + .../ir/JvmIrAgainstOldBoxTestGenerated.java | 5 + .../ir/JvmOldAgainstIrBoxTestGenerated.java | 5 + .../kotlin/ir/IrTextTestCaseGenerated.java | 5 + 22 files changed, 1487 insertions(+), 20 deletions(-) create mode 100644 compiler/testData/codegen/box/ir/clashingFakeOverrideSignatures.kt create mode 100644 compiler/testData/compileKotlinAgainstKotlin/clashingFakeOverrideSignatures.kt create mode 100644 compiler/testData/ir/irText/classes/clashingFakeOverrideSignatures.fir.txt create mode 100644 compiler/testData/ir/irText/classes/clashingFakeOverrideSignatures.kt create mode 100644 compiler/testData/ir/irText/classes/clashingFakeOverrideSignatures.kt.txt create mode 100644 compiler/testData/ir/irText/classes/clashingFakeOverrideSignatures.txt diff --git a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/codegen/FirCompileKotlinAgainstKotlinTestGenerated.java b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/codegen/FirCompileKotlinAgainstKotlinTestGenerated.java index 0c5b20dbeba..457db0f0a30 100644 --- a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/codegen/FirCompileKotlinAgainstKotlinTestGenerated.java +++ b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/codegen/FirCompileKotlinAgainstKotlinTestGenerated.java @@ -54,6 +54,11 @@ public class FirCompileKotlinAgainstKotlinTestGenerated extends AbstractFirCompi runTest("compiler/testData/compileKotlinAgainstKotlin/callsToMultifileClassFromOtherPackage.kt"); } + @TestMetadata("clashingFakeOverrideSignatures.kt") + public void testClashingFakeOverrideSignatures() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/clashingFakeOverrideSignatures.kt"); + } + @TestMetadata("classInObject.kt") public void testClassInObject() throws Exception { runTest("compiler/testData/compileKotlinAgainstKotlin/classInObject.kt"); diff --git a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/codegen/ir/FirBlackBoxCodegenTestGenerated.java b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/codegen/ir/FirBlackBoxCodegenTestGenerated.java index 4ae34240eab..3f083066ccb 100644 --- a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/codegen/ir/FirBlackBoxCodegenTestGenerated.java +++ b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/codegen/ir/FirBlackBoxCodegenTestGenerated.java @@ -15937,6 +15937,11 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT runTest("compiler/testData/codegen/box/ir/anonymousObjectInsideElvis.kt"); } + @TestMetadata("clashingFakeOverrideSignatures.kt") + public void testClashingFakeOverrideSignatures() throws Exception { + runTest("compiler/testData/codegen/box/ir/clashingFakeOverrideSignatures.kt"); + } + @TestMetadata("classInitializers.kt") public void testClassInitializers() throws Exception { runTest("compiler/testData/codegen/box/ir/classInitializers.kt"); diff --git a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/fir/Fir2IrTextTestGenerated.java b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/fir/Fir2IrTextTestGenerated.java index a6d9d2f26b7..8f879e3820d 100644 --- a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/fir/Fir2IrTextTestGenerated.java +++ b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/fir/Fir2IrTextTestGenerated.java @@ -56,6 +56,11 @@ public class Fir2IrTextTestGenerated extends AbstractFir2IrTextTest { runTest("compiler/testData/ir/irText/classes/argumentReorderingInDelegatingConstructorCall.kt"); } + @TestMetadata("clashingFakeOverrideSignatures.kt") + public void testClashingFakeOverrideSignatures() throws Exception { + runTest("compiler/testData/ir/irText/classes/clashingFakeOverrideSignatures.kt"); + } + @TestMetadata("classMembers.kt") public void testClassMembers() throws Exception { runTest("compiler/testData/ir/irText/classes/classMembers.kt"); diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IdSignature.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IdSignature.kt index 7c47602d92e..6be2a847b46 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IdSignature.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IdSignature.kt @@ -114,6 +114,64 @@ sealed class IdSignature { override fun hashCode(): Int = accessorSignature.hashCode() } + // KT-42020 + // This special signature is required to disambiguate fake overrides 'foo(x: T)[T = String]' and 'foo(x: String)' in the code below: + // + // open class Base { + // fun foo(x: T) {} + // fun foo(x: String) {} + // } + // + // class Derived : Base() + // + // (NB similar clash is possible for generic member extension properties as well) + // + // For each fake override 'foo' we collect non-fake overrides overridden by 'foo' + // such that their value parameter types contain type parameters of 'Base', + // sorted by the fully-qualified name of the containing class. + // + // NB this special case of IdSignature is JVM-specific. + class SpecialFakeOverrideSignature( + val memberSignature: IdSignature, + val overriddenSignatures: List + ) : IdSignature() { + override val isPublic: Boolean + get() = memberSignature.isPublic + + override fun topLevelSignature(): IdSignature = + memberSignature.topLevelSignature() + + override fun nearestPublicSig(): IdSignature = + if (memberSignature.isPublic) + this + else + memberSignature.nearestPublicSig() + + override fun packageFqName(): FqName = + memberSignature.packageFqName() + + override fun render(): String = + memberSignature.render() + + override fun equals(other: Any?): Boolean { + if (this === other) return true + if (javaClass != other?.javaClass) return false + + other as SpecialFakeOverrideSignature + + if (memberSignature != other.memberSignature) return false + if (overriddenSignatures != other.overriddenSignatures) return false + + return true + } + + override fun hashCode(): Int { + var result = memberSignature.hashCode() + result = 31 * result + overriddenSignatures.hashCode() + return result + } + } + class FileLocalSignature(val container: IdSignature, val id: Long) : IdSignature() { override val isPublic: Boolean get() = false diff --git a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/signature/IdSignatureBuilder.kt b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/signature/IdSignatureBuilder.kt index 787f6e27202..fd46fd7cdc0 100644 --- a/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/signature/IdSignatureBuilder.kt +++ b/compiler/ir/serialization.common/src/org/jetbrains/kotlin/backend/common/serialization/signature/IdSignatureBuilder.kt @@ -14,6 +14,7 @@ abstract class IdSignatureBuilder { protected val classFqnSegments = mutableListOf() protected var hashId: Long? = null protected var hashIdAcc: Long? = null + protected var overridden: List? = null protected var mask = 0L protected abstract fun accept(d: D) @@ -23,19 +24,30 @@ abstract class IdSignatureBuilder { this.classFqnSegments.clear() this.hashId = null this.mask = 0L + this.overridden = null } protected fun build(): IdSignature { val packageFqName = packageFqn.asString() val classFqName = classFqnSegments.joinToString(".") - return if (hashIdAcc == null) { - IdSignature.PublicSignature(packageFqName, classFqName, hashId, mask) - } else { - val accessorSignature = IdSignature.PublicSignature(packageFqName, classFqName, hashIdAcc, mask) - hashIdAcc = null - classFqnSegments.run { removeAt(lastIndex) } - val propertySignature = build() - IdSignature.AccessorSignature(propertySignature, accessorSignature) + return when { + overridden != null -> { + val preserved = overridden!! + overridden = null + val memberSignature = build() + val overriddenSignatures = preserved.map { buildSignature(it) } + return IdSignature.SpecialFakeOverrideSignature(memberSignature, overriddenSignatures) + } + hashIdAcc == null -> { + IdSignature.PublicSignature(packageFqName, classFqName, hashId, mask) + } + else -> { + val accessorSignature = IdSignature.PublicSignature(packageFqName, classFqName, hashIdAcc, mask) + hashIdAcc = null + classFqnSegments.run { removeAt(lastIndex) } + val propertySignature = build() + IdSignature.AccessorSignature(propertySignature, accessorSignature) + } } } diff --git a/compiler/ir/serialization.jvm/src/org/jetbrains/kotlin/backend/jvm/serialization/JvmIdSignatureDescriptor.kt b/compiler/ir/serialization.jvm/src/org/jetbrains/kotlin/backend/jvm/serialization/JvmIdSignatureDescriptor.kt index eb70b630a80..05372774c96 100644 --- a/compiler/ir/serialization.jvm/src/org/jetbrains/kotlin/backend/jvm/serialization/JvmIdSignatureDescriptor.kt +++ b/compiler/ir/serialization.jvm/src/org/jetbrains/kotlin/backend/jvm/serialization/JvmIdSignatureDescriptor.kt @@ -6,18 +6,92 @@ package org.jetbrains.kotlin.backend.jvm.serialization import org.jetbrains.kotlin.backend.common.serialization.signature.IdSignatureDescriptor -import org.jetbrains.kotlin.descriptors.PropertyDescriptor +import org.jetbrains.kotlin.descriptors.* +import org.jetbrains.kotlin.incremental.components.NoLookupLocation import org.jetbrains.kotlin.ir.util.KotlinMangler import org.jetbrains.kotlin.load.java.descriptors.JavaForKotlinOverridePropertyDescriptor -import org.jetbrains.kotlin.load.java.descriptors.JavaPropertyDescriptor +import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameUnsafe +import org.jetbrains.kotlin.resolve.descriptorUtil.overriddenTreeAsSequence +import org.jetbrains.kotlin.types.KotlinType +import org.jetbrains.kotlin.types.typeUtil.contains +import org.jetbrains.kotlin.utils.addToStdlib.cast class JvmIdSignatureDescriptor(private val mangler: KotlinMangler.DescriptorMangler) : IdSignatureDescriptor(mangler) { private class JvmDescriptorBasedSignatureBuilder(mangler: KotlinMangler.DescriptorMangler) : DescriptorBasedSignatureBuilder(mangler) { + override fun platformSpecificFunction(descriptor: FunctionDescriptor) { + keepTrackOfOverridesForPossiblyClashingFakeOverride(descriptor) + } + override fun platformSpecificProperty(descriptor: PropertyDescriptor) { // See KT-31646 setSpecialJavaProperty(descriptor is JavaForKotlinOverridePropertyDescriptor) + keepTrackOfOverridesForPossiblyClashingFakeOverride(descriptor) } + + override fun platformSpecificGetter(descriptor: PropertyGetterDescriptor) { + keepTrackOfOverridesForPossiblyClashingFakeOverride(descriptor) + } + + override fun platformSpecificSetter(descriptor: PropertySetterDescriptor) { + keepTrackOfOverridesForPossiblyClashingFakeOverride(descriptor) + } + + private fun keepTrackOfOverridesForPossiblyClashingFakeOverride(descriptor: CallableMemberDescriptor) { + if (descriptor.kind != CallableMemberDescriptor.Kind.FAKE_OVERRIDE) return + val containingClass = descriptor.containingDeclaration as? ClassDescriptor ?: return + + val possiblyClashingMembers = when (descriptor) { + is PropertyAccessorDescriptor -> + containingClass.unsubstitutedMemberScope + .getContributedVariables(descriptor.correspondingProperty.name, NoLookupLocation.FROM_BACKEND) + is PropertyDescriptor -> + containingClass.unsubstitutedMemberScope + .getContributedVariables(descriptor.name, NoLookupLocation.FROM_BACKEND) + is FunctionDescriptor -> + containingClass.unsubstitutedMemberScope + .getContributedFunctions(descriptor.name, NoLookupLocation.FROM_BACKEND) + else -> + throw AssertionError("Unexpected CallableMemberDescriptor: $descriptor") + } + if (possiblyClashingMembers.size <= 1) return + + val capturingOverrides = descriptor.overriddenTreeAsSequence(true).filter { + it.kind != CallableMemberDescriptor.Kind.FAKE_OVERRIDE && isCapturingTypeParameter(it) + }.toList() + if (capturingOverrides.isNotEmpty()) { + overridden = capturingOverrides.sortedBy { + it.containingDeclaration.cast().fqNameUnsafe.asString() + } + } + } + + private fun isCapturingTypeParameter(member: CallableMemberDescriptor): Boolean { + val containingClasses = collectContainingClasses(member) + return member.extensionReceiverParameter?.isCapturingTypeParameter(containingClasses) == true || + member.valueParameters.any { it.isCapturingTypeParameter(containingClasses) } + } + + private fun collectContainingClasses(member: CallableMemberDescriptor): Set { + val result = HashSet() + var pointer: DeclarationDescriptor = member + while (true) { + val containingClass = pointer.containingDeclaration as? ClassDescriptor ?: break + result.add(containingClass) + if (!containingClass.isInner) break + pointer = containingClass + } + return result + } + + private fun ParameterDescriptor.isCapturingTypeParameter(containingClasses: Set): Boolean = + type.containsTypeParametersOf(containingClasses) + + private fun KotlinType.containsTypeParametersOf(containingClasses: Set): Boolean = + contains { + val descriptor = it.constructor.declarationDescriptor + descriptor is TypeParameterDescriptor && descriptor.containingDeclaration in containingClasses + } } override fun createSignatureBuilder(): DescriptorBasedSignatureBuilder = JvmDescriptorBasedSignatureBuilder(mangler) diff --git a/compiler/testData/codegen/box/ir/clashingFakeOverrideSignatures.kt b/compiler/testData/codegen/box/ir/clashingFakeOverrideSignatures.kt new file mode 100644 index 00000000000..60c64b33496 --- /dev/null +++ b/compiler/testData/codegen/box/ir/clashingFakeOverrideSignatures.kt @@ -0,0 +1,29 @@ +// TARGET_BACKEND: JVM +// IGNORE_BACKEND_FIR: JVM_IR +// ^ TODO decide if we want to fix KT-42020 for FIR as well + +open class Base { + fun foo(x: T) = "x:$x" + fun foo(y: String) = "y:$y" +} + +open class Derived : Base() + +fun box(): String { + val b = Base() + val test1 = b.foo(x = "O") + b.foo(y = "K") + if (test1 != "x:Oy:K") + throw Exception("test1: $test1") + + val d = Derived() + val test2 = d.foo(x = "O") + d.foo(y = "K") + if (test2 != "x:Oy:K") + throw Exception("test2: $test2") + + val bd: Base = Derived() + val test4 = bd.foo(x = "O") + bd.foo(y = "K") + if (test4 != "x:Oy:K") + throw Exception("test4: $test4") + + return "OK" +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/ir/serializationRegressions/signatureClash.kt b/compiler/testData/codegen/box/ir/serializationRegressions/signatureClash.kt index 5c77a53a785..941a82ebc86 100644 --- a/compiler/testData/codegen/box/ir/serializationRegressions/signatureClash.kt +++ b/compiler/testData/codegen/box/ir/serializationRegressions/signatureClash.kt @@ -3,7 +3,6 @@ // IGNORE_BACKEND: JS // IGNORE_BACKEND: JS_IR // IGNORE_BACKEND: JS_IR_ES6 -// IGNORE_BACKEND: JVM_IR // IGNORE_BACKEND: NATIVE // IGNORE_BACKEND_FIR: JVM_IR // MODULE: lib diff --git a/compiler/testData/compileKotlinAgainstKotlin/clashingFakeOverrideSignatures.kt b/compiler/testData/compileKotlinAgainstKotlin/clashingFakeOverrideSignatures.kt new file mode 100644 index 00000000000..eb06a1ded37 --- /dev/null +++ b/compiler/testData/compileKotlinAgainstKotlin/clashingFakeOverrideSignatures.kt @@ -0,0 +1,33 @@ +// IGNORE_BACKEND_FIR: JVM_IR +// ^ TODO decide if we want to fix KT-42020 for FIR as well +// FILE: a.kt +package a + +open class Base { + fun foo(x: T) = "x:$x" + fun foo(y: String) = "y:$y" +} + +// FILE: b.kt +import a.Base + +open class Derived : Base() + +fun box(): String { + val b = Base() + val test1 = b.foo(x = "O") + b.foo(y = "K") + if (test1 != "x:Oy:K") + throw Exception("test1: $test1") + + val d = Derived() + val test2 = d.foo(x = "O") + d.foo(y = "K") + if (test2 != "x:Oy:K") + throw Exception("test2: $test2") + + val bd: Base = Derived() + val test4 = bd.foo(x = "O") + bd.foo(y = "K") + if (test4 != "x:Oy:K") + throw Exception("test4: $test4") + + return "OK" +} diff --git a/compiler/testData/ir/irText/classes/clashingFakeOverrideSignatures.fir.txt b/compiler/testData/ir/irText/classes/clashingFakeOverrideSignatures.fir.txt new file mode 100644 index 00000000000..59492cee3a0 --- /dev/null +++ b/compiler/testData/ir/irText/classes/clashingFakeOverrideSignatures.fir.txt @@ -0,0 +1,474 @@ +FILE fqName: fileName:/clashingFakeOverrideSignatures.kt + CLASS CLASS name:Base modality:OPEN visibility:public superTypes:[kotlin.Any] + $this: VALUE_PARAMETER INSTANCE_RECEIVER name: type:.Base.Base> + TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] + CONSTRUCTOR visibility:public <> () returnType:.Base.Base> [primary] + BLOCK_BODY + DELEGATING_CONSTRUCTOR_CALL 'public constructor () [primary] declared in kotlin.Any' + INSTANCE_INITIALIZER_CALL classDescriptor='CLASS CLASS name:Base modality:OPEN visibility:public superTypes:[kotlin.Any]' + FUN name:foo visibility:public modality:FINAL <> ($this:.Base.Base>, x:T of .Base) returnType:kotlin.Unit + $this: VALUE_PARAMETER name: type:.Base.Base> + VALUE_PARAMETER name:x index:0 type:T of .Base + BLOCK_BODY + FUN name:foo visibility:public modality:FINAL <> ($this:.Base.Base>, y:kotlin.String) returnType:kotlin.Unit + $this: VALUE_PARAMETER name: type:.Base.Base> + VALUE_PARAMETER name:y index:0 type:kotlin.String + BLOCK_BODY + PROPERTY name:bar visibility:public modality:FINAL [val] + FUN name: visibility:public modality:FINAL <> ($this:.Base.Base>, $receiver:T of .Base) returnType:kotlin.Int + correspondingProperty: PROPERTY name:bar visibility:public modality:FINAL [val] + $this: VALUE_PARAMETER name: type:.Base.Base> + $receiver: VALUE_PARAMETER name: type:T of .Base + BLOCK_BODY + RETURN type=kotlin.Nothing from='public final fun (): kotlin.Int declared in .Base' + CONST Int type=kotlin.Int value=1 + PROPERTY name:bar visibility:public modality:FINAL [val] + FUN name: visibility:public modality:FINAL <> ($this:.Base.Base>, $receiver:kotlin.String) returnType:kotlin.Int + correspondingProperty: PROPERTY name:bar visibility:public modality:FINAL [val] + $this: VALUE_PARAMETER name: type:.Base.Base> + $receiver: VALUE_PARAMETER name: type:kotlin.String + BLOCK_BODY + RETURN type=kotlin.Nothing from='public final fun (): kotlin.Int declared in .Base' + CONST Int type=kotlin.Int value=2 + FUN FAKE_OVERRIDE name:equals visibility:public modality:OPEN <> ($this:kotlin.Any, other:kotlin.Any?) returnType:kotlin.Boolean [fake_override,operator] + overridden: + public open fun equals (other: kotlin.Any?): kotlin.Boolean [operator] declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any + VALUE_PARAMETER name:other index:0 type:kotlin.Any? + FUN FAKE_OVERRIDE name:hashCode visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.Int [fake_override] + overridden: + public open fun hashCode (): kotlin.Int declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any + FUN FAKE_OVERRIDE name:toString visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.String [fake_override] + overridden: + public open fun toString (): kotlin.String declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any + CLASS CLASS name:Derived modality:OPEN visibility:public superTypes:[.Base] + $this: VALUE_PARAMETER INSTANCE_RECEIVER name: type:.Derived + CONSTRUCTOR visibility:public <> () returnType:.Derived [primary] + BLOCK_BODY + DELEGATING_CONSTRUCTOR_CALL 'public constructor () [primary] declared in .Base' + : kotlin.String + INSTANCE_INITIALIZER_CALL classDescriptor='CLASS CLASS name:Derived modality:OPEN visibility:public superTypes:[.Base]' + FUN FAKE_OVERRIDE name:foo visibility:public modality:FINAL <> ($this:.Base.Base>, x:kotlin.String) returnType:kotlin.Unit [fake_override] + overridden: + public final fun foo (y: kotlin.String): kotlin.Unit declared in .Base + $this: VALUE_PARAMETER name: type:.Base.Base> + VALUE_PARAMETER name:x index:0 type:kotlin.String + FUN FAKE_OVERRIDE name:foo visibility:public modality:FINAL <> ($this:.Base.Base>, x:kotlin.String) returnType:kotlin.Unit [fake_override] + overridden: + public final fun foo (y: kotlin.String): kotlin.Unit declared in .Base + $this: VALUE_PARAMETER name: type:.Base.Base> + VALUE_PARAMETER name:x index:0 type:kotlin.String + PROPERTY FAKE_OVERRIDE name:bar visibility:public modality:FINAL [fake_override,val] + FUN FAKE_OVERRIDE name: visibility:public modality:FINAL <> ($this:.Base.Base>, $receiver:kotlin.String) returnType:kotlin.Int [fake_override] + correspondingProperty: PROPERTY FAKE_OVERRIDE name:bar visibility:public modality:FINAL [fake_override,val] + overridden: + public final fun (): kotlin.Int declared in .Base + $this: VALUE_PARAMETER name: type:.Base.Base> + $receiver: VALUE_PARAMETER name: type:kotlin.String + PROPERTY FAKE_OVERRIDE name:bar visibility:public modality:FINAL [fake_override,val] + FUN FAKE_OVERRIDE name: visibility:public modality:FINAL <> ($this:.Base.Base>, $receiver:kotlin.String) returnType:kotlin.Int [fake_override] + correspondingProperty: PROPERTY FAKE_OVERRIDE name:bar visibility:public modality:FINAL [fake_override,val] + overridden: + public final fun (): kotlin.Int declared in .Base + $this: VALUE_PARAMETER name: type:.Base.Base> + $receiver: VALUE_PARAMETER name: type:kotlin.String + FUN FAKE_OVERRIDE name:equals visibility:public modality:OPEN <> ($this:kotlin.Any, other:kotlin.Any?) returnType:kotlin.Boolean [fake_override,operator] + overridden: + public open fun equals (other: kotlin.Any?): kotlin.Boolean [operator] declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any + VALUE_PARAMETER name:other index:0 type:kotlin.Any? + FUN FAKE_OVERRIDE name:hashCode visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.Int [fake_override] + overridden: + public open fun hashCode (): kotlin.Int declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any + FUN FAKE_OVERRIDE name:toString visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.String [fake_override] + overridden: + public open fun toString (): kotlin.String declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any + CLASS CLASS name:Derived2 modality:FINAL visibility:public superTypes:[.Derived] + $this: VALUE_PARAMETER INSTANCE_RECEIVER name: type:.Derived2 + CONSTRUCTOR visibility:public <> () returnType:.Derived2 [primary] + BLOCK_BODY + DELEGATING_CONSTRUCTOR_CALL 'public constructor () [primary] declared in .Derived' + INSTANCE_INITIALIZER_CALL classDescriptor='CLASS CLASS name:Derived2 modality:FINAL visibility:public superTypes:[.Derived]' + FUN FAKE_OVERRIDE name:foo visibility:public modality:FINAL <> ($this:.Base.Base>, x:kotlin.String) returnType:kotlin.Unit [fake_override] + overridden: + public final fun foo (y: kotlin.String): kotlin.Unit declared in .Base + $this: VALUE_PARAMETER name: type:.Base.Base> + VALUE_PARAMETER name:x index:0 type:kotlin.String + FUN FAKE_OVERRIDE name:foo visibility:public modality:FINAL <> ($this:.Base.Base>, x:kotlin.String) returnType:kotlin.Unit [fake_override] + overridden: + public final fun foo (y: kotlin.String): kotlin.Unit declared in .Base + $this: VALUE_PARAMETER name: type:.Base.Base> + VALUE_PARAMETER name:x index:0 type:kotlin.String + PROPERTY FAKE_OVERRIDE name:bar visibility:public modality:FINAL [fake_override,val] + FUN FAKE_OVERRIDE name: visibility:public modality:FINAL <> ($this:.Base.Base>, $receiver:kotlin.String) returnType:kotlin.Int [fake_override] + correspondingProperty: PROPERTY FAKE_OVERRIDE name:bar visibility:public modality:FINAL [fake_override,val] + overridden: + public final fun (): kotlin.Int declared in .Base + $this: VALUE_PARAMETER name: type:.Base.Base> + $receiver: VALUE_PARAMETER name: type:kotlin.String + PROPERTY FAKE_OVERRIDE name:bar visibility:public modality:FINAL [fake_override,val] + FUN FAKE_OVERRIDE name: visibility:public modality:FINAL <> ($this:.Base.Base>, $receiver:kotlin.String) returnType:kotlin.Int [fake_override] + correspondingProperty: PROPERTY FAKE_OVERRIDE name:bar visibility:public modality:FINAL [fake_override,val] + overridden: + public final fun (): kotlin.Int declared in .Base + $this: VALUE_PARAMETER name: type:.Base.Base> + $receiver: VALUE_PARAMETER name: type:kotlin.String + FUN FAKE_OVERRIDE name:equals visibility:public modality:OPEN <> ($this:kotlin.Any, other:kotlin.Any?) returnType:kotlin.Boolean [fake_override,operator] + overridden: + public open fun equals (other: kotlin.Any?): kotlin.Boolean [operator] declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any + VALUE_PARAMETER name:other index:0 type:kotlin.Any? + FUN FAKE_OVERRIDE name:hashCode visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.Int [fake_override] + overridden: + public open fun hashCode (): kotlin.Int declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any + FUN FAKE_OVERRIDE name:toString visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.String [fake_override] + overridden: + public open fun toString (): kotlin.String declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any + FUN name:test visibility:public modality:FINAL <> (b:.Base, d:.Derived, d2:.Derived2) returnType:kotlin.Unit + VALUE_PARAMETER name:b index:0 type:.Base + VALUE_PARAMETER name:d index:1 type:.Derived + VALUE_PARAMETER name:d2 index:2 type:.Derived2 + BLOCK_BODY + CALL 'public final fun foo (x: T of .Base): kotlin.Unit declared in .Base' type=kotlin.Unit origin=null + $this: GET_VAR 'b: .Base declared in .test' type=.Base origin=null + x: CONST String type=kotlin.String value="" + CALL 'public final fun foo (y: kotlin.String): kotlin.Unit declared in .Base' type=kotlin.Unit origin=null + $this: GET_VAR 'b: .Base declared in .test' type=.Base origin=null + y: CONST String type=kotlin.String value="" + CALL 'public final fun foo (x: kotlin.String): kotlin.Unit [fake_override] declared in .Derived' type=kotlin.Unit origin=null + $this: GET_VAR 'd: .Derived declared in .test' type=.Derived origin=null + x: CONST String type=kotlin.String value="" + CALL 'public final fun foo (y: kotlin.String): kotlin.Unit declared in .Base' type=kotlin.Unit origin=null + $this: GET_VAR 'd: .Derived declared in .test' type=.Derived origin=null + y: CONST String type=kotlin.String value="" + CALL 'public final fun foo (x: kotlin.String): kotlin.Unit [fake_override] declared in .Derived' type=kotlin.Unit origin=null + $this: GET_VAR 'd2: .Derived2 declared in .test' type=.Derived2 origin=null + x: CONST String type=kotlin.String value="" + CALL 'public final fun foo (y: kotlin.String): kotlin.Unit declared in .Base' type=kotlin.Unit origin=null + $this: GET_VAR 'd2: .Derived2 declared in .test' type=.Derived2 origin=null + y: CONST String type=kotlin.String value="" + CLASS CLASS name:BaseXY modality:OPEN visibility:public superTypes:[kotlin.Any] + $this: VALUE_PARAMETER INSTANCE_RECEIVER name: type:.BaseXY.BaseXY, Y of .BaseXY> + TYPE_PARAMETER name:X index:0 variance: superTypes:[kotlin.Any?] + TYPE_PARAMETER name:Y index:1 variance: superTypes:[kotlin.Any?] + CONSTRUCTOR visibility:public <> () returnType:.BaseXY.BaseXY, Y of .BaseXY> [primary] + BLOCK_BODY + DELEGATING_CONSTRUCTOR_CALL 'public constructor () [primary] declared in kotlin.Any' + INSTANCE_INITIALIZER_CALL classDescriptor='CLASS CLASS name:BaseXY modality:OPEN visibility:public superTypes:[kotlin.Any]' + FUN name:foo visibility:public modality:FINAL <> ($this:.BaseXY.BaseXY, Y of .BaseXY>, x:X of .BaseXY, y:kotlin.String) returnType:kotlin.Unit + $this: VALUE_PARAMETER name: type:.BaseXY.BaseXY, Y of .BaseXY> + VALUE_PARAMETER name:x index:0 type:X of .BaseXY + VALUE_PARAMETER name:y index:1 type:kotlin.String + BLOCK_BODY + FUN name:foo visibility:public modality:FINAL <> ($this:.BaseXY.BaseXY, Y of .BaseXY>, x:kotlin.String, y:Y of .BaseXY) returnType:kotlin.Unit + $this: VALUE_PARAMETER name: type:.BaseXY.BaseXY, Y of .BaseXY> + VALUE_PARAMETER name:x index:0 type:kotlin.String + VALUE_PARAMETER name:y index:1 type:Y of .BaseXY + BLOCK_BODY + FUN FAKE_OVERRIDE name:equals visibility:public modality:OPEN <> ($this:kotlin.Any, other:kotlin.Any?) returnType:kotlin.Boolean [fake_override,operator] + overridden: + public open fun equals (other: kotlin.Any?): kotlin.Boolean [operator] declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any + VALUE_PARAMETER name:other index:0 type:kotlin.Any? + FUN FAKE_OVERRIDE name:hashCode visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.Int [fake_override] + overridden: + public open fun hashCode (): kotlin.Int declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any + FUN FAKE_OVERRIDE name:toString visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.String [fake_override] + overridden: + public open fun toString (): kotlin.String declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any + CLASS CLASS name:DerivedXY modality:FINAL visibility:public superTypes:[.BaseXY] + $this: VALUE_PARAMETER INSTANCE_RECEIVER name: type:.DerivedXY + CONSTRUCTOR visibility:public <> () returnType:.DerivedXY [primary] + BLOCK_BODY + DELEGATING_CONSTRUCTOR_CALL 'public constructor () [primary] declared in .BaseXY' + : kotlin.String + : kotlin.String + INSTANCE_INITIALIZER_CALL classDescriptor='CLASS CLASS name:DerivedXY modality:FINAL visibility:public superTypes:[.BaseXY]' + FUN FAKE_OVERRIDE name:foo visibility:public modality:FINAL <> ($this:.BaseXY.BaseXY, Y of .BaseXY>, x:kotlin.String, y:kotlin.String) returnType:kotlin.Unit [fake_override] + overridden: + public final fun foo (x: kotlin.String, y: Y of .BaseXY): kotlin.Unit declared in .BaseXY + $this: VALUE_PARAMETER name: type:.BaseXY.BaseXY, Y of .BaseXY> + VALUE_PARAMETER name:x index:0 type:kotlin.String + VALUE_PARAMETER name:y index:1 type:kotlin.String + FUN FAKE_OVERRIDE name:foo visibility:public modality:FINAL <> ($this:.BaseXY.BaseXY, Y of .BaseXY>, x:kotlin.String, y:kotlin.String) returnType:kotlin.Unit [fake_override] + overridden: + public final fun foo (x: kotlin.String, y: Y of .BaseXY): kotlin.Unit declared in .BaseXY + $this: VALUE_PARAMETER name: type:.BaseXY.BaseXY, Y of .BaseXY> + VALUE_PARAMETER name:x index:0 type:kotlin.String + VALUE_PARAMETER name:y index:1 type:kotlin.String + FUN FAKE_OVERRIDE name:equals visibility:public modality:OPEN <> ($this:kotlin.Any, other:kotlin.Any?) returnType:kotlin.Boolean [fake_override,operator] + overridden: + public open fun equals (other: kotlin.Any?): kotlin.Boolean [operator] declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any + VALUE_PARAMETER name:other index:0 type:kotlin.Any? + FUN FAKE_OVERRIDE name:hashCode visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.Int [fake_override] + overridden: + public open fun hashCode (): kotlin.Int declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any + FUN FAKE_OVERRIDE name:toString visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.String [fake_override] + overridden: + public open fun toString (): kotlin.String declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any + FUN name:outerFun visibility:public modality:FINAL <> () returnType:kotlin.Unit + BLOCK_BODY + CLASS CLASS name:LocalBase modality:OPEN visibility:local superTypes:[kotlin.Any] + $this: VALUE_PARAMETER INSTANCE_RECEIVER name: type:.outerFun.LocalBase.outerFun.LocalBase> + TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] + CONSTRUCTOR visibility:public <> () returnType:.outerFun.LocalBase.outerFun.LocalBase> [primary] + BLOCK_BODY + DELEGATING_CONSTRUCTOR_CALL 'public constructor () [primary] declared in kotlin.Any' + INSTANCE_INITIALIZER_CALL classDescriptor='CLASS CLASS name:LocalBase modality:OPEN visibility:local superTypes:[kotlin.Any]' + FUN name:foo visibility:public modality:FINAL <> ($this:.outerFun.LocalBase.outerFun.LocalBase>, x:T of .outerFun.LocalBase) returnType:kotlin.Unit + $this: VALUE_PARAMETER name: type:.outerFun.LocalBase.outerFun.LocalBase> + VALUE_PARAMETER name:x index:0 type:T of .outerFun.LocalBase + BLOCK_BODY + FUN name:foo visibility:public modality:FINAL <> ($this:.outerFun.LocalBase.outerFun.LocalBase>, y:kotlin.String) returnType:kotlin.Unit + $this: VALUE_PARAMETER name: type:.outerFun.LocalBase.outerFun.LocalBase> + VALUE_PARAMETER name:y index:0 type:kotlin.String + BLOCK_BODY + PROPERTY name:bar visibility:public modality:FINAL [val] + FUN name: visibility:public modality:FINAL <> ($this:.outerFun.LocalBase.outerFun.LocalBase>, $receiver:T of .outerFun.LocalBase) returnType:kotlin.Int + correspondingProperty: PROPERTY name:bar visibility:public modality:FINAL [val] + $this: VALUE_PARAMETER name: type:.outerFun.LocalBase.outerFun.LocalBase> + $receiver: VALUE_PARAMETER name: type:T of .outerFun.LocalBase + BLOCK_BODY + RETURN type=kotlin.Nothing from='public final fun (): kotlin.Int declared in .outerFun.LocalBase' + CONST Int type=kotlin.Int value=1 + PROPERTY name:bar visibility:public modality:FINAL [val] + FUN name: visibility:public modality:FINAL <> ($this:.outerFun.LocalBase.outerFun.LocalBase>, $receiver:kotlin.String) returnType:kotlin.Int + correspondingProperty: PROPERTY name:bar visibility:public modality:FINAL [val] + $this: VALUE_PARAMETER name: type:.outerFun.LocalBase.outerFun.LocalBase> + $receiver: VALUE_PARAMETER name: type:kotlin.String + BLOCK_BODY + RETURN type=kotlin.Nothing from='public final fun (): kotlin.Int declared in .outerFun.LocalBase' + CONST Int type=kotlin.Int value=2 + FUN FAKE_OVERRIDE name:equals visibility:public modality:OPEN <> ($this:kotlin.Any, other:kotlin.Any?) returnType:kotlin.Boolean [fake_override,operator] + overridden: + public open fun equals (other: kotlin.Any?): kotlin.Boolean [operator] declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any + VALUE_PARAMETER name:other index:0 type:kotlin.Any? + FUN FAKE_OVERRIDE name:hashCode visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.Int [fake_override] + overridden: + public open fun hashCode (): kotlin.Int declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any + FUN FAKE_OVERRIDE name:toString visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.String [fake_override] + overridden: + public open fun toString (): kotlin.String declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any + CLASS CLASS name:LocalDerived modality:OPEN visibility:local superTypes:[.outerFun.LocalBase] + $this: VALUE_PARAMETER INSTANCE_RECEIVER name: type:.outerFun.LocalDerived + CONSTRUCTOR visibility:public <> () returnType:.outerFun.LocalDerived [primary] + BLOCK_BODY + DELEGATING_CONSTRUCTOR_CALL 'public constructor () [primary] declared in .outerFun.LocalBase' + : kotlin.String + INSTANCE_INITIALIZER_CALL classDescriptor='CLASS CLASS name:LocalDerived modality:OPEN visibility:local superTypes:[.outerFun.LocalBase]' + FUN FAKE_OVERRIDE name:foo visibility:public modality:FINAL <> ($this:.outerFun.LocalBase.outerFun.LocalBase>, x:kotlin.String) returnType:kotlin.Unit [fake_override] + overridden: + public final fun foo (x: T of .outerFun.LocalBase): kotlin.Unit declared in .outerFun.LocalBase + $this: VALUE_PARAMETER name: type:.outerFun.LocalBase.outerFun.LocalBase> + VALUE_PARAMETER name:x index:0 type:kotlin.String + FUN FAKE_OVERRIDE name:foo visibility:public modality:FINAL <> ($this:.outerFun.LocalBase.outerFun.LocalBase>, y:kotlin.String) returnType:kotlin.Unit [fake_override] + overridden: + public final fun foo (y: kotlin.String): kotlin.Unit declared in .outerFun.LocalBase + $this: VALUE_PARAMETER name: type:.outerFun.LocalBase.outerFun.LocalBase> + VALUE_PARAMETER name:y index:0 type:kotlin.String + PROPERTY FAKE_OVERRIDE name:bar visibility:public modality:FINAL [fake_override,val] + FUN FAKE_OVERRIDE name: visibility:public modality:FINAL <> ($this:.outerFun.LocalBase.outerFun.LocalBase>, $receiver:kotlin.String) returnType:kotlin.Int [fake_override] + correspondingProperty: PROPERTY FAKE_OVERRIDE name:bar visibility:public modality:FINAL [fake_override,val] + overridden: + public final fun (): kotlin.Int declared in .outerFun.LocalBase + $this: VALUE_PARAMETER name: type:.outerFun.LocalBase.outerFun.LocalBase> + $receiver: VALUE_PARAMETER name: type:kotlin.String + PROPERTY FAKE_OVERRIDE name:bar visibility:public modality:FINAL [fake_override,val] + FUN FAKE_OVERRIDE name: visibility:public modality:FINAL <> ($this:.outerFun.LocalBase.outerFun.LocalBase>, $receiver:kotlin.String) returnType:kotlin.Int [fake_override] + correspondingProperty: PROPERTY FAKE_OVERRIDE name:bar visibility:public modality:FINAL [fake_override,val] + overridden: + public final fun (): kotlin.Int declared in .outerFun.LocalBase + $this: VALUE_PARAMETER name: type:.outerFun.LocalBase.outerFun.LocalBase> + $receiver: VALUE_PARAMETER name: type:kotlin.String + FUN FAKE_OVERRIDE name:equals visibility:public modality:OPEN <> ($this:kotlin.Any, other:kotlin.Any?) returnType:kotlin.Boolean [fake_override,operator] + overridden: + public open fun equals (other: kotlin.Any?): kotlin.Boolean [operator] declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any + VALUE_PARAMETER name:other index:0 type:kotlin.Any? + FUN FAKE_OVERRIDE name:hashCode visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.Int [fake_override] + overridden: + public open fun hashCode (): kotlin.Int declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any + FUN FAKE_OVERRIDE name:toString visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.String [fake_override] + overridden: + public open fun toString (): kotlin.String declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any + CLASS CLASS name:LocalDerived2 modality:FINAL visibility:local superTypes:[.outerFun.LocalDerived] + $this: VALUE_PARAMETER INSTANCE_RECEIVER name: type:.outerFun.LocalDerived2 + CONSTRUCTOR visibility:public <> () returnType:.outerFun.LocalDerived2 [primary] + BLOCK_BODY + DELEGATING_CONSTRUCTOR_CALL 'public constructor () [primary] declared in .outerFun.LocalDerived' + INSTANCE_INITIALIZER_CALL classDescriptor='CLASS CLASS name:LocalDerived2 modality:FINAL visibility:local superTypes:[.outerFun.LocalDerived]' + FUN FAKE_OVERRIDE name:foo visibility:public modality:FINAL <> ($this:.outerFun.LocalBase.outerFun.LocalBase>, x:kotlin.String) returnType:kotlin.Unit [fake_override] + overridden: + public final fun foo (x: T of .outerFun.LocalBase): kotlin.Unit declared in .outerFun.LocalBase + $this: VALUE_PARAMETER name: type:.outerFun.LocalBase.outerFun.LocalBase> + VALUE_PARAMETER name:x index:0 type:kotlin.String + FUN FAKE_OVERRIDE name:foo visibility:public modality:FINAL <> ($this:.outerFun.LocalBase.outerFun.LocalBase>, y:kotlin.String) returnType:kotlin.Unit [fake_override] + overridden: + public final fun foo (y: kotlin.String): kotlin.Unit declared in .outerFun.LocalBase + $this: VALUE_PARAMETER name: type:.outerFun.LocalBase.outerFun.LocalBase> + VALUE_PARAMETER name:y index:0 type:kotlin.String + PROPERTY FAKE_OVERRIDE name:bar visibility:public modality:FINAL [fake_override,val] + FUN FAKE_OVERRIDE name: visibility:public modality:FINAL <> ($this:.outerFun.LocalBase.outerFun.LocalBase>, $receiver:kotlin.String) returnType:kotlin.Int [fake_override] + correspondingProperty: PROPERTY FAKE_OVERRIDE name:bar visibility:public modality:FINAL [fake_override,val] + overridden: + public final fun (): kotlin.Int declared in .outerFun.LocalBase + $this: VALUE_PARAMETER name: type:.outerFun.LocalBase.outerFun.LocalBase> + $receiver: VALUE_PARAMETER name: type:kotlin.String + PROPERTY FAKE_OVERRIDE name:bar visibility:public modality:FINAL [fake_override,val] + FUN FAKE_OVERRIDE name: visibility:public modality:FINAL <> ($this:.outerFun.LocalBase.outerFun.LocalBase>, $receiver:kotlin.String) returnType:kotlin.Int [fake_override] + correspondingProperty: PROPERTY FAKE_OVERRIDE name:bar visibility:public modality:FINAL [fake_override,val] + overridden: + public final fun (): kotlin.Int declared in .outerFun.LocalBase + $this: VALUE_PARAMETER name: type:.outerFun.LocalBase.outerFun.LocalBase> + $receiver: VALUE_PARAMETER name: type:kotlin.String + FUN FAKE_OVERRIDE name:equals visibility:public modality:OPEN <> ($this:kotlin.Any, other:kotlin.Any?) returnType:kotlin.Boolean [fake_override,operator] + overridden: + public open fun equals (other: kotlin.Any?): kotlin.Boolean [operator] declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any + VALUE_PARAMETER name:other index:0 type:kotlin.Any? + FUN FAKE_OVERRIDE name:hashCode visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.Int [fake_override] + overridden: + public open fun hashCode (): kotlin.Int declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any + FUN FAKE_OVERRIDE name:toString visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.String [fake_override] + overridden: + public open fun toString (): kotlin.String declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any + FUN name:test visibility:local modality:FINAL <> (b:.outerFun.LocalBase, d:.outerFun.LocalDerived, d2:.outerFun.LocalDerived2) returnType:kotlin.Unit + VALUE_PARAMETER name:b index:0 type:.outerFun.LocalBase + VALUE_PARAMETER name:d index:1 type:.outerFun.LocalDerived + VALUE_PARAMETER name:d2 index:2 type:.outerFun.LocalDerived2 + BLOCK_BODY + CALL 'public final fun foo (x: T of .outerFun.LocalBase): kotlin.Unit declared in .outerFun.LocalBase' type=kotlin.Unit origin=null + $this: GET_VAR 'b: .outerFun.LocalBase declared in .outerFun.test' type=.outerFun.LocalBase origin=null + x: CONST String type=kotlin.String value="" + CALL 'public final fun foo (y: kotlin.String): kotlin.Unit declared in .outerFun.LocalBase' type=kotlin.Unit origin=null + $this: GET_VAR 'b: .outerFun.LocalBase declared in .outerFun.test' type=.outerFun.LocalBase origin=null + y: CONST String type=kotlin.String value="" + CALL 'public final fun foo (x: kotlin.String): kotlin.Unit [fake_override] declared in .outerFun.LocalDerived' type=kotlin.Unit origin=null + $this: GET_VAR 'd: .outerFun.LocalDerived declared in .outerFun.test' type=.outerFun.LocalDerived origin=null + x: CONST String type=kotlin.String value="" + CALL 'public final fun foo (y: kotlin.String): kotlin.Unit declared in .outerFun.LocalBase' type=kotlin.Unit origin=null + $this: GET_VAR 'd: .outerFun.LocalDerived declared in .outerFun.test' type=.outerFun.LocalDerived origin=null + y: CONST String type=kotlin.String value="" + CALL 'public final fun foo (x: kotlin.String): kotlin.Unit [fake_override] declared in .outerFun.LocalDerived' type=kotlin.Unit origin=null + $this: GET_VAR 'd2: .outerFun.LocalDerived2 declared in .outerFun.test' type=.outerFun.LocalDerived2 origin=null + x: CONST String type=kotlin.String value="" + CALL 'public final fun foo (y: kotlin.String): kotlin.Unit declared in .outerFun.LocalBase' type=kotlin.Unit origin=null + $this: GET_VAR 'd2: .outerFun.LocalDerived2 declared in .outerFun.test' type=.outerFun.LocalDerived2 origin=null + y: CONST String type=kotlin.String value="" + CLASS CLASS name:Outer modality:OPEN visibility:public superTypes:[kotlin.Any] + $this: VALUE_PARAMETER INSTANCE_RECEIVER name: type:.Outer.Outer> + TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] + CONSTRUCTOR visibility:public <> () returnType:.Outer.Outer> [primary] + BLOCK_BODY + DELEGATING_CONSTRUCTOR_CALL 'public constructor () [primary] declared in kotlin.Any' + INSTANCE_INITIALIZER_CALL classDescriptor='CLASS CLASS name:Outer modality:OPEN visibility:public superTypes:[kotlin.Any]' + CLASS CLASS name:Inner modality:OPEN visibility:public [inner] superTypes:[kotlin.Any] + $this: VALUE_PARAMETER INSTANCE_RECEIVER name: type:.Outer.Inner.Outer> + CONSTRUCTOR visibility:public <> ($this:.Outer.Outer>) returnType:.Outer.Inner.Outer> [primary] + $outer: VALUE_PARAMETER name: type:.Outer.Outer> + BLOCK_BODY + DELEGATING_CONSTRUCTOR_CALL 'public constructor () [primary] declared in kotlin.Any' + INSTANCE_INITIALIZER_CALL classDescriptor='CLASS CLASS name:Inner modality:OPEN visibility:public [inner] superTypes:[kotlin.Any]' + FUN name:foo visibility:public modality:FINAL <> ($this:.Outer.Inner.Outer>, x:T of .Outer) returnType:kotlin.Unit + $this: VALUE_PARAMETER name: type:.Outer.Inner.Outer> + VALUE_PARAMETER name:x index:0 type:T of .Outer + BLOCK_BODY + FUN name:foo visibility:public modality:FINAL <> ($this:.Outer.Inner.Outer>, y:kotlin.String) returnType:kotlin.Unit + $this: VALUE_PARAMETER name: type:.Outer.Inner.Outer> + VALUE_PARAMETER name:y index:0 type:kotlin.String + BLOCK_BODY + FUN FAKE_OVERRIDE name:equals visibility:public modality:OPEN <> ($this:kotlin.Any, other:kotlin.Any?) returnType:kotlin.Boolean [fake_override,operator] + overridden: + public open fun equals (other: kotlin.Any?): kotlin.Boolean [operator] declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any + VALUE_PARAMETER name:other index:0 type:kotlin.Any? + FUN FAKE_OVERRIDE name:hashCode visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.Int [fake_override] + overridden: + public open fun hashCode (): kotlin.Int declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any + FUN FAKE_OVERRIDE name:toString visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.String [fake_override] + overridden: + public open fun toString (): kotlin.String declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any + FUN FAKE_OVERRIDE name:equals visibility:public modality:OPEN <> ($this:kotlin.Any, other:kotlin.Any?) returnType:kotlin.Boolean [fake_override,operator] + overridden: + public open fun equals (other: kotlin.Any?): kotlin.Boolean [operator] declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any + VALUE_PARAMETER name:other index:0 type:kotlin.Any? + FUN FAKE_OVERRIDE name:hashCode visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.Int [fake_override] + overridden: + public open fun hashCode (): kotlin.Int declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any + FUN FAKE_OVERRIDE name:toString visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.String [fake_override] + overridden: + public open fun toString (): kotlin.String declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any + CLASS CLASS name:OuterDerived modality:FINAL visibility:public superTypes:[.Outer] + $this: VALUE_PARAMETER INSTANCE_RECEIVER name: type:.OuterDerived + CONSTRUCTOR visibility:public <> () returnType:.OuterDerived [primary] + BLOCK_BODY + DELEGATING_CONSTRUCTOR_CALL 'public constructor () [primary] declared in .Outer' + : kotlin.String + INSTANCE_INITIALIZER_CALL classDescriptor='CLASS CLASS name:OuterDerived modality:FINAL visibility:public superTypes:[.Outer]' + CLASS CLASS name:InnerDerived modality:FINAL visibility:public [inner] superTypes:[.Outer.Inner] + $this: VALUE_PARAMETER INSTANCE_RECEIVER name: type:.OuterDerived.InnerDerived + CONSTRUCTOR visibility:public <> ($this:.OuterDerived) returnType:.OuterDerived.InnerDerived [primary] + $outer: VALUE_PARAMETER name: type:.OuterDerived + BLOCK_BODY + DELEGATING_CONSTRUCTOR_CALL 'public constructor () [primary] declared in .Outer.Inner' + $this: GET_VAR ': .OuterDerived declared in .OuterDerived' type=.OuterDerived origin=null + INSTANCE_INITIALIZER_CALL classDescriptor='CLASS CLASS name:InnerDerived modality:FINAL visibility:public [inner] superTypes:[.Outer.Inner]' + FUN FAKE_OVERRIDE name:foo visibility:public modality:FINAL <> ($this:.Outer.Inner.Outer>, x:kotlin.String) returnType:kotlin.Unit [fake_override] + overridden: + public final fun foo (y: kotlin.String): kotlin.Unit declared in .Outer.Inner + $this: VALUE_PARAMETER name: type:.Outer.Inner.Outer> + VALUE_PARAMETER name:x index:0 type:kotlin.String + FUN FAKE_OVERRIDE name:foo visibility:public modality:FINAL <> ($this:.Outer.Inner.Outer>, x:kotlin.String) returnType:kotlin.Unit [fake_override] + overridden: + public final fun foo (y: kotlin.String): kotlin.Unit declared in .Outer.Inner + $this: VALUE_PARAMETER name: type:.Outer.Inner.Outer> + VALUE_PARAMETER name:x index:0 type:kotlin.String + FUN FAKE_OVERRIDE name:equals visibility:public modality:OPEN <> ($this:kotlin.Any, other:kotlin.Any?) returnType:kotlin.Boolean [fake_override,operator] + overridden: + public open fun equals (other: kotlin.Any?): kotlin.Boolean [operator] declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any + VALUE_PARAMETER name:other index:0 type:kotlin.Any? + FUN FAKE_OVERRIDE name:hashCode visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.Int [fake_override] + overridden: + public open fun hashCode (): kotlin.Int declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any + FUN FAKE_OVERRIDE name:toString visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.String [fake_override] + overridden: + public open fun toString (): kotlin.String declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any + FUN FAKE_OVERRIDE name:equals visibility:public modality:OPEN <> ($this:kotlin.Any, other:kotlin.Any?) returnType:kotlin.Boolean [fake_override,operator] + overridden: + public open fun equals (other: kotlin.Any?): kotlin.Boolean [operator] declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any + VALUE_PARAMETER name:other index:0 type:kotlin.Any? + FUN FAKE_OVERRIDE name:hashCode visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.Int [fake_override] + overridden: + public open fun hashCode (): kotlin.Int declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any + FUN FAKE_OVERRIDE name:toString visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.String [fake_override] + overridden: + public open fun toString (): kotlin.String declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any diff --git a/compiler/testData/ir/irText/classes/clashingFakeOverrideSignatures.kt b/compiler/testData/ir/irText/classes/clashingFakeOverrideSignatures.kt new file mode 100644 index 00000000000..bba636cd064 --- /dev/null +++ b/compiler/testData/ir/irText/classes/clashingFakeOverrideSignatures.kt @@ -0,0 +1,67 @@ +// IGNORE_BACKEND_FIR: ANY +// ^ TODO decide if we want to fix KT-42020 for FIR as well + +open class Base { + fun foo(x: T) {} + fun foo(y: String) {} + + val T.bar get() = 1 + val String.bar get() = 2 +} + +open class Derived : Base() + +class Derived2 : Derived() + +fun test(b: Base, d: Derived, d2: Derived2) { + b.foo(x = "") + b.foo(y = "") + d.foo(x = "") + d.foo(y = "") + d2.foo(x = "") + d2.foo(y = "") +} + + +open class BaseXY { + fun foo(x: X, y: String) {} + fun foo(x: String, y: Y) {} +} + +class DerivedXY : BaseXY() + + +fun outerFun() { + open class LocalBase { + fun foo(x: T) {} + fun foo(y: String) {} + + val T.bar get() = 1 + val String.bar get() = 2 + } + + open class LocalDerived : LocalBase() + + class LocalDerived2 : LocalDerived() + + fun test(b: LocalBase, d: LocalDerived, d2: LocalDerived2) { + b.foo(x = "") + b.foo(y = "") + d.foo(x = "") + d.foo(y = "") + d2.foo(x = "") + d2.foo(y = "") + } +} + + +open class Outer { + open inner class Inner { + fun foo(x: T) {} + fun foo(y: String) {} + } +} + +class OuterDerived : Outer() { + inner class InnerDerived : Inner() +} \ No newline at end of file diff --git a/compiler/testData/ir/irText/classes/clashingFakeOverrideSignatures.kt.txt b/compiler/testData/ir/irText/classes/clashingFakeOverrideSignatures.kt.txt new file mode 100644 index 00000000000..a2d4c878a57 --- /dev/null +++ b/compiler/testData/ir/irText/classes/clashingFakeOverrideSignatures.kt.txt @@ -0,0 +1,172 @@ +open class Base { + constructor() /* primary */ { + super/*Any*/() + /* () */ + + } + + fun foo(x: T) { + } + + fun foo(y: String) { + } + + val T.bar: Int + get(): Int { + return 1 + } + + val String.bar: Int + get(): Int { + return 2 + } + +} + +open class Derived : Base { + constructor() /* primary */ { + super/*Base*/() + /* () */ + + } + +} + +class Derived2 : Derived { + constructor() /* primary */ { + super/*Derived*/() + /* () */ + + } + +} + +fun test(b: Base, d: Derived, d2: Derived2) { + b.foo(x = "") + b.foo(y = "") + d.foo(x = "") + d.foo(y = "") + d2.foo(x = "") + d2.foo(y = "") +} + +open class BaseXY { + constructor() /* primary */ { + super/*Any*/() + /* () */ + + } + + fun foo(x: X, y: String) { + } + + fun foo(x: String, y: Y) { + } + +} + +class DerivedXY : BaseXY { + constructor() /* primary */ { + super/*BaseXY*/() + /* () */ + + } + +} + +fun outerFun() { + local open class LocalBase { + constructor() /* primary */ { + super/*Any*/() + /* () */ + + } + + fun foo(x: T) { + } + + fun foo(y: String) { + } + + val T.bar: Int + get(): Int { + return 1 + } + + val String.bar: Int + get(): Int { + return 2 + } + + } + + local open class LocalDerived : LocalBase { + constructor() /* primary */ { + super/*LocalBase*/() + /* () */ + + } + + } + + local class LocalDerived2 : LocalDerived { + constructor() /* primary */ { + super/*LocalDerived*/() + /* () */ + + } + + } + + local fun test(b: LocalBase, d: LocalDerived, d2: LocalDerived2) { + b.foo(x = "") + b.foo(y = "") + d.foo(x = "") + d.foo(y = "") + d2.foo(x = "") + d2.foo(y = "") + } + +} + +open class Outer { + constructor() /* primary */ { + super/*Any*/() + /* () */ + + } + + open inner class Inner { + constructor() /* primary */ { + super/*Any*/() + /* () */ + + } + + fun foo(x: T) { + } + + fun foo(y: String) { + } + + } + +} + +class OuterDerived : Outer { + constructor() /* primary */ { + super/*Outer*/() + /* () */ + + } + + inner class InnerDerived : Inner { + constructor() /* primary */ { + .super/*Inner*/() + /* () */ + + } + + } + +} diff --git a/compiler/testData/ir/irText/classes/clashingFakeOverrideSignatures.txt b/compiler/testData/ir/irText/classes/clashingFakeOverrideSignatures.txt new file mode 100644 index 00000000000..999128f55a8 --- /dev/null +++ b/compiler/testData/ir/irText/classes/clashingFakeOverrideSignatures.txt @@ -0,0 +1,474 @@ +FILE fqName: fileName:/clashingFakeOverrideSignatures.kt + CLASS CLASS name:Base modality:OPEN visibility:public superTypes:[kotlin.Any] + $this: VALUE_PARAMETER INSTANCE_RECEIVER name: type:.Base.Base> + TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] + CONSTRUCTOR visibility:public <> () returnType:.Base.Base> [primary] + BLOCK_BODY + DELEGATING_CONSTRUCTOR_CALL 'public constructor () [primary] declared in kotlin.Any' + INSTANCE_INITIALIZER_CALL classDescriptor='CLASS CLASS name:Base modality:OPEN visibility:public superTypes:[kotlin.Any]' + FUN name:foo visibility:public modality:FINAL <> ($this:.Base.Base>, x:T of .Base) returnType:kotlin.Unit + $this: VALUE_PARAMETER name: type:.Base.Base> + VALUE_PARAMETER name:x index:0 type:T of .Base + BLOCK_BODY + FUN name:foo visibility:public modality:FINAL <> ($this:.Base.Base>, y:kotlin.String) returnType:kotlin.Unit + $this: VALUE_PARAMETER name: type:.Base.Base> + VALUE_PARAMETER name:y index:0 type:kotlin.String + BLOCK_BODY + PROPERTY name:bar visibility:public modality:FINAL [val] + FUN name: visibility:public modality:FINAL <> ($this:.Base.Base>, $receiver:T of .Base) returnType:kotlin.Int + correspondingProperty: PROPERTY name:bar visibility:public modality:FINAL [val] + $this: VALUE_PARAMETER name: type:.Base.Base> + $receiver: VALUE_PARAMETER name: type:T of .Base + BLOCK_BODY + RETURN type=kotlin.Nothing from='public final fun (): kotlin.Int declared in .Base' + CONST Int type=kotlin.Int value=1 + PROPERTY name:bar visibility:public modality:FINAL [val] + FUN name: visibility:public modality:FINAL <> ($this:.Base.Base>, $receiver:kotlin.String) returnType:kotlin.Int + correspondingProperty: PROPERTY name:bar visibility:public modality:FINAL [val] + $this: VALUE_PARAMETER name: type:.Base.Base> + $receiver: VALUE_PARAMETER name: type:kotlin.String + BLOCK_BODY + RETURN type=kotlin.Nothing from='public final fun (): kotlin.Int declared in .Base' + CONST Int type=kotlin.Int value=2 + FUN FAKE_OVERRIDE name:equals visibility:public modality:OPEN <> ($this:kotlin.Any, other:kotlin.Any?) returnType:kotlin.Boolean [fake_override,operator] + overridden: + public open fun equals (other: kotlin.Any?): kotlin.Boolean [operator] declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any + VALUE_PARAMETER name:other index:0 type:kotlin.Any? + FUN FAKE_OVERRIDE name:hashCode visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.Int [fake_override] + overridden: + public open fun hashCode (): kotlin.Int declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any + FUN FAKE_OVERRIDE name:toString visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.String [fake_override] + overridden: + public open fun toString (): kotlin.String declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any + CLASS CLASS name:Derived modality:OPEN visibility:public superTypes:[.Base] + $this: VALUE_PARAMETER INSTANCE_RECEIVER name: type:.Derived + CONSTRUCTOR visibility:public <> () returnType:.Derived [primary] + BLOCK_BODY + DELEGATING_CONSTRUCTOR_CALL 'public constructor () [primary] declared in .Base' + : kotlin.String + INSTANCE_INITIALIZER_CALL classDescriptor='CLASS CLASS name:Derived modality:OPEN visibility:public superTypes:[.Base]' + FUN FAKE_OVERRIDE name:foo visibility:public modality:FINAL <> ($this:.Base, x:kotlin.String) returnType:kotlin.Unit [fake_override] + overridden: + public final fun foo (x: T of .Base): kotlin.Unit declared in .Base + $this: VALUE_PARAMETER name: type:.Base + VALUE_PARAMETER name:x index:0 type:kotlin.String + FUN FAKE_OVERRIDE name:foo visibility:public modality:FINAL <> ($this:.Base, y:kotlin.String) returnType:kotlin.Unit [fake_override] + overridden: + public final fun foo (y: kotlin.String): kotlin.Unit declared in .Base + $this: VALUE_PARAMETER name: type:.Base + VALUE_PARAMETER name:y index:0 type:kotlin.String + PROPERTY FAKE_OVERRIDE name:bar visibility:public modality:FINAL [fake_override,val] + FUN FAKE_OVERRIDE name: visibility:public modality:FINAL <> ($this:.Base, $receiver:kotlin.String) returnType:kotlin.Int [fake_override] + correspondingProperty: PROPERTY FAKE_OVERRIDE name:bar visibility:public modality:FINAL [fake_override,val] + overridden: + public final fun (): kotlin.Int declared in .Base + $this: VALUE_PARAMETER name: type:.Base + $receiver: VALUE_PARAMETER name: type:kotlin.String + PROPERTY FAKE_OVERRIDE name:bar visibility:public modality:FINAL [fake_override,val] + FUN FAKE_OVERRIDE name: visibility:public modality:FINAL <> ($this:.Base, $receiver:kotlin.String) returnType:kotlin.Int [fake_override] + correspondingProperty: PROPERTY FAKE_OVERRIDE name:bar visibility:public modality:FINAL [fake_override,val] + overridden: + public final fun (): kotlin.Int declared in .Base + $this: VALUE_PARAMETER name: type:.Base + $receiver: VALUE_PARAMETER name: type:kotlin.String + FUN FAKE_OVERRIDE name:equals visibility:public modality:OPEN <> ($this:kotlin.Any, other:kotlin.Any?) returnType:kotlin.Boolean [fake_override,operator] + overridden: + public open fun equals (other: kotlin.Any?): kotlin.Boolean [fake_override,operator] declared in .Base + $this: VALUE_PARAMETER name: type:kotlin.Any + VALUE_PARAMETER name:other index:0 type:kotlin.Any? + FUN FAKE_OVERRIDE name:hashCode visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.Int [fake_override] + overridden: + public open fun hashCode (): kotlin.Int [fake_override] declared in .Base + $this: VALUE_PARAMETER name: type:kotlin.Any + FUN FAKE_OVERRIDE name:toString visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.String [fake_override] + overridden: + public open fun toString (): kotlin.String [fake_override] declared in .Base + $this: VALUE_PARAMETER name: type:kotlin.Any + CLASS CLASS name:Derived2 modality:FINAL visibility:public superTypes:[.Derived] + $this: VALUE_PARAMETER INSTANCE_RECEIVER name: type:.Derived2 + CONSTRUCTOR visibility:public <> () returnType:.Derived2 [primary] + BLOCK_BODY + DELEGATING_CONSTRUCTOR_CALL 'public constructor () [primary] declared in .Derived' + INSTANCE_INITIALIZER_CALL classDescriptor='CLASS CLASS name:Derived2 modality:FINAL visibility:public superTypes:[.Derived]' + FUN FAKE_OVERRIDE name:foo visibility:public modality:FINAL <> ($this:.Base, x:kotlin.String) returnType:kotlin.Unit [fake_override] + overridden: + public final fun foo (x: kotlin.String): kotlin.Unit [fake_override] declared in .Derived + $this: VALUE_PARAMETER name: type:.Base + VALUE_PARAMETER name:x index:0 type:kotlin.String + FUN FAKE_OVERRIDE name:foo visibility:public modality:FINAL <> ($this:.Base, y:kotlin.String) returnType:kotlin.Unit [fake_override] + overridden: + public final fun foo (y: kotlin.String): kotlin.Unit [fake_override] declared in .Derived + $this: VALUE_PARAMETER name: type:.Base + VALUE_PARAMETER name:y index:0 type:kotlin.String + PROPERTY FAKE_OVERRIDE name:bar visibility:public modality:FINAL [fake_override,val] + FUN FAKE_OVERRIDE name: visibility:public modality:FINAL <> ($this:.Base, $receiver:kotlin.String) returnType:kotlin.Int [fake_override] + correspondingProperty: PROPERTY FAKE_OVERRIDE name:bar visibility:public modality:FINAL [fake_override,val] + overridden: + public final fun (): kotlin.Int [fake_override] declared in .Derived + $this: VALUE_PARAMETER name: type:.Base + $receiver: VALUE_PARAMETER name: type:kotlin.String + PROPERTY FAKE_OVERRIDE name:bar visibility:public modality:FINAL [fake_override,val] + FUN FAKE_OVERRIDE name: visibility:public modality:FINAL <> ($this:.Base, $receiver:kotlin.String) returnType:kotlin.Int [fake_override] + correspondingProperty: PROPERTY FAKE_OVERRIDE name:bar visibility:public modality:FINAL [fake_override,val] + overridden: + public final fun (): kotlin.Int [fake_override] declared in .Derived + $this: VALUE_PARAMETER name: type:.Base + $receiver: VALUE_PARAMETER name: type:kotlin.String + FUN FAKE_OVERRIDE name:equals visibility:public modality:OPEN <> ($this:kotlin.Any, other:kotlin.Any?) returnType:kotlin.Boolean [fake_override,operator] + overridden: + public open fun equals (other: kotlin.Any?): kotlin.Boolean [fake_override,operator] declared in .Derived + $this: VALUE_PARAMETER name: type:kotlin.Any + VALUE_PARAMETER name:other index:0 type:kotlin.Any? + FUN FAKE_OVERRIDE name:hashCode visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.Int [fake_override] + overridden: + public open fun hashCode (): kotlin.Int [fake_override] declared in .Derived + $this: VALUE_PARAMETER name: type:kotlin.Any + FUN FAKE_OVERRIDE name:toString visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.String [fake_override] + overridden: + public open fun toString (): kotlin.String [fake_override] declared in .Derived + $this: VALUE_PARAMETER name: type:kotlin.Any + FUN name:test visibility:public modality:FINAL <> (b:.Base, d:.Derived, d2:.Derived2) returnType:kotlin.Unit + VALUE_PARAMETER name:b index:0 type:.Base + VALUE_PARAMETER name:d index:1 type:.Derived + VALUE_PARAMETER name:d2 index:2 type:.Derived2 + BLOCK_BODY + CALL 'public final fun foo (x: T of .Base): kotlin.Unit declared in .Base' type=kotlin.Unit origin=null + $this: GET_VAR 'b: .Base declared in .test' type=.Base origin=null + x: CONST String type=kotlin.String value="" + CALL 'public final fun foo (y: kotlin.String): kotlin.Unit declared in .Base' type=kotlin.Unit origin=null + $this: GET_VAR 'b: .Base declared in .test' type=.Base origin=null + y: CONST String type=kotlin.String value="" + CALL 'public final fun foo (x: kotlin.String): kotlin.Unit [fake_override] declared in .Derived' type=kotlin.Unit origin=null + $this: GET_VAR 'd: .Derived declared in .test' type=.Derived origin=null + x: CONST String type=kotlin.String value="" + CALL 'public final fun foo (y: kotlin.String): kotlin.Unit [fake_override] declared in .Derived' type=kotlin.Unit origin=null + $this: GET_VAR 'd: .Derived declared in .test' type=.Derived origin=null + y: CONST String type=kotlin.String value="" + CALL 'public final fun foo (x: kotlin.String): kotlin.Unit [fake_override] declared in .Derived2' type=kotlin.Unit origin=null + $this: GET_VAR 'd2: .Derived2 declared in .test' type=.Derived2 origin=null + x: CONST String type=kotlin.String value="" + CALL 'public final fun foo (y: kotlin.String): kotlin.Unit [fake_override] declared in .Derived2' type=kotlin.Unit origin=null + $this: GET_VAR 'd2: .Derived2 declared in .test' type=.Derived2 origin=null + y: CONST String type=kotlin.String value="" + CLASS CLASS name:BaseXY modality:OPEN visibility:public superTypes:[kotlin.Any] + $this: VALUE_PARAMETER INSTANCE_RECEIVER name: type:.BaseXY.BaseXY, Y of .BaseXY> + TYPE_PARAMETER name:X index:0 variance: superTypes:[kotlin.Any?] + TYPE_PARAMETER name:Y index:1 variance: superTypes:[kotlin.Any?] + CONSTRUCTOR visibility:public <> () returnType:.BaseXY.BaseXY, Y of .BaseXY> [primary] + BLOCK_BODY + DELEGATING_CONSTRUCTOR_CALL 'public constructor () [primary] declared in kotlin.Any' + INSTANCE_INITIALIZER_CALL classDescriptor='CLASS CLASS name:BaseXY modality:OPEN visibility:public superTypes:[kotlin.Any]' + FUN name:foo visibility:public modality:FINAL <> ($this:.BaseXY.BaseXY, Y of .BaseXY>, x:X of .BaseXY, y:kotlin.String) returnType:kotlin.Unit + $this: VALUE_PARAMETER name: type:.BaseXY.BaseXY, Y of .BaseXY> + VALUE_PARAMETER name:x index:0 type:X of .BaseXY + VALUE_PARAMETER name:y index:1 type:kotlin.String + BLOCK_BODY + FUN name:foo visibility:public modality:FINAL <> ($this:.BaseXY.BaseXY, Y of .BaseXY>, x:kotlin.String, y:Y of .BaseXY) returnType:kotlin.Unit + $this: VALUE_PARAMETER name: type:.BaseXY.BaseXY, Y of .BaseXY> + VALUE_PARAMETER name:x index:0 type:kotlin.String + VALUE_PARAMETER name:y index:1 type:Y of .BaseXY + BLOCK_BODY + FUN FAKE_OVERRIDE name:equals visibility:public modality:OPEN <> ($this:kotlin.Any, other:kotlin.Any?) returnType:kotlin.Boolean [fake_override,operator] + overridden: + public open fun equals (other: kotlin.Any?): kotlin.Boolean [operator] declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any + VALUE_PARAMETER name:other index:0 type:kotlin.Any? + FUN FAKE_OVERRIDE name:hashCode visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.Int [fake_override] + overridden: + public open fun hashCode (): kotlin.Int declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any + FUN FAKE_OVERRIDE name:toString visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.String [fake_override] + overridden: + public open fun toString (): kotlin.String declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any + CLASS CLASS name:DerivedXY modality:FINAL visibility:public superTypes:[.BaseXY] + $this: VALUE_PARAMETER INSTANCE_RECEIVER name: type:.DerivedXY + CONSTRUCTOR visibility:public <> () returnType:.DerivedXY [primary] + BLOCK_BODY + DELEGATING_CONSTRUCTOR_CALL 'public constructor () [primary] declared in .BaseXY' + : kotlin.String + : kotlin.String + INSTANCE_INITIALIZER_CALL classDescriptor='CLASS CLASS name:DerivedXY modality:FINAL visibility:public superTypes:[.BaseXY]' + FUN FAKE_OVERRIDE name:foo visibility:public modality:FINAL <> ($this:.BaseXY, x:kotlin.String, y:kotlin.String) returnType:kotlin.Unit [fake_override] + overridden: + public final fun foo (x: X of .BaseXY, y: kotlin.String): kotlin.Unit declared in .BaseXY + $this: VALUE_PARAMETER name: type:.BaseXY + VALUE_PARAMETER name:x index:0 type:kotlin.String + VALUE_PARAMETER name:y index:1 type:kotlin.String + FUN FAKE_OVERRIDE name:foo visibility:public modality:FINAL <> ($this:.BaseXY, x:kotlin.String, y:kotlin.String) returnType:kotlin.Unit [fake_override] + overridden: + public final fun foo (x: kotlin.String, y: Y of .BaseXY): kotlin.Unit declared in .BaseXY + $this: VALUE_PARAMETER name: type:.BaseXY + VALUE_PARAMETER name:x index:0 type:kotlin.String + VALUE_PARAMETER name:y index:1 type:kotlin.String + FUN FAKE_OVERRIDE name:equals visibility:public modality:OPEN <> ($this:kotlin.Any, other:kotlin.Any?) returnType:kotlin.Boolean [fake_override,operator] + overridden: + public open fun equals (other: kotlin.Any?): kotlin.Boolean [fake_override,operator] declared in .BaseXY + $this: VALUE_PARAMETER name: type:kotlin.Any + VALUE_PARAMETER name:other index:0 type:kotlin.Any? + FUN FAKE_OVERRIDE name:hashCode visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.Int [fake_override] + overridden: + public open fun hashCode (): kotlin.Int [fake_override] declared in .BaseXY + $this: VALUE_PARAMETER name: type:kotlin.Any + FUN FAKE_OVERRIDE name:toString visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.String [fake_override] + overridden: + public open fun toString (): kotlin.String [fake_override] declared in .BaseXY + $this: VALUE_PARAMETER name: type:kotlin.Any + FUN name:outerFun visibility:public modality:FINAL <> () returnType:kotlin.Unit + BLOCK_BODY + CLASS CLASS name:LocalBase modality:OPEN visibility:local superTypes:[kotlin.Any] + $this: VALUE_PARAMETER INSTANCE_RECEIVER name: type:.outerFun.LocalBase.outerFun.LocalBase> + TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] + CONSTRUCTOR visibility:public <> () returnType:.outerFun.LocalBase.outerFun.LocalBase> [primary] + BLOCK_BODY + DELEGATING_CONSTRUCTOR_CALL 'public constructor () [primary] declared in kotlin.Any' + INSTANCE_INITIALIZER_CALL classDescriptor='CLASS CLASS name:LocalBase modality:OPEN visibility:local superTypes:[kotlin.Any]' + FUN name:foo visibility:public modality:FINAL <> ($this:.outerFun.LocalBase.outerFun.LocalBase>, x:T of .outerFun.LocalBase) returnType:kotlin.Unit + $this: VALUE_PARAMETER name: type:.outerFun.LocalBase.outerFun.LocalBase> + VALUE_PARAMETER name:x index:0 type:T of .outerFun.LocalBase + BLOCK_BODY + FUN name:foo visibility:public modality:FINAL <> ($this:.outerFun.LocalBase.outerFun.LocalBase>, y:kotlin.String) returnType:kotlin.Unit + $this: VALUE_PARAMETER name: type:.outerFun.LocalBase.outerFun.LocalBase> + VALUE_PARAMETER name:y index:0 type:kotlin.String + BLOCK_BODY + PROPERTY name:bar visibility:public modality:FINAL [val] + FUN name: visibility:public modality:FINAL <> ($this:.outerFun.LocalBase.outerFun.LocalBase>, $receiver:T of .outerFun.LocalBase) returnType:kotlin.Int + correspondingProperty: PROPERTY name:bar visibility:public modality:FINAL [val] + $this: VALUE_PARAMETER name: type:.outerFun.LocalBase.outerFun.LocalBase> + $receiver: VALUE_PARAMETER name: type:T of .outerFun.LocalBase + BLOCK_BODY + RETURN type=kotlin.Nothing from='public final fun (): kotlin.Int declared in .outerFun.LocalBase' + CONST Int type=kotlin.Int value=1 + PROPERTY name:bar visibility:public modality:FINAL [val] + FUN name: visibility:public modality:FINAL <> ($this:.outerFun.LocalBase.outerFun.LocalBase>, $receiver:kotlin.String) returnType:kotlin.Int + correspondingProperty: PROPERTY name:bar visibility:public modality:FINAL [val] + $this: VALUE_PARAMETER name: type:.outerFun.LocalBase.outerFun.LocalBase> + $receiver: VALUE_PARAMETER name: type:kotlin.String + BLOCK_BODY + RETURN type=kotlin.Nothing from='public final fun (): kotlin.Int declared in .outerFun.LocalBase' + CONST Int type=kotlin.Int value=2 + FUN FAKE_OVERRIDE name:equals visibility:public modality:OPEN <> ($this:kotlin.Any, other:kotlin.Any?) returnType:kotlin.Boolean [fake_override,operator] + overridden: + public open fun equals (other: kotlin.Any?): kotlin.Boolean [operator] declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any + VALUE_PARAMETER name:other index:0 type:kotlin.Any? + FUN FAKE_OVERRIDE name:hashCode visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.Int [fake_override] + overridden: + public open fun hashCode (): kotlin.Int declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any + FUN FAKE_OVERRIDE name:toString visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.String [fake_override] + overridden: + public open fun toString (): kotlin.String declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any + CLASS CLASS name:LocalDerived modality:OPEN visibility:local superTypes:[.outerFun.LocalBase] + $this: VALUE_PARAMETER INSTANCE_RECEIVER name: type:.outerFun.LocalDerived + CONSTRUCTOR visibility:public <> () returnType:.outerFun.LocalDerived [primary] + BLOCK_BODY + DELEGATING_CONSTRUCTOR_CALL 'public constructor () [primary] declared in .outerFun.LocalBase' + : kotlin.String + INSTANCE_INITIALIZER_CALL classDescriptor='CLASS CLASS name:LocalDerived modality:OPEN visibility:local superTypes:[.outerFun.LocalBase]' + FUN FAKE_OVERRIDE name:foo visibility:public modality:FINAL <> ($this:.outerFun.LocalBase, x:kotlin.String) returnType:kotlin.Unit [fake_override] + overridden: + public final fun foo (x: T of .outerFun.LocalBase): kotlin.Unit declared in .outerFun.LocalBase + $this: VALUE_PARAMETER name: type:.outerFun.LocalBase + VALUE_PARAMETER name:x index:0 type:kotlin.String + FUN FAKE_OVERRIDE name:foo visibility:public modality:FINAL <> ($this:.outerFun.LocalBase, y:kotlin.String) returnType:kotlin.Unit [fake_override] + overridden: + public final fun foo (y: kotlin.String): kotlin.Unit declared in .outerFun.LocalBase + $this: VALUE_PARAMETER name: type:.outerFun.LocalBase + VALUE_PARAMETER name:y index:0 type:kotlin.String + PROPERTY FAKE_OVERRIDE name:bar visibility:public modality:FINAL [fake_override,val] + FUN FAKE_OVERRIDE name: visibility:public modality:FINAL <> ($this:.outerFun.LocalBase, $receiver:kotlin.String) returnType:kotlin.Int [fake_override] + correspondingProperty: PROPERTY FAKE_OVERRIDE name:bar visibility:public modality:FINAL [fake_override,val] + overridden: + public final fun (): kotlin.Int declared in .outerFun.LocalBase + $this: VALUE_PARAMETER name: type:.outerFun.LocalBase + $receiver: VALUE_PARAMETER name: type:kotlin.String + PROPERTY FAKE_OVERRIDE name:bar visibility:public modality:FINAL [fake_override,val] + FUN FAKE_OVERRIDE name: visibility:public modality:FINAL <> ($this:.outerFun.LocalBase, $receiver:kotlin.String) returnType:kotlin.Int [fake_override] + correspondingProperty: PROPERTY FAKE_OVERRIDE name:bar visibility:public modality:FINAL [fake_override,val] + overridden: + public final fun (): kotlin.Int declared in .outerFun.LocalBase + $this: VALUE_PARAMETER name: type:.outerFun.LocalBase + $receiver: VALUE_PARAMETER name: type:kotlin.String + FUN FAKE_OVERRIDE name:equals visibility:public modality:OPEN <> ($this:kotlin.Any, other:kotlin.Any?) returnType:kotlin.Boolean [fake_override,operator] + overridden: + public open fun equals (other: kotlin.Any?): kotlin.Boolean [fake_override,operator] declared in .outerFun.LocalBase + $this: VALUE_PARAMETER name: type:kotlin.Any + VALUE_PARAMETER name:other index:0 type:kotlin.Any? + FUN FAKE_OVERRIDE name:hashCode visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.Int [fake_override] + overridden: + public open fun hashCode (): kotlin.Int [fake_override] declared in .outerFun.LocalBase + $this: VALUE_PARAMETER name: type:kotlin.Any + FUN FAKE_OVERRIDE name:toString visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.String [fake_override] + overridden: + public open fun toString (): kotlin.String [fake_override] declared in .outerFun.LocalBase + $this: VALUE_PARAMETER name: type:kotlin.Any + CLASS CLASS name:LocalDerived2 modality:FINAL visibility:local superTypes:[.outerFun.LocalDerived] + $this: VALUE_PARAMETER INSTANCE_RECEIVER name: type:.outerFun.LocalDerived2 + CONSTRUCTOR visibility:public <> () returnType:.outerFun.LocalDerived2 [primary] + BLOCK_BODY + DELEGATING_CONSTRUCTOR_CALL 'public constructor () [primary] declared in .outerFun.LocalDerived' + INSTANCE_INITIALIZER_CALL classDescriptor='CLASS CLASS name:LocalDerived2 modality:FINAL visibility:local superTypes:[.outerFun.LocalDerived]' + FUN FAKE_OVERRIDE name:foo visibility:public modality:FINAL <> ($this:.outerFun.LocalBase, x:kotlin.String) returnType:kotlin.Unit [fake_override] + overridden: + public final fun foo (x: kotlin.String): kotlin.Unit [fake_override] declared in .outerFun.LocalDerived + $this: VALUE_PARAMETER name: type:.outerFun.LocalBase + VALUE_PARAMETER name:x index:0 type:kotlin.String + FUN FAKE_OVERRIDE name:foo visibility:public modality:FINAL <> ($this:.outerFun.LocalBase, y:kotlin.String) returnType:kotlin.Unit [fake_override] + overridden: + public final fun foo (y: kotlin.String): kotlin.Unit [fake_override] declared in .outerFun.LocalDerived + $this: VALUE_PARAMETER name: type:.outerFun.LocalBase + VALUE_PARAMETER name:y index:0 type:kotlin.String + PROPERTY FAKE_OVERRIDE name:bar visibility:public modality:FINAL [fake_override,val] + FUN FAKE_OVERRIDE name: visibility:public modality:FINAL <> ($this:.outerFun.LocalBase, $receiver:kotlin.String) returnType:kotlin.Int [fake_override] + correspondingProperty: PROPERTY FAKE_OVERRIDE name:bar visibility:public modality:FINAL [fake_override,val] + overridden: + public final fun (): kotlin.Int [fake_override] declared in .outerFun.LocalDerived + $this: VALUE_PARAMETER name: type:.outerFun.LocalBase + $receiver: VALUE_PARAMETER name: type:kotlin.String + PROPERTY FAKE_OVERRIDE name:bar visibility:public modality:FINAL [fake_override,val] + FUN FAKE_OVERRIDE name: visibility:public modality:FINAL <> ($this:.outerFun.LocalBase, $receiver:kotlin.String) returnType:kotlin.Int [fake_override] + correspondingProperty: PROPERTY FAKE_OVERRIDE name:bar visibility:public modality:FINAL [fake_override,val] + overridden: + public final fun (): kotlin.Int [fake_override] declared in .outerFun.LocalDerived + $this: VALUE_PARAMETER name: type:.outerFun.LocalBase + $receiver: VALUE_PARAMETER name: type:kotlin.String + FUN FAKE_OVERRIDE name:equals visibility:public modality:OPEN <> ($this:kotlin.Any, other:kotlin.Any?) returnType:kotlin.Boolean [fake_override,operator] + overridden: + public open fun equals (other: kotlin.Any?): kotlin.Boolean [fake_override,operator] declared in .outerFun.LocalDerived + $this: VALUE_PARAMETER name: type:kotlin.Any + VALUE_PARAMETER name:other index:0 type:kotlin.Any? + FUN FAKE_OVERRIDE name:hashCode visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.Int [fake_override] + overridden: + public open fun hashCode (): kotlin.Int [fake_override] declared in .outerFun.LocalDerived + $this: VALUE_PARAMETER name: type:kotlin.Any + FUN FAKE_OVERRIDE name:toString visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.String [fake_override] + overridden: + public open fun toString (): kotlin.String [fake_override] declared in .outerFun.LocalDerived + $this: VALUE_PARAMETER name: type:kotlin.Any + FUN name:test visibility:local modality:FINAL <> (b:.outerFun.LocalBase, d:.outerFun.LocalDerived, d2:.outerFun.LocalDerived2) returnType:kotlin.Unit + VALUE_PARAMETER name:b index:0 type:.outerFun.LocalBase + VALUE_PARAMETER name:d index:1 type:.outerFun.LocalDerived + VALUE_PARAMETER name:d2 index:2 type:.outerFun.LocalDerived2 + BLOCK_BODY + CALL 'public final fun foo (x: T of .outerFun.LocalBase): kotlin.Unit declared in .outerFun.LocalBase' type=kotlin.Unit origin=null + $this: GET_VAR 'b: .outerFun.LocalBase declared in .outerFun.test' type=.outerFun.LocalBase origin=null + x: CONST String type=kotlin.String value="" + CALL 'public final fun foo (y: kotlin.String): kotlin.Unit declared in .outerFun.LocalBase' type=kotlin.Unit origin=null + $this: GET_VAR 'b: .outerFun.LocalBase declared in .outerFun.test' type=.outerFun.LocalBase origin=null + y: CONST String type=kotlin.String value="" + CALL 'public final fun foo (x: kotlin.String): kotlin.Unit [fake_override] declared in .outerFun.LocalDerived' type=kotlin.Unit origin=null + $this: GET_VAR 'd: .outerFun.LocalDerived declared in .outerFun.test' type=.outerFun.LocalDerived origin=null + x: CONST String type=kotlin.String value="" + CALL 'public final fun foo (y: kotlin.String): kotlin.Unit [fake_override] declared in .outerFun.LocalDerived' type=kotlin.Unit origin=null + $this: GET_VAR 'd: .outerFun.LocalDerived declared in .outerFun.test' type=.outerFun.LocalDerived origin=null + y: CONST String type=kotlin.String value="" + CALL 'public final fun foo (x: kotlin.String): kotlin.Unit [fake_override] declared in .outerFun.LocalDerived2' type=kotlin.Unit origin=null + $this: GET_VAR 'd2: .outerFun.LocalDerived2 declared in .outerFun.test' type=.outerFun.LocalDerived2 origin=null + x: CONST String type=kotlin.String value="" + CALL 'public final fun foo (y: kotlin.String): kotlin.Unit [fake_override] declared in .outerFun.LocalDerived2' type=kotlin.Unit origin=null + $this: GET_VAR 'd2: .outerFun.LocalDerived2 declared in .outerFun.test' type=.outerFun.LocalDerived2 origin=null + y: CONST String type=kotlin.String value="" + CLASS CLASS name:Outer modality:OPEN visibility:public superTypes:[kotlin.Any] + $this: VALUE_PARAMETER INSTANCE_RECEIVER name: type:.Outer.Outer> + TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] + CONSTRUCTOR visibility:public <> () returnType:.Outer.Outer> [primary] + BLOCK_BODY + DELEGATING_CONSTRUCTOR_CALL 'public constructor () [primary] declared in kotlin.Any' + INSTANCE_INITIALIZER_CALL classDescriptor='CLASS CLASS name:Outer modality:OPEN visibility:public superTypes:[kotlin.Any]' + CLASS CLASS name:Inner modality:OPEN visibility:public [inner] superTypes:[kotlin.Any] + $this: VALUE_PARAMETER INSTANCE_RECEIVER name: type:.Outer.Inner.Outer> + CONSTRUCTOR visibility:public <> ($this:.Outer.Outer>) returnType:.Outer.Inner.Outer> [primary] + $outer: VALUE_PARAMETER name: type:.Outer.Outer> + BLOCK_BODY + DELEGATING_CONSTRUCTOR_CALL 'public constructor () [primary] declared in kotlin.Any' + INSTANCE_INITIALIZER_CALL classDescriptor='CLASS CLASS name:Inner modality:OPEN visibility:public [inner] superTypes:[kotlin.Any]' + FUN name:foo visibility:public modality:FINAL <> ($this:.Outer.Inner.Outer>, x:T of .Outer) returnType:kotlin.Unit + $this: VALUE_PARAMETER name: type:.Outer.Inner.Outer> + VALUE_PARAMETER name:x index:0 type:T of .Outer + BLOCK_BODY + FUN name:foo visibility:public modality:FINAL <> ($this:.Outer.Inner.Outer>, y:kotlin.String) returnType:kotlin.Unit + $this: VALUE_PARAMETER name: type:.Outer.Inner.Outer> + VALUE_PARAMETER name:y index:0 type:kotlin.String + BLOCK_BODY + FUN FAKE_OVERRIDE name:equals visibility:public modality:OPEN <> ($this:kotlin.Any, other:kotlin.Any?) returnType:kotlin.Boolean [fake_override,operator] + overridden: + public open fun equals (other: kotlin.Any?): kotlin.Boolean [operator] declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any + VALUE_PARAMETER name:other index:0 type:kotlin.Any? + FUN FAKE_OVERRIDE name:hashCode visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.Int [fake_override] + overridden: + public open fun hashCode (): kotlin.Int declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any + FUN FAKE_OVERRIDE name:toString visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.String [fake_override] + overridden: + public open fun toString (): kotlin.String declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any + FUN FAKE_OVERRIDE name:equals visibility:public modality:OPEN <> ($this:kotlin.Any, other:kotlin.Any?) returnType:kotlin.Boolean [fake_override,operator] + overridden: + public open fun equals (other: kotlin.Any?): kotlin.Boolean [operator] declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any + VALUE_PARAMETER name:other index:0 type:kotlin.Any? + FUN FAKE_OVERRIDE name:hashCode visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.Int [fake_override] + overridden: + public open fun hashCode (): kotlin.Int declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any + FUN FAKE_OVERRIDE name:toString visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.String [fake_override] + overridden: + public open fun toString (): kotlin.String declared in kotlin.Any + $this: VALUE_PARAMETER name: type:kotlin.Any + CLASS CLASS name:OuterDerived modality:FINAL visibility:public superTypes:[.Outer] + $this: VALUE_PARAMETER INSTANCE_RECEIVER name: type:.OuterDerived + CONSTRUCTOR visibility:public <> () returnType:.OuterDerived [primary] + BLOCK_BODY + DELEGATING_CONSTRUCTOR_CALL 'public constructor () [primary] declared in .Outer' + : kotlin.String + INSTANCE_INITIALIZER_CALL classDescriptor='CLASS CLASS name:OuterDerived modality:FINAL visibility:public superTypes:[.Outer]' + CLASS CLASS name:InnerDerived modality:FINAL visibility:public [inner] superTypes:[.Outer.Inner] + $this: VALUE_PARAMETER INSTANCE_RECEIVER name: type:.OuterDerived.InnerDerived + CONSTRUCTOR visibility:public <> ($this:.OuterDerived) returnType:.OuterDerived.InnerDerived [primary] + $outer: VALUE_PARAMETER name: type:.OuterDerived + BLOCK_BODY + DELEGATING_CONSTRUCTOR_CALL 'public constructor () [primary] declared in .Outer.Inner' + $this: GET_VAR ': .OuterDerived declared in .OuterDerived.InnerDerived.' type=.OuterDerived origin=null + INSTANCE_INITIALIZER_CALL classDescriptor='CLASS CLASS name:InnerDerived modality:FINAL visibility:public [inner] superTypes:[.Outer.Inner]' + FUN FAKE_OVERRIDE name:foo visibility:public modality:FINAL <> ($this:.Outer.Inner, x:kotlin.String) returnType:kotlin.Unit [fake_override] + overridden: + public final fun foo (x: T of .Outer): kotlin.Unit declared in .Outer.Inner + $this: VALUE_PARAMETER name: type:.Outer.Inner + VALUE_PARAMETER name:x index:0 type:kotlin.String + FUN FAKE_OVERRIDE name:foo visibility:public modality:FINAL <> ($this:.Outer.Inner, y:kotlin.String) returnType:kotlin.Unit [fake_override] + overridden: + public final fun foo (y: kotlin.String): kotlin.Unit declared in .Outer.Inner + $this: VALUE_PARAMETER name: type:.Outer.Inner + VALUE_PARAMETER name:y index:0 type:kotlin.String + FUN FAKE_OVERRIDE name:equals visibility:public modality:OPEN <> ($this:kotlin.Any, other:kotlin.Any?) returnType:kotlin.Boolean [fake_override,operator] + overridden: + public open fun equals (other: kotlin.Any?): kotlin.Boolean [fake_override,operator] declared in .Outer.Inner + $this: VALUE_PARAMETER name: type:kotlin.Any + VALUE_PARAMETER name:other index:0 type:kotlin.Any? + FUN FAKE_OVERRIDE name:hashCode visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.Int [fake_override] + overridden: + public open fun hashCode (): kotlin.Int [fake_override] declared in .Outer.Inner + $this: VALUE_PARAMETER name: type:kotlin.Any + FUN FAKE_OVERRIDE name:toString visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.String [fake_override] + overridden: + public open fun toString (): kotlin.String [fake_override] declared in .Outer.Inner + $this: VALUE_PARAMETER name: type:kotlin.Any + FUN FAKE_OVERRIDE name:equals visibility:public modality:OPEN <> ($this:kotlin.Any, other:kotlin.Any?) returnType:kotlin.Boolean [fake_override,operator] + overridden: + public open fun equals (other: kotlin.Any?): kotlin.Boolean [fake_override,operator] declared in .Outer + $this: VALUE_PARAMETER name: type:kotlin.Any + VALUE_PARAMETER name:other index:0 type:kotlin.Any? + FUN FAKE_OVERRIDE name:hashCode visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.Int [fake_override] + overridden: + public open fun hashCode (): kotlin.Int [fake_override] declared in .Outer + $this: VALUE_PARAMETER name: type:kotlin.Any + FUN FAKE_OVERRIDE name:toString visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.String [fake_override] + overridden: + public open fun toString (): kotlin.String [fake_override] declared in .Outer + $this: VALUE_PARAMETER name: type:kotlin.Any diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/ir/AbstractIrGeneratorTestCase.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/ir/AbstractIrGeneratorTestCase.kt index cc7d7857c25..8c13fecda66 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/ir/AbstractIrGeneratorTestCase.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/ir/AbstractIrGeneratorTestCase.kt @@ -19,14 +19,19 @@ package org.jetbrains.kotlin.ir import org.jetbrains.kotlin.analyzer.AnalysisResult import org.jetbrains.kotlin.backend.common.serialization.signature.IdSignatureDescriptor import org.jetbrains.kotlin.backend.jvm.JvmGeneratorExtensions +import org.jetbrains.kotlin.backend.jvm.serialization.JvmIdSignatureDescriptor import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment import org.jetbrains.kotlin.codegen.CodegenTestCase +import org.jetbrains.kotlin.config.LanguageVersionSettings import org.jetbrains.kotlin.config.languageVersionSettings +import org.jetbrains.kotlin.idea.MainFunctionDetector import org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.JsManglerDesc +import org.jetbrains.kotlin.ir.backend.jvm.serialization.JvmManglerDesc import org.jetbrains.kotlin.ir.declarations.IrFile import org.jetbrains.kotlin.ir.declarations.IrModuleFragment import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl +import org.jetbrains.kotlin.ir.util.IdSignatureComposer import org.jetbrains.kotlin.ir.util.NameProvider import org.jetbrains.kotlin.ir.util.SymbolTable import org.jetbrains.kotlin.ir.util.generateTypicalIrProviderList @@ -36,11 +41,11 @@ import org.jetbrains.kotlin.psi2ir.Psi2IrConfiguration import org.jetbrains.kotlin.psi2ir.Psi2IrTranslator import org.jetbrains.kotlin.psi2ir.generators.GeneratorExtensions import org.jetbrains.kotlin.resolve.AnalyzingUtils +import org.jetbrains.kotlin.resolve.BindingContext import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil import org.jetbrains.kotlin.test.ConfigurationKind import org.jetbrains.kotlin.test.InTextDirectivesUtils import org.jetbrains.kotlin.test.KotlinTestUtils.getAnnotationsJar -import org.jetbrains.kotlin.test.TargetBackend import java.io.File import java.util.* @@ -95,7 +100,12 @@ abstract class AbstractIrGeneratorTestCase : CodegenTestCase() { } protected open fun doGenerateIrModule(psi2IrTranslator: Psi2IrTranslator): IrModuleFragment = - generateIrModuleWithJvmResolve(myFiles.psiFiles, myEnvironment, psi2IrTranslator) + generateIrModuleWithJvmResolve( + myFiles.psiFiles, + myEnvironment, + psi2IrTranslator, + myEnvironment.configuration.languageVersionSettings + ) protected fun generateIrFilesAsSingleModule(testFiles: List, ignoreErrors: Boolean = false): Map { val irModule = generateIrModule(ignoreErrors) @@ -118,22 +128,31 @@ abstract class AbstractIrGeneratorTestCase : CodegenTestCase() { moduleDescriptors = emptyList(), friendModuleDescriptors = emptyList() ), - psi2ir, ktFilesToAnalyze, GeneratorExtensions() + psi2ir, ktFilesToAnalyze, GeneratorExtensions(), + createIdSignatureComposer = { IdSignatureDescriptor(JsManglerDesc) } ) fun generateIrModuleWithJvmResolve( - ktFilesToAnalyze: List, environment: KotlinCoreEnvironment, psi2ir: Psi2IrTranslator - ): IrModuleFragment = - generateIrModule( + ktFilesToAnalyze: List, + environment: KotlinCoreEnvironment, + psi2ir: Psi2IrTranslator, + languageVersionSettings: LanguageVersionSettings + ): IrModuleFragment { + return generateIrModule( JvmResolveUtil.analyze(ktFilesToAnalyze, environment), psi2ir, ktFilesToAnalyze, - JvmGeneratorExtensions(generateFacades = false) + JvmGeneratorExtensions(generateFacades = false), + createIdSignatureComposer = { bindingContext -> + JvmIdSignatureDescriptor(JvmManglerDesc(MainFunctionDetector(bindingContext, languageVersionSettings))) + } ) + } private fun generateIrModule( analysisResult: AnalysisResult, psi2ir: Psi2IrTranslator, ktFilesToAnalyze: List, - generatorExtensions: GeneratorExtensions + generatorExtensions: GeneratorExtensions, + createIdSignatureComposer: (BindingContext) -> IdSignatureComposer ): IrModuleFragment { val (bindingContext, moduleDescriptor) = analysisResult if (!psi2ir.configuration.ignoreErrors) { @@ -143,7 +162,8 @@ abstract class AbstractIrGeneratorTestCase : CodegenTestCase() { val context = psi2ir.createGeneratorContext( moduleDescriptor, bindingContext, - SymbolTable(IdSignatureDescriptor(JsManglerDesc), IrFactoryImpl, NameProvider.DEFAULT), + // SymbolTable(IdSignatureDescriptor(JsManglerDesc), IrFactoryImpl, NameProvider.DEFAULT), + SymbolTable(createIdSignatureComposer(bindingContext), IrFactoryImpl, NameProvider.DEFAULT), generatorExtensions ) val irProviders = generateTypicalIrProviderList( diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java index 491fd945ca5..89a1e8aa068 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java @@ -15937,6 +15937,11 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { runTest("compiler/testData/codegen/box/ir/anonymousObjectInsideElvis.kt"); } + @TestMetadata("clashingFakeOverrideSignatures.kt") + public void testClashingFakeOverrideSignatures() throws Exception { + runTest("compiler/testData/codegen/box/ir/clashingFakeOverrideSignatures.kt"); + } + @TestMetadata("classInitializers.kt") public void testClassInitializers() throws Exception { runTest("compiler/testData/codegen/box/ir/classInitializers.kt"); diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/CompileKotlinAgainstKotlinTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/CompileKotlinAgainstKotlinTestGenerated.java index 768154b00c0..742bc9735a6 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/CompileKotlinAgainstKotlinTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/CompileKotlinAgainstKotlinTestGenerated.java @@ -53,6 +53,11 @@ public class CompileKotlinAgainstKotlinTestGenerated extends AbstractCompileKotl runTest("compiler/testData/compileKotlinAgainstKotlin/callsToMultifileClassFromOtherPackage.kt"); } + @TestMetadata("clashingFakeOverrideSignatures.kt") + public void testClashingFakeOverrideSignatures() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/clashingFakeOverrideSignatures.kt"); + } + @TestMetadata("classInObject.kt") public void testClassInObject() throws Exception { runTest("compiler/testData/compileKotlinAgainstKotlin/classInObject.kt"); diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java index 3bf118dd06e..cfc78f96461 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java @@ -15937,6 +15937,11 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes runTest("compiler/testData/codegen/box/ir/anonymousObjectInsideElvis.kt"); } + @TestMetadata("clashingFakeOverrideSignatures.kt") + public void testClashingFakeOverrideSignatures() throws Exception { + runTest("compiler/testData/codegen/box/ir/clashingFakeOverrideSignatures.kt"); + } + @TestMetadata("classInitializers.kt") public void testClassInitializers() throws Exception { runTest("compiler/testData/codegen/box/ir/classInitializers.kt"); diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java index ed92c4b4efc..ec2168073e4 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java @@ -15937,6 +15937,11 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes runTest("compiler/testData/codegen/box/ir/anonymousObjectInsideElvis.kt"); } + @TestMetadata("clashingFakeOverrideSignatures.kt") + public void testClashingFakeOverrideSignatures() throws Exception { + runTest("compiler/testData/codegen/box/ir/clashingFakeOverrideSignatures.kt"); + } + @TestMetadata("classInitializers.kt") public void testClassInitializers() throws Exception { runTest("compiler/testData/codegen/box/ir/classInitializers.kt"); diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrCompileKotlinAgainstKotlinTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrCompileKotlinAgainstKotlinTestGenerated.java index 661e383ed48..b3b619d0713 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrCompileKotlinAgainstKotlinTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrCompileKotlinAgainstKotlinTestGenerated.java @@ -54,6 +54,11 @@ public class IrCompileKotlinAgainstKotlinTestGenerated extends AbstractIrCompile runTest("compiler/testData/compileKotlinAgainstKotlin/callsToMultifileClassFromOtherPackage.kt"); } + @TestMetadata("clashingFakeOverrideSignatures.kt") + public void testClashingFakeOverrideSignatures() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/clashingFakeOverrideSignatures.kt"); + } + @TestMetadata("classInObject.kt") public void testClassInObject() throws Exception { runTest("compiler/testData/compileKotlinAgainstKotlin/classInObject.kt"); diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/JvmIrAgainstOldBoxTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/JvmIrAgainstOldBoxTestGenerated.java index 2bf647867d7..5005fea3504 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/JvmIrAgainstOldBoxTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/JvmIrAgainstOldBoxTestGenerated.java @@ -54,6 +54,11 @@ public class JvmIrAgainstOldBoxTestGenerated extends AbstractJvmIrAgainstOldBoxT runTest("compiler/testData/compileKotlinAgainstKotlin/callsToMultifileClassFromOtherPackage.kt"); } + @TestMetadata("clashingFakeOverrideSignatures.kt") + public void testClashingFakeOverrideSignatures() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/clashingFakeOverrideSignatures.kt"); + } + @TestMetadata("classInObject.kt") public void testClassInObject() throws Exception { runTest("compiler/testData/compileKotlinAgainstKotlin/classInObject.kt"); diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/JvmOldAgainstIrBoxTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/JvmOldAgainstIrBoxTestGenerated.java index b9e522e054a..4d326471d3c 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/JvmOldAgainstIrBoxTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/JvmOldAgainstIrBoxTestGenerated.java @@ -54,6 +54,11 @@ public class JvmOldAgainstIrBoxTestGenerated extends AbstractJvmOldAgainstIrBoxT runTest("compiler/testData/compileKotlinAgainstKotlin/callsToMultifileClassFromOtherPackage.kt"); } + @TestMetadata("clashingFakeOverrideSignatures.kt") + public void testClashingFakeOverrideSignatures() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/clashingFakeOverrideSignatures.kt"); + } + @TestMetadata("classInObject.kt") public void testClassInObject() throws Exception { runTest("compiler/testData/compileKotlinAgainstKotlin/classInObject.kt"); diff --git a/compiler/tests-gen/org/jetbrains/kotlin/ir/IrTextTestCaseGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/ir/IrTextTestCaseGenerated.java index a6d46b7c275..f90fb2e507a 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/ir/IrTextTestCaseGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/ir/IrTextTestCaseGenerated.java @@ -55,6 +55,11 @@ public class IrTextTestCaseGenerated extends AbstractIrTextTestCase { runTest("compiler/testData/ir/irText/classes/argumentReorderingInDelegatingConstructorCall.kt"); } + @TestMetadata("clashingFakeOverrideSignatures.kt") + public void testClashingFakeOverrideSignatures() throws Exception { + runTest("compiler/testData/ir/irText/classes/clashingFakeOverrideSignatures.kt"); + } + @TestMetadata("classMembers.kt") public void testClassMembers() throws Exception { runTest("compiler/testData/ir/irText/classes/classMembers.kt"); From 0ea6b32c018fe0bd11700b62d0cee7b2615c8f60 Mon Sep 17 00:00:00 2001 From: Jinseong Jeon Date: Tue, 8 Dec 2020 13:26:37 -0800 Subject: [PATCH 025/196] NI: allow lower bound of flexible type for coercion-to-Unit Example from box/inference/coercionToUnitForLambdaReturnTypeWithFlexibleConstraint // FILE: TestJ.java public class TestJ { public static In materialize() { return null; } } // FILE: test.kt class In fun inferred(e: In?, l: () -> T): T = l() fun box() { inferred(TestJ.materialize(), { null }) } `materialize` has flexible type, both for `In` and `T`. When analyzing `{ null }`, collected type constraints include: ft <: T (from ft>, In>?>) By allowing the lower bound of flexible type, FIR resolution can visit `{ null }` with the expected type Unit, which will lead to proper coercion to Unit at the end. --- .../resolve/calls/inference/model/NewConstraintSystemImpl.kt | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/compiler/resolution.common/src/org/jetbrains/kotlin/resolve/calls/inference/model/NewConstraintSystemImpl.kt b/compiler/resolution.common/src/org/jetbrains/kotlin/resolve/calls/inference/model/NewConstraintSystemImpl.kt index 76f82239400..a8b6598eeaa 100644 --- a/compiler/resolution.common/src/org/jetbrains/kotlin/resolve/calls/inference/model/NewConstraintSystemImpl.kt +++ b/compiler/resolution.common/src/org/jetbrains/kotlin/resolve/calls/inference/model/NewConstraintSystemImpl.kt @@ -437,6 +437,9 @@ class NewConstraintSystemImpl( override fun hasUpperOrEqualUnitConstraint(type: KotlinTypeMarker): Boolean { checkState(State.BUILDING, State.COMPLETION, State.FREEZED) val constraints = storage.notFixedTypeVariables[type.typeConstructor()]?.constraints ?: return false - return constraints.any { (it.kind == ConstraintKind.UPPER || it.kind == ConstraintKind.EQUALITY) && it.type.isUnit() } + return constraints.any { + (it.kind == ConstraintKind.UPPER || it.kind == ConstraintKind.EQUALITY) && + it.type.lowerBoundIfFlexible().isUnit() + } } } From 4ab0897d7d7343268179247efc89d6144ede9b69 Mon Sep 17 00:00:00 2001 From: Jinseong Jeon Date: Tue, 8 Dec 2020 14:34:25 -0800 Subject: [PATCH 026/196] FIR: pass the explicit expected type to block type This helps avoid adding redundant return Unit into block. --- .../resolve/FirExpressionsResolveTransformer.kt | 8 +++++++- .../irText/expressions/coercionToUnit.fir.kt.txt | 2 +- .../ir/irText/expressions/coercionToUnit.fir.txt | 2 +- .../typeVariableAfterBuildMap.fir.kt.txt | 2 +- .../firProblems/typeVariableAfterBuildMap.fir.txt | 11 +++++------ .../ir/irText/stubs/builtinMap.fir.kt.txt | 2 +- .../testData/ir/irText/stubs/builtinMap.fir.txt | 15 +++++++-------- 7 files changed, 23 insertions(+), 19 deletions(-) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt index 340b9122ad8..ad2274e51e0 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt @@ -309,7 +309,13 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform TransformData.Data(value) } block.transformOtherChildren(transformer, data) - block.writeResultType(session) + if (data is ResolutionMode.WithExpectedType && data.expectedTypeRef is FirResolvedTypeRef) { + // Top-down propagation: from the explicit type of the enclosing declaration to the block type + block.resultType = data.expectedTypeRef + } else { + // Bottom-up propagation: from the return type of the last expression in the block to the block type + block.writeResultType(session) + } dataFlowAnalyzer.exitBlock(block) } diff --git a/compiler/testData/ir/irText/expressions/coercionToUnit.fir.kt.txt b/compiler/testData/ir/irText/expressions/coercionToUnit.fir.kt.txt index ab06fa52ba3..2d878235e87 100644 --- a/compiler/testData/ir/irText/expressions/coercionToUnit.fir.kt.txt +++ b/compiler/testData/ir/irText/expressions/coercionToUnit.fir.kt.txt @@ -1,6 +1,6 @@ val test1: Function0 field = local fun (): Int { - return 42 + 42 /*~> Unit */ } get diff --git a/compiler/testData/ir/irText/expressions/coercionToUnit.fir.txt b/compiler/testData/ir/irText/expressions/coercionToUnit.fir.txt index 89ac7828f47..18e3854f53c 100644 --- a/compiler/testData/ir/irText/expressions/coercionToUnit.fir.txt +++ b/compiler/testData/ir/irText/expressions/coercionToUnit.fir.txt @@ -5,7 +5,7 @@ FILE fqName: fileName:/coercionToUnit.kt FUN_EXPR type=kotlin.Function0 origin=LAMBDA FUN LOCAL_FUNCTION_FOR_LAMBDA name: visibility:local modality:FINAL <> () returnType:kotlin.Int BLOCK_BODY - RETURN type=kotlin.Nothing from='local final fun (): kotlin.Int declared in .test1' + TYPE_OP type=kotlin.Unit origin=IMPLICIT_COERCION_TO_UNIT typeOperand=kotlin.Unit CONST Int type=kotlin.Int value=42 FUN DEFAULT_PROPERTY_ACCESSOR name: visibility:public modality:FINAL <> () returnType:kotlin.Function0 correspondingProperty: PROPERTY name:test1 visibility:public modality:FINAL [val] diff --git a/compiler/testData/ir/irText/firProblems/typeVariableAfterBuildMap.fir.kt.txt b/compiler/testData/ir/irText/firProblems/typeVariableAfterBuildMap.fir.kt.txt index cecf37e0998..208bad8f60e 100644 --- a/compiler/testData/ir/irText/firProblems/typeVariableAfterBuildMap.fir.kt.txt +++ b/compiler/testData/ir/irText/firProblems/typeVariableAfterBuildMap.fir.kt.txt @@ -167,7 +167,7 @@ object Visibilities { .put(key = Private, value = 0) /*~> Unit */ .put(key = Internal, value = 1) /*~> Unit */ .put(key = Protected, value = 1) /*~> Unit */ - return .put(key = Public, value = 2) /*~> Unit */ + .put(key = Public, value = 2) /*~> Unit */ } ) private get diff --git a/compiler/testData/ir/irText/firProblems/typeVariableAfterBuildMap.fir.txt b/compiler/testData/ir/irText/firProblems/typeVariableAfterBuildMap.fir.txt index 102f6689c32..c4ed0731a15 100644 --- a/compiler/testData/ir/irText/firProblems/typeVariableAfterBuildMap.fir.txt +++ b/compiler/testData/ir/irText/firProblems/typeVariableAfterBuildMap.fir.txt @@ -572,12 +572,11 @@ FILE fqName: fileName:/typeVariableAfterBuildMap.kt $this: GET_VAR ': kotlin.collections.MutableMap<.Visibility, kotlin.Int> declared in .Visibilities.ORDERED_VISIBILITIES.' type=kotlin.collections.MutableMap<.Visibility, kotlin.Int> origin=null key: GET_OBJECT 'CLASS OBJECT name:Protected modality:FINAL visibility:public superTypes:[.Visibility]' type=.Visibilities.Protected value: CONST Int type=kotlin.Int value=1 - RETURN type=kotlin.Nothing from='local final fun (): kotlin.Unit declared in .Visibilities.ORDERED_VISIBILITIES' - TYPE_OP type=kotlin.Unit origin=IMPLICIT_COERCION_TO_UNIT typeOperand=kotlin.Unit - CALL 'public abstract fun put (key: K of kotlin.collections.MutableMap, value: V of kotlin.collections.MutableMap): V of kotlin.collections.MutableMap? declared in kotlin.collections.MutableMap' type=kotlin.Int? origin=null - $this: GET_VAR ': kotlin.collections.MutableMap<.Visibility, kotlin.Int> declared in .Visibilities.ORDERED_VISIBILITIES.' type=kotlin.collections.MutableMap<.Visibility, kotlin.Int> origin=null - key: GET_OBJECT 'CLASS OBJECT name:Public modality:FINAL visibility:public superTypes:[.Visibility]' type=.Visibilities.Public - value: CONST Int type=kotlin.Int value=2 + TYPE_OP type=kotlin.Unit origin=IMPLICIT_COERCION_TO_UNIT typeOperand=kotlin.Unit + CALL 'public abstract fun put (key: K of kotlin.collections.MutableMap, value: V of kotlin.collections.MutableMap): V of kotlin.collections.MutableMap? declared in kotlin.collections.MutableMap' type=kotlin.Int? origin=null + $this: GET_VAR ': kotlin.collections.MutableMap<.Visibility, kotlin.Int> declared in .Visibilities.ORDERED_VISIBILITIES.' type=kotlin.collections.MutableMap<.Visibility, kotlin.Int> origin=null + key: GET_OBJECT 'CLASS OBJECT name:Public modality:FINAL visibility:public superTypes:[.Visibility]' type=.Visibilities.Public + value: CONST Int type=kotlin.Int value=2 FUN DEFAULT_PROPERTY_ACCESSOR name: visibility:private modality:FINAL <> ($this:.Visibilities) returnType:kotlin.collections.Map<.Visibility, kotlin.Int> correspondingProperty: PROPERTY name:ORDERED_VISIBILITIES visibility:private modality:FINAL [val] $this: VALUE_PARAMETER name: type:.Visibilities diff --git a/compiler/testData/ir/irText/stubs/builtinMap.fir.kt.txt b/compiler/testData/ir/irText/stubs/builtinMap.fir.kt.txt index 98510fbd27f..1a2febaf1d0 100644 --- a/compiler/testData/ir/irText/stubs/builtinMap.fir.kt.txt +++ b/compiler/testData/ir/irText/stubs/builtinMap.fir.kt.txt @@ -2,7 +2,7 @@ fun Map.plus(pair: Pair): Map return when { .isEmpty() -> mapOf(pair = pair) else -> LinkedHashMap(p0 = ).apply>(block = local fun LinkedHashMap.() { - return .put(p0 = pair.(), p1 = pair.()) /*~> Unit */ + .put(p0 = pair.(), p1 = pair.()) /*~> Unit */ } ) } diff --git a/compiler/testData/ir/irText/stubs/builtinMap.fir.txt b/compiler/testData/ir/irText/stubs/builtinMap.fir.txt index 0216d629a41..2df3708de14 100644 --- a/compiler/testData/ir/irText/stubs/builtinMap.fir.txt +++ b/compiler/testData/ir/irText/stubs/builtinMap.fir.txt @@ -26,11 +26,10 @@ FILE fqName: fileName:/builtinMap.kt FUN LOCAL_FUNCTION_FOR_LAMBDA name: visibility:local modality:FINAL <> ($receiver:java.util.LinkedHashMap.plus?, V1 of .plus?>) returnType:kotlin.Unit $receiver: VALUE_PARAMETER name: type:java.util.LinkedHashMap.plus?, V1 of .plus?> BLOCK_BODY - RETURN type=kotlin.Nothing from='local final fun (): kotlin.Unit declared in .plus' - TYPE_OP type=kotlin.Unit origin=IMPLICIT_COERCION_TO_UNIT typeOperand=kotlin.Unit - CALL 'public open fun put (p0: @[FlexibleNullability] K of java.util.LinkedHashMap?, p1: @[FlexibleNullability] V of java.util.LinkedHashMap?): @[FlexibleNullability] V of java.util.LinkedHashMap? declared in java.util.LinkedHashMap' type=V1 of .plus? origin=null - $this: GET_VAR ': java.util.LinkedHashMap.plus?, V1 of .plus?> declared in .plus.' type=java.util.LinkedHashMap.plus?, V1 of .plus?> origin=null - p0: CALL 'public final fun (): A of kotlin.Pair declared in kotlin.Pair' type=K1 of .plus origin=GET_PROPERTY - $this: GET_VAR 'pair: kotlin.Pair.plus, V1 of .plus> declared in .plus' type=kotlin.Pair.plus, V1 of .plus> origin=null - p1: CALL 'public final fun (): B of kotlin.Pair declared in kotlin.Pair' type=V1 of .plus origin=GET_PROPERTY - $this: GET_VAR 'pair: kotlin.Pair.plus, V1 of .plus> declared in .plus' type=kotlin.Pair.plus, V1 of .plus> origin=null + TYPE_OP type=kotlin.Unit origin=IMPLICIT_COERCION_TO_UNIT typeOperand=kotlin.Unit + CALL 'public open fun put (p0: @[FlexibleNullability] K of java.util.LinkedHashMap?, p1: @[FlexibleNullability] V of java.util.LinkedHashMap?): @[FlexibleNullability] V of java.util.LinkedHashMap? declared in java.util.LinkedHashMap' type=V1 of .plus? origin=null + $this: GET_VAR ': java.util.LinkedHashMap.plus?, V1 of .plus?> declared in .plus.' type=java.util.LinkedHashMap.plus?, V1 of .plus?> origin=null + p0: CALL 'public final fun (): A of kotlin.Pair declared in kotlin.Pair' type=K1 of .plus origin=GET_PROPERTY + $this: GET_VAR 'pair: kotlin.Pair.plus, V1 of .plus> declared in .plus' type=kotlin.Pair.plus, V1 of .plus> origin=null + p1: CALL 'public final fun (): B of kotlin.Pair declared in kotlin.Pair' type=V1 of .plus origin=GET_PROPERTY + $this: GET_VAR 'pair: kotlin.Pair.plus, V1 of .plus> declared in .plus' type=kotlin.Pair.plus, V1 of .plus> origin=null From 6239301f4ea7e291c47ad3a4af30dd5c626d2481 Mon Sep 17 00:00:00 2001 From: Jinseong Jeon Date: Tue, 8 Dec 2020 14:53:04 -0800 Subject: [PATCH 027/196] FIR: no constraint for coerced-to-Unit last expression of lambda --- .../RedundantReturnUnitTypeChecker.txt | 4 +-- .../resolveWithStdlib/complexPostponedCfg.dot | 2 +- .../resolveWithStdlib/complexPostponedCfg.txt | 2 +- .../inference/PostponedArgumentsAnalyzer.kt | 32 ++++++++++++------- ...rLambdaReturnTypeWithFlexibleConstraint.kt | 1 - .../postponedArgumentsAnalysis/basic.fir.kt | 4 +-- .../suspendFunctions.fir.kt | 8 ++--- 7 files changed, 31 insertions(+), 22 deletions(-) diff --git a/compiler/fir/analysis-tests/testData/extendedCheckers/RedundantReturnUnitTypeChecker.txt b/compiler/fir/analysis-tests/testData/extendedCheckers/RedundantReturnUnitTypeChecker.txt index ede0c8c0e4e..58e4524988a 100644 --- a/compiler/fir/analysis-tests/testData/extendedCheckers/RedundantReturnUnitTypeChecker.txt +++ b/compiler/fir/analysis-tests/testData/extendedCheckers/RedundantReturnUnitTypeChecker.txt @@ -59,7 +59,7 @@ FILE: RedundantReturnUnitTypeChecker.kt } public final fun foo(): R|kotlin/Unit| { - ^foo this@R|/B|.R|/B.run|( = run@fun (): R|kotlin/Int| { + ^foo this@R|/B|.R|/B.run|( = run@fun (): R|kotlin/Unit| { this@R|/B|.R|/B.bar|() } ) @@ -88,7 +88,7 @@ FILE: RedundantReturnUnitTypeChecker.kt } public final fun goo(): R|kotlin/Unit| { - ^goo (this@R|/B|, Int(1)).R|/B.let|( = let@fun (it: R|kotlin/Int|): R|kotlin/Int| { + ^goo (this@R|/B|, Int(1)).R|/B.let|( = let@fun (it: R|kotlin/Int|): R|kotlin/Unit| { this@R|/B|.R|/B.bar|() } ) diff --git a/compiler/fir/analysis-tests/testData/resolveWithStdlib/complexPostponedCfg.dot b/compiler/fir/analysis-tests/testData/resolveWithStdlib/complexPostponedCfg.dot index bdb4b3cb219..f4efbcab670 100644 --- a/compiler/fir/analysis-tests/testData/resolveWithStdlib/complexPostponedCfg.dot +++ b/compiler/fir/analysis-tests/testData/resolveWithStdlib/complexPostponedCfg.dot @@ -63,7 +63,7 @@ digraph complexPostponedCfg_kt { } 34 [label="Call arguments union" style="filled" fillcolor=yellow]; 35 [label="Postponed exit from lambda"]; - 36 [label="Function call: R|kotlin/with|(...)"]; + 36 [label="Function call: R|kotlin/with|(...)"]; 37 [label="Exit block"]; } 38 [label="Exit function anonymousFunction" style="filled" fillcolor=red]; diff --git a/compiler/fir/analysis-tests/testData/resolveWithStdlib/complexPostponedCfg.txt b/compiler/fir/analysis-tests/testData/resolveWithStdlib/complexPostponedCfg.txt index 9ece8fb6153..567a734e67b 100644 --- a/compiler/fir/analysis-tests/testData/resolveWithStdlib/complexPostponedCfg.txt +++ b/compiler/fir/analysis-tests/testData/resolveWithStdlib/complexPostponedCfg.txt @@ -7,7 +7,7 @@ FILE: complexPostponedCfg.kt lval firstCalls: R|kotlin/collections/List| = R|kotlin/with||>((R|/statements|.R|kotlin/collections/last|() as R|FirFunctionCall|), = setCall@fun R|FirFunctionCall|.(): R|kotlin/collections/List| { ^ R|kotlin/collections/buildList|( = buildList@fun R|kotlin/collections/MutableList|.(): R|kotlin/Unit| { this@R|special/anonymous|.R|SubstitutionOverride|(this@R|special/anonymous|) - R|kotlin/with|((R|/arguments|.R|kotlin/collections/last|() as R|FirFunctionCall|), = plusCall@fun R|FirFunctionCall|.(): R|kotlin/Boolean| { + R|kotlin/with|((R|/arguments|.R|kotlin/collections/last|() as R|FirFunctionCall|), = plusCall@fun R|FirFunctionCall|.(): R|kotlin/Unit| { this@R|special/anonymous|.R|SubstitutionOverride|(this@R|special/anonymous|) this@R|special/anonymous|.R|SubstitutionOverride|((R|/explicitReceiver| as R|FirFunctionCall|)) } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/PostponedArgumentsAnalyzer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/PostponedArgumentsAnalyzer.kt index 886b301fb1c..617fc230892 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/PostponedArgumentsAnalyzer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/PostponedArgumentsAnalyzer.kt @@ -130,7 +130,7 @@ class PostponedArgumentsAnalyzer( rawReturnType, stubsForPostponedVariables ) - applyResultsOfAnalyzedLambdaToCandidateSystem(c, lambda, candidate, results, ::substitute) + applyResultsOfAnalyzedLambdaToCandidateSystem(c, lambda, candidate, results, expectedTypeForReturnArguments, ::substitute) return results } @@ -139,6 +139,7 @@ class PostponedArgumentsAnalyzer( lambda: ResolvedLambdaAtom, candidate: Candidate, results: ReturnArgumentsAnalysisResult, + expectedReturnType: ConeKotlinType? = null, substitute: (ConeKotlinType) -> ConeKotlinType = c.createSubstituteFunctorForLambdaAnalysis() ) { val (returnArguments, inferenceSession) = results @@ -164,21 +165,30 @@ class PostponedArgumentsAnalyzer( val checkerSink: CheckerSink = CheckerSinkImpl(candidate) + val lastExpression = lambda.atom.body?.statements?.lastOrNull() as? FirExpression var hasExpressionInReturnArguments = false + // No constraint for return expressions of lambda if it has Unit return type. val lambdaReturnType = lambda.returnType.let(substitute).takeUnless { it.isUnit } returnArguments.forEach { if (it !is FirExpression) return@forEach hasExpressionInReturnArguments = true - candidate.resolveArgumentExpression( - c.getBuilder(), - it, - lambdaReturnType, - lambda.atom.returnTypeRef, // TODO: proper ref - checkerSink, - context = resolutionContext, - isReceiver = false, - isDispatch = false - ) + // If it is the last expression, and the expected type is Unit, that expression will be coerced to Unit. + // If the last expression is of Unit type, of course it's not coercion-to-Unit case. + val lastExpressionCoercedToUnit = + it == lastExpression && expectedReturnType?.isUnit == true && !it.typeRef.coneType.isUnit + // No constraint for the last expression of lambda if it will be coerced to Unit. + if (!lastExpressionCoercedToUnit) { + candidate.resolveArgumentExpression( + c.getBuilder(), + it, + lambdaReturnType, + lambda.atom.returnTypeRef, // TODO: proper ref + checkerSink, + context = resolutionContext, + isReceiver = false, + isDispatch = false + ) + } } if (!hasExpressionInReturnArguments && lambdaReturnType != null) { diff --git a/compiler/testData/codegen/box/inference/coercionToUnitForLambdaReturnTypeWithFlexibleConstraint.kt b/compiler/testData/codegen/box/inference/coercionToUnitForLambdaReturnTypeWithFlexibleConstraint.kt index 508097cad2a..18743a61156 100644 --- a/compiler/testData/codegen/box/inference/coercionToUnitForLambdaReturnTypeWithFlexibleConstraint.kt +++ b/compiler/testData/codegen/box/inference/coercionToUnitForLambdaReturnTypeWithFlexibleConstraint.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR // TARGET_BACKEND: JVM // FILE: TestJ.java diff --git a/compiler/testData/diagnostics/tests/inference/completion/postponedArgumentsAnalysis/basic.fir.kt b/compiler/testData/diagnostics/tests/inference/completion/postponedArgumentsAnalysis/basic.fir.kt index 06588262147..86870041ce5 100644 --- a/compiler/testData/diagnostics/tests/inference/completion/postponedArgumentsAnalysis/basic.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/completion/postponedArgumentsAnalysis/basic.fir.kt @@ -142,8 +142,8 @@ fun main() { val x18: (C) -> Unit = select(id { it }, { it }, id<(B) -> Unit> { x -> x }) // Resolution of extension/non-extension functions combination - val x19: String.() -> Unit = select(")!>id { this }, ")!>id(fun(x: String) {})) - val x20: String.() -> Unit = select(")!>{ this }, (fun(x: String) {})) + val x19: String.() -> Unit = select(")!>id { this }, ")!>id(fun(x: String) {})) + val x20: String.() -> Unit = select(")!>{ this }, (fun(x: String) {})) val x21: String.() -> Unit = select(")!>id(fun(x: String) {}), ")!>id(fun(x: String) {})) select(id Unit>(fun(x: String) {}), ")!>id(fun(x: String) {})) select(")!>id(fun String.(x: String) {}), ")!>id(fun(x: String, y: String) {})) diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/suspendFunctions.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/suspendFunctions.fir.kt index 5b464405de2..3eac7717eb6 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/suspendFunctions.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/suspendFunctions.fir.kt @@ -14,12 +14,12 @@ fun main() { select(")!>id {}, id(suspend {})) select(")!>id {}, id Unit> {}) - takeSuspend(")!>id { it }, ")!>{ x -> x }) + takeSuspend(")!>id { it }, ")!>{ x -> x }) - val x1: suspend (Int) -> Unit = takeSuspend(")!>id { it }, ")!>{ x -> x }) + val x1: suspend (Int) -> Unit = takeSuspend(")!>id { it }, ")!>{ x -> x }) // Here, the error should be - val x2: (Int) -> Unit = takeSuspend(")!>id { it }, ")!>{ x -> x }) - val x3: suspend (Int) -> Unit = takeSimpleFunction(")!>id { it }, ")!>{ x -> x }) + val x2: (Int) -> Unit = takeSuspend(")!>id { it }, ")!>{ x -> x }) + val x3: suspend (Int) -> Unit = takeSimpleFunction(")!>id { it }, ")!>{ x -> x }) val x4: (Int) -> Unit = takeSimpleFunction(id Unit> {}, {}) } From efeabac2c5444d26d5be73bac1e4337cbcb361ee Mon Sep 17 00:00:00 2001 From: Jinseong Jeon Date: Mon, 14 Dec 2020 10:27:05 -0800 Subject: [PATCH 028/196] FIR: do not force coercion-to-Unit for nullable lambda return type 3d7d87ac should have been implemented as aafe41c did. --- .../kotlin/fir/resolve/inference/PostponedArgumentsAnalyzer.kt | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/PostponedArgumentsAnalyzer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/PostponedArgumentsAnalyzer.kt index 617fc230892..56c5d4aa1bc 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/PostponedArgumentsAnalyzer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/PostponedArgumentsAnalyzer.kt @@ -116,8 +116,7 @@ class PostponedArgumentsAnalyzer( c.canBeProper(rawReturnType) -> substitute(rawReturnType) // For Unit-coercion - c.hasUpperOrEqualUnitConstraint(rawReturnType) -> - if (rawReturnType.isMarkedNullable) unitType.withNullability(ConeNullability.NULLABLE) else unitType + !rawReturnType.isMarkedNullable && c.hasUpperOrEqualUnitConstraint(rawReturnType) -> unitType else -> null } From 602ed42b99b7e049f650bbe26d972d86afe3a64d Mon Sep 17 00:00:00 2001 From: Svyatoslav Kuzmich Date: Tue, 15 Dec 2020 17:39:24 +0300 Subject: [PATCH 029/196] [Wasm] Move intrinsic generators to generators/wasm Reason: avoid kotlin-stdlib-gen dependency on kotlinStdlib() via wasm.ir --- generators/build.gradle.kts | 4 ++ .../wasm/WasmIntrinsicGenerator.kt | 45 +++++++++++-------- .../stdlib/wasm/src/generated/_WasmArrays.kt | 16 +++++-- .../stdlib/wasm/src/generated/_WasmOp.kt | 16 +++++-- .../tools/kotlin-stdlib-gen/build.gradle | 1 - .../src/generators/GenerateStandardLib.kt | 4 +- 6 files changed, 58 insertions(+), 28 deletions(-) rename libraries/tools/kotlin-stdlib-gen/src/generators/GenerateWasmOps.kt => generators/wasm/WasmIntrinsicGenerator.kt (80%) diff --git a/generators/build.gradle.kts b/generators/build.gradle.kts index 56404acce8e..ac1f859e942 100644 --- a/generators/build.gradle.kts +++ b/generators/build.gradle.kts @@ -24,6 +24,7 @@ fun extraSourceSet(name: String, extendMain: Boolean = true): Pair + val types = listOf( + "Byte", + "Char", + "Short", + "Int", + "Long", + "Float", + "Double" + ) + + types.forEach { primitive -> val isPacked = primitive in setOf( - PrimitiveType.Byte, - PrimitiveType.Short, - PrimitiveType.Char, + "Byte", + "Char", + "Short", ) - val isUnsigned = primitive.isUnsigned() || primitive == PrimitiveType.Char + val isUnsigned = primitive == "Char" writer.appendLine( wasmArrayForType( - primitive.name, + primitive, false, isPacked, isUnsigned ) ) @@ -113,4 +116,10 @@ fun wasmArrayForType( } """.trimIndent() +} + +fun main() { + val targetDir = File("libraries/stdlib/wasm/src/generated") + generateWasmOps(targetDir) + generateWasmArrays(targetDir) } \ No newline at end of file diff --git a/libraries/stdlib/wasm/src/generated/_WasmArrays.kt b/libraries/stdlib/wasm/src/generated/_WasmArrays.kt index b50a47da571..1e1d41b23a7 100644 --- a/libraries/stdlib/wasm/src/generated/_WasmArrays.kt +++ b/libraries/stdlib/wasm/src/generated/_WasmArrays.kt @@ -1,13 +1,23 @@ /* * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. - * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + * + * 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 kotlin.wasm.internal // -// NOTE: THIS FILE IS AUTO-GENERATED by the GenerateStandardLib.kt -// See: https://github.com/JetBrains/kotlin/tree/master/libraries/stdlib +// NOTE: THIS FILE IS AUTO-GENERATED by the generators/wasm/WasmIntrinsicGenerator.kt // @WasmArrayOf(Any::class, isNullable = true) diff --git a/libraries/stdlib/wasm/src/generated/_WasmOp.kt b/libraries/stdlib/wasm/src/generated/_WasmOp.kt index 36f58dca653..87e2f12b01a 100644 --- a/libraries/stdlib/wasm/src/generated/_WasmOp.kt +++ b/libraries/stdlib/wasm/src/generated/_WasmOp.kt @@ -1,13 +1,23 @@ /* * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. - * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + * + * 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 kotlin.wasm.internal // -// NOTE: THIS FILE IS AUTO-GENERATED by the GenerateStandardLib.kt -// See: https://github.com/JetBrains/kotlin/tree/master/libraries/stdlib +// NOTE: THIS FILE IS AUTO-GENERATED by the generators/wasm/WasmIntrinsicGenerator.kt // @ExcludedFromCodegen diff --git a/libraries/tools/kotlin-stdlib-gen/build.gradle b/libraries/tools/kotlin-stdlib-gen/build.gradle index c50f3f6dbe9..d1f953ec885 100644 --- a/libraries/tools/kotlin-stdlib-gen/build.gradle +++ b/libraries/tools/kotlin-stdlib-gen/build.gradle @@ -10,7 +10,6 @@ sourceSets { dependencies { compile "org.jetbrains.kotlin:kotlin-stdlib:$bootstrapKotlinVersion" compile "org.jetbrains.kotlin:kotlin-reflect:$bootstrapKotlinVersion" - compile project(":wasm:wasm.ir") } compileKotlin { diff --git a/libraries/tools/kotlin-stdlib-gen/src/generators/GenerateStandardLib.kt b/libraries/tools/kotlin-stdlib-gen/src/generators/GenerateStandardLib.kt index 9d84e3552b5..ea61e30f872 100644 --- a/libraries/tools/kotlin-stdlib-gen/src/generators/GenerateStandardLib.kt +++ b/libraries/tools/kotlin-stdlib-gen/src/generators/GenerateStandardLib.kt @@ -5,8 +5,8 @@ package generators -import java.io.* import templates.* +import java.io.File import kotlin.system.exitProcess /** @@ -71,8 +71,6 @@ fun main(args: Array) { } targetDir.resolve("_${source.name.capitalize()}$platformSuffix.kt") } - - targetBaseDirs[KotlinTarget.WASM]?.let { generateWasmBuiltIns(it) } } fun File.resolveExistingDir(subpath: String) = resolve(subpath).also { it.requireExistingDir() } From fe64b13140ef781fc44f5b619a4106b8e707e142 Mon Sep 17 00:00:00 2001 From: Andrei Klunnyi Date: Thu, 3 Dec 2020 19:05:54 +0100 Subject: [PATCH 030/196] KTIJ-650 [Code completion]: support for "sealed interface" ^KTIJ-650 fixed --- .../idea/completion/KeywordCompletion.kt | 105 +++++++++++------- .../testData/keywords/AfterClassProperty.kt | 1 + .../testData/keywords/AfterClasses.kt | 1 + .../keywords/AfterClasses_LangLevel10.kt | 2 + .../keywords/AfterClasses_LangLevel11.kt | 2 + .../testData/keywords/AfterFuns.kt | 1 + .../keywords/GlobalPropertyAccessors.kt | 2 + .../keywords/InAnnotationClassScope.kt | 1 + .../testData/keywords/InClassBeforeFun.kt | 1 + .../testData/keywords/InClassScope.kt | 1 + .../testData/keywords/InEnumScope2.kt | 1 + .../testData/keywords/InInterfaceScope.kt | 1 + .../testData/keywords/InObjectScope.kt | 1 + .../keywords/InTopScopeAfterPackage.kt | 2 + .../testData/keywords/PropertyAccessors.kt | 1 + .../testData/keywords/PropertyAccessors2.kt | 1 + .../testData/keywords/PropertySetter.kt | 1 + .../keywords/SealedForDeclaredClass.kt | 3 + .../keywords/SealedForDeclaredInterface.kt | 3 + .../testData/keywords/SealedWithName.kt | 6 + .../testData/keywords/SealedWithoutName.kt | 6 + .../testData/keywords/TopScope.kt | 2 + .../testData/keywords/TopScope3-.kt | 1 + .../testData/keywords/topScope2.kt | 1 + .../test/KeywordCompletionTestGenerated.java | 20 ++++ 25 files changed, 124 insertions(+), 43 deletions(-) create mode 100644 idea/idea-completion/testData/keywords/SealedForDeclaredClass.kt create mode 100644 idea/idea-completion/testData/keywords/SealedForDeclaredInterface.kt create mode 100644 idea/idea-completion/testData/keywords/SealedWithName.kt create mode 100644 idea/idea-completion/testData/keywords/SealedWithoutName.kt diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KeywordCompletion.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KeywordCompletion.kt index 11abbe4de65..fa799b10972 100644 --- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KeywordCompletion.kt +++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KeywordCompletion.kt @@ -66,15 +66,15 @@ object KeywordCompletion { private val KEYWORDS_TO_IGNORE_PREFIX = TokenSet.create(OVERRIDE_KEYWORD /* it's needed to complete overrides that should be work by member name too */) - private val COMPOUND_KEYWORDS = mapOf( - COMPANION_KEYWORD to OBJECT_KEYWORD, - DATA_KEYWORD to CLASS_KEYWORD, - ENUM_KEYWORD to CLASS_KEYWORD, - ANNOTATION_KEYWORD to CLASS_KEYWORD, - SEALED_KEYWORD to CLASS_KEYWORD, - LATEINIT_KEYWORD to VAR_KEYWORD, - CONST_KEYWORD to VAL_KEYWORD, - SUSPEND_KEYWORD to FUN_KEYWORD + private val COMPOUND_KEYWORDS = mapOf>( + COMPANION_KEYWORD to setOf(OBJECT_KEYWORD), + DATA_KEYWORD to setOf(CLASS_KEYWORD), + ENUM_KEYWORD to setOf(CLASS_KEYWORD), + ANNOTATION_KEYWORD to setOf(CLASS_KEYWORD), + SEALED_KEYWORD to setOf(CLASS_KEYWORD, INTERFACE_KEYWORD), + LATEINIT_KEYWORD to setOf(VAR_KEYWORD), + CONST_KEYWORD to setOf(VAL_KEYWORD), + SUSPEND_KEYWORD to setOf(FUN_KEYWORD) ) private val KEYWORD_CONSTRUCTS = mapOf( @@ -105,54 +105,73 @@ object KeywordCompletion { SET_KEYWORD ).map { it.value } + "companion object" + fun complete(position: PsiElement, prefixMatcher: PrefixMatcher, isJvmModule: Boolean, consumer: (LookupElement) -> Unit) { if (!GENERAL_FILTER.isAcceptable(position, position)) return val parserFilter = buildFilter(position) for (keywordToken in ALL_KEYWORDS) { - var keyword = keywordToken.value - - val nextKeyword = when { - keywordToken == SUSPEND_KEYWORD && position.getStrictParentOfType() != null -> null - else -> COMPOUND_KEYWORDS[keywordToken] + val nextKeywords = keywordToken.getNextPossibleKeywords(position) ?: setOf(null) + nextKeywords.forEach { + handleCompoundKeyword(position, keywordToken, it, isJvmModule, prefixMatcher, parserFilter, consumer) } - var applicableAsCompound = false - if (nextKeyword != null) { - fun PsiElement.isSpace() = this is PsiWhiteSpace && '\n' !in getText() + } + } - var next = position.nextLeaf { !(it.isSpace() || it.text == "$") }?.text - if (next != null && next.startsWith("$")) { - next = next.substring(1) - } - if (next != nextKeyword.value) - keyword += " " + nextKeyword.value - else - applicableAsCompound = true - } + private fun KtKeywordToken.getNextPossibleKeywords(position: PsiElement): Set? { + return when { + this == SUSPEND_KEYWORD && position.getStrictParentOfType() != null -> null + else -> COMPOUND_KEYWORDS[this] + } + } - if (keywordToken == DYNAMIC_KEYWORD && isJvmModule) continue // not supported for JVM + private fun handleCompoundKeyword( + position: PsiElement, + keywordToken: KtKeywordToken, + nextKeyword: KtKeywordToken?, + isJvmModule: Boolean, + prefixMatcher: PrefixMatcher, + parserFilter: (KtKeywordToken) -> Boolean, + consumer: (LookupElement) -> Unit + ) { + var keyword = keywordToken.value - if (keywordToken !in KEYWORDS_TO_IGNORE_PREFIX && !prefixMatcher.isStartMatch(keyword)) continue + var applicableAsCompound = false + if (nextKeyword != null) { + fun PsiElement.isSpace() = this is PsiWhiteSpace && '\n' !in getText() - if (!parserFilter(keywordToken)) continue + var next = position.nextLeaf { !(it.isSpace() || it.text == "$") }?.text + next = next?.removePrefix("$") - val constructText = KEYWORD_CONSTRUCTS[keywordToken] - if (constructText != null && !applicableAsCompound) { - val element = createKeywordConstructLookupElement(position.project, keyword, constructText) - consumer(element) - } else { - if (listOf(CLASS_KEYWORD, OBJECT_KEYWORD, INTERFACE_KEYWORD).any { keyword.endsWith(it.value) }) { - val topLevelClassName = getTopLevelClassName(position) - if (topLevelClassName != null) { - if (keyword.startsWith(DATA_KEYWORD.value)) { - consumer(createKeywordConstructLookupElement(position.project, keyword, "$keyword $topLevelClassName(caret)")) - } else { - consumer(createLookupElementBuilder("$keyword $topLevelClassName", position)) - } + val nextIsNotYetPresent = keywordToken.getNextPossibleKeywords(position)?.none { it.value == next } == true + if (nextIsNotYetPresent) + keyword += " " + nextKeyword.value + else + applicableAsCompound = true + } + + if (keywordToken == DYNAMIC_KEYWORD && isJvmModule) return // not supported for JVM + + if (keywordToken !in KEYWORDS_TO_IGNORE_PREFIX && !prefixMatcher.isStartMatch(keyword)) return + + if (!parserFilter(keywordToken)) return + + val constructText = KEYWORD_CONSTRUCTS[keywordToken] + if (constructText != null && !applicableAsCompound) { + val element = createKeywordConstructLookupElement(position.project, keyword, constructText) + consumer(element) + } else { + if (listOf(CLASS_KEYWORD, OBJECT_KEYWORD, INTERFACE_KEYWORD).any { keyword.endsWith(it.value) }) { + val topLevelClassName = getTopLevelClassName(position) + if (topLevelClassName != null) { + if (keyword.startsWith(DATA_KEYWORD.value)) { + consumer(createKeywordConstructLookupElement(position.project, keyword, "$keyword $topLevelClassName(caret)")) + } else { + consumer(createLookupElementBuilder("$keyword $topLevelClassName", position)) } } - consumer(createLookupElementBuilder(keyword, position)) } + consumer(createLookupElementBuilder(keyword, position)) } } diff --git a/idea/idea-completion/testData/keywords/AfterClassProperty.kt b/idea/idea-completion/testData/keywords/AfterClassProperty.kt index eda4112e774..788cee4e10a 100644 --- a/idea/idea-completion/testData/keywords/AfterClassProperty.kt +++ b/idea/idea-completion/testData/keywords/AfterClassProperty.kt @@ -33,6 +33,7 @@ class MouseMovedEventArgs // EXIST: operator // EXIST: infix // EXIST: sealed class +// EXIST: sealed interface // EXIST: lateinit var // EXIST: data class // EXIST: inline diff --git a/idea/idea-completion/testData/keywords/AfterClasses.kt b/idea/idea-completion/testData/keywords/AfterClasses.kt index 2aaaaf6a926..6d16b266393 100644 --- a/idea/idea-completion/testData/keywords/AfterClasses.kt +++ b/idea/idea-completion/testData/keywords/AfterClasses.kt @@ -31,6 +31,7 @@ class AfterClasses { // EXIST: operator // EXIST: infix // EXIST: sealed class +// EXIST: sealed interface // EXIST: data class // EXIST: inline // EXIST: value diff --git a/idea/idea-completion/testData/keywords/AfterClasses_LangLevel10.kt b/idea/idea-completion/testData/keywords/AfterClasses_LangLevel10.kt index 17727796838..d6dd4d72438 100644 --- a/idea/idea-completion/testData/keywords/AfterClasses_LangLevel10.kt +++ b/idea/idea-completion/testData/keywords/AfterClasses_LangLevel10.kt @@ -33,6 +33,8 @@ class B { // EXIST: infix // EXIST: sealed class // EXIST: sealed class AfterClasses_LangLevel10 +// EXIST: sealed interface AfterClasses_LangLevel10 +// EXIST: sealed interface // EXIST: data class // EXIST: { "lookupString":"data class", "itemText":"data class", "tailText":" AfterClasses_LangLevel10(...)", "attributes":"bold" } // EXIST: inline diff --git a/idea/idea-completion/testData/keywords/AfterClasses_LangLevel11.kt b/idea/idea-completion/testData/keywords/AfterClasses_LangLevel11.kt index 24bbfe25aad..7263e242a82 100644 --- a/idea/idea-completion/testData/keywords/AfterClasses_LangLevel11.kt +++ b/idea/idea-completion/testData/keywords/AfterClasses_LangLevel11.kt @@ -33,6 +33,8 @@ class B { // EXIST: infix // EXIST: sealed class // EXIST: sealed class AfterClasses_LangLevel11 +// EXIST: sealed interface AfterClasses_LangLevel11 +// EXIST: sealed interface // EXIST: data class // EXIST: { "lookupString":"data class", "itemText":"data class", "tailText":" AfterClasses_LangLevel11(...)", "attributes":"bold" } // EXIST: inline diff --git a/idea/idea-completion/testData/keywords/AfterFuns.kt b/idea/idea-completion/testData/keywords/AfterFuns.kt index 54966f4890a..3f915220f47 100644 --- a/idea/idea-completion/testData/keywords/AfterFuns.kt +++ b/idea/idea-completion/testData/keywords/AfterFuns.kt @@ -32,6 +32,7 @@ class A { // EXIST: operator // EXIST: infix // EXIST: sealed class +// EXIST: sealed interface // EXIST: lateinit var // EXIST: data class // EXIST: inline diff --git a/idea/idea-completion/testData/keywords/GlobalPropertyAccessors.kt b/idea/idea-completion/testData/keywords/GlobalPropertyAccessors.kt index 8220a22f884..ab7873fa77e 100644 --- a/idea/idea-completion/testData/keywords/GlobalPropertyAccessors.kt +++ b/idea/idea-completion/testData/keywords/GlobalPropertyAccessors.kt @@ -37,6 +37,8 @@ var a : Int // EXIST: infix // EXIST: sealed class // EXIST: sealed class GlobalPropertyAccessors +// EXIST: sealed interface GlobalPropertyAccessors +// EXIST: sealed interface // EXIST: data class // EXIST: { "lookupString":"data class", "itemText":"data class", "tailText":" GlobalPropertyAccessors(...)", "attributes":"bold" } // EXIST: inline diff --git a/idea/idea-completion/testData/keywords/InAnnotationClassScope.kt b/idea/idea-completion/testData/keywords/InAnnotationClassScope.kt index 834ffb8f046..cc49effaff9 100644 --- a/idea/idea-completion/testData/keywords/InAnnotationClassScope.kt +++ b/idea/idea-completion/testData/keywords/InAnnotationClassScope.kt @@ -18,6 +18,7 @@ annotation class Test { // EXIST: operator // EXIST: infix // EXIST: sealed class +// EXIST: sealed interface // EXIST: lateinit var // EXIST: data class // EXIST: inline diff --git a/idea/idea-completion/testData/keywords/InClassBeforeFun.kt b/idea/idea-completion/testData/keywords/InClassBeforeFun.kt index 44b688bde61..ebc5751c42d 100644 --- a/idea/idea-completion/testData/keywords/InClassBeforeFun.kt +++ b/idea/idea-completion/testData/keywords/InClassBeforeFun.kt @@ -30,6 +30,7 @@ public class Test { // EXIST: operator // EXIST: infix // EXIST: sealed class +// EXIST: sealed interface // EXIST: lateinit var // EXIST: data class // EXIST: inline diff --git a/idea/idea-completion/testData/keywords/InClassScope.kt b/idea/idea-completion/testData/keywords/InClassScope.kt index a8f87a62b64..de5a03acfe6 100644 --- a/idea/idea-completion/testData/keywords/InClassScope.kt +++ b/idea/idea-completion/testData/keywords/InClassScope.kt @@ -24,6 +24,7 @@ class TestClass { // EXIST: operator // EXIST: infix // EXIST: sealed class +// EXIST: sealed interface // EXIST: lateinit var // EXIST: data class // EXIST: inline diff --git a/idea/idea-completion/testData/keywords/InEnumScope2.kt b/idea/idea-completion/testData/keywords/InEnumScope2.kt index f8e87c232c5..2251838ea0f 100644 --- a/idea/idea-completion/testData/keywords/InEnumScope2.kt +++ b/idea/idea-completion/testData/keywords/InEnumScope2.kt @@ -18,6 +18,7 @@ enum class Test { // EXIST: operator // EXIST: infix // EXIST: sealed class +// EXIST: sealed interface // EXIST: lateinit var // EXIST: data class // EXIST: inline diff --git a/idea/idea-completion/testData/keywords/InInterfaceScope.kt b/idea/idea-completion/testData/keywords/InInterfaceScope.kt index 230e1573307..11689d4e8de 100644 --- a/idea/idea-completion/testData/keywords/InInterfaceScope.kt +++ b/idea/idea-completion/testData/keywords/InInterfaceScope.kt @@ -20,6 +20,7 @@ interface Test { // EXIST: operator // EXIST: infix // EXIST: sealed class +// EXIST: sealed interface // EXIST: lateinit var // EXIST: data class // EXIST: inline diff --git a/idea/idea-completion/testData/keywords/InObjectScope.kt b/idea/idea-completion/testData/keywords/InObjectScope.kt index b2c7f817171..8f8fc86717b 100644 --- a/idea/idea-completion/testData/keywords/InObjectScope.kt +++ b/idea/idea-completion/testData/keywords/InObjectScope.kt @@ -21,6 +21,7 @@ object Test { // EXIST: operator // EXIST: infix // EXIST: sealed class +// EXIST: sealed interface // EXIST: lateinit var // EXIST: data class // EXIST: inline diff --git a/idea/idea-completion/testData/keywords/InTopScopeAfterPackage.kt b/idea/idea-completion/testData/keywords/InTopScopeAfterPackage.kt index f6eb462e225..282b0c8d8df 100644 --- a/idea/idea-completion/testData/keywords/InTopScopeAfterPackage.kt +++ b/idea/idea-completion/testData/keywords/InTopScopeAfterPackage.kt @@ -24,6 +24,8 @@ package Test // EXIST: infix // EXIST: sealed class // EXIST: sealed class InTopScopeAfterPackage +// EXIST: sealed interface InTopScopeAfterPackage +// EXIST: sealed interface // EXIST: data class // EXIST: { "lookupString":"data class", "itemText":"data class", "tailText":" InTopScopeAfterPackage(...)", "attributes":"bold" } // EXIST: inline diff --git a/idea/idea-completion/testData/keywords/PropertyAccessors.kt b/idea/idea-completion/testData/keywords/PropertyAccessors.kt index b662fdf7444..8a6e6ace135 100644 --- a/idea/idea-completion/testData/keywords/PropertyAccessors.kt +++ b/idea/idea-completion/testData/keywords/PropertyAccessors.kt @@ -32,6 +32,7 @@ class Some { // EXIST: operator // EXIST: infix // EXIST: sealed class +// EXIST: sealed interface // EXIST: lateinit var // EXIST: data class // EXIST: inline diff --git a/idea/idea-completion/testData/keywords/PropertyAccessors2.kt b/idea/idea-completion/testData/keywords/PropertyAccessors2.kt index f4326fbd54b..269f3f45e15 100644 --- a/idea/idea-completion/testData/keywords/PropertyAccessors2.kt +++ b/idea/idea-completion/testData/keywords/PropertyAccessors2.kt @@ -32,6 +32,7 @@ class Some { // EXIST: operator // EXIST: infix // EXIST: sealed class +// EXIST: sealed interface // EXIST: lateinit var // EXIST: data class // EXIST: inline diff --git a/idea/idea-completion/testData/keywords/PropertySetter.kt b/idea/idea-completion/testData/keywords/PropertySetter.kt index 491c24fe4c1..f950db00539 100644 --- a/idea/idea-completion/testData/keywords/PropertySetter.kt +++ b/idea/idea-completion/testData/keywords/PropertySetter.kt @@ -30,6 +30,7 @@ class Some { // EXIST: operator // EXIST: infix // EXIST: sealed class +// EXIST: sealed interface // EXIST: lateinit var // EXIST: data class // EXIST: inline diff --git a/idea/idea-completion/testData/keywords/SealedForDeclaredClass.kt b/idea/idea-completion/testData/keywords/SealedForDeclaredClass.kt new file mode 100644 index 00000000000..f12d91839e1 --- /dev/null +++ b/idea/idea-completion/testData/keywords/SealedForDeclaredClass.kt @@ -0,0 +1,3 @@ +sealclass A +// EXIST: "sealed" +// NOTHING_ELSE \ No newline at end of file diff --git a/idea/idea-completion/testData/keywords/SealedForDeclaredInterface.kt b/idea/idea-completion/testData/keywords/SealedForDeclaredInterface.kt new file mode 100644 index 00000000000..c1a96d3b410 --- /dev/null +++ b/idea/idea-completion/testData/keywords/SealedForDeclaredInterface.kt @@ -0,0 +1,3 @@ +sealinterface A +// EXIST: "sealed" +// NOTHING_ELSE \ No newline at end of file diff --git a/idea/idea-completion/testData/keywords/SealedWithName.kt b/idea/idea-completion/testData/keywords/SealedWithName.kt new file mode 100644 index 00000000000..345a354e786 --- /dev/null +++ b/idea/idea-completion/testData/keywords/SealedWithName.kt @@ -0,0 +1,6 @@ +seal +// EXIST: "sealed class SealedWithName" +// EXIST: "sealed interface SealedWithName" +// EXIST: "sealed class" +// EXIST: "sealed interface" +// NOTHING_ELSE \ No newline at end of file diff --git a/idea/idea-completion/testData/keywords/SealedWithoutName.kt b/idea/idea-completion/testData/keywords/SealedWithoutName.kt new file mode 100644 index 00000000000..de4abff9998 --- /dev/null +++ b/idea/idea-completion/testData/keywords/SealedWithoutName.kt @@ -0,0 +1,6 @@ +class OuterClass { + seal +} +// EXIST: "sealed class" +// EXIST: "sealed interface" +// NOTHING_ELSE \ No newline at end of file diff --git a/idea/idea-completion/testData/keywords/TopScope.kt b/idea/idea-completion/testData/keywords/TopScope.kt index a0047259892..47b03855278 100644 --- a/idea/idea-completion/testData/keywords/TopScope.kt +++ b/idea/idea-completion/testData/keywords/TopScope.kt @@ -23,6 +23,8 @@ // EXIST: infix // EXIST: sealed class // EXIST: sealed class TopScope +// EXIST: sealed interface TopScope +// EXIST: sealed interface // EXIST: data class // EXIST: { "lookupString":"data class", "itemText":"data class", "tailText":" TopScope(...)", "attributes":"bold" } // EXIST: inline diff --git a/idea/idea-completion/testData/keywords/TopScope3-.kt b/idea/idea-completion/testData/keywords/TopScope3-.kt index dda4333afe5..63e8eaf6465 100644 --- a/idea/idea-completion/testData/keywords/TopScope3-.kt +++ b/idea/idea-completion/testData/keywords/TopScope3-.kt @@ -18,6 +18,7 @@ // EXIST: operator // EXIST: infix // EXIST: sealed class +// EXIST: sealed interface // EXIST: data class // EXIST: inline // EXIST: value diff --git a/idea/idea-completion/testData/keywords/topScope2.kt b/idea/idea-completion/testData/keywords/topScope2.kt index dda4333afe5..63e8eaf6465 100644 --- a/idea/idea-completion/testData/keywords/topScope2.kt +++ b/idea/idea-completion/testData/keywords/topScope2.kt @@ -18,6 +18,7 @@ // EXIST: operator // EXIST: infix // EXIST: sealed class +// EXIST: sealed interface // EXIST: data class // EXIST: inline // EXIST: value diff --git a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/KeywordCompletionTestGenerated.java b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/KeywordCompletionTestGenerated.java index 9c58628cac0..4f596d121ef 100644 --- a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/KeywordCompletionTestGenerated.java +++ b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/KeywordCompletionTestGenerated.java @@ -503,6 +503,26 @@ public class KeywordCompletionTestGenerated extends AbstractKeywordCompletionTes runTest("idea/idea-completion/testData/keywords/ReturnSet.kt"); } + @TestMetadata("SealedForDeclaredClass.kt") + public void testSealedForDeclaredClass() throws Exception { + runTest("idea/idea-completion/testData/keywords/SealedForDeclaredClass.kt"); + } + + @TestMetadata("SealedForDeclaredInterface.kt") + public void testSealedForDeclaredInterface() throws Exception { + runTest("idea/idea-completion/testData/keywords/SealedForDeclaredInterface.kt"); + } + + @TestMetadata("SealedWithName.kt") + public void testSealedWithName() throws Exception { + runTest("idea/idea-completion/testData/keywords/SealedWithName.kt"); + } + + @TestMetadata("SealedWithoutName.kt") + public void testSealedWithoutName() throws Exception { + runTest("idea/idea-completion/testData/keywords/SealedWithoutName.kt"); + } + @TestMetadata("SuspendInParameterTypePosition.kt") public void testSuspendInParameterTypePosition() throws Exception { runTest("idea/idea-completion/testData/keywords/SuspendInParameterTypePosition.kt"); From f02b73103b7f97b826e61c882d8c34d90e78dff4 Mon Sep 17 00:00:00 2001 From: Andrei Klunnyi Date: Fri, 4 Dec 2020 12:43:19 +0100 Subject: [PATCH 031/196] KTIJ-650 [Code completion]: no "sealed" for classes with modifiers annotation, data, enum, inner, open - classes supplied with these modifiers cannot be sealed. Commit fixes code completion - "sealed" is no longer suggested in the mentioned case. --- .../idea/completion/KeywordCompletion.kt | 33 +++++++++++++++-- .../keywords/SealedForAlreadySealed.kt | 4 +++ .../keywords/SealedForAnnotationClass.kt | 4 +++ .../testData/keywords/SealedForDataClass.kt | 2 ++ .../testData/keywords/SealedForEnumClass.kt | 2 ++ .../keywords/SealedForFunInterface.kt | 6 ++++ .../testData/keywords/SealedForInnerClass.kt | 4 +++ .../testData/keywords/SealedForOpenClass.kt | 2 ++ .../test/KeywordCompletionTestGenerated.java | 35 +++++++++++++++++++ 9 files changed, 89 insertions(+), 3 deletions(-) create mode 100644 idea/idea-completion/testData/keywords/SealedForAlreadySealed.kt create mode 100644 idea/idea-completion/testData/keywords/SealedForAnnotationClass.kt create mode 100644 idea/idea-completion/testData/keywords/SealedForDataClass.kt create mode 100644 idea/idea-completion/testData/keywords/SealedForEnumClass.kt create mode 100644 idea/idea-completion/testData/keywords/SealedForFunInterface.kt create mode 100644 idea/idea-completion/testData/keywords/SealedForInnerClass.kt create mode 100644 idea/idea-completion/testData/keywords/SealedForOpenClass.kt diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KeywordCompletion.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KeywordCompletion.kt index fa799b10972..9317092d4fe 100644 --- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KeywordCompletion.kt +++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KeywordCompletion.kt @@ -66,17 +66,32 @@ object KeywordCompletion { private val KEYWORDS_TO_IGNORE_PREFIX = TokenSet.create(OVERRIDE_KEYWORD /* it's needed to complete overrides that should be work by member name too */) + private val INCOMPATIBLE_KEYWORDS_AROUND_SEALED = setOf( + SEALED_KEYWORD, + ANNOTATION_KEYWORD, + DATA_KEYWORD, + ENUM_KEYWORD, + OPEN_KEYWORD, + INNER_KEYWORD, + ABSTRACT_KEYWORD + ).mapTo(HashSet()) { it.value } + private val COMPOUND_KEYWORDS = mapOf>( COMPANION_KEYWORD to setOf(OBJECT_KEYWORD), DATA_KEYWORD to setOf(CLASS_KEYWORD), ENUM_KEYWORD to setOf(CLASS_KEYWORD), ANNOTATION_KEYWORD to setOf(CLASS_KEYWORD), - SEALED_KEYWORD to setOf(CLASS_KEYWORD, INTERFACE_KEYWORD), + SEALED_KEYWORD to setOf(CLASS_KEYWORD, INTERFACE_KEYWORD, FUN_KEYWORD), LATEINIT_KEYWORD to setOf(VAR_KEYWORD), CONST_KEYWORD to setOf(VAL_KEYWORD), SUSPEND_KEYWORD to setOf(FUN_KEYWORD) ) + private val COMPOUND_KEYWORDS_NOT_SUGGEST_TOGETHER = mapOf>( + // 'fun' can follow 'sealed', e.g. "sealed fun interface". But "sealed fun" looks irrelevant differ to "sealed interface/class". + SEALED_KEYWORD to setOf(FUN_KEYWORD), + ) + private val KEYWORD_CONSTRUCTS = mapOf( IF_KEYWORD to "fun foo() { if (caret)", WHILE_KEYWORD to "fun foo() { while(caret)", @@ -105,7 +120,6 @@ object KeywordCompletion { SET_KEYWORD ).map { it.value } + "companion object" - fun complete(position: PsiElement, prefixMatcher: PrefixMatcher, isJvmModule: Boolean, consumer: (LookupElement) -> Unit) { if (!GENERAL_FILTER.isAcceptable(position, position)) return @@ -125,6 +139,11 @@ object KeywordCompletion { } } + private fun KtKeywordToken.avoidSuggestingWith(keywordToken: KtKeywordToken): Boolean { + val nextKeywords = COMPOUND_KEYWORDS_NOT_SUGGEST_TOGETHER[this] ?: return false + return keywordToken in nextKeywords + } + private fun handleCompoundKeyword( position: PsiElement, keywordToken: KtKeywordToken, @@ -143,7 +162,15 @@ object KeywordCompletion { var next = position.nextLeaf { !(it.isSpace() || it.text == "$") }?.text next = next?.removePrefix("$") + if (keywordToken == SEALED_KEYWORD) { + if (next in INCOMPATIBLE_KEYWORDS_AROUND_SEALED) return + val prev = position.prevLeaf { !(it.isSpace() || it is PsiErrorElement) }?.text + if (prev in INCOMPATIBLE_KEYWORDS_AROUND_SEALED) return + } + val nextIsNotYetPresent = keywordToken.getNextPossibleKeywords(position)?.none { it.value == next } == true + if (nextIsNotYetPresent && keywordToken.avoidSuggestingWith(nextKeyword)) return + if (nextIsNotYetPresent) keyword += " " + nextKeyword.value else @@ -609,4 +636,4 @@ object KeywordCompletion { else -> it.parent } } -} +} \ No newline at end of file diff --git a/idea/idea-completion/testData/keywords/SealedForAlreadySealed.kt b/idea/idea-completion/testData/keywords/SealedForAlreadySealed.kt new file mode 100644 index 00000000000..7d8d077dcd3 --- /dev/null +++ b/idea/idea-completion/testData/keywords/SealedForAlreadySealed.kt @@ -0,0 +1,4 @@ +seal sealed class A +// ABSENT: "sealed" +// ABSENT: "sealed class" +// ABSENT: "sealed interface" \ No newline at end of file diff --git a/idea/idea-completion/testData/keywords/SealedForAnnotationClass.kt b/idea/idea-completion/testData/keywords/SealedForAnnotationClass.kt new file mode 100644 index 00000000000..7fe489d68bc --- /dev/null +++ b/idea/idea-completion/testData/keywords/SealedForAnnotationClass.kt @@ -0,0 +1,4 @@ +seal annotation class A +// ABSENT: "sealed" +// ABSENT: "sealed class" +// ABSENT: "sealed interface" \ No newline at end of file diff --git a/idea/idea-completion/testData/keywords/SealedForDataClass.kt b/idea/idea-completion/testData/keywords/SealedForDataClass.kt new file mode 100644 index 00000000000..08688c6481b --- /dev/null +++ b/idea/idea-completion/testData/keywords/SealedForDataClass.kt @@ -0,0 +1,2 @@ +seal data class A(val f: Int) +// ABSENT: "sealed" \ No newline at end of file diff --git a/idea/idea-completion/testData/keywords/SealedForEnumClass.kt b/idea/idea-completion/testData/keywords/SealedForEnumClass.kt new file mode 100644 index 00000000000..e4699e61300 --- /dev/null +++ b/idea/idea-completion/testData/keywords/SealedForEnumClass.kt @@ -0,0 +1,2 @@ +seal enum class A +// ABSENT: "sealed" \ No newline at end of file diff --git a/idea/idea-completion/testData/keywords/SealedForFunInterface.kt b/idea/idea-completion/testData/keywords/SealedForFunInterface.kt new file mode 100644 index 00000000000..5eabec43764 --- /dev/null +++ b/idea/idea-completion/testData/keywords/SealedForFunInterface.kt @@ -0,0 +1,6 @@ +seal fun interface A { + fun aFunction() +} + +// EXIST: "sealed" +// NOTHING_ELSE \ No newline at end of file diff --git a/idea/idea-completion/testData/keywords/SealedForInnerClass.kt b/idea/idea-completion/testData/keywords/SealedForInnerClass.kt new file mode 100644 index 00000000000..dcaf19f6cb6 --- /dev/null +++ b/idea/idea-completion/testData/keywords/SealedForInnerClass.kt @@ -0,0 +1,4 @@ +class A { + sealinner class B +} +// ABSENT: "sealed" \ No newline at end of file diff --git a/idea/idea-completion/testData/keywords/SealedForOpenClass.kt b/idea/idea-completion/testData/keywords/SealedForOpenClass.kt new file mode 100644 index 00000000000..3abc4394930 --- /dev/null +++ b/idea/idea-completion/testData/keywords/SealedForOpenClass.kt @@ -0,0 +1,2 @@ +seal open class A +// ABSENT: "sealed" \ No newline at end of file diff --git a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/KeywordCompletionTestGenerated.java b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/KeywordCompletionTestGenerated.java index 4f596d121ef..98da39a1e69 100644 --- a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/KeywordCompletionTestGenerated.java +++ b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/KeywordCompletionTestGenerated.java @@ -503,6 +503,21 @@ public class KeywordCompletionTestGenerated extends AbstractKeywordCompletionTes runTest("idea/idea-completion/testData/keywords/ReturnSet.kt"); } + @TestMetadata("SealedForAlreadySealed.kt") + public void testSealedForAlreadySealed() throws Exception { + runTest("idea/idea-completion/testData/keywords/SealedForAlreadySealed.kt"); + } + + @TestMetadata("SealedForAnnotationClass.kt") + public void testSealedForAnnotationClass() throws Exception { + runTest("idea/idea-completion/testData/keywords/SealedForAnnotationClass.kt"); + } + + @TestMetadata("SealedForDataClass.kt") + public void testSealedForDataClass() throws Exception { + runTest("idea/idea-completion/testData/keywords/SealedForDataClass.kt"); + } + @TestMetadata("SealedForDeclaredClass.kt") public void testSealedForDeclaredClass() throws Exception { runTest("idea/idea-completion/testData/keywords/SealedForDeclaredClass.kt"); @@ -513,6 +528,26 @@ public class KeywordCompletionTestGenerated extends AbstractKeywordCompletionTes runTest("idea/idea-completion/testData/keywords/SealedForDeclaredInterface.kt"); } + @TestMetadata("SealedForEnumClass.kt") + public void testSealedForEnumClass() throws Exception { + runTest("idea/idea-completion/testData/keywords/SealedForEnumClass.kt"); + } + + @TestMetadata("SealedForFunInterface.kt") + public void testSealedForFunInterface() throws Exception { + runTest("idea/idea-completion/testData/keywords/SealedForFunInterface.kt"); + } + + @TestMetadata("SealedForInnerClass.kt") + public void testSealedForInnerClass() throws Exception { + runTest("idea/idea-completion/testData/keywords/SealedForInnerClass.kt"); + } + + @TestMetadata("SealedForOpenClass.kt") + public void testSealedForOpenClass() throws Exception { + runTest("idea/idea-completion/testData/keywords/SealedForOpenClass.kt"); + } + @TestMetadata("SealedWithName.kt") public void testSealedWithName() throws Exception { runTest("idea/idea-completion/testData/keywords/SealedWithName.kt"); From 3af0257b3802bb206a9539d6d6f0309186955f8f Mon Sep 17 00:00:00 2001 From: Andrei Klunnyi Date: Thu, 10 Dec 2020 15:09:16 +0100 Subject: [PATCH 032/196] KTIJ-664 [SealedClassInheritorsProvider]: IDE-specific implementation --- .../kotlin/frontend/java/di/injection.kt | 10 ++-- .../jvm/JvmResolverForModuleFactory.kt | 5 +- .../kotlin/analyzer/AnalyzerFacade.kt | 5 +- .../common/CommonResolverForModuleFactory.kt | 3 +- .../jetbrains/kotlin/frontend/di/injection.kt | 5 +- .../resolve/SealedClassInheritorsProvider.kt | 10 ++-- .../DeserializedClassDescriptor.kt | 4 +- .../CompositeResolverForModuleFactory.kt | 5 +- .../resolve/JsResolverForModuleFactory.kt | 4 +- .../caches/resolve/IdeaResolverForProject.kt | 4 +- .../IdeSealedClassInheritorsProvider.kt | 53 +++++++++++++++++++ .../NativeResolverForModuleFactory.kt | 4 +- .../checker/sealed/SealedDeclaration.kt | 14 +++++ .../checker/sealed/SealedInheritors.kt | 35 ++++++++++++ .../sealed/SealedOutsidePackageInheritors.kt | 7 +++ .../kotlin/checkers/PsiCheckerSealedTest.kt | 32 +++++++++++ .../builder/CommonizedClassDescriptor.kt | 5 +- 17 files changed, 181 insertions(+), 24 deletions(-) create mode 100644 idea/idea-analysis/src/org/jetbrains/kotlin/idea/compiler/IdeSealedClassInheritorsProvider.kt create mode 100644 idea/testData/checker/sealed/SealedDeclaration.kt create mode 100644 idea/testData/checker/sealed/SealedInheritors.kt create mode 100644 idea/testData/checker/sealed/SealedOutsidePackageInheritors.kt create mode 100644 idea/tests/org/jetbrains/kotlin/checkers/PsiCheckerSealedTest.kt diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt index f17a0fdff53..4b814ca32f0 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt @@ -41,10 +41,8 @@ import org.jetbrains.kotlin.load.kotlin.DeserializationComponentsForJava import org.jetbrains.kotlin.load.kotlin.PackagePartProvider import org.jetbrains.kotlin.load.kotlin.VirtualFileFinderFactory import org.jetbrains.kotlin.platform.TargetPlatform -import org.jetbrains.kotlin.resolve.BindingTrace -import org.jetbrains.kotlin.resolve.TargetEnvironment +import org.jetbrains.kotlin.resolve.* import org.jetbrains.kotlin.resolve.calls.tower.ImplicitsExtensionsResolutionFilter -import org.jetbrains.kotlin.resolve.createContainer import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver import org.jetbrains.kotlin.resolve.jvm.JvmDiagnosticComponents import org.jetbrains.kotlin.resolve.jvm.multiplatform.OptionalAnnotationPackageFragmentProvider @@ -68,8 +66,12 @@ fun createContainerForLazyResolveWithJava( configureJavaClassFinder: (StorageComponentContainer.() -> Unit)? = null, javaClassTracker: JavaClassesTracker? = null, implicitsResolutionFilter: ImplicitsExtensionsResolutionFilter? = null, + sealedInheritorsProvider: SealedClassInheritorsProvider = CliSealedClassInheritorsProvider ): StorageComponentContainer = createContainer("LazyResolveWithJava", JvmPlatformAnalyzerServices) { - configureModule(moduleContext, jvmPlatform, JvmPlatformAnalyzerServices, bindingTrace, languageVersionSettings) + configureModule( + moduleContext, jvmPlatform, JvmPlatformAnalyzerServices, bindingTrace, languageVersionSettings, + sealedInheritorsProvider + ) configureIncrementalCompilation(lookupTracker, expectActualTracker) configureStandardResolveComponents() diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmResolverForModuleFactory.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmResolverForModuleFactory.kt index 1879fa01bf2..531b53b7e27 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmResolverForModuleFactory.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmResolverForModuleFactory.kt @@ -31,6 +31,7 @@ import org.jetbrains.kotlin.load.kotlin.PackagePartProvider import org.jetbrains.kotlin.platform.jvm.isJvm import org.jetbrains.kotlin.resolve.CodeAnalyzerInitializer import org.jetbrains.kotlin.platform.TargetPlatform +import org.jetbrains.kotlin.resolve.SealedClassInheritorsProvider import org.jetbrains.kotlin.resolve.TargetEnvironment import org.jetbrains.kotlin.resolve.jvm.extensions.PackageFragmentProviderExtension import org.jetbrains.kotlin.resolve.lazy.ResolveSession @@ -54,7 +55,8 @@ class JvmResolverForModuleFactory( moduleContext: ModuleContext, moduleContent: ModuleContent, resolverForProject: ResolverForProject, - languageVersionSettings: LanguageVersionSettings + languageVersionSettings: LanguageVersionSettings, + sealedInheritorsProvider: SealedClassInheritorsProvider ): ResolverForModule { val (moduleInfo, syntheticFiles, moduleContentScope) = moduleContent val project = moduleContext.project @@ -108,6 +110,7 @@ class JvmResolverForModuleFactory( ExpectActualTracker.DoNothing, packagePartProvider, languageVersionSettings, + sealedInheritorsProvider = sealedInheritorsProvider, useBuiltInsProvider = false // TODO: load built-ins from module dependencies in IDE ) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/analyzer/AnalyzerFacade.kt b/compiler/frontend/src/org/jetbrains/kotlin/analyzer/AnalyzerFacade.kt index 5dbdf8f0090..9c7f9e7ec19 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/analyzer/AnalyzerFacade.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/analyzer/AnalyzerFacade.kt @@ -32,6 +32,8 @@ import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.platform.TargetPlatform import org.jetbrains.kotlin.platform.TargetPlatformVersion import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.resolve.SealedClassInheritorsProvider +import org.jetbrains.kotlin.resolve.CliSealedClassInheritorsProvider import org.jetbrains.kotlin.storage.StorageManager import org.jetbrains.kotlin.storage.getValue import java.util.* @@ -119,7 +121,8 @@ abstract class ResolverForModuleFactory { moduleContext: ModuleContext, moduleContent: ModuleContent, resolverForProject: ResolverForProject, - languageVersionSettings: LanguageVersionSettings + languageVersionSettings: LanguageVersionSettings, + sealedInheritorsProvider: SealedClassInheritorsProvider = CliSealedClassInheritorsProvider ): ResolverForModule } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/analyzer/common/CommonResolverForModuleFactory.kt b/compiler/frontend/src/org/jetbrains/kotlin/analyzer/common/CommonResolverForModuleFactory.kt index baf857079c6..c567395a529 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/analyzer/common/CommonResolverForModuleFactory.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/analyzer/common/CommonResolverForModuleFactory.kt @@ -85,7 +85,8 @@ class CommonResolverForModuleFactory( moduleContext: ModuleContext, moduleContent: ModuleContent, resolverForProject: ResolverForProject, - languageVersionSettings: LanguageVersionSettings + languageVersionSettings: LanguageVersionSettings, + sealedInheritorsProvider: SealedClassInheritorsProvider ): ResolverForModule { val (moduleInfo, syntheticFiles, moduleContentScope) = moduleContent val project = moduleContext.project diff --git a/compiler/frontend/src/org/jetbrains/kotlin/frontend/di/injection.kt b/compiler/frontend/src/org/jetbrains/kotlin/frontend/di/injection.kt index 33f1f8e84ba..db014953858 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/frontend/di/injection.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/frontend/di/injection.kt @@ -51,8 +51,10 @@ fun StorageComponentContainer.configureModule( platform: TargetPlatform, analyzerServices: PlatformDependentAnalyzerServices, trace: BindingTrace, - languageVersionSettings: LanguageVersionSettings + languageVersionSettings: LanguageVersionSettings, + sealedProvider: SealedClassInheritorsProvider = CliSealedClassInheritorsProvider ) { + useInstance(sealedProvider) useInstance(moduleContext) useInstance(moduleContext.module) useInstance(moduleContext.project) @@ -103,7 +105,6 @@ private fun StorageComponentContainer.configurePlatformIndependentComponents() { useImpl() useImpl() useInstance(ProgressManagerBasedCancellationChecker) - useInstance(SealedClassInheritorsProviderImpl) } /** diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/SealedClassInheritorsProvider.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/SealedClassInheritorsProvider.kt index 0927584612e..253e165ebd5 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/resolve/SealedClassInheritorsProvider.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/SealedClassInheritorsProvider.kt @@ -18,17 +18,17 @@ abstract class SealedClassInheritorsProvider { */ abstract fun computeSealedSubclasses( sealedClass: ClassDescriptor, - freedomForSealedInterfacesSupported: Boolean + allowSealedInheritorsInDifferentFilesOfSamePackage: Boolean ): Collection } -object SealedClassInheritorsProviderImpl : SealedClassInheritorsProvider() { +object CliSealedClassInheritorsProvider : SealedClassInheritorsProvider() { // Note this is a generic and slow implementation which would work almost for any subclass of ClassDescriptor. // Please avoid using it in new code. // TODO: do something more clever instead at call sites of this function override fun computeSealedSubclasses( sealedClass: ClassDescriptor, - freedomForSealedInterfacesSupported: Boolean + allowSealedInheritorsInDifferentFilesOfSamePackage: Boolean ): Collection { if (sealedClass.modality != Modality.SEALED) return emptyList() @@ -48,7 +48,7 @@ object SealedClassInheritorsProviderImpl : SealedClassInheritorsProvider() { } } - val container = if (!freedomForSealedInterfacesSupported) { + val container = if (!allowSealedInheritorsInDifferentFilesOfSamePackage) { sealedClass.containingDeclaration } else { sealedClass.parents.firstOrNull { it is PackageFragmentDescriptor } @@ -56,7 +56,7 @@ object SealedClassInheritorsProviderImpl : SealedClassInheritorsProvider() { if (container is PackageFragmentDescriptor) { collectSubclasses( container.getMemberScope(), - collectNested = freedomForSealedInterfacesSupported + collectNested = allowSealedInheritorsInDifferentFilesOfSamePackage ) } collectSubclasses(sealedClass.unsubstitutedInnerClassesScope, collectNested = true) diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedClassDescriptor.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedClassDescriptor.kt index bb29c10df39..1f9be75662b 100644 --- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedClassDescriptor.kt +++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedClassDescriptor.kt @@ -18,7 +18,7 @@ import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.DescriptorFactory import org.jetbrains.kotlin.resolve.NonReportingOverrideStrategy import org.jetbrains.kotlin.resolve.OverridingUtil -import org.jetbrains.kotlin.resolve.SealedClassInheritorsProviderImpl +import org.jetbrains.kotlin.resolve.CliSealedClassInheritorsProvider import org.jetbrains.kotlin.resolve.descriptorUtil.classId import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter import org.jetbrains.kotlin.resolve.scopes.MemberScope @@ -165,7 +165,7 @@ class DeserializedClassDescriptor( } // This is needed because classes compiled with Kotlin 1.0 did not contain the sealed_subclass_fq_name field - return SealedClassInheritorsProviderImpl.computeSealedSubclasses(this, freedomForSealedInterfacesSupported = false) + return CliSealedClassInheritorsProvider.computeSealedSubclasses(this, allowSealedInheritorsInDifferentFilesOfSamePackage = false) } override fun getSealedSubclasses() = sealedSubclasses() diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/caches/resolve/CompositeResolverForModuleFactory.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/caches/resolve/CompositeResolverForModuleFactory.kt index 7b9f2e11be7..18104ec0db3 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/caches/resolve/CompositeResolverForModuleFactory.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/caches/resolve/CompositeResolverForModuleFactory.kt @@ -56,7 +56,8 @@ class CompositeResolverForModuleFactory( moduleContext: ModuleContext, moduleContent: ModuleContent, resolverForProject: ResolverForProject, - languageVersionSettings: LanguageVersionSettings + languageVersionSettings: LanguageVersionSettings, + sealedInheritorsProvider: SealedClassInheritorsProvider ): ResolverForModule { val (moduleInfo, syntheticFiles, moduleContentScope) = moduleContent val project = moduleContext.project @@ -178,7 +179,7 @@ class CompositeResolverForModuleFactory( } // Called by all normal containers set-ups - configureModule(moduleContext, targetPlatform, analyzerServices, trace, languageVersionSettings) + configureModule(moduleContext, targetPlatform, analyzerServices, trace, languageVersionSettings,) configureStandardResolveComponents() useInstance(moduleContentScope) useInstance(declarationProviderFactory) diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/caches/resolve/JsResolverForModuleFactory.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/caches/resolve/JsResolverForModuleFactory.kt index 52de11d0adc..07ea2de2312 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/caches/resolve/JsResolverForModuleFactory.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/caches/resolve/JsResolverForModuleFactory.kt @@ -20,6 +20,7 @@ import org.jetbrains.kotlin.js.resolve.JsPlatformAnalyzerServices import org.jetbrains.kotlin.platform.idePlatformKind import org.jetbrains.kotlin.platform.js.JsPlatforms import org.jetbrains.kotlin.resolve.BindingTraceContext +import org.jetbrains.kotlin.resolve.SealedClassInheritorsProvider import org.jetbrains.kotlin.resolve.TargetEnvironment import org.jetbrains.kotlin.resolve.lazy.ResolveSession import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactoryService @@ -38,7 +39,8 @@ class JsResolverForModuleFactory( moduleContext: ModuleContext, moduleContent: ModuleContent, resolverForProject: ResolverForProject, - languageVersionSettings: LanguageVersionSettings + languageVersionSettings: LanguageVersionSettings, + sealedInheritorsProvider: SealedClassInheritorsProvider ): ResolverForModule { val (moduleInfo, syntheticFiles, moduleContentScope) = moduleContent val project = moduleContext.project diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/IdeaResolverForProject.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/IdeaResolverForProject.kt index 6018b0533c4..a6d6c3ea69b 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/IdeaResolverForProject.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/IdeaResolverForProject.kt @@ -24,6 +24,7 @@ import org.jetbrains.kotlin.idea.caches.project.IdeaModuleInfo import org.jetbrains.kotlin.idea.caches.project.getNullableModuleInfo import org.jetbrains.kotlin.idea.compiler.IDELanguageSettingsProvider import org.jetbrains.kotlin.idea.project.IdeaEnvironment +import org.jetbrains.kotlin.idea.compiler.IdeSealedClassInheritorsProvider import org.jetbrains.kotlin.idea.project.findAnalyzerServices import org.jetbrains.kotlin.idea.project.useCompositeAnalysis import org.jetbrains.kotlin.load.java.structure.JavaClass @@ -83,7 +84,8 @@ class IdeaResolverForProject( projectContext.withModule(descriptor), moduleContent, this, - languageVersionSettings + languageVersionSettings, + sealedInheritorsProvider = IdeSealedClassInheritorsProvider ) } diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/compiler/IdeSealedClassInheritorsProvider.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/compiler/IdeSealedClassInheritorsProvider.kt new file mode 100644 index 00000000000..7f0268cd7c8 --- /dev/null +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/compiler/IdeSealedClassInheritorsProvider.kt @@ -0,0 +1,53 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.idea.compiler + +import com.intellij.psi.* +import com.intellij.psi.search.* +import com.intellij.psi.search.searches.ClassInheritorsSearch +import com.intellij.psi.search.searches.ClassInheritorsSearch.SearchParameters +import org.jetbrains.kotlin.asJava.toLightClass +import org.jetbrains.kotlin.descriptors.ClassDescriptor +import org.jetbrains.kotlin.descriptors.containingPackage +import org.jetbrains.kotlin.idea.caches.resolve.util.javaResolutionFacade +import org.jetbrains.kotlin.idea.caches.resolve.util.resolveToDescriptor +import org.jetbrains.kotlin.idea.util.module +import org.jetbrains.kotlin.js.resolve.diagnostics.findPsi +import org.jetbrains.kotlin.psi.KtClass +import org.jetbrains.kotlin.resolve.SealedClassInheritorsProvider + +object IdeSealedClassInheritorsProvider : SealedClassInheritorsProvider() { + + override fun computeSealedSubclasses( + sealedClass: ClassDescriptor, + allowSealedInheritorsInDifferentFilesOfSamePackage: Boolean + ): Collection { + + val sealedKtClass = sealedClass.findPsi() as? KtClass ?: return emptyList() + val searchScope: SearchScope = if (allowSealedInheritorsInDifferentFilesOfSamePackage) { + val module = sealedKtClass.module ?: return emptyList() + val moduleSourceScope = GlobalSearchScope.moduleScope(module) + val containingPackage = sealedClass.containingPackage() ?: return emptyList() + val psiPackage = JavaDirectoryService.getInstance().getPackage(sealedKtClass.containingFile.containingDirectory) + ?: JavaPsiFacade.getInstance(sealedKtClass.project).findPackage(containingPackage.asString()) + ?: return emptyList() + val packageScope = PackageScope(psiPackage, false, false) + moduleSourceScope.intersectWith(packageScope) + } else { + GlobalSearchScope.fileScope(sealedKtClass.containingFile) // Kotlin version prior to 1.5 + } + + val lightClass = sealedKtClass.toLightClass() ?: return emptyList() + val searchParameters = SearchParameters(lightClass, searchScope, false, true, false) + + return ClassInheritorsSearch.search(searchParameters) + .map mapper@{ + val resolutionFacade = it.javaResolutionFacade() ?: return@mapper null + it.resolveToDescriptor(resolutionFacade) + }.filterNotNull() + .sortedBy(ClassDescriptor::getName) // order needs to be stable (at least for tests) + } +} \ No newline at end of file diff --git a/idea/idea-native/src/org/jetbrains/kotlin/ide/konan/analyzer/NativeResolverForModuleFactory.kt b/idea/idea-native/src/org/jetbrains/kotlin/ide/konan/analyzer/NativeResolverForModuleFactory.kt index 0d7200cceb8..65bdd545d39 100644 --- a/idea/idea-native/src/org/jetbrains/kotlin/ide/konan/analyzer/NativeResolverForModuleFactory.kt +++ b/idea/idea-native/src/org/jetbrains/kotlin/ide/konan/analyzer/NativeResolverForModuleFactory.kt @@ -17,6 +17,7 @@ import org.jetbrains.kotlin.platform.TargetPlatform import org.jetbrains.kotlin.platform.idePlatformKind import org.jetbrains.kotlin.platform.konan.NativePlatforms import org.jetbrains.kotlin.resolve.CodeAnalyzerInitializer +import org.jetbrains.kotlin.resolve.SealedClassInheritorsProvider import org.jetbrains.kotlin.resolve.TargetEnvironment import org.jetbrains.kotlin.resolve.konan.platform.NativePlatformAnalyzerServices import org.jetbrains.kotlin.resolve.lazy.ResolveSession @@ -32,7 +33,8 @@ class NativeResolverForModuleFactory( moduleContext: ModuleContext, moduleContent: ModuleContent, resolverForProject: ResolverForProject, - languageVersionSettings: LanguageVersionSettings + languageVersionSettings: LanguageVersionSettings, + sealedInheritorsProvider: SealedClassInheritorsProvider ): ResolverForModule { val declarationProviderFactory = createDeclarationProviderFactory( diff --git a/idea/testData/checker/sealed/SealedDeclaration.kt b/idea/testData/checker/sealed/SealedDeclaration.kt new file mode 100644 index 00000000000..f56775bc907 --- /dev/null +++ b/idea/testData/checker/sealed/SealedDeclaration.kt @@ -0,0 +1,14 @@ +// COMPILER_ARGUMENTS: -XXLanguage:+SealedInterfaces -XXLanguage:+FreedomForSealedClasses + +package sealed + +sealed class SealedDeclarationClass { + class AClass: SealedDeclarationClass() +} + +sealed interface SealedDeclarationInterface { + class A: SealedDeclarationInterface +} + +class B: SealedDeclarationInterface +class BClass: SealedDeclarationClass() \ No newline at end of file diff --git a/idea/testData/checker/sealed/SealedInheritors.kt b/idea/testData/checker/sealed/SealedInheritors.kt new file mode 100644 index 00000000000..3b399c28141 --- /dev/null +++ b/idea/testData/checker/sealed/SealedInheritors.kt @@ -0,0 +1,35 @@ +// COMPILER_ARGUMENTS: -XXLanguage:+SealedInterfaces -XXLanguage:+FreedomForSealedClasses +package sealed + +class C: SealedDeclarationInterface {} +class CClass: SealedDeclarationClass() {} + +class D: SealedDeclarationInterface { + class E: SealedDeclarationInterface { + class F: SealedDeclarationInterface + } +} + +class DClass: SealedDeclarationClass() { + class EClass: SealedDeclarationClass() { + class FClass: SealedDeclarationClass() + } +} + +fun checkWhenNone(value: SealedDeclarationInterface): Int = when (value) { +} + +fun checkWhenNone(value: SealedDeclarationClass): Int = when (value) { +} + +fun checkWhenOneMissing(value: SealedDeclarationInterface): Int = when (value) { + is SealedDeclarationInterface.A -> 1 + is B -> 2 + is C -> 3 +} + +fun checkWhenOneMissing(value: SealedDeclarationClass): Int = when (value) { + is SealedDeclarationClass.AClass -> 1 + is BClass -> 2 + is CClass -> 3 +} \ No newline at end of file diff --git a/idea/testData/checker/sealed/SealedOutsidePackageInheritors.kt b/idea/testData/checker/sealed/SealedOutsidePackageInheritors.kt new file mode 100644 index 00000000000..8a8913fd11f --- /dev/null +++ b/idea/testData/checker/sealed/SealedOutsidePackageInheritors.kt @@ -0,0 +1,7 @@ +// COMPILER_ARGUMENTS: -XXLanguage:+SealedInterfaces -XXLanguage:+FreedomForSealedClasses +package sealed.otherpackage +import sealed.SealedDeclarationInterface +import sealed.SealedDeclarationClass + +class D: SealedDeclarationInterface +class DClass: SealedDeclarationClass() \ No newline at end of file diff --git a/idea/tests/org/jetbrains/kotlin/checkers/PsiCheckerSealedTest.kt b/idea/tests/org/jetbrains/kotlin/checkers/PsiCheckerSealedTest.kt new file mode 100644 index 00000000000..594fda3e8a1 --- /dev/null +++ b/idea/tests/org/jetbrains/kotlin/checkers/PsiCheckerSealedTest.kt @@ -0,0 +1,32 @@ +/* + * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.checkers + +import com.intellij.testFramework.LightProjectDescriptor +import org.jetbrains.kotlin.test.JUnit3WithIdeaConfigurationRunner +import org.jetbrains.kotlin.test.TestMetadata +import org.junit.runner.RunWith + +@TestMetadata("idea/testData/checker/sealed") +@RunWith(JUnit3WithIdeaConfigurationRunner::class) +class PsiCheckerSealedTest : AbstractPsiCheckerTest() { + + fun testOutsideOfPackageInheritors() { + doTest( + "SealedOutsidePackageInheritors.kt", // opened in the test editor + "SealedDeclaration.kt" + ) + } + + fun testWhenExhaustiveness() { + doTest( + "SealedInheritors.kt", // opened in the test editor + "SealedDeclaration.kt" + ) + } + + override fun getProjectDescriptor(): LightProjectDescriptor = getProjectDescriptorFromTestName() +} \ No newline at end of file diff --git a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/builder/CommonizedClassDescriptor.kt b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/builder/CommonizedClassDescriptor.kt index 3404c4cd519..cc1fd67a432 100644 --- a/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/builder/CommonizedClassDescriptor.kt +++ b/native/commonizer/src/org/jetbrains/kotlin/descriptors/commonizer/builder/CommonizedClassDescriptor.kt @@ -5,7 +5,6 @@ package org.jetbrains.kotlin.descriptors.commonizer.builder -import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.descriptors.annotations.Annotations import org.jetbrains.kotlin.descriptors.commonizer.cir.CirType @@ -15,7 +14,7 @@ import org.jetbrains.kotlin.descriptors.impl.ClassDescriptorBase import org.jetbrains.kotlin.incremental.components.NoLookupLocation import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.DescriptorFactory.createPrimaryConstructorForObject -import org.jetbrains.kotlin.resolve.SealedClassInheritorsProviderImpl +import org.jetbrains.kotlin.resolve.CliSealedClassInheritorsProvider import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe import org.jetbrains.kotlin.resolve.scopes.MemberScope import org.jetbrains.kotlin.resolve.scopes.StaticScopeForKotlinEnum @@ -55,7 +54,7 @@ class CommonizedClassDescriptor( private val sealedSubclasses = targetComponents.storageManager.createLazyValue { // TODO: pass proper language version settings if (modality == Modality.SEALED) { - SealedClassInheritorsProviderImpl.computeSealedSubclasses(this, freedomForSealedInterfacesSupported = false) + CliSealedClassInheritorsProvider.computeSealedSubclasses(this, allowSealedInheritorsInDifferentFilesOfSamePackage = false) } else { emptyList() } From a0ed14eafe5f18a404231c3e207ab91d9ff9bd73 Mon Sep 17 00:00:00 2001 From: Ilya Kirillov Date: Fri, 11 Dec 2020 17:55:51 +0100 Subject: [PATCH 033/196] FIR: use real source element for return statement fix fir --- .../org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt | 2 +- .../org/jetbrains/kotlin/fir/builder/BaseFirBuilder.kt | 10 ++++++++-- .../src/org/jetbrains/kotlin/fir/FirSourceElement.kt | 7 +++++++ 3 files changed, 16 insertions(+), 3 deletions(-) diff --git a/compiler/fir/raw-fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt b/compiler/fir/raw-fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt index 9901f5a2481..cc71b2975c1 100644 --- a/compiler/fir/raw-fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt +++ b/compiler/fir/raw-fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt @@ -1528,7 +1528,7 @@ class RawFirBuilder( val source = expression.toFirSourceElement(FirFakeSourceElementKind.ImplicitUnit) val result = expression.returnedExpression?.toFirExpression("Incorrect return expression") ?: buildUnitExpression { this.source = source } - return result.toReturn(source, expression.getTargetLabel()?.getReferencedName()) + return result.toReturn(source, expression.getTargetLabel()?.getReferencedName(), fromKtReturnExpression = true) } override fun visitTryExpression(expression: KtTryExpression, data: Unit): FirElement { diff --git a/compiler/fir/raw-fir/raw-fir.common/src/org/jetbrains/kotlin/fir/builder/BaseFirBuilder.kt b/compiler/fir/raw-fir/raw-fir.common/src/org/jetbrains/kotlin/fir/builder/BaseFirBuilder.kt index be9bec961f1..23f169d1c74 100644 --- a/compiler/fir/raw-fir/raw-fir.common/src/org/jetbrains/kotlin/fir/builder/BaseFirBuilder.kt +++ b/compiler/fir/raw-fir/raw-fir.common/src/org/jetbrains/kotlin/fir/builder/BaseFirBuilder.kt @@ -148,7 +148,11 @@ abstract class BaseFirBuilder(val baseSession: FirSession, val context: Conte val ANONYMOUS_OBJECT_NAME = Name.special("") } - fun FirExpression.toReturn(baseSource: FirSourceElement? = source, labelName: String? = null): FirReturnExpression { + fun FirExpression.toReturn( + baseSource: FirSourceElement? = source, + labelName: String? = null, + fromKtReturnExpression: Boolean = false + ): FirReturnExpression { return buildReturnExpression { fun FirFunctionTarget.bindToErrorFunction(message: String, kind: DiagnosticKind) { bind( @@ -162,7 +166,9 @@ abstract class BaseFirBuilder(val baseSession: FirSession, val context: Conte ) } - source = baseSource?.fakeElement(FirFakeSourceElementKind.ImplicitReturn) + source = + if (fromKtReturnExpression) baseSource?.realElement() + else baseSource?.fakeElement(FirFakeSourceElementKind.ImplicitReturn) result = this@toReturn if (labelName == null) { target = context.firFunctionTargets.lastOrNull { !it.isLambda } ?: FirFunctionTarget(labelName, isLambda = false).apply { diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirSourceElement.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirSourceElement.kt index d0907c15124..cc05f1bb283 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirSourceElement.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirSourceElement.kt @@ -264,6 +264,13 @@ fun FirSourceElement.fakeElement(newKind: FirFakeSourceElementKind): FirSourceEl } } +fun FirSourceElement.realElement(): FirSourceElement = when (this) { + is FirRealPsiSourceElement<*> -> this + is FirLightSourceElement -> FirLightSourceElement(lighterASTNode, startOffset, endOffset, treeStructure, FirRealSourceElementKind) + is FirPsiSourceElement<*> -> FirRealPsiSourceElement(psi) +} + + class FirLightSourceElement( override val lighterASTNode: LighterASTNode, override val startOffset: Int, From c61d4b5f9c14b3d1cfc42a12f52c32d0765f8592 Mon Sep 17 00:00:00 2001 From: Ilya Kirillov Date: Fri, 11 Dec 2020 17:56:09 +0100 Subject: [PATCH 034/196] FIR IDE: introduce return statement target provider --- .../kotlin/generators/tests/GenerateTests.kt | 5 ++ .../KotlinFirCompletionContributor.kt | 11 +++ .../idea/frontend/api/KtAnalysisSession.kt | 4 ++ .../KtExpressionHandlingComponent.kt | 13 ++++ .../frontend/api/fir/KtFirAnalysisSession.kt | 2 + .../KtFirExpressionHandlingComponent.kt | 26 +++++++ ...returnFromFunctionViaLambdaWithoutLabel.kt | 8 +++ .../returnFromFunctionWithLabel.kt | 3 + .../returnFromFunctionWithoutLabel.kt | 3 + .../returnFromLambdaWithLabel.kt | 8 +++ .../AbstractReturnExpressionTargetTest.kt | 72 +++++++++++++++++++ .../ReturnExpressionTargetTestGenerated.java | 50 +++++++++++++ 12 files changed, 205 insertions(+) create mode 100644 idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/components/KtExpressionHandlingComponent.kt create mode 100644 idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirExpressionHandlingComponent.kt create mode 100644 idea/idea-frontend-fir/testData/components/returnExpressionTarget/returnFromFunctionViaLambdaWithoutLabel.kt create mode 100644 idea/idea-frontend-fir/testData/components/returnExpressionTarget/returnFromFunctionWithLabel.kt create mode 100644 idea/idea-frontend-fir/testData/components/returnExpressionTarget/returnFromFunctionWithoutLabel.kt create mode 100644 idea/idea-frontend-fir/testData/components/returnExpressionTarget/returnFromLambdaWithLabel.kt create mode 100644 idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/components/AbstractReturnExpressionTargetTest.kt create mode 100644 idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/components/ReturnExpressionTargetTestGenerated.java diff --git a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt index b39488b4eb8..dbb2203c252 100644 --- a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt +++ b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt @@ -88,6 +88,7 @@ import org.jetbrains.kotlin.idea.fir.low.level.api.file.structure.AbstractFileSt import org.jetbrains.kotlin.idea.fir.low.level.api.sessions.AbstractSessionsInvalidationTest import org.jetbrains.kotlin.idea.fir.low.level.api.trackers.AbstractProjectWideOutOfBlockKotlinModificationTrackerTest import org.jetbrains.kotlin.idea.folding.AbstractKotlinFoldingTest +import org.jetbrains.kotlin.idea.frontend.api.components.AbstractReturnExpressionTargetTest import org.jetbrains.kotlin.idea.frontend.api.fir.AbstractResolveCallTest import org.jetbrains.kotlin.idea.frontend.api.scopes.AbstractMemberScopeByFqNameTest import org.jetbrains.kotlin.idea.frontend.api.symbols.* @@ -1021,6 +1022,10 @@ fun main(args: Array) { testClass { model("symbolMemoryLeak") } + + testClass { + model("components/returnExpressionTarget") + } } testGroup("idea/idea-frontend-fir/idea-fir-low-level-api/tests", "idea/testData") { diff --git a/idea/idea-fir/src/org/jetbrains/kotlin/idea/completion/KotlinFirCompletionContributor.kt b/idea/idea-fir/src/org/jetbrains/kotlin/idea/completion/KotlinFirCompletionContributor.kt index da11845cfd8..32cc7cad790 100644 --- a/idea/idea-fir/src/org/jetbrains/kotlin/idea/completion/KotlinFirCompletionContributor.kt +++ b/idea/idea-fir/src/org/jetbrains/kotlin/idea/completion/KotlinFirCompletionContributor.kt @@ -20,6 +20,7 @@ import org.jetbrains.kotlin.idea.frontend.api.symbols.KtCallableSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.KtSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtNamedSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.isExtension +import org.jetbrains.kotlin.idea.frontend.api.types.KtType import org.jetbrains.kotlin.idea.references.mainReference import org.jetbrains.kotlin.lexer.KtTokens import org.jetbrains.kotlin.psi.* @@ -148,3 +149,13 @@ private class KotlinAvailableScopesCompletionProvider(prefixMatcher: PrefixMatch collectTypesCompletion(result, implicitScopes) } } + +private object ExpectedTypeProvider { + fun KtAnalysisSession.getExpectedType(nameExpression: KtSimpleNameExpression, parameters: CompletionParameters): KtType? = + getExpectedTypeByReturnExpression(nameExpression) + + private fun KtAnalysisSession.getExpectedTypeByReturnExpression(nameExpression: KtSimpleNameExpression): KtType? { + val parentReturn = nameExpression.parent as? KtReturnExpression ?: return null + TODO() + } +} \ No newline at end of file diff --git a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/KtAnalysisSession.kt b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/KtAnalysisSession.kt index fcd06bf919e..6cf8bcf4394 100644 --- a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/KtAnalysisSession.kt +++ b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/KtAnalysisSession.kt @@ -45,6 +45,7 @@ abstract class KtAnalysisSession(final override val token: ValidityToken) : Vali protected abstract val symbolDeclarationOverridesProvider: KtSymbolDeclarationOverridesProvider @Suppress("LeakingThis") protected open val typeRenderer: KtTypeRenderer = KtDefaultTypeRenderer(this, token) + protected abstract val expressionHandlingComponent: KtExpressionHandlingComponent /// TODO: get rid of @Deprecated("Used only in completion now, temporary") @@ -148,4 +149,7 @@ abstract class KtAnalysisSession(final override val token: ValidityToken) : Vali fun KtType.render(options: KtTypeRendererOptions = KtTypeRendererOptions.DEFAULT): String = typeRenderer.render(this, options) + + fun KtReturnExpression.getReturnTargetSymbol(): KtFunctionLikeSymbol? = + expressionHandlingComponent.getReturnExpressionTargetSymbol(this) } diff --git a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/components/KtExpressionHandlingComponent.kt b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/components/KtExpressionHandlingComponent.kt new file mode 100644 index 00000000000..48a1e6548bf --- /dev/null +++ b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/components/KtExpressionHandlingComponent.kt @@ -0,0 +1,13 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.idea.frontend.api.components + +import org.jetbrains.kotlin.idea.frontend.api.symbols.KtFunctionLikeSymbol +import org.jetbrains.kotlin.psi.KtReturnExpression + +abstract class KtExpressionHandlingComponent : KtAnalysisSessionComponent() { + abstract fun getReturnExpressionTargetSymbol(returnExpression: KtReturnExpression): KtFunctionLikeSymbol? +} \ No newline at end of file diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/KtFirAnalysisSession.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/KtFirAnalysisSession.kt index 52f1dbd0bf7..e06928dd18f 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/KtFirAnalysisSession.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/KtFirAnalysisSession.kt @@ -45,6 +45,8 @@ private constructor( override val symbolDeclarationOverridesProvider: KtSymbolDeclarationOverridesProvider = KtFirSymbolDeclarationOverridesProvider(this, token) + override val expressionHandlingComponent: KtExpressionHandlingComponent = KtFirExpressionHandlingComponent(this, token) + override fun createContextDependentCopy(): KtAnalysisSession { check(!isContextSession) { "Cannot create context-dependent copy of KtAnalysis session from a context dependent one" } val contextResolveState = LowLevelFirApiFacadeForCompletion.getResolveStateForCompletion(firResolveState) diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirExpressionHandlingComponent.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirExpressionHandlingComponent.kt new file mode 100644 index 00000000000..4b5647c8fe2 --- /dev/null +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirExpressionHandlingComponent.kt @@ -0,0 +1,26 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.idea.frontend.api.fir.components + +import org.jetbrains.kotlin.fir.expressions.FirReturnExpression +import org.jetbrains.kotlin.idea.fir.low.level.api.api.getOrBuildFirSafe +import org.jetbrains.kotlin.idea.frontend.api.ValidityToken +import org.jetbrains.kotlin.idea.frontend.api.components.KtExpressionHandlingComponent +import org.jetbrains.kotlin.idea.frontend.api.fir.KtFirAnalysisSession +import org.jetbrains.kotlin.idea.frontend.api.symbols.KtCallableSymbol +import org.jetbrains.kotlin.idea.frontend.api.symbols.KtFunctionLikeSymbol +import org.jetbrains.kotlin.psi.KtReturnExpression + +internal class KtFirExpressionHandlingComponent( + override val analysisSession: KtFirAnalysisSession, + override val token: ValidityToken, +) : KtExpressionHandlingComponent(), KtFirAnalysisSessionComponent { + override fun getReturnExpressionTargetSymbol(returnExpression: KtReturnExpression): KtFunctionLikeSymbol? { + val fir = returnExpression.getOrBuildFirSafe(firResolveState) ?: return null + val firTargetSymbol = fir.target.labeledElement + return firSymbolBuilder.buildCallableSymbol(firTargetSymbol) as KtFunctionLikeSymbol + } +} \ No newline at end of file diff --git a/idea/idea-frontend-fir/testData/components/returnExpressionTarget/returnFromFunctionViaLambdaWithoutLabel.kt b/idea/idea-frontend-fir/testData/components/returnExpressionTarget/returnFromFunctionViaLambdaWithoutLabel.kt new file mode 100644 index 00000000000..3a56362d76f --- /dev/null +++ b/idea/idea-frontend-fir/testData/components/returnExpressionTarget/returnFromFunctionViaLambdaWithoutLabel.kt @@ -0,0 +1,8 @@ +fun /* EXPECTED_TARGET */x(): Int { + receiveLambda { + return 1 + } + return 2 +} + +inline fun receiveLambda(x: () -> Unit){} \ No newline at end of file diff --git a/idea/idea-frontend-fir/testData/components/returnExpressionTarget/returnFromFunctionWithLabel.kt b/idea/idea-frontend-fir/testData/components/returnExpressionTarget/returnFromFunctionWithLabel.kt new file mode 100644 index 00000000000..a241be8a3e7 --- /dev/null +++ b/idea/idea-frontend-fir/testData/components/returnExpressionTarget/returnFromFunctionWithLabel.kt @@ -0,0 +1,3 @@ +fun /* EXPECTED_TARGET */x(): Int { + return 1 +} \ No newline at end of file diff --git a/idea/idea-frontend-fir/testData/components/returnExpressionTarget/returnFromFunctionWithoutLabel.kt b/idea/idea-frontend-fir/testData/components/returnExpressionTarget/returnFromFunctionWithoutLabel.kt new file mode 100644 index 00000000000..8c33f8dfe24 --- /dev/null +++ b/idea/idea-frontend-fir/testData/components/returnExpressionTarget/returnFromFunctionWithoutLabel.kt @@ -0,0 +1,3 @@ +fun /* EXPECTED_TARGET */x(): Int { + return 1 +} diff --git a/idea/idea-frontend-fir/testData/components/returnExpressionTarget/returnFromLambdaWithLabel.kt b/idea/idea-frontend-fir/testData/components/returnExpressionTarget/returnFromLambdaWithLabel.kt new file mode 100644 index 00000000000..fa270faa0ce --- /dev/null +++ b/idea/idea-frontend-fir/testData/components/returnExpressionTarget/returnFromLambdaWithLabel.kt @@ -0,0 +1,8 @@ +fun x(): Int { + receiveLambda { /* EXPECTED_TARGET */ + return@receiveLambda 1 + } + return 2 +} + +fun receiveLambda(x: () -> Int){} \ No newline at end of file diff --git a/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/components/AbstractReturnExpressionTargetTest.kt b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/components/AbstractReturnExpressionTargetTest.kt new file mode 100644 index 00000000000..64d7b6b8c4c --- /dev/null +++ b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/components/AbstractReturnExpressionTargetTest.kt @@ -0,0 +1,72 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.idea.frontend.api.components + +import com.intellij.openapi.util.io.FileUtil +import com.intellij.psi.PsiComment +import com.intellij.psi.util.parentOfType +import junit.framework.Assert +import org.jetbrains.kotlin.idea.executeOnPooledThreadInReadAction +import org.jetbrains.kotlin.idea.frontend.api.analyze +import org.jetbrains.kotlin.idea.test.KotlinLightCodeInsightFixtureTestCase +import org.jetbrains.kotlin.idea.util.application.executeOnPooledThread +import org.jetbrains.kotlin.idea.util.application.runReadAction +import org.jetbrains.kotlin.psi.KtDeclaration +import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.psi.KtReturnExpression +import org.jetbrains.kotlin.psi.psiUtil.forEachDescendantOfType +import org.jetbrains.kotlin.test.InTextDirectivesUtils +import java.io.File + +abstract class AbstractReturnExpressionTargetTest : KotlinLightCodeInsightFixtureTestCase() { + override fun isFirPlugin() = true + + protected fun doTest(path: String) { + val testDataFile = File(path) + val ktFile = myFixture.configureByText(testDataFile.name, FileUtil.loadFile(testDataFile)) as KtFile + + val ktReturnExpressionAtCaret = ktFile.findElementAt(myFixture.caretOffset)?.parentOfType() + ?: error("No element was found at caret or no is present in the test file") + + val expectedReturnTarget = ktFile.getExpectedReturnTarget() + + val actualReturnTargetPsi: KtDeclaration? = executeOnPooledThreadInReadAction { + analyze(ktFile) { + val actualReturnTargetSymbol = ktReturnExpressionAtCaret.getReturnTargetSymbol() ?: return@analyze null + actualReturnTargetSymbol.psi as KtDeclaration + } + } + + Assert.assertEquals(expectedReturnTarget?.text, actualReturnTargetPsi?.text) + } + + private fun KtFile.getExpectedReturnTarget(): KtDeclaration? { + var declaration: KtDeclaration? = null + forEachDescendantOfType { comment -> + if (comment.text == EXPECTED_RETURN_TARGET_COMMENT) { + if (declaration != null) { + error("More than one $EXPECTED_RETURN_TARGET_COMMENT found") + } + declaration = comment.parentOfType() + } + } + val noDeclarationExpected = InTextDirectivesUtils.findStringWithPrefixes(text, NO_TARGET_EXPECTED_PREFIX) != null + return when { + noDeclarationExpected && declaration != null -> { + error("$noDeclarationExpected was present together with $EXPECTED_RETURN_TARGET_COMMENT") + } + !noDeclarationExpected && declaration == null -> { + error("No $EXPECTED_RETURN_TARGET_COMMENT present, but $NO_TARGET_EXPECTED_PREFIX is not provided") + } + else -> declaration + } + } + + companion object { + private const val EXPECTED_RETURN_TARGET_COMMENT = "/* EXPECTED_TARGET */" + private const val NO_TARGET_EXPECTED_PREFIX = "// NO_TARGET_EXPECTED" + } +} \ No newline at end of file diff --git a/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/components/ReturnExpressionTargetTestGenerated.java b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/components/ReturnExpressionTargetTestGenerated.java new file mode 100644 index 00000000000..661b661367d --- /dev/null +++ b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/components/ReturnExpressionTargetTestGenerated.java @@ -0,0 +1,50 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.idea.frontend.api.components; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; +import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.runner.RunWith; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("idea/idea-frontend-fir/testData/components/returnExpressionTarget") +@TestDataPath("$PROJECT_ROOT") +@RunWith(JUnit3RunnerWithInners.class) +public class ReturnExpressionTargetTestGenerated extends AbstractReturnExpressionTargetTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); + } + + public void testAllFilesPresentInReturnExpressionTarget() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-frontend-fir/testData/components/returnExpressionTarget"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @TestMetadata("returnFromFunctionViaLambdaWithoutLabel.kt") + public void testReturnFromFunctionViaLambdaWithoutLabel() throws Exception { + runTest("idea/idea-frontend-fir/testData/components/returnExpressionTarget/returnFromFunctionViaLambdaWithoutLabel.kt"); + } + + @TestMetadata("returnFromFunctionWithLabel.kt") + public void testReturnFromFunctionWithLabel() throws Exception { + runTest("idea/idea-frontend-fir/testData/components/returnExpressionTarget/returnFromFunctionWithLabel.kt"); + } + + @TestMetadata("returnFromFunctionWithoutLabel.kt") + public void testReturnFromFunctionWithoutLabel() throws Exception { + runTest("idea/idea-frontend-fir/testData/components/returnExpressionTarget/returnFromFunctionWithoutLabel.kt"); + } + + @TestMetadata("returnFromLambdaWithLabel.kt") + public void testReturnFromLambdaWithLabel() throws Exception { + runTest("idea/idea-frontend-fir/testData/components/returnExpressionTarget/returnFromLambdaWithLabel.kt"); + } +} From 19fff2b1e7345a1980756a9eb5cc8f78a097357a Mon Sep 17 00:00:00 2001 From: Ilya Kirillov Date: Sat, 12 Dec 2020 12:23:21 +0100 Subject: [PATCH 035/196] FIR IDE: implement expected type weigher for completion --- .../KotlinFirCompletionContributor.kt | 73 +++++++++++++------ .../KotlinFirLookupElementFactory.kt | 1 + .../weighers/ExpectedTypeWeigher.kt | 51 +++++++++++++ .../idea/completion/weighers/Weighers.kt | 27 +++++++ .../idea/frontend/api/KtAnalysisSession.kt | 6 +- .../frontend/api/components/KtTypeProvider.kt | 2 + .../api/fir/components/KtFirTypeProvider.kt | 11 +++ 7 files changed, 145 insertions(+), 26 deletions(-) create mode 100644 idea/idea-fir/src/org/jetbrains/kotlin/idea/completion/weighers/ExpectedTypeWeigher.kt create mode 100644 idea/idea-fir/src/org/jetbrains/kotlin/idea/completion/weighers/Weighers.kt diff --git a/idea/idea-fir/src/org/jetbrains/kotlin/idea/completion/KotlinFirCompletionContributor.kt b/idea/idea-fir/src/org/jetbrains/kotlin/idea/completion/KotlinFirCompletionContributor.kt index 32cc7cad790..eaf200a602a 100644 --- a/idea/idea-fir/src/org/jetbrains/kotlin/idea/completion/KotlinFirCompletionContributor.kt +++ b/idea/idea-fir/src/org/jetbrains/kotlin/idea/completion/KotlinFirCompletionContributor.kt @@ -6,9 +6,11 @@ package org.jetbrains.kotlin.idea.completion import com.intellij.codeInsight.completion.* +import com.intellij.codeInsight.lookup.LookupElement import com.intellij.patterns.PlatformPatterns import com.intellij.patterns.PsiJavaPatterns import com.intellij.util.ProcessingContext +import org.jetbrains.kotlin.idea.completion.weighers.Weighers import org.jetbrains.kotlin.idea.fir.low.level.api.util.originalKtFile import org.jetbrains.kotlin.idea.frontend.api.InvalidWayOfUsingAnalysisSession import org.jetbrains.kotlin.idea.frontend.api.KtAnalysisSession @@ -36,9 +38,17 @@ private object KotlinFirCompletionProvider : CompletionProvider !name.isSpecial && prefixMatcher.prefixMatches(name.identifier) } - private fun KtAnalysisSession.addSymbolToCompletion(completionResultSet: CompletionResultSet, symbol: KtSymbol) { + private fun KtAnalysisSession.addSymbolToCompletion(completionResultSet: CompletionResultSet, expectedType: KtType?, symbol: KtSymbol) { if (symbol !is KtNamedSymbol) return - with(lookupElementFactory) { createLookupElement(symbol)?.let(completionResultSet::addElement) } + with(lookupElementFactory) { + createLookupElement(symbol) + ?.let { applyWeighers(it, symbol, expectedType) } + ?.let(completionResultSet::addElement) + } + } + + private fun KtAnalysisSession.applyWeighers( + lookupElement: LookupElement, + symbol: KtSymbol, + expectedType: KtType? + ): LookupElement = lookupElement.apply { + with(Weighers) { applyWeighsToLookupElement(lookupElement, symbol, expectedType) } } private fun recordOriginalFile(completionParameters: CompletionParameters) { @@ -90,29 +112,41 @@ private class KotlinAvailableScopesCompletionProvider(prefixMatcher: PrefixMatch val explicitReceiver = nameExpression.getReceiverExpression() with(getAnalysisSessionFor(originalFile).createContextDependentCopy()) { + val expectedType = nameExpression.getExpectedType() + val (implicitScopes, _) = originalFile.getScopeContextForPosition(nameExpression) fun KtCallableSymbol.hasSuitableExtensionReceiver(): Boolean = checkExtensionIsSuitable(originalFile, nameExpression, explicitReceiver) when { - nameExpression.parent is KtUserType -> collectTypesCompletion(result, implicitScopes) - explicitReceiver != null -> - collectDotCompletion(result, implicitScopes, explicitReceiver, KtCallableSymbol::hasSuitableExtensionReceiver) - else -> collectDefaultCompletion(result, implicitScopes, KtCallableSymbol::hasSuitableExtensionReceiver) + nameExpression.parent is KtUserType -> collectTypesCompletion(result, implicitScopes, expectedType) + explicitReceiver != null -> collectDotCompletion( + result, + implicitScopes, + explicitReceiver, + expectedType, + KtCallableSymbol::hasSuitableExtensionReceiver + ) + else -> collectDefaultCompletion(result, implicitScopes, expectedType, KtCallableSymbol::hasSuitableExtensionReceiver) } } } - private fun KtAnalysisSession.collectTypesCompletion(result: CompletionResultSet, implicitScopes: KtScope) { + private fun KtAnalysisSession.collectTypesCompletion( + result: CompletionResultSet, + implicitScopes: KtScope, + expectedType: KtType?, + ) { val availableClasses = implicitScopes.getClassifierSymbols(scopeNameFilter) - availableClasses.forEach { addSymbolToCompletion(result, it) } + availableClasses.forEach { addSymbolToCompletion(result, expectedType, it) } } private fun KtAnalysisSession.collectDotCompletion( result: CompletionResultSet, implicitScopes: KtCompositeScope, explicitReceiver: KtExpression, + expectedType: KtType?, hasSuitableExtensionReceiver: KtCallableSymbol.() -> Boolean ) { val typeOfPossibleReceiver = explicitReceiver.getKtType() @@ -126,13 +160,14 @@ private class KotlinAvailableScopesCompletionProvider(prefixMatcher: PrefixMatch .getCallableSymbols(scopeNameFilter) .filter { it.isExtension && it.hasSuitableExtensionReceiver() } - nonExtensionMembers.forEach { addSymbolToCompletion(result, it) } - extensionNonMembers.forEach { addSymbolToCompletion(result, it) } + nonExtensionMembers.forEach { addSymbolToCompletion(result, expectedType, it) } + extensionNonMembers.forEach { addSymbolToCompletion(result, expectedType, it) } } private fun KtAnalysisSession.collectDefaultCompletion( result: CompletionResultSet, implicitScopes: KtCompositeScope, + expectedType: KtType?, hasSuitableExtensionReceiver: KtCallableSymbol.() -> Boolean, ) { val availableNonExtensions = implicitScopes @@ -143,19 +178,9 @@ private class KotlinAvailableScopesCompletionProvider(prefixMatcher: PrefixMatch .getCallableSymbols(scopeNameFilter) .filter { it.isExtension && it.hasSuitableExtensionReceiver() } - availableNonExtensions.forEach { addSymbolToCompletion(result, it) } - extensionsWhichCanBeCalled.forEach { addSymbolToCompletion(result, it) } + availableNonExtensions.forEach { addSymbolToCompletion(result, expectedType, it) } + extensionsWhichCanBeCalled.forEach { addSymbolToCompletion(result, expectedType, it) } - collectTypesCompletion(result, implicitScopes) - } -} - -private object ExpectedTypeProvider { - fun KtAnalysisSession.getExpectedType(nameExpression: KtSimpleNameExpression, parameters: CompletionParameters): KtType? = - getExpectedTypeByReturnExpression(nameExpression) - - private fun KtAnalysisSession.getExpectedTypeByReturnExpression(nameExpression: KtSimpleNameExpression): KtType? { - val parentReturn = nameExpression.parent as? KtReturnExpression ?: return null - TODO() + collectTypesCompletion(result, implicitScopes, expectedType) } } \ No newline at end of file diff --git a/idea/idea-fir/src/org/jetbrains/kotlin/idea/completion/KotlinFirLookupElementFactory.kt b/idea/idea-fir/src/org/jetbrains/kotlin/idea/completion/KotlinFirLookupElementFactory.kt index 1b75bed1628..01d79ba6a5a 100644 --- a/idea/idea-fir/src/org/jetbrains/kotlin/idea/completion/KotlinFirLookupElementFactory.kt +++ b/idea/idea-fir/src/org/jetbrains/kotlin/idea/completion/KotlinFirLookupElementFactory.kt @@ -19,6 +19,7 @@ import com.intellij.psi.PsiElement import org.jetbrains.kotlin.idea.frontend.api.KtAnalysisSession import org.jetbrains.kotlin.idea.frontend.api.symbols.* import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtNamedSymbol +import org.jetbrains.kotlin.idea.frontend.api.types.KtType import org.jetbrains.kotlin.lexer.KtTokens import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.psi.KtTypeArgumentList diff --git a/idea/idea-fir/src/org/jetbrains/kotlin/idea/completion/weighers/ExpectedTypeWeigher.kt b/idea/idea-fir/src/org/jetbrains/kotlin/idea/completion/weighers/ExpectedTypeWeigher.kt new file mode 100644 index 00000000000..d77a1794f87 --- /dev/null +++ b/idea/idea-fir/src/org/jetbrains/kotlin/idea/completion/weighers/ExpectedTypeWeigher.kt @@ -0,0 +1,51 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.idea.completion.weighers + +import com.intellij.codeInsight.lookup.LookupElement +import com.intellij.codeInsight.lookup.LookupElementWeigher +import com.intellij.openapi.util.Key +import org.jetbrains.kotlin.idea.frontend.api.KtAnalysisSession +import org.jetbrains.kotlin.idea.frontend.api.symbols.KtSymbol +import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtTypedSymbol +import org.jetbrains.kotlin.idea.frontend.api.types.KtType +import org.jetbrains.kotlin.psi.UserDataProperty + + +internal object ExpectedTypeWeigher { + object Weigher : LookupElementWeigher(WEIGHER_ID) { + override fun weigh(element: LookupElement): Comparable<*>? = + element.matchesExpectedType + } + + fun KtAnalysisSession.addWeight(lookupElement: LookupElement, symbol: KtSymbol, expectedType: KtType?) { + lookupElement.matchesExpectedType = matchesExpectedType(symbol, expectedType) + } + + private fun KtAnalysisSession.matchesExpectedType( + symbol: KtSymbol, + expectedType: KtType? + ) = when { + expectedType == null -> MatchesExpectedType.NON_TYPABLE + symbol !is KtTypedSymbol -> MatchesExpectedType.NON_TYPABLE + else -> MatchesExpectedType.matches(symbol.type isSubTypeOf expectedType) + } + + + private var LookupElement.matchesExpectedType by UserDataProperty(Key("MATCHES_EXPECTED_TYPE")) + + enum class MatchesExpectedType { + MATCHES, NON_TYPABLE, NOT_MATCHES, ; + + companion object { + fun matches(matches: Boolean) = if (matches) MATCHES else NOT_MATCHES + } + } + + const val WEIGHER_ID = "kotlin.expected.type" +} + + diff --git a/idea/idea-fir/src/org/jetbrains/kotlin/idea/completion/weighers/Weighers.kt b/idea/idea-fir/src/org/jetbrains/kotlin/idea/completion/weighers/Weighers.kt new file mode 100644 index 00000000000..e80ad300d00 --- /dev/null +++ b/idea/idea-fir/src/org/jetbrains/kotlin/idea/completion/weighers/Weighers.kt @@ -0,0 +1,27 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.idea.completion.weighers + +import com.intellij.codeInsight.completion.CompletionSorter +import com.intellij.codeInsight.lookup.LookupElement +import org.jetbrains.kotlin.idea.frontend.api.KtAnalysisSession +import org.jetbrains.kotlin.idea.frontend.api.symbols.KtSymbol +import org.jetbrains.kotlin.idea.frontend.api.types.KtType + +internal object Weighers { + fun KtAnalysisSession.applyWeighsToLookupElement(lookupElement: LookupElement, symbol: KtSymbol, expectedType: KtType?) { + with(ExpectedTypeWeigher) { addWeight(lookupElement, symbol, expectedType) } + } + + fun addWeighersToCompletionSorter(sorter: CompletionSorter): CompletionSorter = + sorter + .weighBefore(PlatformWeighersIds.STATS, ExpectedTypeWeigher.Weigher) + + private object PlatformWeighersIds { + const val PREFIX = "prefix" + const val STATS = "stats" + } +} \ No newline at end of file diff --git a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/KtAnalysisSession.kt b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/KtAnalysisSession.kt index 6cf8bcf4394..d77780b0bbf 100644 --- a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/KtAnalysisSession.kt +++ b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/KtAnalysisSession.kt @@ -62,9 +62,11 @@ abstract class KtAnalysisSession(final override val token: ValidityToken) : Vali fun KtDeclaration.getReturnKtType(): KtType = typeProvider.getReturnTypeForKtDeclaration(this) - fun KtType.isEqualTo(other: KtType): Boolean = typeProvider.isEqualTo(this, other) + infix fun KtType.isEqualTo(other: KtType): Boolean = typeProvider.isEqualTo(this, other) - fun KtType.isSubTypeOf(superType: KtType): Boolean = typeProvider.isSubTypeOf(this, superType) + infix fun KtType.isSubTypeOf(superType: KtType): Boolean = typeProvider.isSubTypeOf(this, superType) + + fun KtExpression.getExpectedType(): KtType? = typeProvider.getExpectedType(this) fun KtType.isBuiltInFunctionalType(): Boolean = typeProvider.isBuiltinFunctionalType(this) diff --git a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/components/KtTypeProvider.kt b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/components/KtTypeProvider.kt index 36656610719..e2da817d878 100644 --- a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/components/KtTypeProvider.kt +++ b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/components/KtTypeProvider.kt @@ -18,4 +18,6 @@ abstract class KtTypeProvider : KtAnalysisSessionComponent() { //TODO get rid of abstract fun isBuiltinFunctionalType(type: KtType): Boolean + + abstract fun getExpectedType(expression: KtExpression): KtType? } \ No newline at end of file diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirTypeProvider.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirTypeProvider.kt index 6c13627ed92..207c3e23e88 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirTypeProvider.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirTypeProvider.kt @@ -5,6 +5,7 @@ package org.jetbrains.kotlin.idea.frontend.api.fir.components +import com.intellij.psi.util.parentOfType import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.resolve.inference.isBuiltinFunctionalType @@ -20,6 +21,7 @@ import org.jetbrains.kotlin.idea.frontend.api.types.KtType import org.jetbrains.kotlin.idea.frontend.api.withValidityAssertion import org.jetbrains.kotlin.psi.KtDeclaration import org.jetbrains.kotlin.psi.KtExpression +import org.jetbrains.kotlin.psi.KtReturnExpression import org.jetbrains.kotlin.types.AbstractTypeChecker import org.jetbrains.kotlin.types.AbstractTypeCheckerContext @@ -36,6 +38,15 @@ internal class KtFirTypeProvider( expression.getOrBuildFirOfType(firResolveState).typeRef.coneType.asKtType() } + override fun getExpectedType(expression: KtExpression): KtType? = + getExpectedTypeByReturnExpression(expression) + + private fun getExpectedTypeByReturnExpression(expression: KtExpression): KtType? { + val returnParent = expression.parentOfType() ?: return null + val targetSymbol = with(analysisSession) { returnParent.getReturnTargetSymbol() } ?: return null + return targetSymbol.type + } + override fun isEqualTo(first: KtType, second: KtType): Boolean = withValidityAssertion { second.assertIsValid() check(first is KtFirType) From 299f36183cc99f1bdc04e42ecc860b556fbc4b5c Mon Sep 17 00:00:00 2001 From: Ilya Kirillov Date: Sat, 12 Dec 2020 14:44:51 +0100 Subject: [PATCH 036/196] FIR IDE: add tests for completion weighers from old testdata --- .../kotlin/generators/tests/GenerateTests.kt | 5 + .../testData/weighers/basic/Prefix.kt | 2 + .../basic/expectedInfo/ExpectedType2.kt | 2 + .../weighers/AbstractCompletionWeigherTest.kt | 12 +- .../wheigher/AbstractHighLevelWeigherTest.kt | 21 + .../HighLevelWeigherTestGenerated.java | 535 ++++++++++++++++++ 6 files changed, 574 insertions(+), 3 deletions(-) create mode 100644 idea/idea-fir/tests/org/jetbrains/kotlin/idea/completion/wheigher/AbstractHighLevelWeigherTest.kt create mode 100644 idea/idea-fir/tests/org/jetbrains/kotlin/idea/completion/wheigher/HighLevelWeigherTestGenerated.java diff --git a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt index dbb2203c252..727a4c200ab 100644 --- a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt +++ b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt @@ -51,6 +51,7 @@ import org.jetbrains.kotlin.idea.completion.test.* import org.jetbrains.kotlin.idea.completion.test.handlers.* import org.jetbrains.kotlin.idea.completion.test.weighers.AbstractBasicCompletionWeigherTest import org.jetbrains.kotlin.idea.completion.test.weighers.AbstractSmartCompletionWeigherTest +import org.jetbrains.kotlin.idea.completion.wheigher.AbstractHighLevelWeigherTest import org.jetbrains.kotlin.idea.configuration.AbstractGradleConfigureProjectByChangingFileTest import org.jetbrains.kotlin.idea.conversion.copy.AbstractJavaToKotlinCopyPasteConversionTest import org.jetbrains.kotlin.idea.conversion.copy.AbstractLiteralKotlinToKotlinCopyPasteTest @@ -1102,6 +1103,10 @@ fun main(args: Array) { testClass { model("handlers/basic", pattern = KT_WITHOUT_DOTS_IN_NAME) } + + testClass { + model("weighers/basic", pattern = KT_OR_KTS_WITHOUT_DOTS_IN_NAME) + } } testGroup("idea/idea-fir/tests", "idea/testData/findUsages") { diff --git a/idea/idea-completion/testData/weighers/basic/Prefix.kt b/idea/idea-completion/testData/weighers/basic/Prefix.kt index c6122d64830..0efe810d78d 100644 --- a/idea/idea-completion/testData/weighers/basic/Prefix.kt +++ b/idea/idea-completion/testData/weighers/basic/Prefix.kt @@ -1,3 +1,5 @@ +// FIR_COMPARISON + fun shouldCompleteTopLevelCallablesFromIndex() = true fun foo(statement: String) { diff --git a/idea/idea-completion/testData/weighers/basic/expectedInfo/ExpectedType2.kt b/idea/idea-completion/testData/weighers/basic/expectedInfo/ExpectedType2.kt index 0c98ee4ec12..b259f83697b 100644 --- a/idea/idea-completion/testData/weighers/basic/expectedInfo/ExpectedType2.kt +++ b/idea/idea-completion/testData/weighers/basic/expectedInfo/ExpectedType2.kt @@ -1,3 +1,5 @@ +// FIR_COMPARISON + interface I { fun takeXxx(): Int = 0 fun takeYyy(): String = "" diff --git a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/weighers/AbstractCompletionWeigherTest.kt b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/weighers/AbstractCompletionWeigherTest.kt index a03e1a038fa..ab64416ab73 100644 --- a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/weighers/AbstractCompletionWeigherTest.kt +++ b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/weighers/AbstractCompletionWeigherTest.kt @@ -28,11 +28,17 @@ abstract class AbstractCompletionWeigherTest(val completionType: CompletionType, val items = InTextDirectivesUtils.findArrayWithPrefixes(text, "// ORDER:") Assert.assertTrue("""Some items should be defined with "// ORDER:" directive""", items.isNotEmpty()) - withCustomCompilerOptions(text, project, module) { - myFixture.complete(completionType, InTextDirectivesUtils.getPrefixedInt(text, "// INVOCATION_COUNT:") ?: 1) - myFixture.assertPreferredCompletionItems(InTextDirectivesUtils.getPrefixedInt(text, "// SELECTED:") ?: 0, *items) + executeTest { + withCustomCompilerOptions(text, project, module) { + myFixture.complete(completionType, InTextDirectivesUtils.getPrefixedInt(text, "// INVOCATION_COUNT:") ?: 1) + myFixture.assertPreferredCompletionItems(InTextDirectivesUtils.getPrefixedInt(text, "// SELECTED:") ?: 0, *items) + } } } + + open fun executeTest(test: () -> Unit) { + test() + } } abstract class AbstractBasicCompletionWeigherTest() : AbstractCompletionWeigherTest(CompletionType.BASIC, "weighers/basic") { diff --git a/idea/idea-fir/tests/org/jetbrains/kotlin/idea/completion/wheigher/AbstractHighLevelWeigherTest.kt b/idea/idea-fir/tests/org/jetbrains/kotlin/idea/completion/wheigher/AbstractHighLevelWeigherTest.kt new file mode 100644 index 00000000000..b778763bd22 --- /dev/null +++ b/idea/idea-fir/tests/org/jetbrains/kotlin/idea/completion/wheigher/AbstractHighLevelWeigherTest.kt @@ -0,0 +1,21 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.idea.completion.wheigher + +import org.jetbrains.kotlin.idea.completion.test.weighers.AbstractBasicCompletionWeigherTest +import org.jetbrains.kotlin.test.uitls.IgnoreTests + +abstract class AbstractHighLevelWeigherTest : AbstractBasicCompletionWeigherTest() { + override fun isFirPlugin(): Boolean = true + + override val captureExceptions: Boolean = false + + override fun executeTest(test: () -> Unit) { + IgnoreTests.runTestIfEnabledByFileDirective(testDataFile().toPath(), IgnoreTests.DIRECTIVES.FIR_COMPARISON, ".after") { + test() + } + } +} \ No newline at end of file diff --git a/idea/idea-fir/tests/org/jetbrains/kotlin/idea/completion/wheigher/HighLevelWeigherTestGenerated.java b/idea/idea-fir/tests/org/jetbrains/kotlin/idea/completion/wheigher/HighLevelWeigherTestGenerated.java new file mode 100644 index 00000000000..1db3ed5d37a --- /dev/null +++ b/idea/idea-fir/tests/org/jetbrains/kotlin/idea/completion/wheigher/HighLevelWeigherTestGenerated.java @@ -0,0 +1,535 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.idea.completion.wheigher; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; +import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.runner.RunWith; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("idea/idea-completion/testData/weighers/basic") +@TestDataPath("$PROJECT_ROOT") +@RunWith(JUnit3RunnerWithInners.class) +public class HighLevelWeigherTestGenerated extends AbstractHighLevelWeigherTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); + } + + @TestMetadata("AfterNullable.kt") + public void testAfterNullable() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/AfterNullable.kt"); + } + + public void testAllFilesPresentInBasic() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/weighers/basic"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); + } + + @TestMetadata("CallableReference_NothingLast.kt") + public void testCallableReference_NothingLast() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/CallableReference_NothingLast.kt"); + } + + @TestMetadata("Callables.kt") + public void testCallables() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/Callables.kt"); + } + + @TestMetadata("DelegateToOtherObject.kt") + public void testDelegateToOtherObject() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/DelegateToOtherObject.kt"); + } + + @TestMetadata("DeprecatedFun.kt") + public void testDeprecatedFun() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/DeprecatedFun.kt"); + } + + @TestMetadata("DeprecatedJavaClass.kt") + public void testDeprecatedJavaClass() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/DeprecatedJavaClass.kt"); + } + + @TestMetadata("DeprecatedSinceKotlinFun.kt") + public void testDeprecatedSinceKotlinFun() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/DeprecatedSinceKotlinFun.kt"); + } + + @TestMetadata("DslCallWithExpectedType.kt") + public void testDslCallWithExpectedType() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/DslCallWithExpectedType.kt"); + } + + @TestMetadata("DslCalls.kt") + public void testDslCalls() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/DslCalls.kt"); + } + + @TestMetadata("DslCallsAnnotatedFunctionType.kt") + public void testDslCallsAnnotatedFunctionType() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/DslCallsAnnotatedFunctionType.kt"); + } + + @TestMetadata("DslCallsWithMultipleReceivers.kt") + public void testDslCallsWithMultipleReceivers() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/DslCallsWithMultipleReceivers.kt"); + } + + @TestMetadata("DslMemberCalls.kt") + public void testDslMemberCalls() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/DslMemberCalls.kt"); + } + + @TestMetadata("ExactMatchForKeyword.kt") + public void testExactMatchForKeyword() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/ExactMatchForKeyword.kt"); + } + + @TestMetadata("ImportedFirst.kt") + public void testImportedFirst() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/ImportedFirst.kt"); + } + + @TestMetadata("ImportedFirstForJavaClass.kt") + public void testImportedFirstForJavaClass() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/ImportedFirstForJavaClass.kt"); + } + + @TestMetadata("ImportedOrder.kt") + public void testImportedOrder() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/ImportedOrder.kt"); + } + + @TestMetadata("KT-25588_1.kts") + public void testKT_25588_1() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/KT-25588_1.kts"); + } + + @TestMetadata("KT-25588_2.kts") + public void testKT_25588_2() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/KT-25588_2.kts"); + } + + @TestMetadata("KeywordsLast.kt") + public void testKeywordsLast() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/KeywordsLast.kt"); + } + + @TestMetadata("LambdaSignature.kt") + public void testLambdaSignature() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/LambdaSignature.kt"); + } + + @TestMetadata("LocalFileBeforeImported.kt") + public void testLocalFileBeforeImported() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/LocalFileBeforeImported.kt"); + } + + @TestMetadata("LocalValuesAndParams.kt") + public void testLocalValuesAndParams() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/LocalValuesAndParams.kt"); + } + + @TestMetadata("LocalsBeforeKeywords.kt") + public void testLocalsBeforeKeywords() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/LocalsBeforeKeywords.kt"); + } + + @TestMetadata("LocalsPropertiesKeywords.kt") + public void testLocalsPropertiesKeywords() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/LocalsPropertiesKeywords.kt"); + } + + @TestMetadata("NamedParameters.kt") + public void testNamedParameters() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/NamedParameters.kt"); + } + + @TestMetadata("NamedParameters2.kt") + public void testNamedParameters2() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/NamedParameters2.kt"); + } + + @TestMetadata("NamedParameters3.kt") + public void testNamedParameters3() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/NamedParameters3.kt"); + } + + @TestMetadata("NoExpectedType.kt") + public void testNoExpectedType() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/NoExpectedType.kt"); + } + + @TestMetadata("Packages.kt") + public void testPackages() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/Packages.kt"); + } + + @TestMetadata("ParametersBeforeKeywords.kt") + public void testParametersBeforeKeywords() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/ParametersBeforeKeywords.kt"); + } + + @TestMetadata("PreferFromJdk.kt") + public void testPreferFromJdk() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/PreferFromJdk.kt"); + } + + @TestMetadata("PreferGetMethodToProperty.kt") + public void testPreferGetMethodToProperty() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/PreferGetMethodToProperty.kt"); + } + + @TestMetadata("Prefix.kt") + public void testPrefix() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/Prefix.kt"); + } + + @TestMetadata("PropertiesBeforeKeywords.kt") + public void testPropertiesBeforeKeywords() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/PropertiesBeforeKeywords.kt"); + } + + @TestMetadata("StaticMembers.kt") + public void testStaticMembers() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/StaticMembers.kt"); + } + + @TestMetadata("SuperMembers.kt") + public void testSuperMembers() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/SuperMembers.kt"); + } + + @TestMetadata("TopLevelKeywordWithClassName.kt") + public void testTopLevelKeywordWithClassName() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/TopLevelKeywordWithClassName.kt"); + } + + @TestMetadata("UnavailableDslReceiver.kt") + public void testUnavailableDslReceiver() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/UnavailableDslReceiver.kt"); + } + + @TestMetadata("idea/idea-completion/testData/weighers/basic/contextualReturn") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ContextualReturn extends AbstractHighLevelWeigherTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); + } + + public void testAllFilesPresentInContextualReturn() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/weighers/basic/contextualReturn"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); + } + + @TestMetadata("idea/idea-completion/testData/weighers/basic/contextualReturn/noReturnType") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class NoReturnType extends AbstractHighLevelWeigherTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); + } + + public void testAllFilesPresentInNoReturnType() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/weighers/basic/contextualReturn/noReturnType"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); + } + + @TestMetadata("BeginOfNestedBlock.kt") + public void testBeginOfNestedBlock() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/contextualReturn/noReturnType/BeginOfNestedBlock.kt"); + } + + @TestMetadata("BeginOfTopLevelBlock.kt") + public void testBeginOfTopLevelBlock() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/contextualReturn/noReturnType/BeginOfTopLevelBlock.kt"); + } + + @TestMetadata("EndOfNestedBlock.kt") + public void testEndOfNestedBlock() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/contextualReturn/noReturnType/EndOfNestedBlock.kt"); + } + + @TestMetadata("EndOfTopLevelBlock.kt") + public void testEndOfTopLevelBlock() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/contextualReturn/noReturnType/EndOfTopLevelBlock.kt"); + } + + @TestMetadata("ForWithBody.kt") + public void testForWithBody() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/contextualReturn/noReturnType/ForWithBody.kt"); + } + + @TestMetadata("ForWithoutBody.kt") + public void testForWithoutBody() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/contextualReturn/noReturnType/ForWithoutBody.kt"); + } + + @TestMetadata("IfWithoutBody.kt") + public void testIfWithoutBody() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/contextualReturn/noReturnType/IfWithoutBody.kt"); + } + + @TestMetadata("InElvis.kt") + public void testInElvis() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/contextualReturn/noReturnType/InElvis.kt"); + } + + @TestMetadata("InElvisWhenSmartCompletionWins.kt") + public void testInElvisWhenSmartCompletionWins() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/contextualReturn/noReturnType/InElvisWhenSmartCompletionWins.kt"); + } + + @TestMetadata("InWhenSingleExpression.kt") + public void testInWhenSingleExpression() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/contextualReturn/noReturnType/InWhenSingleExpression.kt"); + } + + @TestMetadata("InWhenWithBody.kt") + public void testInWhenWithBody() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/contextualReturn/noReturnType/InWhenWithBody.kt"); + } + } + + @TestMetadata("idea/idea-completion/testData/weighers/basic/contextualReturn/withReturnType") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class WithReturnType extends AbstractHighLevelWeigherTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); + } + + public void testAllFilesPresentInWithReturnType() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/weighers/basic/contextualReturn/withReturnType"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); + } + + @TestMetadata("BeginOfNestedBlock.kt") + public void testBeginOfNestedBlock() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/contextualReturn/withReturnType/BeginOfNestedBlock.kt"); + } + + @TestMetadata("BeginOfTopLevelBlock.kt") + public void testBeginOfTopLevelBlock() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/contextualReturn/withReturnType/BeginOfTopLevelBlock.kt"); + } + + @TestMetadata("EndOfNestedBlock.kt") + public void testEndOfNestedBlock() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/contextualReturn/withReturnType/EndOfNestedBlock.kt"); + } + + @TestMetadata("EndOfTopLevelBlock.kt") + public void testEndOfTopLevelBlock() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/contextualReturn/withReturnType/EndOfTopLevelBlock.kt"); + } + + @TestMetadata("ForWithBody.kt") + public void testForWithBody() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/contextualReturn/withReturnType/ForWithBody.kt"); + } + + @TestMetadata("ForWithoutBody.kt") + public void testForWithoutBody() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/contextualReturn/withReturnType/ForWithoutBody.kt"); + } + + @TestMetadata("IfWithoutBody.kt") + public void testIfWithoutBody() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/contextualReturn/withReturnType/IfWithoutBody.kt"); + } + + @TestMetadata("InElvis.kt") + public void testInElvis() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/contextualReturn/withReturnType/InElvis.kt"); + } + + @TestMetadata("InElvisInReturn.kt") + public void testInElvisInReturn() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/contextualReturn/withReturnType/InElvisInReturn.kt"); + } + + @TestMetadata("InElvisWhenSmartCompletionWins.kt") + public void testInElvisWhenSmartCompletionWins() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/contextualReturn/withReturnType/InElvisWhenSmartCompletionWins.kt"); + } + + @TestMetadata("InIfAsReturnedExpression.kt") + public void testInIfAsReturnedExpression() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/contextualReturn/withReturnType/InIfAsReturnedExpression.kt"); + } + + @TestMetadata("InIfInWhenWithBodyAsReturnedExpression.kt") + public void testInIfInWhenWithBodyAsReturnedExpression() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/contextualReturn/withReturnType/InIfInWhenWithBodyAsReturnedExpression.kt"); + } + + @TestMetadata("InNotElvisBinaryOperator.kt") + public void testInNotElvisBinaryOperator() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/contextualReturn/withReturnType/InNotElvisBinaryOperator.kt"); + } + + @TestMetadata("InWhenAsReturnedExpression.kt") + public void testInWhenAsReturnedExpression() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/contextualReturn/withReturnType/InWhenAsReturnedExpression.kt"); + } + + @TestMetadata("InWhenSingleExpression.kt") + public void testInWhenSingleExpression() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/contextualReturn/withReturnType/InWhenSingleExpression.kt"); + } + + @TestMetadata("InWhenWithBody.kt") + public void testInWhenWithBody() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/contextualReturn/withReturnType/InWhenWithBody.kt"); + } + + @TestMetadata("InWhenWithBodyAsReturnedExpression.kt") + public void testInWhenWithBodyAsReturnedExpression() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/contextualReturn/withReturnType/InWhenWithBodyAsReturnedExpression.kt"); + } + } + } + + @TestMetadata("idea/idea-completion/testData/weighers/basic/expectedInfo") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ExpectedInfo extends AbstractHighLevelWeigherTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); + } + + @TestMetadata("AfterAs.kt") + public void testAfterAs() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/expectedInfo/AfterAs.kt"); + } + + public void testAllFilesPresentInExpectedInfo() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/weighers/basic/expectedInfo"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); + } + + @TestMetadata("CompanionObjectMethod.kt") + public void testCompanionObjectMethod() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/expectedInfo/CompanionObjectMethod.kt"); + } + + @TestMetadata("EnumEntries.kt") + public void testEnumEntries() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/expectedInfo/EnumEntries.kt"); + } + + @TestMetadata("ExpectedType.kt") + public void testExpectedType() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/expectedInfo/ExpectedType.kt"); + } + + @TestMetadata("ExpectedType2.kt") + public void testExpectedType2() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/expectedInfo/ExpectedType2.kt"); + } + + @TestMetadata("LambdaValue.kt") + public void testLambdaValue() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/expectedInfo/LambdaValue.kt"); + } + + @TestMetadata("MultiArgsItem.kt") + public void testMultiArgsItem() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/expectedInfo/MultiArgsItem.kt"); + } + + @TestMetadata("NameSimilarity.kt") + public void testNameSimilarity() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/expectedInfo/NameSimilarity.kt"); + } + + @TestMetadata("NameSimilarityAndNoExpectedType.kt") + public void testNameSimilarityAndNoExpectedType() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/expectedInfo/NameSimilarityAndNoExpectedType.kt"); + } + + @TestMetadata("NameSimilarityAndNoExpectedType2.kt") + public void testNameSimilarityAndNoExpectedType2() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/expectedInfo/NameSimilarityAndNoExpectedType2.kt"); + } + + @TestMetadata("NoStupidComparison.kt") + public void testNoStupidComparison() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/expectedInfo/NoStupidComparison.kt"); + } + + @TestMetadata("Null.kt") + public void testNull() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/expectedInfo/Null.kt"); + } + + @TestMetadata("PreferMatchingThis.kt") + public void testPreferMatchingThis() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/expectedInfo/PreferMatchingThis.kt"); + } + + @TestMetadata("TrueFalse.kt") + public void testTrueFalse() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/expectedInfo/TrueFalse.kt"); + } + + @TestMetadata("WhenByEnum.kt") + public void testWhenByEnum() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/expectedInfo/WhenByEnum.kt"); + } + } + + @TestMetadata("idea/idea-completion/testData/weighers/basic/parameterNameAndType") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ParameterNameAndType extends AbstractHighLevelWeigherTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); + } + + public void testAllFilesPresentInParameterNameAndType() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/weighers/basic/parameterNameAndType"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); + } + + @TestMetadata("Deprecated.kt") + public void testDeprecated() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/parameterNameAndType/Deprecated.kt"); + } + + @TestMetadata("FromCurrentFilePriority.kt") + public void testFromCurrentFilePriority() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/parameterNameAndType/FromCurrentFilePriority.kt"); + } + + @TestMetadata("ImportedFirst.kt") + public void testImportedFirst() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/parameterNameAndType/ImportedFirst.kt"); + } + + @TestMetadata("MoreWordsMatchFirst.kt") + public void testMoreWordsMatchFirst() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/parameterNameAndType/MoreWordsMatchFirst.kt"); + } + + @TestMetadata("ShorterFirst.kt") + public void testShorterFirst() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/parameterNameAndType/ShorterFirst.kt"); + } + + @TestMetadata("StartMatchFirst.kt") + public void testStartMatchFirst() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/parameterNameAndType/StartMatchFirst.kt"); + } + + @TestMetadata("UserPrefix.kt") + public void testUserPrefix() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/parameterNameAndType/UserPrefix.kt"); + } + } +} From 835577383b56b3b1a9daed4dedf3cd5d6ccca6c6 Mon Sep 17 00:00:00 2001 From: Ilya Kirillov Date: Sat, 12 Dec 2020 17:44:45 +0100 Subject: [PATCH 037/196] FIR IDE: introduce expected type provider for return expressions --- .../kotlin/generators/tests/GenerateTests.kt | 5 ++ .../idea/frontend/api/KtAnalysisSession.kt | 3 +- .../frontend/api/components/KtTypeProvider.kt | 3 +- .../api/fir/components/KtFirTypeProvider.kt | 17 ++++-- .../returnFromFunction.kt | 5 ++ .../returnFromFunctionQualifiedReceiver.kt | 5 ++ .../returnFromFunctionQualifiedSelector.kt | 5 ++ .../returnFromLambda.kt | 10 ++++ .../AbstractExpectedExpressionTypeTest.kt | 54 +++++++++++++++++++ .../ExpectedExpressionTypeTestGenerated.java | 50 +++++++++++++++++ 10 files changed, 152 insertions(+), 5 deletions(-) create mode 100644 idea/idea-frontend-fir/testData/components/expectedExpressionType/returnFromFunction.kt create mode 100644 idea/idea-frontend-fir/testData/components/expectedExpressionType/returnFromFunctionQualifiedReceiver.kt create mode 100644 idea/idea-frontend-fir/testData/components/expectedExpressionType/returnFromFunctionQualifiedSelector.kt create mode 100644 idea/idea-frontend-fir/testData/components/expectedExpressionType/returnFromLambda.kt create mode 100644 idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/components/AbstractExpectedExpressionTypeTest.kt create mode 100644 idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/components/ExpectedExpressionTypeTestGenerated.java diff --git a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt index 727a4c200ab..b05d4a0f326 100644 --- a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt +++ b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt @@ -89,6 +89,7 @@ import org.jetbrains.kotlin.idea.fir.low.level.api.file.structure.AbstractFileSt import org.jetbrains.kotlin.idea.fir.low.level.api.sessions.AbstractSessionsInvalidationTest import org.jetbrains.kotlin.idea.fir.low.level.api.trackers.AbstractProjectWideOutOfBlockKotlinModificationTrackerTest import org.jetbrains.kotlin.idea.folding.AbstractKotlinFoldingTest +import org.jetbrains.kotlin.idea.frontend.api.components.AbstractExpectedExpressionTypeTest import org.jetbrains.kotlin.idea.frontend.api.components.AbstractReturnExpressionTargetTest import org.jetbrains.kotlin.idea.frontend.api.fir.AbstractResolveCallTest import org.jetbrains.kotlin.idea.frontend.api.scopes.AbstractMemberScopeByFqNameTest @@ -1027,6 +1028,10 @@ fun main(args: Array) { testClass { model("components/returnExpressionTarget") } + + testClass { + model("components/expectedExpressionType") + } } testGroup("idea/idea-frontend-fir/idea-fir-low-level-api/tests", "idea/testData") { diff --git a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/KtAnalysisSession.kt b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/KtAnalysisSession.kt index d77780b0bbf..688f75077a8 100644 --- a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/KtAnalysisSession.kt +++ b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/KtAnalysisSession.kt @@ -5,6 +5,7 @@ package org.jetbrains.kotlin.idea.frontend.api +import com.intellij.psi.PsiElement import org.jetbrains.kotlin.diagnostics.Diagnostic import org.jetbrains.kotlin.idea.frontend.api.calls.KtCall import org.jetbrains.kotlin.idea.frontend.api.components.* @@ -66,7 +67,7 @@ abstract class KtAnalysisSession(final override val token: ValidityToken) : Vali infix fun KtType.isSubTypeOf(superType: KtType): Boolean = typeProvider.isSubTypeOf(this, superType) - fun KtExpression.getExpectedType(): KtType? = typeProvider.getExpectedType(this) + fun PsiElement.getExpectedType(): KtType? = typeProvider.getExpectedType(this) fun KtType.isBuiltInFunctionalType(): Boolean = typeProvider.isBuiltinFunctionalType(this) diff --git a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/components/KtTypeProvider.kt b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/components/KtTypeProvider.kt index e2da817d878..77f73b476c3 100644 --- a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/components/KtTypeProvider.kt +++ b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/components/KtTypeProvider.kt @@ -5,6 +5,7 @@ package org.jetbrains.kotlin.idea.frontend.api.components +import com.intellij.psi.PsiElement import org.jetbrains.kotlin.idea.frontend.api.types.KtType import org.jetbrains.kotlin.psi.KtDeclaration import org.jetbrains.kotlin.psi.KtExpression @@ -19,5 +20,5 @@ abstract class KtTypeProvider : KtAnalysisSessionComponent() { //TODO get rid of abstract fun isBuiltinFunctionalType(type: KtType): Boolean - abstract fun getExpectedType(expression: KtExpression): KtType? + abstract fun getExpectedType(expression: PsiElement): KtType? } \ No newline at end of file diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirTypeProvider.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirTypeProvider.kt index 207c3e23e88..00396705548 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirTypeProvider.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirTypeProvider.kt @@ -5,6 +5,7 @@ package org.jetbrains.kotlin.idea.frontend.api.fir.components +import com.intellij.psi.PsiElement import com.intellij.psi.util.parentOfType import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration import org.jetbrains.kotlin.fir.expressions.FirExpression @@ -21,6 +22,7 @@ import org.jetbrains.kotlin.idea.frontend.api.types.KtType import org.jetbrains.kotlin.idea.frontend.api.withValidityAssertion import org.jetbrains.kotlin.psi.KtDeclaration import org.jetbrains.kotlin.psi.KtExpression +import org.jetbrains.kotlin.psi.KtQualifiedExpression import org.jetbrains.kotlin.psi.KtReturnExpression import org.jetbrains.kotlin.types.AbstractTypeChecker import org.jetbrains.kotlin.types.AbstractTypeCheckerContext @@ -38,15 +40,24 @@ internal class KtFirTypeProvider( expression.getOrBuildFirOfType(firResolveState).typeRef.coneType.asKtType() } - override fun getExpectedType(expression: KtExpression): KtType? = + override fun getExpectedType(expression: PsiElement): KtType? = getExpectedTypeByReturnExpression(expression) - private fun getExpectedTypeByReturnExpression(expression: KtExpression): KtType? { - val returnParent = expression.parentOfType() ?: return null + private fun getExpectedTypeByReturnExpression(expression: PsiElement): KtType? { + val returnParent = expression.getReturnExpressionWithThisType() ?: return null val targetSymbol = with(analysisSession) { returnParent.getReturnTargetSymbol() } ?: return null return targetSymbol.type } + private fun PsiElement.getReturnExpressionWithThisType(): KtReturnExpression? { + val parent = parent + return when { + parent is KtReturnExpression && parent.returnedExpression == this -> parent + parent is KtQualifiedExpression && parent.selectorExpression == this -> parent.getReturnExpressionWithThisType() + else -> null + } + } + override fun isEqualTo(first: KtType, second: KtType): Boolean = withValidityAssertion { second.assertIsValid() check(first is KtFirType) diff --git a/idea/idea-frontend-fir/testData/components/expectedExpressionType/returnFromFunction.kt b/idea/idea-frontend-fir/testData/components/expectedExpressionType/returnFromFunction.kt new file mode 100644 index 00000000000..f439f323a4f --- /dev/null +++ b/idea/idea-frontend-fir/testData/components/expectedExpressionType/returnFromFunction.kt @@ -0,0 +1,5 @@ +fun foo(): Int { + return a +} + +// EXPECTED_TYPE: kotlin/Int \ No newline at end of file diff --git a/idea/idea-frontend-fir/testData/components/expectedExpressionType/returnFromFunctionQualifiedReceiver.kt b/idea/idea-frontend-fir/testData/components/expectedExpressionType/returnFromFunctionQualifiedReceiver.kt new file mode 100644 index 00000000000..b5bfe48d639 --- /dev/null +++ b/idea/idea-frontend-fir/testData/components/expectedExpressionType/returnFromFunctionQualifiedReceiver.kt @@ -0,0 +1,5 @@ +fun foo(): Int { + return xfd.a +} + +// EXPECTED_TYPE: null \ No newline at end of file diff --git a/idea/idea-frontend-fir/testData/components/expectedExpressionType/returnFromFunctionQualifiedSelector.kt b/idea/idea-frontend-fir/testData/components/expectedExpressionType/returnFromFunctionQualifiedSelector.kt new file mode 100644 index 00000000000..80b711af393 --- /dev/null +++ b/idea/idea-frontend-fir/testData/components/expectedExpressionType/returnFromFunctionQualifiedSelector.kt @@ -0,0 +1,5 @@ +fun foo(): Int { + return x.a +} + +// EXPECTED_TYPE: kotlin/Int \ No newline at end of file diff --git a/idea/idea-frontend-fir/testData/components/expectedExpressionType/returnFromLambda.kt b/idea/idea-frontend-fir/testData/components/expectedExpressionType/returnFromLambda.kt new file mode 100644 index 00000000000..c20387bf9a5 --- /dev/null +++ b/idea/idea-frontend-fir/testData/components/expectedExpressionType/returnFromLambda.kt @@ -0,0 +1,10 @@ +fun x(): Int { + receiveLambda { + return@receiveLambda fd + } + return 2 +} + +fun receiveLambda(x: () -> Int){} + +// EXPECTED_TYPE: kotlin/Int \ No newline at end of file diff --git a/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/components/AbstractExpectedExpressionTypeTest.kt b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/components/AbstractExpectedExpressionTypeTest.kt new file mode 100644 index 00000000000..36fa7a84a0b --- /dev/null +++ b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/components/AbstractExpectedExpressionTypeTest.kt @@ -0,0 +1,54 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.idea.frontend.api.components + +import com.intellij.openapi.util.io.FileUtil +import com.intellij.psi.PsiComment +import com.intellij.psi.util.parentOfType +import junit.framework.Assert +import org.jetbrains.kotlin.idea.executeOnPooledThreadInReadAction +import org.jetbrains.kotlin.idea.frontend.api.analyze +import org.jetbrains.kotlin.idea.test.KotlinLightCodeInsightFixtureTestCase +import org.jetbrains.kotlin.psi.KtDeclaration +import org.jetbrains.kotlin.psi.KtExpression +import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.psi.KtReturnExpression +import org.jetbrains.kotlin.psi.psiUtil.forEachDescendantOfType +import org.jetbrains.kotlin.test.InTextDirectivesUtils +import org.jetbrains.kotlin.test.KotlinTestUtils +import java.io.File + +abstract class AbstractExpectedExpressionTypeTest : KotlinLightCodeInsightFixtureTestCase() { + override fun isFirPlugin() = true + + protected fun doTest(path: String) { + val testDataFile = File(path) + val ktFile = myFixture.configureByText(testDataFile.name, FileUtil.loadFile(testDataFile)) as KtFile + + val expressionAtCaret = ktFile.findElementAt(myFixture.caretOffset)?.parentOfType() + ?: error("No element was found at caret or no is present in the test file") + + val actualExpectedTypeText: String? = executeOnPooledThreadInReadAction { + analyze(ktFile) { + expressionAtCaret.getExpectedType()?.asStringForDebugging() + } + } + + KotlinTestUtils.assertEqualsToFile(File(path), testDataFile.getTextWithActualType(actualExpectedTypeText)) + } + + private fun File.getTextWithActualType(actualType: String?) : String { + val text = FileUtil.loadFile(this) + val textWithoutTypeDirective = text.split('\n') + .filterNot { it.startsWith(EXPECTED_TYPE_TEXT_DIRECTIVE) } + .joinToString(separator = "\n") + return "$textWithoutTypeDirective\n$EXPECTED_TYPE_TEXT_DIRECTIVE $actualType" + } + + companion object { + private const val EXPECTED_TYPE_TEXT_DIRECTIVE = "// EXPECTED_TYPE:" + } +} \ No newline at end of file diff --git a/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/components/ExpectedExpressionTypeTestGenerated.java b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/components/ExpectedExpressionTypeTestGenerated.java new file mode 100644 index 00000000000..42c954b9116 --- /dev/null +++ b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/components/ExpectedExpressionTypeTestGenerated.java @@ -0,0 +1,50 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.idea.frontend.api.components; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; +import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.runner.RunWith; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("idea/idea-frontend-fir/testData/components/expectedExpressionType") +@TestDataPath("$PROJECT_ROOT") +@RunWith(JUnit3RunnerWithInners.class) +public class ExpectedExpressionTypeTestGenerated extends AbstractExpectedExpressionTypeTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); + } + + public void testAllFilesPresentInExpectedExpressionType() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-frontend-fir/testData/components/expectedExpressionType"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @TestMetadata("returnFromFunction.kt") + public void testReturnFromFunction() throws Exception { + runTest("idea/idea-frontend-fir/testData/components/expectedExpressionType/returnFromFunction.kt"); + } + + @TestMetadata("returnFromFunctionQualifiedReceiver.kt") + public void testReturnFromFunctionQualifiedReceiver() throws Exception { + runTest("idea/idea-frontend-fir/testData/components/expectedExpressionType/returnFromFunctionQualifiedReceiver.kt"); + } + + @TestMetadata("returnFromFunctionQualifiedSelector.kt") + public void testReturnFromFunctionQualifiedSelector() throws Exception { + runTest("idea/idea-frontend-fir/testData/components/expectedExpressionType/returnFromFunctionQualifiedSelector.kt"); + } + + @TestMetadata("returnFromLambda.kt") + public void testReturnFromLambda() throws Exception { + runTest("idea/idea-frontend-fir/testData/components/expectedExpressionType/returnFromLambda.kt"); + } +} From c2d83353e81a99866606ac29adc2a17a7c445d38 Mon Sep 17 00:00:00 2001 From: Ilya Kirillov Date: Sun, 13 Dec 2020 12:18:05 +0100 Subject: [PATCH 038/196] FIR IDE: introduce builtin types container --- .../frontend/api/components/KtTypeProvider.kt | 25 +++++++++++ .../api/fir/components/KtFirBuiltInTypes.kt | 45 +++++++++++++++++++ .../api/fir/components/KtFirTypeProvider.kt | 4 ++ 3 files changed, 74 insertions(+) create mode 100644 idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirBuiltInTypes.kt diff --git a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/components/KtTypeProvider.kt b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/components/KtTypeProvider.kt index 77f73b476c3..e30578fb31e 100644 --- a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/components/KtTypeProvider.kt +++ b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/components/KtTypeProvider.kt @@ -6,6 +6,7 @@ package org.jetbrains.kotlin.idea.frontend.api.components import com.intellij.psi.PsiElement +import org.jetbrains.kotlin.idea.frontend.api.ValidityTokenOwner import org.jetbrains.kotlin.idea.frontend.api.types.KtType import org.jetbrains.kotlin.psi.KtDeclaration import org.jetbrains.kotlin.psi.KtExpression @@ -21,4 +22,28 @@ abstract class KtTypeProvider : KtAnalysisSessionComponent() { abstract fun isBuiltinFunctionalType(type: KtType): Boolean abstract fun getExpectedType(expression: PsiElement): KtType? + + abstract val builtinTypes: KtBuiltinTypes +} + +@Suppress("PropertyName") +abstract class KtBuiltinTypes : ValidityTokenOwner { + abstract val INT: KtType + abstract val LONG: KtType + abstract val SHORT: KtType + abstract val BYTE: KtType + + abstract val FLOAT: KtType + abstract val DOUBLE: KtType + + abstract val BOOLEAN: KtType + abstract val CHAR: KtType + abstract val STRING: KtType + + abstract val UNIT: KtType + abstract val NOTHING: KtType + abstract val ANY: KtType + + abstract val NULLABLE_ANY: KtType + abstract val NULLABLE_NOTHING: KtType } \ No newline at end of file diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirBuiltInTypes.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirBuiltInTypes.kt new file mode 100644 index 00000000000..605bef300c7 --- /dev/null +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirBuiltInTypes.kt @@ -0,0 +1,45 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.idea.frontend.api.fir.components + +import org.jetbrains.kotlin.fir.BuiltinTypes +import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl +import org.jetbrains.kotlin.fir.types.impl.FirImplicitBuiltinTypeRef +import org.jetbrains.kotlin.idea.frontend.api.ValidityToken +import org.jetbrains.kotlin.idea.frontend.api.components.KtBuiltinTypes +import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder +import org.jetbrains.kotlin.idea.frontend.api.fir.types.KtFirClassType +import org.jetbrains.kotlin.idea.frontend.api.fir.utils.cached +import org.jetbrains.kotlin.idea.frontend.api.fir.utils.weakRef +import org.jetbrains.kotlin.idea.frontend.api.types.KtType + +internal class KtFirBuiltInTypes(builtinTypes: BuiltinTypes, builder: KtSymbolByFirBuilder, override val token: ValidityToken) : KtBuiltinTypes() { + private val builder by weakRef(builder) + + override val INT: KtType by cachedBuiltin(builtinTypes.intType) + override val LONG: KtType by cachedBuiltin(builtinTypes.longType) + override val SHORT: KtType by cachedBuiltin(builtinTypes.shortType) + override val BYTE: KtType by cachedBuiltin(builtinTypes.byteType) + + override val FLOAT: KtType by cachedBuiltin(builtinTypes.floatType) + override val DOUBLE: KtType by cachedBuiltin(builtinTypes.doubleType) + + override val CHAR: KtType by cachedBuiltin(builtinTypes.charType) + override val BOOLEAN: KtType by cachedBuiltin(builtinTypes.booleanType) + override val STRING: KtType by cachedBuiltin(builtinTypes.stringType) + + override val UNIT: KtType by cachedBuiltin(builtinTypes.unitType) + override val NOTHING: KtType by cachedBuiltin(builtinTypes.nothingType) + override val ANY: KtType by cachedBuiltin(builtinTypes.anyType) + + + override val NULLABLE_ANY: KtType by cachedBuiltin(builtinTypes.nullableAnyType) + override val NULLABLE_NOTHING: KtType by cachedBuiltin(builtinTypes.nullableNothingType) + + private fun cachedBuiltin(builtinTypeRef: FirImplicitBuiltinTypeRef) = cached { + KtFirClassType(builtinTypeRef.type as ConeClassLikeTypeImpl, token, builder) // TODO builder leaking + } +} \ No newline at end of file diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirTypeProvider.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirTypeProvider.kt index 00396705548..20dd0dd1c39 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirTypeProvider.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirTypeProvider.kt @@ -15,6 +15,7 @@ import org.jetbrains.kotlin.fir.types.coneType import org.jetbrains.kotlin.idea.fir.low.level.api.api.getOrBuildFirOfType import org.jetbrains.kotlin.idea.frontend.api.ValidityToken import org.jetbrains.kotlin.idea.frontend.api.assertIsValid +import org.jetbrains.kotlin.idea.frontend.api.components.KtBuiltinTypes import org.jetbrains.kotlin.idea.frontend.api.components.KtTypeProvider import org.jetbrains.kotlin.idea.frontend.api.fir.KtFirAnalysisSession import org.jetbrains.kotlin.idea.frontend.api.fir.types.KtFirType @@ -85,6 +86,9 @@ internal class KtFirTypeProvider( type.coneType.isBuiltinFunctionalType(analysisSession.firResolveState.rootModuleSession) //TODO use correct session here } + override val builtinTypes: KtBuiltinTypes = + KtFirBuiltInTypes(analysisSession.firResolveState.rootModuleSession.builtinTypes, analysisSession.firSymbolBuilder, token) + private fun createTypeCheckerContext() = ConeTypeCheckerContext( isErrorTypeEqualsToAnything = true, isStubTypeEqualsToAnything = true, From b16ebe2dc4df6f145760471e1e6c4de44568201b Mon Sep 17 00:00:00 2001 From: Ilya Kirillov Date: Sun, 13 Dec 2020 12:55:08 +0100 Subject: [PATCH 039/196] FIR IDE: consider if & while conditions expected type as boolean --- .../api/fir/components/KtFirTypeProvider.kt | 50 ++++++++++++++----- .../expectedExpressionType/ifCondition.kt | 5 ++ .../ifConditionQualified.kt | 5 ++ .../expectedExpressionType/whileCondition.kt | 5 ++ .../whileConditionQualified.kt | 5 ++ .../ExpectedExpressionTypeTestGenerated.java | 20 ++++++++ 6 files changed, 77 insertions(+), 13 deletions(-) create mode 100644 idea/idea-frontend-fir/testData/components/expectedExpressionType/ifCondition.kt create mode 100644 idea/idea-frontend-fir/testData/components/expectedExpressionType/ifConditionQualified.kt create mode 100644 idea/idea-frontend-fir/testData/components/expectedExpressionType/whileCondition.kt create mode 100644 idea/idea-frontend-fir/testData/components/expectedExpressionType/whileConditionQualified.kt diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirTypeProvider.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirTypeProvider.kt index 20dd0dd1c39..674bbb05689 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirTypeProvider.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirTypeProvider.kt @@ -6,7 +6,6 @@ package org.jetbrains.kotlin.idea.frontend.api.fir.components import com.intellij.psi.PsiElement -import com.intellij.psi.util.parentOfType import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.resolve.inference.isBuiltinFunctionalType @@ -21,12 +20,10 @@ import org.jetbrains.kotlin.idea.frontend.api.fir.KtFirAnalysisSession import org.jetbrains.kotlin.idea.frontend.api.fir.types.KtFirType import org.jetbrains.kotlin.idea.frontend.api.types.KtType import org.jetbrains.kotlin.idea.frontend.api.withValidityAssertion -import org.jetbrains.kotlin.psi.KtDeclaration -import org.jetbrains.kotlin.psi.KtExpression -import org.jetbrains.kotlin.psi.KtQualifiedExpression -import org.jetbrains.kotlin.psi.KtReturnExpression +import org.jetbrains.kotlin.psi.* import org.jetbrains.kotlin.types.AbstractTypeChecker import org.jetbrains.kotlin.types.AbstractTypeCheckerContext +import kotlin.reflect.KClass internal class KtFirTypeProvider( override val analysisSession: KtFirAnalysisSession, @@ -43,6 +40,7 @@ internal class KtFirTypeProvider( override fun getExpectedType(expression: PsiElement): KtType? = getExpectedTypeByReturnExpression(expression) + ?: getExpressionTypeByIfOrBooleanCondition(expression) private fun getExpectedTypeByReturnExpression(expression: PsiElement): KtType? { val returnParent = expression.getReturnExpressionWithThisType() ?: return null @@ -50,15 +48,20 @@ internal class KtFirTypeProvider( return targetSymbol.type } - private fun PsiElement.getReturnExpressionWithThisType(): KtReturnExpression? { - val parent = parent - return when { - parent is KtReturnExpression && parent.returnedExpression == this -> parent - parent is KtQualifiedExpression && parent.selectorExpression == this -> parent.getReturnExpressionWithThisType() - else -> null - } + private fun PsiElement.getReturnExpressionWithThisType(): KtReturnExpression? = + unwrapQualified { returnExpr, target -> returnExpr.returnedExpression == target } + + private fun getExpressionTypeByIfOrBooleanCondition(expression: PsiElement): KtType? = when { + expression.isWhileLoopCondition() || expression.isIfCondition() -> builtinTypes.BOOLEAN + else -> null } + private fun PsiElement.isWhileLoopCondition() = + unwrapQualified { whileExpr, cond -> whileExpr.condition == cond } != null + + private fun PsiElement.isIfCondition() = + unwrapQualified { ifExpr, cond -> ifExpr.condition == cond } != null + override fun isEqualTo(first: KtType, second: KtType): Boolean = withValidityAssertion { second.assertIsValid() check(first is KtFirType) @@ -94,4 +97,25 @@ internal class KtFirTypeProvider( isStubTypeEqualsToAnything = true, analysisSession.firResolveState.rootModuleSession //TODO use correct session here ) -} \ No newline at end of file +} + +private inline fun PsiElement.unwrapQualified(check: (R, PsiElement) -> Boolean): R? { + val parent = nonContainerParent + return when { + parent is R && check(parent, this) -> parent + parent is KtQualifiedExpression && parent.selectorExpression == this -> { + val grandParent = parent.nonContainerParent + when { + grandParent is R && check(grandParent, parent) -> grandParent + else -> null + } + } + else -> null + } +} + +private val PsiElement.nonContainerParent: PsiElement? + get() = when (val parent = parent) { + is KtContainerNode -> parent.parent + else -> parent + } \ No newline at end of file diff --git a/idea/idea-frontend-fir/testData/components/expectedExpressionType/ifCondition.kt b/idea/idea-frontend-fir/testData/components/expectedExpressionType/ifCondition.kt new file mode 100644 index 00000000000..d375d652d08 --- /dev/null +++ b/idea/idea-frontend-fir/testData/components/expectedExpressionType/ifCondition.kt @@ -0,0 +1,5 @@ +fun x() { + if(xy){ +} + +// EXPECTED_TYPE: kotlin/Boolean \ No newline at end of file diff --git a/idea/idea-frontend-fir/testData/components/expectedExpressionType/ifConditionQualified.kt b/idea/idea-frontend-fir/testData/components/expectedExpressionType/ifConditionQualified.kt new file mode 100644 index 00000000000..a7153790034 --- /dev/null +++ b/idea/idea-frontend-fir/testData/components/expectedExpressionType/ifConditionQualified.kt @@ -0,0 +1,5 @@ +fun x() { + if(x.fdfd){ +} + +// EXPECTED_TYPE: kotlin/Boolean \ No newline at end of file diff --git a/idea/idea-frontend-fir/testData/components/expectedExpressionType/whileCondition.kt b/idea/idea-frontend-fir/testData/components/expectedExpressionType/whileCondition.kt new file mode 100644 index 00000000000..3dadaff806a --- /dev/null +++ b/idea/idea-frontend-fir/testData/components/expectedExpressionType/whileCondition.kt @@ -0,0 +1,5 @@ +fun x() { + while(xy){ +} + +// EXPECTED_TYPE: kotlin/Boolean \ No newline at end of file diff --git a/idea/idea-frontend-fir/testData/components/expectedExpressionType/whileConditionQualified.kt b/idea/idea-frontend-fir/testData/components/expectedExpressionType/whileConditionQualified.kt new file mode 100644 index 00000000000..080a09ca2b0 --- /dev/null +++ b/idea/idea-frontend-fir/testData/components/expectedExpressionType/whileConditionQualified.kt @@ -0,0 +1,5 @@ +fun x() { + while(x.fdfd){ +} + +// EXPECTED_TYPE: kotlin/Boolean \ No newline at end of file diff --git a/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/components/ExpectedExpressionTypeTestGenerated.java b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/components/ExpectedExpressionTypeTestGenerated.java index 42c954b9116..d10b77e8801 100644 --- a/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/components/ExpectedExpressionTypeTestGenerated.java +++ b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/components/ExpectedExpressionTypeTestGenerated.java @@ -28,6 +28,16 @@ public class ExpectedExpressionTypeTestGenerated extends AbstractExpectedExpress KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-frontend-fir/testData/components/expectedExpressionType"), Pattern.compile("^(.+)\\.kt$"), null, true); } + @TestMetadata("ifCondition.kt") + public void testIfCondition() throws Exception { + runTest("idea/idea-frontend-fir/testData/components/expectedExpressionType/ifCondition.kt"); + } + + @TestMetadata("ifConditionQualified.kt") + public void testIfConditionQualified() throws Exception { + runTest("idea/idea-frontend-fir/testData/components/expectedExpressionType/ifConditionQualified.kt"); + } + @TestMetadata("returnFromFunction.kt") public void testReturnFromFunction() throws Exception { runTest("idea/idea-frontend-fir/testData/components/expectedExpressionType/returnFromFunction.kt"); @@ -47,4 +57,14 @@ public class ExpectedExpressionTypeTestGenerated extends AbstractExpectedExpress public void testReturnFromLambda() throws Exception { runTest("idea/idea-frontend-fir/testData/components/expectedExpressionType/returnFromLambda.kt"); } + + @TestMetadata("whileCondition.kt") + public void testWhileCondition() throws Exception { + runTest("idea/idea-frontend-fir/testData/components/expectedExpressionType/whileCondition.kt"); + } + + @TestMetadata("whileConditionQualified.kt") + public void testWhileConditionQualified() throws Exception { + runTest("idea/idea-frontend-fir/testData/components/expectedExpressionType/whileConditionQualified.kt"); + } } From 7be8d69870f45b3f384b234217287f8cf1a44cff Mon Sep 17 00:00:00 2001 From: Ilya Kirillov Date: Sun, 13 Dec 2020 17:57:30 +0100 Subject: [PATCH 040/196] FIR IDE: add completion weighers tests for return/if/while --- .../expectedType/ifConditionQualified.kt | 18 +++++++++ .../basic/expectedType/returnFromFunction.kt | 13 +++++++ .../returnFromFunctionQualifiedSelector.kt | 17 +++++++++ .../basic/expectedType/returnFromLambda.kt | 17 +++++++++ .../expectedType/whileConditionQualified.kt | 18 +++++++++ .../BasicCompletionWeigherTestGenerated.java | 38 +++++++++++++++++++ .../HighLevelWeigherTestGenerated.java | 38 +++++++++++++++++++ 7 files changed, 159 insertions(+) create mode 100644 idea/idea-completion/testData/weighers/basic/expectedType/ifConditionQualified.kt create mode 100644 idea/idea-completion/testData/weighers/basic/expectedType/returnFromFunction.kt create mode 100644 idea/idea-completion/testData/weighers/basic/expectedType/returnFromFunctionQualifiedSelector.kt create mode 100644 idea/idea-completion/testData/weighers/basic/expectedType/returnFromLambda.kt create mode 100644 idea/idea-completion/testData/weighers/basic/expectedType/whileConditionQualified.kt diff --git a/idea/idea-completion/testData/weighers/basic/expectedType/ifConditionQualified.kt b/idea/idea-completion/testData/weighers/basic/expectedType/ifConditionQualified.kt new file mode 100644 index 00000000000..67d548e7b90 --- /dev/null +++ b/idea/idea-completion/testData/weighers/basic/expectedType/ifConditionQualified.kt @@ -0,0 +1,18 @@ +// FIR_COMPARISON + +object x { + val b: Boolean = true + val c: String = "true" + val d: Int = 1 + val e: Long = 1L + val f: Boolean = true + + fun foo(): Boolean = true +} + + +fun test() { + if(x.){ +} + +// ORDER: b, f, foo \ No newline at end of file diff --git a/idea/idea-completion/testData/weighers/basic/expectedType/returnFromFunction.kt b/idea/idea-completion/testData/weighers/basic/expectedType/returnFromFunction.kt new file mode 100644 index 00000000000..3ce0a0dce4b --- /dev/null +++ b/idea/idea-completion/testData/weighers/basic/expectedType/returnFromFunction.kt @@ -0,0 +1,13 @@ +val b: Boolean = true +val c: String = "true" +val d: Int = 1 +val e: Long = 1L +val f: Boolean = true + +fun foo(): Boolean + +fun test(): Int { + return +} + +//ORDER: test, d \ No newline at end of file diff --git a/idea/idea-completion/testData/weighers/basic/expectedType/returnFromFunctionQualifiedSelector.kt b/idea/idea-completion/testData/weighers/basic/expectedType/returnFromFunctionQualifiedSelector.kt new file mode 100644 index 00000000000..df342ebe47d --- /dev/null +++ b/idea/idea-completion/testData/weighers/basic/expectedType/returnFromFunctionQualifiedSelector.kt @@ -0,0 +1,17 @@ +// FIR_COMPARISON + +object x { + val b: Boolean = true + val c: String = "true" + val d: Int = 1 + val e: Long = 1L + val f: Boolean = true + + fun foo(): Int +} + +fun test(): Int { + return x. +} + +//ORDER: d, foo, f \ No newline at end of file diff --git a/idea/idea-completion/testData/weighers/basic/expectedType/returnFromLambda.kt b/idea/idea-completion/testData/weighers/basic/expectedType/returnFromLambda.kt new file mode 100644 index 00000000000..289e1935ed5 --- /dev/null +++ b/idea/idea-completion/testData/weighers/basic/expectedType/returnFromLambda.kt @@ -0,0 +1,17 @@ +// FIR_COMPARISON + +val a: Int +val b: String +val c: Long +val d: Int + +fun test(): Int { + receiveLambda { + return@receiveLambda + } + return 2 +} + +fun receiveLambda(x: () -> Int){} + +// ORDER: a, d, test \ No newline at end of file diff --git a/idea/idea-completion/testData/weighers/basic/expectedType/whileConditionQualified.kt b/idea/idea-completion/testData/weighers/basic/expectedType/whileConditionQualified.kt new file mode 100644 index 00000000000..bd75fcaa56c --- /dev/null +++ b/idea/idea-completion/testData/weighers/basic/expectedType/whileConditionQualified.kt @@ -0,0 +1,18 @@ +// FIR_COMPARISON + +object x { + val b: Boolean = true + val c: String = "true" + val d: Int = 1 + val e: Long = 1L + val f: Boolean = true + + fun foo(): Boolean = true +} + + +fun x() { + while(x.){ +} + +// ORDER: b, f, foo \ No newline at end of file diff --git a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/weighers/BasicCompletionWeigherTestGenerated.java b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/weighers/BasicCompletionWeigherTestGenerated.java index 471eb610940..161db59f2cb 100644 --- a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/weighers/BasicCompletionWeigherTestGenerated.java +++ b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/weighers/BasicCompletionWeigherTestGenerated.java @@ -485,6 +485,44 @@ public class BasicCompletionWeigherTestGenerated extends AbstractBasicCompletion } } + @TestMetadata("idea/idea-completion/testData/weighers/basic/expectedType") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ExpectedType extends AbstractBasicCompletionWeigherTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); + } + + public void testAllFilesPresentInExpectedType() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/weighers/basic/expectedType"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); + } + + @TestMetadata("ifConditionQualified.kt") + public void testIfConditionQualified() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/expectedType/ifConditionQualified.kt"); + } + + @TestMetadata("returnFromFunction.kt") + public void testReturnFromFunction() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/expectedType/returnFromFunction.kt"); + } + + @TestMetadata("returnFromFunctionQualifiedSelector.kt") + public void testReturnFromFunctionQualifiedSelector() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/expectedType/returnFromFunctionQualifiedSelector.kt"); + } + + @TestMetadata("returnFromLambda.kt") + public void testReturnFromLambda() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/expectedType/returnFromLambda.kt"); + } + + @TestMetadata("whileConditionQualified.kt") + public void testWhileConditionQualified() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/expectedType/whileConditionQualified.kt"); + } + } + @TestMetadata("idea/idea-completion/testData/weighers/basic/parameterNameAndType") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) diff --git a/idea/idea-fir/tests/org/jetbrains/kotlin/idea/completion/wheigher/HighLevelWeigherTestGenerated.java b/idea/idea-fir/tests/org/jetbrains/kotlin/idea/completion/wheigher/HighLevelWeigherTestGenerated.java index 1db3ed5d37a..cce33472ca0 100644 --- a/idea/idea-fir/tests/org/jetbrains/kotlin/idea/completion/wheigher/HighLevelWeigherTestGenerated.java +++ b/idea/idea-fir/tests/org/jetbrains/kotlin/idea/completion/wheigher/HighLevelWeigherTestGenerated.java @@ -485,6 +485,44 @@ public class HighLevelWeigherTestGenerated extends AbstractHighLevelWeigherTest } } + @TestMetadata("idea/idea-completion/testData/weighers/basic/expectedType") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ExpectedType extends AbstractHighLevelWeigherTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); + } + + public void testAllFilesPresentInExpectedType() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/weighers/basic/expectedType"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); + } + + @TestMetadata("ifConditionQualified.kt") + public void testIfConditionQualified() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/expectedType/ifConditionQualified.kt"); + } + + @TestMetadata("returnFromFunction.kt") + public void testReturnFromFunction() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/expectedType/returnFromFunction.kt"); + } + + @TestMetadata("returnFromFunctionQualifiedSelector.kt") + public void testReturnFromFunctionQualifiedSelector() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/expectedType/returnFromFunctionQualifiedSelector.kt"); + } + + @TestMetadata("returnFromLambda.kt") + public void testReturnFromLambda() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/expectedType/returnFromLambda.kt"); + } + + @TestMetadata("whileConditionQualified.kt") + public void testWhileConditionQualified() throws Exception { + runTest("idea/idea-completion/testData/weighers/basic/expectedType/whileConditionQualified.kt"); + } + } + @TestMetadata("idea/idea-completion/testData/weighers/basic/parameterNameAndType") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) From 2101816f032504826bdbc895387d50ff263f2425 Mon Sep 17 00:00:00 2001 From: Ilya Kirillov Date: Sun, 13 Dec 2020 21:17:11 +0100 Subject: [PATCH 041/196] FIR IDE: add expected type calculation for function calls does not work in case of incomplete call expression :( --- idea/idea-frontend-fir/build.gradle.kts | 1 + .../api/fir/components/KtFirTypeProvider.kt | 27 +++++++++++++++++++ .../functionLambdaParam.kt | 7 +++++ .../functionNamedlParam.kt | 9 +++++++ .../functionParamWithTypeParam.kt | 9 +++++++ .../functionPositionalParam.kt | 7 +++++ .../AbstractExpectedExpressionTypeTest.kt | 5 +++- .../ExpectedExpressionTypeTestGenerated.java | 20 ++++++++++++++ .../kotlin/test/uitls/IgnoreTests.kt | 10 +++++++ 9 files changed, 94 insertions(+), 1 deletion(-) create mode 100644 idea/idea-frontend-fir/testData/components/expectedExpressionType/functionLambdaParam.kt create mode 100644 idea/idea-frontend-fir/testData/components/expectedExpressionType/functionNamedlParam.kt create mode 100644 idea/idea-frontend-fir/testData/components/expectedExpressionType/functionParamWithTypeParam.kt create mode 100644 idea/idea-frontend-fir/testData/components/expectedExpressionType/functionPositionalParam.kt diff --git a/idea/idea-frontend-fir/build.gradle.kts b/idea/idea-frontend-fir/build.gradle.kts index 1f29a646041..b38c1a826f8 100644 --- a/idea/idea-frontend-fir/build.gradle.kts +++ b/idea/idea-frontend-fir/build.gradle.kts @@ -32,6 +32,7 @@ dependencies { testCompile(projectTests(":idea:idea-test-framework")) testCompile(project(":kotlin-test:kotlin-test-junit")) testCompile(commonDep("junit:junit")) + testCompile(projectTests(":idea:idea-frontend-independent")) compile(intellijPluginDep("java")) } diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirTypeProvider.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirTypeProvider.kt index 674bbb05689..780100b9a61 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirTypeProvider.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirTypeProvider.kt @@ -6,12 +6,19 @@ package org.jetbrains.kotlin.idea.frontend.api.fir.components import com.intellij.psi.PsiElement +import com.jetbrains.rd.util.firstOrNull import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration +import org.jetbrains.kotlin.fir.expressions.FirCall import org.jetbrains.kotlin.fir.expressions.FirExpression +import org.jetbrains.kotlin.fir.expressions.FirFunctionCall +import org.jetbrains.kotlin.fir.expressions.argumentMapping +import org.jetbrains.kotlin.fir.psi import org.jetbrains.kotlin.fir.resolve.inference.isBuiltinFunctionalType import org.jetbrains.kotlin.fir.types.ConeTypeCheckerContext import org.jetbrains.kotlin.fir.types.coneType +import org.jetbrains.kotlin.idea.fir.low.level.api.api.getOrBuildFir import org.jetbrains.kotlin.idea.fir.low.level.api.api.getOrBuildFirOfType +import org.jetbrains.kotlin.idea.fir.low.level.api.api.getOrBuildFirSafe import org.jetbrains.kotlin.idea.frontend.api.ValidityToken import org.jetbrains.kotlin.idea.frontend.api.assertIsValid import org.jetbrains.kotlin.idea.frontend.api.components.KtBuiltinTypes @@ -23,6 +30,7 @@ import org.jetbrains.kotlin.idea.frontend.api.withValidityAssertion import org.jetbrains.kotlin.psi.* import org.jetbrains.kotlin.types.AbstractTypeChecker import org.jetbrains.kotlin.types.AbstractTypeCheckerContext +import org.jetbrains.kotlin.utils.addToStdlib.firstNotNullResult import kotlin.reflect.KClass internal class KtFirTypeProvider( @@ -41,6 +49,23 @@ internal class KtFirTypeProvider( override fun getExpectedType(expression: PsiElement): KtType? = getExpectedTypeByReturnExpression(expression) ?: getExpressionTypeByIfOrBooleanCondition(expression) + ?: getExpectedTypeOfFunctionParameter(expression) + + private fun getExpectedTypeOfFunctionParameter(expression: PsiElement): KtType? { + val (ktCallExpression, ktArgument) = expression.getFunctionCallAsWithThisAsParameter() ?: return null + val firCall = ktCallExpression.getOrBuildFirSafe(firResolveState) ?: return null + val arguments = firCall.argumentMapping ?: return null + val firParameterForExpression = arguments.entries.firstOrNull { (arg, _) -> arg.psi == ktArgument }?.value ?: return null + return firParameterForExpression.returnTypeRef.coneType.asKtType() + } + + private fun PsiElement.getFunctionCallAsWithThisAsParameter(): KtCallWithArgument? { + val valueArgument = unwrapQualified { valueArg, expr -> valueArg.getArgumentExpression() == expr } ?: return null + val argumentsList = valueArgument.parent as? KtValueArgumentList ?: return null + val callExpression = argumentsList.parent as? KtCallExpression ?: return null + val argumentExpression = valueArgument.getArgumentExpression() ?: return null + return KtCallWithArgument(callExpression, argumentExpression) + } private fun getExpectedTypeByReturnExpression(expression: PsiElement): KtType? { val returnParent = expression.getReturnExpressionWithThisType() ?: return null @@ -99,6 +124,8 @@ internal class KtFirTypeProvider( ) } +private data class KtCallWithArgument(val call: KtCallExpression, val argument: KtExpression) + private inline fun PsiElement.unwrapQualified(check: (R, PsiElement) -> Boolean): R? { val parent = nonContainerParent return when { diff --git a/idea/idea-frontend-fir/testData/components/expectedExpressionType/functionLambdaParam.kt b/idea/idea-frontend-fir/testData/components/expectedExpressionType/functionLambdaParam.kt new file mode 100644 index 00000000000..75012a111d0 --- /dev/null +++ b/idea/idea-frontend-fir/testData/components/expectedExpressionType/functionLambdaParam.kt @@ -0,0 +1,7 @@ +fun x() { + toCall(1, "", av) +} + +fun toCall(x: Int, y: String, lambda: (Int) -> String): Char = 'a' + +// EXPECTED_TYPE: kotlin/Function1 \ No newline at end of file diff --git a/idea/idea-frontend-fir/testData/components/expectedExpressionType/functionNamedlParam.kt b/idea/idea-frontend-fir/testData/components/expectedExpressionType/functionNamedlParam.kt new file mode 100644 index 00000000000..4f4cb4940b9 --- /dev/null +++ b/idea/idea-frontend-fir/testData/components/expectedExpressionType/functionNamedlParam.kt @@ -0,0 +1,9 @@ +// FIX_ME: should work on non fully resolved calls + +fun x() { + toCall(1, z = av) +} + +fun toCall(x: Int, y: String, z: Boolean): Char = 'a' + +// EXPECTED_TYPE: kotlin/Boolean \ No newline at end of file diff --git a/idea/idea-frontend-fir/testData/components/expectedExpressionType/functionParamWithTypeParam.kt b/idea/idea-frontend-fir/testData/components/expectedExpressionType/functionParamWithTypeParam.kt new file mode 100644 index 00000000000..534126ea8cb --- /dev/null +++ b/idea/idea-frontend-fir/testData/components/expectedExpressionType/functionParamWithTypeParam.kt @@ -0,0 +1,9 @@ +// FIX_ME: should work on non fully resolved calls + +fun x() { + toCall(ab, 12) +} + +fun toCall(x: T, y: T): Char = 'a' + +// EXPECTED_TYPE: kotlin/Int \ No newline at end of file diff --git a/idea/idea-frontend-fir/testData/components/expectedExpressionType/functionPositionalParam.kt b/idea/idea-frontend-fir/testData/components/expectedExpressionType/functionPositionalParam.kt new file mode 100644 index 00000000000..b2ec3c58e29 --- /dev/null +++ b/idea/idea-frontend-fir/testData/components/expectedExpressionType/functionPositionalParam.kt @@ -0,0 +1,7 @@ +fun x() { + toCall(1, av, true) +} + +fun toCall(x: Int, y: String, z: Boolean): Char = 'a' + +// EXPECTED_TYPE: kotlin/String \ No newline at end of file diff --git a/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/components/AbstractExpectedExpressionTypeTest.kt b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/components/AbstractExpectedExpressionTypeTest.kt index 36fa7a84a0b..a6e22a9b354 100644 --- a/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/components/AbstractExpectedExpressionTypeTest.kt +++ b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/components/AbstractExpectedExpressionTypeTest.kt @@ -19,6 +19,7 @@ import org.jetbrains.kotlin.psi.KtReturnExpression import org.jetbrains.kotlin.psi.psiUtil.forEachDescendantOfType import org.jetbrains.kotlin.test.InTextDirectivesUtils import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.uitls.IgnoreTests import java.io.File abstract class AbstractExpectedExpressionTypeTest : KotlinLightCodeInsightFixtureTestCase() { @@ -37,7 +38,9 @@ abstract class AbstractExpectedExpressionTypeTest : KotlinLightCodeInsightFixtur } } - KotlinTestUtils.assertEqualsToFile(File(path), testDataFile.getTextWithActualType(actualExpectedTypeText)) + IgnoreTests.runTestWithFixMeSupport(testDataFile.toPath()) { + KotlinTestUtils.assertEqualsToFile(File(path), testDataFile.getTextWithActualType(actualExpectedTypeText)) + } } private fun File.getTextWithActualType(actualType: String?) : String { diff --git a/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/components/ExpectedExpressionTypeTestGenerated.java b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/components/ExpectedExpressionTypeTestGenerated.java index d10b77e8801..b5cf808bcc0 100644 --- a/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/components/ExpectedExpressionTypeTestGenerated.java +++ b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/components/ExpectedExpressionTypeTestGenerated.java @@ -28,6 +28,26 @@ public class ExpectedExpressionTypeTestGenerated extends AbstractExpectedExpress KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-frontend-fir/testData/components/expectedExpressionType"), Pattern.compile("^(.+)\\.kt$"), null, true); } + @TestMetadata("functionLambdaParam.kt") + public void testFunctionLambdaParam() throws Exception { + runTest("idea/idea-frontend-fir/testData/components/expectedExpressionType/functionLambdaParam.kt"); + } + + @TestMetadata("functionNamedlParam.kt") + public void testFunctionNamedlParam() throws Exception { + runTest("idea/idea-frontend-fir/testData/components/expectedExpressionType/functionNamedlParam.kt"); + } + + @TestMetadata("functionParamWithTypeParam.kt") + public void testFunctionParamWithTypeParam() throws Exception { + runTest("idea/idea-frontend-fir/testData/components/expectedExpressionType/functionParamWithTypeParam.kt"); + } + + @TestMetadata("functionPositionalParam.kt") + public void testFunctionPositionalParam() throws Exception { + runTest("idea/idea-frontend-fir/testData/components/expectedExpressionType/functionPositionalParam.kt"); + } + @TestMetadata("ifCondition.kt") public void testIfCondition() throws Exception { runTest("idea/idea-frontend-fir/testData/components/expectedExpressionType/ifCondition.kt"); diff --git a/idea/idea-frontend-independent/tests/org/jetbrains/kotlin/test/uitls/IgnoreTests.kt b/idea/idea-frontend-independent/tests/org/jetbrains/kotlin/test/uitls/IgnoreTests.kt index 54908b64f08..141a03d7403 100644 --- a/idea/idea-frontend-independent/tests/org/jetbrains/kotlin/test/uitls/IgnoreTests.kt +++ b/idea/idea-frontend-independent/tests/org/jetbrains/kotlin/test/uitls/IgnoreTests.kt @@ -27,6 +27,15 @@ object IgnoreTests { ) } + fun runTestWithFixMeSupport(testFile: Path, test: () -> Unit) { + runTestIfEnabledByDirective( + testFile, + EnableOrDisableTestDirective.Disable(DIRECTIVES.FIX_ME), + additionalFilesExtensions = emptyList(), + test = test + ) + } + fun runTestIfNotDisabledByFileDirective( testFile: Path, disableTestDirective: String, @@ -128,5 +137,6 @@ object IgnoreTests { object DIRECTIVES { const val FIR_COMPARISON = "// FIR_COMPARISON" const val IGNORE_FIR = "// IGNORE_FIR" + const val FIX_ME = "// FIX_ME: " } } \ No newline at end of file From 2d5b23b650cbf77f3427950eb703319e8a53d3a9 Mon Sep 17 00:00:00 2001 From: Ilya Kirillov Date: Sun, 13 Dec 2020 21:51:52 +0100 Subject: [PATCH 042/196] FIR IDE: separate KtExpressionTypeProvider into components --- .../idea/frontend/api/KtAnalysisSession.kt | 17 ++- .../components/KtExpressionTypeProvider.kt | 19 +++ .../api/components/KtSubtypingComponent.kt | 13 ++ .../frontend/api/components/KtTypeProvider.kt | 14 +- .../frontend/api/fir/KtFirAnalysisSession.kt | 4 +- .../KtFirAnalysisSessionComponent.kt | 7 + .../components/KtFirExpressionTypeProvider.kt | 107 ++++++++++++++++ .../components/KtFirSubtyppingComponent.kt | 43 +++++++ .../api/fir/components/KtFirTypeProvider.kt | 120 ------------------ 9 files changed, 205 insertions(+), 139 deletions(-) create mode 100644 idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/components/KtExpressionTypeProvider.kt create mode 100644 idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/components/KtSubtypingComponent.kt create mode 100644 idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirExpressionTypeProvider.kt create mode 100644 idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirSubtyppingComponent.kt diff --git a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/KtAnalysisSession.kt b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/KtAnalysisSession.kt index 688f75077a8..52284ebdf37 100644 --- a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/KtAnalysisSession.kt +++ b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/KtAnalysisSession.kt @@ -36,7 +36,6 @@ import org.jetbrains.kotlin.psi.* */ abstract class KtAnalysisSession(final override val token: ValidityToken) : ValidityTokenOwner { protected abstract val smartCastProvider: KtSmartCastProvider - protected abstract val typeProvider: KtTypeProvider protected abstract val diagnosticProvider: KtDiagnosticProvider protected abstract val scopeProvider: KtScopeProvider protected abstract val containingDeclarationProvider: KtSymbolContainingDeclarationProvider @@ -45,7 +44,11 @@ abstract class KtAnalysisSession(final override val token: ValidityToken) : Vali protected abstract val completionCandidateChecker: KtCompletionCandidateChecker protected abstract val symbolDeclarationOverridesProvider: KtSymbolDeclarationOverridesProvider @Suppress("LeakingThis") + protected open val typeRenderer: KtTypeRenderer = KtDefaultTypeRenderer(this, token) + protected abstract val expressionTypeProvider: KtExpressionTypeProvider + protected abstract val typeProvider: KtTypeProvider + protected abstract val subtypingComponent: KtSubtypingComponent protected abstract val expressionHandlingComponent: KtExpressionHandlingComponent /// TODO: get rid of @@ -59,18 +62,20 @@ abstract class KtAnalysisSession(final override val token: ValidityToken) : Vali fun KtExpression.getImplicitReceiverSmartCasts(): Collection = smartCastProvider.getImplicitReceiverSmartCasts(this) - fun KtExpression.getKtType(): KtType = typeProvider.getKtExpressionType(this) + fun KtExpression.getKtType(): KtType = expressionTypeProvider.getKtExpressionType(this) - fun KtDeclaration.getReturnKtType(): KtType = typeProvider.getReturnTypeForKtDeclaration(this) + fun KtDeclaration.getReturnKtType(): KtType = expressionTypeProvider.getReturnTypeForKtDeclaration(this) - infix fun KtType.isEqualTo(other: KtType): Boolean = typeProvider.isEqualTo(this, other) + infix fun KtType.isEqualTo(other: KtType): Boolean = subtypingComponent.isEqualTo(this, other) - infix fun KtType.isSubTypeOf(superType: KtType): Boolean = typeProvider.isSubTypeOf(this, superType) + infix fun KtType.isSubTypeOf(superType: KtType): Boolean = subtypingComponent.isSubTypeOf(this, superType) - fun PsiElement.getExpectedType(): KtType? = typeProvider.getExpectedType(this) + fun PsiElement.getExpectedType(): KtType? = expressionTypeProvider.getExpectedType(this) fun KtType.isBuiltInFunctionalType(): Boolean = typeProvider.isBuiltinFunctionalType(this) + val builtinTypes: KtBuiltinTypes get() = typeProvider.builtinTypes + fun KtElement.getDiagnostics(): Collection = diagnosticProvider.getDiagnosticsForElement(this) fun KtFile.collectDiagnosticsForFile(): Collection = diagnosticProvider.collectDiagnosticsForFile(this) diff --git a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/components/KtExpressionTypeProvider.kt b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/components/KtExpressionTypeProvider.kt new file mode 100644 index 00000000000..5a4de47792b --- /dev/null +++ b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/components/KtExpressionTypeProvider.kt @@ -0,0 +1,19 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.idea.frontend.api.components + +import com.intellij.psi.PsiElement +import org.jetbrains.kotlin.idea.frontend.api.ValidityTokenOwner +import org.jetbrains.kotlin.idea.frontend.api.types.KtType +import org.jetbrains.kotlin.psi.KtDeclaration +import org.jetbrains.kotlin.psi.KtExpression + +abstract class KtExpressionTypeProvider : KtAnalysisSessionComponent() { + abstract fun getReturnTypeForKtDeclaration(declaration: KtDeclaration): KtType + abstract fun getKtExpressionType(expression: KtExpression): KtType + + abstract fun getExpectedType(expression: PsiElement): KtType? +} diff --git a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/components/KtSubtypingComponent.kt b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/components/KtSubtypingComponent.kt new file mode 100644 index 00000000000..58c0e33ef24 --- /dev/null +++ b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/components/KtSubtypingComponent.kt @@ -0,0 +1,13 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.idea.frontend.api.components + +import org.jetbrains.kotlin.idea.frontend.api.types.KtType + +abstract class KtSubtypingComponent : KtAnalysisSessionComponent() { + abstract fun isEqualTo(first: KtType, second: KtType): Boolean + abstract fun isSubTypeOf(subType: KtType, superType: KtType): Boolean +} \ No newline at end of file diff --git a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/components/KtTypeProvider.kt b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/components/KtTypeProvider.kt index e30578fb31e..4d01d8f7bad 100644 --- a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/components/KtTypeProvider.kt +++ b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/components/KtTypeProvider.kt @@ -5,27 +5,17 @@ package org.jetbrains.kotlin.idea.frontend.api.components -import com.intellij.psi.PsiElement import org.jetbrains.kotlin.idea.frontend.api.ValidityTokenOwner import org.jetbrains.kotlin.idea.frontend.api.types.KtType -import org.jetbrains.kotlin.psi.KtDeclaration -import org.jetbrains.kotlin.psi.KtExpression abstract class KtTypeProvider : KtAnalysisSessionComponent() { - abstract fun getReturnTypeForKtDeclaration(declaration: KtDeclaration): KtType - abstract fun getKtExpressionType(expression: KtExpression): KtType - - abstract fun isEqualTo(first: KtType, second: KtType): Boolean - abstract fun isSubTypeOf(subType: KtType, superType: KtType): Boolean - - //TODO get rid of + //TODO get rid of it abstract fun isBuiltinFunctionalType(type: KtType): Boolean - abstract fun getExpectedType(expression: PsiElement): KtType? - abstract val builtinTypes: KtBuiltinTypes } + @Suppress("PropertyName") abstract class KtBuiltinTypes : ValidityTokenOwner { abstract val INT: KtType diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/KtFirAnalysisSession.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/KtFirAnalysisSession.kt index e06928dd18f..7b4403293f6 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/KtFirAnalysisSession.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/KtFirAnalysisSession.kt @@ -34,7 +34,7 @@ private constructor( } override val smartCastProvider: KtSmartCastProvider = KtFirSmartcastProvider(this, token) - override val typeProvider: KtTypeProvider = KtFirTypeProvider(this, token) + override val expressionTypeProvider: KtExpressionTypeProvider = KtFirExpressionTypeProvider(this, token) override val diagnosticProvider: KtDiagnosticProvider = KtFirDiagnosticProvider(this, token) override val containingDeclarationProvider = KtFirSymbolContainingDeclarationProvider(this, token) override val callResolver: KtCallResolver = KtFirCallResolver(this, token) @@ -46,6 +46,8 @@ private constructor( KtFirSymbolDeclarationOverridesProvider(this, token) override val expressionHandlingComponent: KtExpressionHandlingComponent = KtFirExpressionHandlingComponent(this, token) + override val typeProvider: KtTypeProvider = KtFirTypeProvider(this, token) + override val subtypingComponent: KtSubtypingComponent = KtFirSubtypingComponent(this, token) override fun createContextDependentCopy(): KtAnalysisSession { check(!isContextSession) { "Cannot create context-dependent copy of KtAnalysis session from a context dependent one" } diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirAnalysisSessionComponent.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirAnalysisSessionComponent.kt index 8087abcbbdc..4690e370358 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirAnalysisSessionComponent.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirAnalysisSessionComponent.kt @@ -6,6 +6,7 @@ package org.jetbrains.kotlin.idea.frontend.api.fir.components import org.jetbrains.kotlin.fir.types.ConeKotlinType +import org.jetbrains.kotlin.fir.types.ConeTypeCheckerContext import org.jetbrains.kotlin.idea.frontend.api.fir.KtFirAnalysisSession internal interface KtFirAnalysisSessionComponent { @@ -14,4 +15,10 @@ internal interface KtFirAnalysisSessionComponent { val firSymbolBuilder get() = analysisSession.firSymbolBuilder val firResolveState get() = analysisSession.firResolveState fun ConeKotlinType.asKtType() = analysisSession.firSymbolBuilder.buildKtType(this) + + fun createTypeCheckerContext() = ConeTypeCheckerContext( + isErrorTypeEqualsToAnything = true, + isStubTypeEqualsToAnything = true, + analysisSession.firResolveState.rootModuleSession //TODO use correct session here + ) } \ No newline at end of file diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirExpressionTypeProvider.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirExpressionTypeProvider.kt new file mode 100644 index 00000000000..bd608b9f2d3 --- /dev/null +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirExpressionTypeProvider.kt @@ -0,0 +1,107 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.idea.frontend.api.fir.components + +import com.intellij.psi.PsiElement +import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration +import org.jetbrains.kotlin.fir.expressions.FirExpression +import org.jetbrains.kotlin.fir.expressions.FirFunctionCall +import org.jetbrains.kotlin.fir.expressions.argumentMapping +import org.jetbrains.kotlin.fir.psi +import org.jetbrains.kotlin.fir.resolve.inference.isBuiltinFunctionalType +import org.jetbrains.kotlin.fir.types.ConeTypeCheckerContext +import org.jetbrains.kotlin.fir.types.coneType +import org.jetbrains.kotlin.idea.fir.low.level.api.api.getOrBuildFirOfType +import org.jetbrains.kotlin.idea.fir.low.level.api.api.getOrBuildFirSafe +import org.jetbrains.kotlin.idea.frontend.api.ValidityToken +import org.jetbrains.kotlin.idea.frontend.api.assertIsValid +import org.jetbrains.kotlin.idea.frontend.api.components.KtBuiltinTypes +import org.jetbrains.kotlin.idea.frontend.api.components.KtExpressionTypeProvider +import org.jetbrains.kotlin.idea.frontend.api.fir.KtFirAnalysisSession +import org.jetbrains.kotlin.idea.frontend.api.fir.types.KtFirType +import org.jetbrains.kotlin.idea.frontend.api.types.KtType +import org.jetbrains.kotlin.idea.frontend.api.withValidityAssertion +import org.jetbrains.kotlin.psi.* +import org.jetbrains.kotlin.types.AbstractTypeChecker +import org.jetbrains.kotlin.types.AbstractTypeCheckerContext + +internal class KtFirExpressionTypeProvider( + override val analysisSession: KtFirAnalysisSession, + override val token: ValidityToken, +) : KtExpressionTypeProvider(), KtFirAnalysisSessionComponent { + override fun getReturnTypeForKtDeclaration(declaration: KtDeclaration): KtType = withValidityAssertion { + val firDeclaration = declaration.getOrBuildFirOfType>(firResolveState) + firDeclaration.returnTypeRef.coneType.asKtType() + } + + override fun getKtExpressionType(expression: KtExpression): KtType = withValidityAssertion { + expression.getOrBuildFirOfType(firResolveState).typeRef.coneType.asKtType() + } + + override fun getExpectedType(expression: PsiElement): KtType? = + getExpectedTypeByReturnExpression(expression) + ?: getExpressionTypeByIfOrBooleanCondition(expression) + ?: getExpectedTypeOfFunctionParameter(expression) + + private fun getExpectedTypeOfFunctionParameter(expression: PsiElement): KtType? { + val (ktCallExpression, ktArgument) = expression.getFunctionCallAsWithThisAsParameter() ?: return null + val firCall = ktCallExpression.getOrBuildFirSafe(firResolveState) ?: return null + val arguments = firCall.argumentMapping ?: return null + val firParameterForExpression = arguments.entries.firstOrNull { (arg, _) -> arg.psi == ktArgument }?.value ?: return null + return firParameterForExpression.returnTypeRef.coneType.asKtType() + } + + private fun PsiElement.getFunctionCallAsWithThisAsParameter(): KtCallWithArgument? { + val valueArgument = unwrapQualified { valueArg, expr -> valueArg.getArgumentExpression() == expr } ?: return null + val argumentsList = valueArgument.parent as? KtValueArgumentList ?: return null + val callExpression = argumentsList.parent as? KtCallExpression ?: return null + val argumentExpression = valueArgument.getArgumentExpression() ?: return null + return KtCallWithArgument(callExpression, argumentExpression) + } + + private fun getExpectedTypeByReturnExpression(expression: PsiElement): KtType? { + val returnParent = expression.getReturnExpressionWithThisType() ?: return null + val targetSymbol = with(analysisSession) { returnParent.getReturnTargetSymbol() } ?: return null + return targetSymbol.type + } + + private fun PsiElement.getReturnExpressionWithThisType(): KtReturnExpression? = + unwrapQualified { returnExpr, target -> returnExpr.returnedExpression == target } + + private fun getExpressionTypeByIfOrBooleanCondition(expression: PsiElement): KtType? = when { + expression.isWhileLoopCondition() || expression.isIfCondition() -> with(analysisSession) { builtinTypes.BOOLEAN } + else -> null + } + + private fun PsiElement.isWhileLoopCondition() = + unwrapQualified { whileExpr, cond -> whileExpr.condition == cond } != null + + private fun PsiElement.isIfCondition() = + unwrapQualified { ifExpr, cond -> ifExpr.condition == cond } != null +} + +private data class KtCallWithArgument(val call: KtCallExpression, val argument: KtExpression) + +private inline fun PsiElement.unwrapQualified(check: (R, PsiElement) -> Boolean): R? { + val parent = nonContainerParent + return when { + parent is R && check(parent, this) -> parent + parent is KtQualifiedExpression && parent.selectorExpression == this -> { + val grandParent = parent.nonContainerParent + when { + grandParent is R && check(grandParent, parent) -> grandParent + else -> null + } + } + else -> null + } +} + +private val PsiElement.nonContainerParent: PsiElement? + get() = when (val parent = parent) { + is KtContainerNode -> parent.parent + else -> parent + } \ No newline at end of file diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirSubtyppingComponent.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirSubtyppingComponent.kt new file mode 100644 index 00000000000..f3ea0ceb07f --- /dev/null +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirSubtyppingComponent.kt @@ -0,0 +1,43 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.idea.frontend.api.fir.components + +import org.jetbrains.kotlin.idea.frontend.api.ValidityToken +import org.jetbrains.kotlin.idea.frontend.api.assertIsValid +import org.jetbrains.kotlin.idea.frontend.api.components.KtSubtypingComponent +import org.jetbrains.kotlin.idea.frontend.api.fir.KtFirAnalysisSession +import org.jetbrains.kotlin.idea.frontend.api.fir.types.KtFirType +import org.jetbrains.kotlin.idea.frontend.api.types.KtType +import org.jetbrains.kotlin.idea.frontend.api.withValidityAssertion +import org.jetbrains.kotlin.types.AbstractTypeChecker +import org.jetbrains.kotlin.types.AbstractTypeCheckerContext + +internal class KtFirSubtypingComponent( + override val analysisSession: KtFirAnalysisSession, + override val token: ValidityToken, +) : KtSubtypingComponent(), KtFirAnalysisSessionComponent { + override fun isEqualTo(first: KtType, second: KtType): Boolean = withValidityAssertion { + second.assertIsValid() + check(first is KtFirType) + check(second is KtFirType) + return AbstractTypeChecker.equalTypes( + createTypeCheckerContext() as AbstractTypeCheckerContext, + first.coneType, + second.coneType + ) + } + + override fun isSubTypeOf(subType: KtType, superType: KtType): Boolean = withValidityAssertion { + superType.assertIsValid() + check(subType is KtFirType) + check(superType is KtFirType) + return AbstractTypeChecker.isSubtypeOf( + createTypeCheckerContext() as AbstractTypeCheckerContext, + subType.coneType, + superType.coneType + ) + } +} diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirTypeProvider.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirTypeProvider.kt index 780100b9a61..9752bf206ea 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirTypeProvider.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirTypeProvider.kt @@ -5,110 +5,19 @@ package org.jetbrains.kotlin.idea.frontend.api.fir.components -import com.intellij.psi.PsiElement -import com.jetbrains.rd.util.firstOrNull -import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration -import org.jetbrains.kotlin.fir.expressions.FirCall -import org.jetbrains.kotlin.fir.expressions.FirExpression -import org.jetbrains.kotlin.fir.expressions.FirFunctionCall -import org.jetbrains.kotlin.fir.expressions.argumentMapping -import org.jetbrains.kotlin.fir.psi import org.jetbrains.kotlin.fir.resolve.inference.isBuiltinFunctionalType -import org.jetbrains.kotlin.fir.types.ConeTypeCheckerContext -import org.jetbrains.kotlin.fir.types.coneType -import org.jetbrains.kotlin.idea.fir.low.level.api.api.getOrBuildFir -import org.jetbrains.kotlin.idea.fir.low.level.api.api.getOrBuildFirOfType -import org.jetbrains.kotlin.idea.fir.low.level.api.api.getOrBuildFirSafe import org.jetbrains.kotlin.idea.frontend.api.ValidityToken -import org.jetbrains.kotlin.idea.frontend.api.assertIsValid import org.jetbrains.kotlin.idea.frontend.api.components.KtBuiltinTypes import org.jetbrains.kotlin.idea.frontend.api.components.KtTypeProvider import org.jetbrains.kotlin.idea.frontend.api.fir.KtFirAnalysisSession import org.jetbrains.kotlin.idea.frontend.api.fir.types.KtFirType import org.jetbrains.kotlin.idea.frontend.api.types.KtType import org.jetbrains.kotlin.idea.frontend.api.withValidityAssertion -import org.jetbrains.kotlin.psi.* -import org.jetbrains.kotlin.types.AbstractTypeChecker -import org.jetbrains.kotlin.types.AbstractTypeCheckerContext -import org.jetbrains.kotlin.utils.addToStdlib.firstNotNullResult -import kotlin.reflect.KClass internal class KtFirTypeProvider( override val analysisSession: KtFirAnalysisSession, override val token: ValidityToken, ) : KtTypeProvider(), KtFirAnalysisSessionComponent { - override fun getReturnTypeForKtDeclaration(declaration: KtDeclaration): KtType = withValidityAssertion { - val firDeclaration = declaration.getOrBuildFirOfType>(firResolveState) - firDeclaration.returnTypeRef.coneType.asKtType() - } - - override fun getKtExpressionType(expression: KtExpression): KtType = withValidityAssertion { - expression.getOrBuildFirOfType(firResolveState).typeRef.coneType.asKtType() - } - - override fun getExpectedType(expression: PsiElement): KtType? = - getExpectedTypeByReturnExpression(expression) - ?: getExpressionTypeByIfOrBooleanCondition(expression) - ?: getExpectedTypeOfFunctionParameter(expression) - - private fun getExpectedTypeOfFunctionParameter(expression: PsiElement): KtType? { - val (ktCallExpression, ktArgument) = expression.getFunctionCallAsWithThisAsParameter() ?: return null - val firCall = ktCallExpression.getOrBuildFirSafe(firResolveState) ?: return null - val arguments = firCall.argumentMapping ?: return null - val firParameterForExpression = arguments.entries.firstOrNull { (arg, _) -> arg.psi == ktArgument }?.value ?: return null - return firParameterForExpression.returnTypeRef.coneType.asKtType() - } - - private fun PsiElement.getFunctionCallAsWithThisAsParameter(): KtCallWithArgument? { - val valueArgument = unwrapQualified { valueArg, expr -> valueArg.getArgumentExpression() == expr } ?: return null - val argumentsList = valueArgument.parent as? KtValueArgumentList ?: return null - val callExpression = argumentsList.parent as? KtCallExpression ?: return null - val argumentExpression = valueArgument.getArgumentExpression() ?: return null - return KtCallWithArgument(callExpression, argumentExpression) - } - - private fun getExpectedTypeByReturnExpression(expression: PsiElement): KtType? { - val returnParent = expression.getReturnExpressionWithThisType() ?: return null - val targetSymbol = with(analysisSession) { returnParent.getReturnTargetSymbol() } ?: return null - return targetSymbol.type - } - - private fun PsiElement.getReturnExpressionWithThisType(): KtReturnExpression? = - unwrapQualified { returnExpr, target -> returnExpr.returnedExpression == target } - - private fun getExpressionTypeByIfOrBooleanCondition(expression: PsiElement): KtType? = when { - expression.isWhileLoopCondition() || expression.isIfCondition() -> builtinTypes.BOOLEAN - else -> null - } - - private fun PsiElement.isWhileLoopCondition() = - unwrapQualified { whileExpr, cond -> whileExpr.condition == cond } != null - - private fun PsiElement.isIfCondition() = - unwrapQualified { ifExpr, cond -> ifExpr.condition == cond } != null - - override fun isEqualTo(first: KtType, second: KtType): Boolean = withValidityAssertion { - second.assertIsValid() - check(first is KtFirType) - check(second is KtFirType) - return AbstractTypeChecker.equalTypes( - this.createTypeCheckerContext() as AbstractTypeCheckerContext, - first.coneType, - second.coneType - ) - } - - override fun isSubTypeOf(subType: KtType, superType: KtType): Boolean = withValidityAssertion { - superType.assertIsValid() - check(subType is KtFirType) - check(superType is KtFirType) - return AbstractTypeChecker.isSubtypeOf( - this.createTypeCheckerContext() as AbstractTypeCheckerContext, - subType.coneType, - superType.coneType - ) - } - override fun isBuiltinFunctionalType(type: KtType): Boolean = withValidityAssertion { check(type is KtFirType) type.coneType.isBuiltinFunctionalType(analysisSession.firResolveState.rootModuleSession) //TODO use correct session here @@ -116,33 +25,4 @@ internal class KtFirTypeProvider( override val builtinTypes: KtBuiltinTypes = KtFirBuiltInTypes(analysisSession.firResolveState.rootModuleSession.builtinTypes, analysisSession.firSymbolBuilder, token) - - private fun createTypeCheckerContext() = ConeTypeCheckerContext( - isErrorTypeEqualsToAnything = true, - isStubTypeEqualsToAnything = true, - analysisSession.firResolveState.rootModuleSession //TODO use correct session here - ) } - -private data class KtCallWithArgument(val call: KtCallExpression, val argument: KtExpression) - -private inline fun PsiElement.unwrapQualified(check: (R, PsiElement) -> Boolean): R? { - val parent = nonContainerParent - return when { - parent is R && check(parent, this) -> parent - parent is KtQualifiedExpression && parent.selectorExpression == this -> { - val grandParent = parent.nonContainerParent - when { - grandParent is R && check(grandParent, parent) -> grandParent - else -> null - } - } - else -> null - } -} - -private val PsiElement.nonContainerParent: PsiElement? - get() = when (val parent = parent) { - is KtContainerNode -> parent.parent - else -> parent - } \ No newline at end of file From 40b1a4df5a3e90ebc4b0014c3467d4b226b48997 Mon Sep 17 00:00:00 2001 From: Ilya Kirillov Date: Mon, 14 Dec 2020 11:57:19 +0100 Subject: [PATCH 043/196] FIR IDE: temp mute failing find usages test --- .../findUsages/kotlin/findFunctionUsages/labeledReturns.0.kt | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/idea/testData/findUsages/kotlin/findFunctionUsages/labeledReturns.0.kt b/idea/testData/findUsages/kotlin/findFunctionUsages/labeledReturns.0.kt index 351fa6094bf..cd098cfaec2 100644 --- a/idea/testData/findUsages/kotlin/findFunctionUsages/labeledReturns.0.kt +++ b/idea/testData/findUsages/kotlin/findFunctionUsages/labeledReturns.0.kt @@ -9,4 +9,6 @@ fun test() { } foo(fun(): Boolean { return@foo false }) -} \ No newline at end of file +} + +// FIR_IGNORE \ No newline at end of file From 940ec06f5bc8b051839eaa810cac3f62de520d7d Mon Sep 17 00:00:00 2001 From: Ilya Kirillov Date: Mon, 14 Dec 2020 13:46:58 +0100 Subject: [PATCH 044/196] FIR IDE: precalculate completion context on dependent analysis session creation --- .../KotlinFirCompletionContributor.kt | 2 +- .../idea/frontend/api/KtAnalysisSession.kt | 10 ++--- .../KtExpressionHandlingComponent.kt | 3 +- .../frontend/api/fir/KtFirAnalysisSession.kt | 43 ++++++++++++++++--- .../KtFirCompletionCandidateChecker.kt | 8 +--- .../KtFirExpressionHandlingComponent.kt | 4 +- .../components/KtFirExpressionTypeProvider.kt | 3 +- .../api/fir/components/KtFirScopeProvider.kt | 18 ++------ .../components/TowerDataContextProvider.kt | 19 ++++++++ 9 files changed, 73 insertions(+), 37 deletions(-) create mode 100644 idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/TowerDataContextProvider.kt diff --git a/idea/idea-fir/src/org/jetbrains/kotlin/idea/completion/KotlinFirCompletionContributor.kt b/idea/idea-fir/src/org/jetbrains/kotlin/idea/completion/KotlinFirCompletionContributor.kt index eaf200a602a..c6b56a4133e 100644 --- a/idea/idea-fir/src/org/jetbrains/kotlin/idea/completion/KotlinFirCompletionContributor.kt +++ b/idea/idea-fir/src/org/jetbrains/kotlin/idea/completion/KotlinFirCompletionContributor.kt @@ -111,7 +111,7 @@ private class KotlinAvailableScopesCompletionProvider(prefixMatcher: PrefixMatch val explicitReceiver = nameExpression.getReceiverExpression() - with(getAnalysisSessionFor(originalFile).createContextDependentCopy()) { + with(getAnalysisSessionFor(originalFile).createContextDependentCopy(originalFile, nameExpression)) { val expectedType = nameExpression.getExpectedType() val (implicitScopes, _) = originalFile.getScopeContextForPosition(nameExpression) diff --git a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/KtAnalysisSession.kt b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/KtAnalysisSession.kt index 52284ebdf37..87d92fa5959 100644 --- a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/KtAnalysisSession.kt +++ b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/KtAnalysisSession.kt @@ -43,6 +43,7 @@ abstract class KtAnalysisSession(final override val token: ValidityToken) : Vali protected abstract val callResolver: KtCallResolver protected abstract val completionCandidateChecker: KtCompletionCandidateChecker protected abstract val symbolDeclarationOverridesProvider: KtSymbolDeclarationOverridesProvider + @Suppress("LeakingThis") protected open val typeRenderer: KtTypeRenderer = KtDefaultTypeRenderer(this, token) @@ -51,16 +52,15 @@ abstract class KtAnalysisSession(final override val token: ValidityToken) : Vali protected abstract val subtypingComponent: KtSubtypingComponent protected abstract val expressionHandlingComponent: KtExpressionHandlingComponent - /// TODO: get rid of - @Deprecated("Used only in completion now, temporary") - abstract fun createContextDependentCopy(): KtAnalysisSession + abstract fun createContextDependentCopy(originalKtFile: KtFile, fakeKtElement: KtElement): KtAnalysisSession fun KtCallableSymbol.getOverriddenSymbols(containingDeclaration: KtClassOrObjectSymbol): List = symbolDeclarationOverridesProvider.getOverriddenSymbols(this, containingDeclaration) fun KtExpression.getSmartCasts(): Collection = smartCastProvider.getSmartCastedToTypes(this) - fun KtExpression.getImplicitReceiverSmartCasts(): Collection = smartCastProvider.getImplicitReceiverSmartCasts(this) + fun KtExpression.getImplicitReceiverSmartCasts(): Collection = + smartCastProvider.getImplicitReceiverSmartCasts(this) fun KtExpression.getKtType(): KtType = expressionTypeProvider.getKtExpressionType(this) @@ -158,6 +158,6 @@ abstract class KtAnalysisSession(final override val token: ValidityToken) : Vali fun KtType.render(options: KtTypeRendererOptions = KtTypeRendererOptions.DEFAULT): String = typeRenderer.render(this, options) - fun KtReturnExpression.getReturnTargetSymbol(): KtFunctionLikeSymbol? = + fun KtReturnExpression.getReturnTargetSymbol(): KtCallableSymbol? = expressionHandlingComponent.getReturnExpressionTargetSymbol(this) } diff --git a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/components/KtExpressionHandlingComponent.kt b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/components/KtExpressionHandlingComponent.kt index 48a1e6548bf..74a5c7a46f1 100644 --- a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/components/KtExpressionHandlingComponent.kt +++ b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/components/KtExpressionHandlingComponent.kt @@ -5,9 +5,10 @@ package org.jetbrains.kotlin.idea.frontend.api.components +import org.jetbrains.kotlin.idea.frontend.api.symbols.KtCallableSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.KtFunctionLikeSymbol import org.jetbrains.kotlin.psi.KtReturnExpression abstract class KtExpressionHandlingComponent : KtAnalysisSessionComponent() { - abstract fun getReturnExpressionTargetSymbol(returnExpression: KtReturnExpression): KtFunctionLikeSymbol? + abstract fun getReturnExpressionTargetSymbol(returnExpression: KtReturnExpression): KtCallableSymbol? } \ No newline at end of file diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/KtFirAnalysisSession.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/KtFirAnalysisSession.kt index 7b4403293f6..38669123b8c 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/KtFirAnalysisSession.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/KtFirAnalysisSession.kt @@ -6,9 +6,11 @@ package org.jetbrains.kotlin.idea.frontend.api.fir import com.intellij.openapi.project.Project +import org.jetbrains.kotlin.fir.declarations.FirFile import org.jetbrains.kotlin.fir.resolve.firSymbolProvider import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirModuleResolveState import org.jetbrains.kotlin.idea.fir.low.level.api.api.LowLevelFirApiFacadeForCompletion +import org.jetbrains.kotlin.idea.fir.low.level.api.api.getFirFile import org.jetbrains.kotlin.idea.fir.low.level.api.api.getResolveState import org.jetbrains.kotlin.idea.frontend.api.KtAnalysisSession import org.jetbrains.kotlin.idea.frontend.api.ReadActionConfinementValidityToken @@ -17,9 +19,12 @@ import org.jetbrains.kotlin.idea.frontend.api.assertIsValid import org.jetbrains.kotlin.idea.frontend.api.components.* import org.jetbrains.kotlin.idea.frontend.api.fir.components.* import org.jetbrains.kotlin.idea.frontend.api.fir.symbols.KtFirSymbolProvider +import org.jetbrains.kotlin.idea.frontend.api.fir.utils.EnclosingDeclarationContext +import org.jetbrains.kotlin.idea.frontend.api.fir.utils.buildCompletionContext import org.jetbrains.kotlin.idea.frontend.api.fir.utils.threadLocal import org.jetbrains.kotlin.idea.frontend.api.symbols.KtSymbolProvider import org.jetbrains.kotlin.psi.KtElement +import org.jetbrains.kotlin.psi.KtFile internal class KtFirAnalysisSession private constructor( @@ -27,12 +32,14 @@ private constructor( val firResolveState: FirModuleResolveState, internal val firSymbolBuilder: KtSymbolByFirBuilder, token: ValidityToken, - val isContextSession: Boolean, + val context: KtFirAnalysisSessionContext, ) : KtAnalysisSession(token) { init { assertIsValid() } + internal val towerDataContextProvider: TowerDataContextProvider = TowerDataContextProvider(this) + override val smartCastProvider: KtSmartCastProvider = KtFirSmartcastProvider(this, token) override val expressionTypeProvider: KtExpressionTypeProvider = KtFirExpressionTypeProvider(this, token) override val diagnosticProvider: KtDiagnosticProvider = KtFirDiagnosticProvider(this, token) @@ -49,15 +56,19 @@ private constructor( override val typeProvider: KtTypeProvider = KtFirTypeProvider(this, token) override val subtypingComponent: KtSubtypingComponent = KtFirSubtypingComponent(this, token) - override fun createContextDependentCopy(): KtAnalysisSession { - check(!isContextSession) { "Cannot create context-dependent copy of KtAnalysis session from a context dependent one" } + override fun createContextDependentCopy(originalKtFile: KtFile, fakeKtElement: KtElement): KtAnalysisSession { + check(context == KtFirAnalysisSessionContext.DefaultContext) { + "Cannot create context-dependent copy of KtAnalysis session from a context dependent one" + } val contextResolveState = LowLevelFirApiFacadeForCompletion.getResolveStateForCompletion(firResolveState) + val originalFirFile = originalKtFile.getFirFile(firResolveState) + val context = KtFirAnalysisSessionContext.FakeFileContext(originalKtFile, originalFirFile, fakeKtElement, contextResolveState) return KtFirAnalysisSession( project, contextResolveState, firSymbolBuilder.createReadOnlyCopy(contextResolveState), token, - isContextSession = true + context ) } @@ -82,9 +93,31 @@ private constructor( firResolveState, firSymbolBuilder, token, - isContextSession = false + KtFirAnalysisSessionContext.DefaultContext ) } } } +internal sealed class KtFirAnalysisSessionContext { + object DefaultContext : KtFirAnalysisSessionContext() + + class FakeFileContext( + originalFile: KtFile, + firFile: FirFile, + fakeContextElement: KtElement, + fakeModuleResolveState: FirModuleResolveState + ) : KtFirAnalysisSessionContext() { + init { + require(!fakeContextElement.isPhysical) + } + + val completionContext = run { + val enclosingContext = EnclosingDeclarationContext.detect(originalFile, fakeContextElement) + enclosingContext.buildCompletionContext(firFile, fakeModuleResolveState) + } + + val fakeKtFile = fakeContextElement.containingKtFile + } +} + diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirCompletionCandidateChecker.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirCompletionCandidateChecker.kt index 69e2d9da2f8..d40022cc98e 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirCompletionCandidateChecker.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirCompletionCandidateChecker.kt @@ -92,13 +92,7 @@ internal class KtFirCompletionCandidateChecker( firFile: FirFile, fakeNameExpression: KtSimpleNameExpression ): Sequence?> { - val enclosingContext = EnclosingDeclarationContext.detect(originalFile, fakeNameExpression) - - val completionContext = completionContextCache.computeIfAbsent(firFile to enclosingContext.fakeEnclosingDeclaration) { - enclosingContext.buildCompletionContext(firFile, firResolveState) - } - - val towerDataContext = completionContext.getTowerDataContext(fakeNameExpression) + val towerDataContext = analysisSession.towerDataContextProvider.getTowerDataContext(fakeNameExpression) return sequence { yield(null) // otherwise explicit receiver won't be checked when there are no implicit receivers in completion position diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirExpressionHandlingComponent.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirExpressionHandlingComponent.kt index 4b5647c8fe2..d8048dcb056 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirExpressionHandlingComponent.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirExpressionHandlingComponent.kt @@ -18,9 +18,9 @@ internal class KtFirExpressionHandlingComponent( override val analysisSession: KtFirAnalysisSession, override val token: ValidityToken, ) : KtExpressionHandlingComponent(), KtFirAnalysisSessionComponent { - override fun getReturnExpressionTargetSymbol(returnExpression: KtReturnExpression): KtFunctionLikeSymbol? { + override fun getReturnExpressionTargetSymbol(returnExpression: KtReturnExpression): KtCallableSymbol? { val fir = returnExpression.getOrBuildFirSafe(firResolveState) ?: return null val firTargetSymbol = fir.target.labeledElement - return firSymbolBuilder.buildCallableSymbol(firTargetSymbol) as KtFunctionLikeSymbol + return firSymbolBuilder.buildCallableSymbol(firTargetSymbol) } } \ No newline at end of file diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirExpressionTypeProvider.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirExpressionTypeProvider.kt index bd608b9f2d3..7ec8775ce3a 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirExpressionTypeProvider.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirExpressionTypeProvider.kt @@ -22,6 +22,7 @@ import org.jetbrains.kotlin.idea.frontend.api.components.KtBuiltinTypes import org.jetbrains.kotlin.idea.frontend.api.components.KtExpressionTypeProvider import org.jetbrains.kotlin.idea.frontend.api.fir.KtFirAnalysisSession import org.jetbrains.kotlin.idea.frontend.api.fir.types.KtFirType +import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtTypedSymbol import org.jetbrains.kotlin.idea.frontend.api.types.KtType import org.jetbrains.kotlin.idea.frontend.api.withValidityAssertion import org.jetbrains.kotlin.psi.* @@ -65,7 +66,7 @@ internal class KtFirExpressionTypeProvider( private fun getExpectedTypeByReturnExpression(expression: PsiElement): KtType? { val returnParent = expression.getReturnExpressionWithThisType() ?: return null val targetSymbol = with(analysisSession) { returnParent.getReturnTargetSymbol() } ?: return null - return targetSymbol.type + return (targetSymbol as? KtTypedSymbol)?.type } private fun PsiElement.getReturnExpressionWithThisType(): KtReturnExpression? = diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirScopeProvider.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirScopeProvider.kt index ee24918c7de..ad299016598 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirScopeProvider.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirScopeProvider.kt @@ -42,13 +42,13 @@ import org.jetbrains.kotlin.psi.KtFile import java.util.* internal class KtFirScopeProvider( - analysisSession: KtAnalysisSession, + analysisSession: KtFirAnalysisSession, builder: KtSymbolByFirBuilder, private val project: Project, firResolveState: FirModuleResolveState, override val token: ValidityToken, ) : KtScopeProvider(), ValidityTokenOwner { - override val analysisSession: KtAnalysisSession by weakRef(analysisSession) + override val analysisSession: KtFirAnalysisSession by weakRef(analysisSession) private val builder by weakRef(builder) private val firResolveState by weakRef(firResolveState) private val firScopeStorage = FirScopeRegistry() @@ -136,9 +136,7 @@ internal class KtFirScopeProvider( originalFile: KtFile, positionInFakeFile: KtElement ): KtScopeContext = withValidityAssertion { - val completionContext = buildCompletionContextForEnclosingDeclaration(originalFile, positionInFakeFile) - - val towerDataContext = completionContext.getTowerDataContext(positionInFakeFile) + val towerDataContext = analysisSession.towerDataContextProvider.getTowerDataContext(positionInFakeFile) val implicitReceivers = towerDataContext.nonLocalTowerDataElements.mapNotNull { it.implicitReceiver }.distinct() val implicitReceiversTypes = implicitReceivers.map { builder.buildKtType(it.type) } @@ -160,16 +158,6 @@ internal class KtFirScopeProvider( ) } - private fun buildCompletionContextForEnclosingDeclaration( - ktFile: KtFile, - positionInFakeFile: KtElement - ): LowLevelFirApiFacadeForCompletion.FirCompletionContext { - val firFile = ktFile.getFirFile(firResolveState) - val declarationContext = EnclosingDeclarationContext.detect(ktFile, positionInFakeFile) - - return declarationContext.buildCompletionContext(firFile, firResolveState) - } - private fun convertToKtScope(firScope: FirScope): KtScope { firScopeStorage.register(firScope) return when (firScope) { diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/TowerDataContextProvider.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/TowerDataContextProvider.kt new file mode 100644 index 00000000000..48911883bc0 --- /dev/null +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/TowerDataContextProvider.kt @@ -0,0 +1,19 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.idea.frontend.api.fir.components + +import org.jetbrains.kotlin.fir.resolve.FirTowerDataContext +import org.jetbrains.kotlin.idea.frontend.api.fir.KtFirAnalysisSession +import org.jetbrains.kotlin.idea.frontend.api.fir.KtFirAnalysisSessionContext +import org.jetbrains.kotlin.psi.KtElement + +internal class TowerDataContextProvider(private val analysisSession: KtFirAnalysisSession) { + fun getTowerDataContext(statement: KtElement): FirTowerDataContext { + val fakeContext = analysisSession.context as? KtFirAnalysisSessionContext.FakeFileContext + ?: error("Getting data context for non context-dependent session is not supported yet") + return fakeContext.completionContext.getTowerDataContext(statement) + } +} \ No newline at end of file From 67fc1bcb3dd2633cdd6ec74ab8e2f53129d6021a Mon Sep 17 00:00:00 2001 From: Ilya Kirillov Date: Mon, 14 Dec 2020 15:13:25 +0100 Subject: [PATCH 045/196] FIR IDE: add debug error message when not possible to find fir declarartion by psi --- .../kotlin/idea/fir/low/level/api/util/declarationUtils.kt | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/util/declarationUtils.kt b/idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/util/declarationUtils.kt index 6d33a71c210..fe2fffbf6fc 100644 --- a/idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/util/declarationUtils.kt +++ b/idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/util/declarationUtils.kt @@ -91,7 +91,8 @@ private fun KtDeclaration.findSourceNonLocalFirDeclarationByProvider( firFile.declarations } val original = originalDeclaration - declarations?.first { it.psi === this || it.psi == original } + declarations?.firstOrNull { it.psi == this || it.psi == original } + ?: error("Cannot find corresponding fir for\n${this.getElementTextInContext()}") } this is KtConstructor<*> -> { val containingClass = containingClassOrObject From 5a9ff3471a411cead670f898f9bad4806b751df1 Mon Sep 17 00:00:00 2001 From: Ilya Kirillov Date: Mon, 14 Dec 2020 21:26:45 +0100 Subject: [PATCH 046/196] FIR IDE: fix function targets on context element copy --- .../api/LowLevelFirApiFacadeForCompletion.kt | 25 +++++++++++++------ 1 file changed, 18 insertions(+), 7 deletions(-) diff --git a/idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/api/LowLevelFirApiFacadeForCompletion.kt b/idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/api/LowLevelFirApiFacadeForCompletion.kt index 61c1ea3cea8..ec529402f4b 100644 --- a/idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/api/LowLevelFirApiFacadeForCompletion.kt +++ b/idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/api/LowLevelFirApiFacadeForCompletion.kt @@ -6,16 +6,16 @@ package org.jetbrains.kotlin.idea.fir.low.level.api.api import com.intellij.psi.PsiElement +import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirSession -import org.jetbrains.kotlin.fir.declarations.FirFile -import org.jetbrains.kotlin.fir.declarations.FirProperty -import org.jetbrains.kotlin.fir.declarations.FirResolvePhase -import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction +import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.builder.buildPropertyAccessorCopy import org.jetbrains.kotlin.fir.declarations.builder.buildPropertyCopy import org.jetbrains.kotlin.fir.declarations.builder.buildSimpleFunctionCopy +import org.jetbrains.kotlin.fir.expressions.FirReturnExpression import org.jetbrains.kotlin.fir.resolve.FirTowerDataContext import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol +import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid import org.jetbrains.kotlin.idea.fir.low.level.api.FirModuleResolveStateForCompletion import org.jetbrains.kotlin.idea.fir.low.level.api.FirModuleResolveStateImpl import org.jetbrains.kotlin.idea.fir.low.level.api.element.builder.FirTowerDataContextCollector @@ -106,10 +106,9 @@ object LowLevelFirApiFacadeForCompletion { resolvePhase = minOf(originalFunction.resolvePhase, FirResolvePhase.DECLARATIONS) source = builtFunction.source session = state.rootModuleSession - } + }.apply { reassignAllReturnTargets (builtFunction) } } - private fun buildPropertyCopyForCompletion( firIdeProvider: FirIdeProvider, element: KtProperty, @@ -129,7 +128,7 @@ object LowLevelFirApiFacadeForCompletion { resolvePhase = minOf(builtSetter.resolvePhase, FirResolvePhase.DECLARATIONS) source = builtSetter.source session = state.rootModuleSession - } + }.apply { reassignAllReturnTargets(builtSetter) } } else { builtSetter } @@ -146,4 +145,16 @@ object LowLevelFirApiFacadeForCompletion { session = state.rootModuleSession } } + + + private fun FirFunction<*>.reassignAllReturnTargets(from: FirFunction<*>) { + this.accept(object : FirVisitorVoid() { + override fun visitElement(element: FirElement) { + if (element is FirReturnExpression && element.target.labeledElement == from) { + element.target.bind(this@reassignAllReturnTargets) + } + element.acceptChildren(this) + } + }) + } } From 94deddef7f5a6ec570100dd69b4e75809b44cbbc Mon Sep 17 00:00:00 2001 From: Victor Petukhov Date: Wed, 16 Dec 2020 10:24:12 +0300 Subject: [PATCH 047/196] Revert "Minor: cover negative cases with test +m" This reverts commit 04a4f9cd --- .../JvmStaticInPrivateCompanionChecker.kt | 10 +++---- .../jvmStatic/privateCompanionObject.fir.kt | 29 +------------------ .../jvmStatic/privateCompanionObject.kt | 29 +------------------ .../jvmStatic/privateCompanionObject.txt | 21 -------------- 4 files changed, 6 insertions(+), 83 deletions(-) diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JvmStaticInPrivateCompanionChecker.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JvmStaticInPrivateCompanionChecker.kt index 9eeb7b44d48..e08d7f0ecae 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JvmStaticInPrivateCompanionChecker.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JvmStaticInPrivateCompanionChecker.kt @@ -18,16 +18,14 @@ import org.jetbrains.kotlin.utils.addToStdlib.safeAs class JvmStaticInPrivateCompanionChecker : DeclarationChecker { override fun check(declaration: KtDeclaration, descriptor: DeclarationDescriptor, context: DeclarationCheckerContext) { - val containingDeclaration = descriptor.containingDeclaration - if (containingDeclaration !is ClassDescriptor - || !containingDeclaration.isCompanionObject - || !Visibilities.isPrivate(containingDeclaration.visibility.delegate) - ) return + descriptor.containingDeclaration.safeAs()?.takeIf { + it.isCompanionObject && Visibilities.isPrivate(it.visibility.delegate) + } ?: return val jvmStaticAnnotation = descriptor.annotations.findAnnotation(JVM_STATIC_ANNOTATION_FQ_NAME) ?: return - val reportTarget = jvmStaticAnnotation.source.safeAs()?.psi ?: return + val reportTarget = jvmStaticAnnotation.source.safeAs()?.psi ?: declaration context.trace.report(JVM_STATIC_IN_PRIVATE_COMPANION.on(reportTarget)) } } \ No newline at end of file diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/privateCompanionObject.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/privateCompanionObject.fir.kt index e6dac1eb6b0..4b6f9d5ae3b 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/privateCompanionObject.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/privateCompanionObject.fir.kt @@ -26,31 +26,4 @@ class WithPrivateCompanion { @JvmStatic fun staticFunction() {} } -} - -class WithPublicCompanion { - companion object { - @JvmStatic - val staticVal1: Int = 42 - - val staticVal2: Int - @JvmStatic get() = 42 - - @get:JvmStatic - val staticVal3: Int = 42 - - @JvmStatic - var staticVar1: Int = 42 - - var staticVar2: Int - @JvmStatic get() = 42 - @JvmStatic set(value) {} - - @get: JvmStatic - @set: JvmStatic - var staticVar3: Int = 42 - - @JvmStatic - fun staticFunction() {} - } -} +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/privateCompanionObject.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/privateCompanionObject.kt index 0adcfbf6b42..1c718ce215b 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/privateCompanionObject.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/privateCompanionObject.kt @@ -26,31 +26,4 @@ class WithPrivateCompanion { @JvmStatic fun staticFunction() {} } -} - -class WithPublicCompanion { - companion object { - @JvmStatic - val staticVal1: Int = 42 - - val staticVal2: Int - @JvmStatic get() = 42 - - @get:JvmStatic - val staticVal3: Int = 42 - - @JvmStatic - var staticVar1: Int = 42 - - var staticVar2: Int - @JvmStatic get() = 42 - @JvmStatic set(value) {} - - @get: JvmStatic - @set: JvmStatic - var staticVar3: Int = 42 - - @JvmStatic - fun staticFunction() {} - } -} +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/privateCompanionObject.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/privateCompanionObject.txt index c04308bf1bd..f6ceea5ca4d 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/privateCompanionObject.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/privateCompanionObject.txt @@ -20,24 +20,3 @@ public final class WithPrivateCompanion { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } } - -public final class WithPublicCompanion { - public constructor WithPublicCompanion() - public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int - public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String - - public companion object Companion { - private constructor Companion() - @kotlin.jvm.JvmStatic public final val staticVal1: kotlin.Int = 42 - @get:kotlin.jvm.JvmStatic public final val staticVal2: kotlin.Int - @get:kotlin.jvm.JvmStatic public final val staticVal3: kotlin.Int = 42 - @kotlin.jvm.JvmStatic public final var staticVar1: kotlin.Int - @get:kotlin.jvm.JvmStatic @set:kotlin.jvm.JvmStatic public final var staticVar2: kotlin.Int - @get:kotlin.jvm.JvmStatic @set:kotlin.jvm.JvmStatic public final var staticVar3: kotlin.Int - public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int - @kotlin.jvm.JvmStatic public final fun staticFunction(): kotlin.Unit - public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String - } -} From d32d0a65f0fdde69e5a8fde48e82a2a396cd8e9c Mon Sep 17 00:00:00 2001 From: Victor Petukhov Date: Wed, 16 Dec 2020 10:24:18 +0300 Subject: [PATCH 048/196] Revert "Report warning on @JvmStatic in private companion objects" This reverts commit 9669ab14 --- .../JvmStaticInPrivateCompanionChecker.kt | 31 ------------------- .../jvm/platform/JvmPlatformConfigurator.kt | 1 - .../jetbrains/kotlin/diagnostics/Errors.java | 1 - .../rendering/DefaultErrorMessages.java | 1 - .../jvmStatic/privateCompanionObject.fir.kt | 29 ----------------- .../jvmStatic/privateCompanionObject.kt | 19 ++++++------ 6 files changed, 10 insertions(+), 72 deletions(-) delete mode 100644 compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JvmStaticInPrivateCompanionChecker.kt delete mode 100644 compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/privateCompanionObject.fir.kt diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JvmStaticInPrivateCompanionChecker.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JvmStaticInPrivateCompanionChecker.kt deleted file mode 100644 index e08d7f0ecae..00000000000 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JvmStaticInPrivateCompanionChecker.kt +++ /dev/null @@ -1,31 +0,0 @@ -/* - * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. - * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. - */ - -package org.jetbrains.kotlin.resolve.jvm.checkers - -import org.jetbrains.kotlin.descriptors.ClassDescriptor -import org.jetbrains.kotlin.descriptors.DeclarationDescriptor -import org.jetbrains.kotlin.descriptors.Visibilities -import org.jetbrains.kotlin.diagnostics.Errors.JVM_STATIC_IN_PRIVATE_COMPANION -import org.jetbrains.kotlin.psi.KtDeclaration -import org.jetbrains.kotlin.resolve.annotations.JVM_STATIC_ANNOTATION_FQ_NAME -import org.jetbrains.kotlin.resolve.checkers.DeclarationChecker -import org.jetbrains.kotlin.resolve.checkers.DeclarationCheckerContext -import org.jetbrains.kotlin.resolve.source.KotlinSourceElement -import org.jetbrains.kotlin.utils.addToStdlib.safeAs - -class JvmStaticInPrivateCompanionChecker : DeclarationChecker { - override fun check(declaration: KtDeclaration, descriptor: DeclarationDescriptor, context: DeclarationCheckerContext) { - - descriptor.containingDeclaration.safeAs()?.takeIf { - it.isCompanionObject && Visibilities.isPrivate(it.visibility.delegate) - } ?: return - - val jvmStaticAnnotation = descriptor.annotations.findAnnotation(JVM_STATIC_ANNOTATION_FQ_NAME) ?: return - - val reportTarget = jvmStaticAnnotation.source.safeAs()?.psi ?: declaration - context.trace.report(JVM_STATIC_IN_PRIVATE_COMPANION.on(reportTarget)) - } -} \ No newline at end of file diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/platform/JvmPlatformConfigurator.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/platform/JvmPlatformConfigurator.kt index 9c0addcdca7..cc8db2176c6 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/platform/JvmPlatformConfigurator.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/platform/JvmPlatformConfigurator.kt @@ -97,7 +97,6 @@ object JvmPlatformConfigurator : PlatformConfiguratorBase( ) { override fun configureModuleComponents(container: StorageComponentContainer) { container.useImpl() - container.useImpl() container.useImpl() container.useImpl() container.useImpl() diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java index 3fcbcc93663..f0f38f9ac6f 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java @@ -285,7 +285,6 @@ public interface Errors { DiagnosticFactory1 EXPERIMENTAL_UNSIGNED_LITERALS_ERROR = DiagnosticFactory1.create(ERROR); DiagnosticFactory0 NON_PARENTHESIZED_ANNOTATIONS_ON_FUNCTIONAL_TYPES = DiagnosticFactory0.create(ERROR); - DiagnosticFactory0 JVM_STATIC_IN_PRIVATE_COMPANION = DiagnosticFactory0.create(WARNING); // Const DiagnosticFactory0 CONST_VAL_NOT_TOP_LEVEL_OR_OBJECT = DiagnosticFactory0.create(ERROR); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java index 254ffeef805..75f9a22e5b8 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java @@ -170,7 +170,6 @@ public class DefaultErrorMessages { MAP.put(EXPERIMENTAL_UNSIGNED_LITERALS_ERROR, "{0}", STRING); MAP.put(NON_PARENTHESIZED_ANNOTATIONS_ON_FUNCTIONAL_TYPES, "Non-parenthesized annotations on function types without receiver aren't yet supported (see KT-31734 for details)"); - MAP.put(JVM_STATIC_IN_PRIVATE_COMPANION, "@JvmStatic is prohibited in private companion objects. This warning will become an error in the next major version"); MAP.put(REDUNDANT_MODIFIER, "Modifier ''{0}'' is redundant because ''{1}'' is present", TO_STRING, TO_STRING); MAP.put(REDUNDANT_OPEN_IN_INTERFACE, "Modifier 'open' is redundant for abstract interface members"); diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/privateCompanionObject.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/privateCompanionObject.fir.kt deleted file mode 100644 index 4b6f9d5ae3b..00000000000 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/privateCompanionObject.fir.kt +++ /dev/null @@ -1,29 +0,0 @@ -// Issue: KT-25114 -// !DIAGNOSTICS: -UNUSED_PARAMETER - -class WithPrivateCompanion { - private companion object { - @JvmStatic - val staticVal1: Int = 42 - - val staticVal2: Int - @JvmStatic get() = 42 - - @get:JvmStatic - val staticVal3: Int = 42 - - @JvmStatic - var staticVar1: Int = 42 - - var staticVar2: Int - @JvmStatic get() = 42 - @JvmStatic set(value) {} - - @get: JvmStatic - @set: JvmStatic - var staticVar3: Int = 42 - - @JvmStatic - fun staticFunction() {} - } -} \ No newline at end of file diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/privateCompanionObject.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/privateCompanionObject.kt index 1c718ce215b..7a809f942eb 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/privateCompanionObject.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/privateCompanionObject.kt @@ -1,29 +1,30 @@ // Issue: KT-25114 +// FIR_IDENTICAL // !DIAGNOSTICS: -UNUSED_PARAMETER class WithPrivateCompanion { private companion object { - @JvmStatic + @JvmStatic val staticVal1: Int = 42 val staticVal2: Int - @JvmStatic get() = 42 + @JvmStatic get() = 42 - @get:JvmStatic + @get:JvmStatic val staticVal3: Int = 42 - @JvmStatic + @JvmStatic var staticVar1: Int = 42 var staticVar2: Int - @JvmStatic get() = 42 - @JvmStatic set(value) {} + @JvmStatic get() = 42 + @JvmStatic set(value) {} - @get: JvmStatic - @set: JvmStatic + @get: JvmStatic + @set: JvmStatic var staticVar3: Int = 42 - @JvmStatic + @JvmStatic fun staticFunction() {} } } \ No newline at end of file From 3895ad375c9fd5edbe54d8bbf3dfa3d5b5197667 Mon Sep 17 00:00:00 2001 From: Igor Yakovlev Date: Tue, 8 Dec 2020 02:28:30 +0300 Subject: [PATCH 049/196] [FIR IDE] LC add jvmstatic method into companion object --- .../classes/FirLightAnnotationClassSymbol.kt | 2 +- .../classes/FirLightAnonymousClassForSymbol.kt | 2 +- .../classes/FirLightClassForEnumEntry.kt | 2 +- .../asJava/classes/FirLightClassForFacade.kt | 2 +- .../asJava/classes/FirLightClassForSymbol.kt | 18 +++++++++++++++++- .../classes/FirLightInterfaceClassSymbol.kt | 2 +- .../idea/asJava/classes/firLightClassUtils.kt | 12 +++++++----- .../methods/FirLightAccessorMethodForSymbol.kt | 1 + .../methods/FirLightSimpleMethodForSymbol.kt | 7 ++++--- 9 files changed, 34 insertions(+), 14 deletions(-) diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightAnnotationClassSymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightAnnotationClassSymbol.kt index 9c21a75b77c..df7d68466cd 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightAnnotationClassSymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightAnnotationClassSymbol.kt @@ -47,7 +47,7 @@ internal class FirLightAnnotationClassSymbol( .filterNot { it is KtFunctionSymbol && it.visibility == KtSymbolVisibility.PRIVATE } .filterNot { it is KtConstructorSymbol } - createMethods(visibleDeclarations, isTopLevel = false, result) + createMethods(visibleDeclarations, result) } result diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightAnonymousClassForSymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightAnonymousClassForSymbol.kt index 7144e063f74..06b0995479b 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightAnonymousClassForSymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightAnonymousClassForSymbol.kt @@ -60,7 +60,7 @@ internal class FirLightAnonymousClassForSymbol( analyzeWithSymbolAsContext(anonymousObjectSymbol) { val callableSymbols = anonymousObjectSymbol.getDeclaredMemberScope().getCallableSymbols() - createMethods(callableSymbols, isTopLevel = false, result) + createMethods(callableSymbols, result) } result diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightClassForEnumEntry.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightClassForEnumEntry.kt index afe0fe15cf4..97648a2cd1a 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightClassForEnumEntry.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightClassForEnumEntry.kt @@ -128,7 +128,7 @@ internal class FirLightClassForEnumEntry( analyzeWithSymbolAsContext(enumEntrySymbol) { val callableSymbols = enumEntrySymbol.getDeclaredMemberScope().getCallableSymbols() - createMethods(callableSymbols, isTopLevel = false, result) + createMethods(callableSymbols, result) } return result diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightClassForFacade.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightClassForFacade.kt index a73ad96e8bc..081fa3f7f8b 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightClassForFacade.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightClassForFacade.kt @@ -82,7 +82,7 @@ class FirLightClassForFacade( } } - createMethods(symbols.asSequence(), isTopLevel = true, result) + createMethods(symbols.asSequence(), result, isTopLevel = true) } private val _ownMethods: List by lazyPub { diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightClassForSymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightClassForSymbol.kt index 9ba4f8a9fbc..ec7b25a4f6d 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightClassForSymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightClassForSymbol.kt @@ -6,6 +6,8 @@ package org.jetbrains.kotlin.idea.asJava import com.intellij.psi.* +import org.jetbrains.kotlin.asJava.builder.memberIndex +import org.jetbrains.kotlin.asJava.classes.METHOD_INDEX_BASE import org.jetbrains.kotlin.asJava.classes.METHOD_INDEX_FOR_DEFAULT_CTOR import org.jetbrains.kotlin.asJava.classes.lazyPub import org.jetbrains.kotlin.asJava.elements.KtLightField @@ -100,7 +102,8 @@ internal open class FirLightClassForSymbol( } } - createMethods(visibleDeclarations, isTopLevel = false, result) + val suppressStatic = classOrObjectSymbol.classKind == KtClassKind.COMPANION_OBJECT + createMethods(visibleDeclarations, result, suppressStaticForMethods = suppressStatic) } if (result.none { it.isConstructor }) { @@ -116,6 +119,8 @@ internal open class FirLightClassForSymbol( } } + addMethodsFromCompanionIfNeeded(result) + result } @@ -140,6 +145,17 @@ internal open class FirLightClassForSymbol( } } + private fun addMethodsFromCompanionIfNeeded(result: MutableList) { + classOrObjectSymbol.companionObject?.run { + analyzeWithSymbolAsContext(this) { + val methods = getDeclaredMemberScope().getCallableSymbols() + .filterIsInstance() + .filter { it.hasJvmStaticAnnotation() } + createMethods(methods, result) + } + } + } + private fun addInstanceFieldIfNeeded(result: MutableList) { val isNamedObject = classOrObjectSymbol.classKind == KtClassKind.OBJECT if (isNamedObject && classOrObjectSymbol.symbolKind != KtSymbolKind.LOCAL) { diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightInterfaceClassSymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightInterfaceClassSymbol.kt index 34797721b82..2bdd005b60e 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightInterfaceClassSymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightInterfaceClassSymbol.kt @@ -43,7 +43,7 @@ internal class FirLightInterfaceClassSymbol( val visibleDeclarations = classOrObjectSymbol.getDeclaredMemberScope().getCallableSymbols() .filterNot { it is KtFunctionSymbol && it.visibility == KtSymbolVisibility.PRIVATE } - createMethods(visibleDeclarations, isTopLevel = false, result) + createMethods(visibleDeclarations, result) } result diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/firLightClassUtils.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/firLightClassUtils.kt index d8207fd284c..a3cfb594314 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/firLightClassUtils.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/firLightClassUtils.kt @@ -98,10 +98,10 @@ private fun lightClassForEnumEntry(ktEnumEntry: KtEnumEntry): KtLightClass? { internal fun FirLightClassBase.createMethods( declarations: Sequence, - isTopLevel: Boolean, - result: MutableList + result: MutableList, + isTopLevel: Boolean = false, + suppressStaticForMethods: Boolean = false ) { - var methodIndex = METHOD_INDEX_BASE for (declaration in declarations) { if (declaration is KtFunctionSymbol && declaration.isInline) continue @@ -112,13 +112,15 @@ internal fun FirLightClassBase.createMethods( when (declaration) { is KtFunctionSymbol -> { + var methodIndex = METHOD_INDEX_BASE result.add( FirLightSimpleMethodForSymbol( functionSymbol = declaration, lightMemberOrigin = null, containingClass = this@createMethods, isTopLevel = isTopLevel, - methodIndex = methodIndex++ + methodIndex = methodIndex, + suppressStatic = suppressStaticForMethods ) ) @@ -150,7 +152,7 @@ internal fun FirLightClassBase.createMethods( constructorSymbol = declaration, lightMemberOrigin = null, containingClass = this@createMethods, - methodIndex++ + methodIndex = METHOD_INDEX_BASE ) ) } diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/methods/FirLightAccessorMethodForSymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/methods/FirLightAccessorMethodForSymbol.kt index 6b3caeeb277..9282450897e 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/methods/FirLightAccessorMethodForSymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/methods/FirLightAccessorMethodForSymbol.kt @@ -139,6 +139,7 @@ internal class FirLightAccessorMethodForSymbol( override fun equals(other: Any?): Boolean = this === other || (other is FirLightAccessorMethodForSymbol && + isGetter == other.isGetter && kotlinOrigin == other.kotlinOrigin && propertyAccessorSymbol == other.propertyAccessorSymbol) diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/methods/FirLightSimpleMethodForSymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/methods/FirLightSimpleMethodForSymbol.kt index 814a7c631a8..f511a5089f4 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/methods/FirLightSimpleMethodForSymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/methods/FirLightSimpleMethodForSymbol.kt @@ -22,13 +22,14 @@ internal class FirLightSimpleMethodForSymbol( containingClass: FirLightClassBase, methodIndex: Int, isTopLevel: Boolean, - argumentsSkipMask: BitSet? = null + argumentsSkipMask: BitSet? = null, + suppressStatic: Boolean = false ) : FirLightMethodForSymbol( functionSymbol = functionSymbol, lightMemberOrigin = lightMemberOrigin, containingClass = containingClass, methodIndex = methodIndex, - argumentsSkipMask = argumentsSkipMask + argumentsSkipMask = argumentsSkipMask, ) { private val _name: String by lazyPub { @@ -96,7 +97,7 @@ internal class FirLightSimpleMethodForSymbol( modifiers.add(_visibility) - if (functionSymbol.hasJvmStaticAnnotation()) { + if (!suppressStatic && functionSymbol.hasJvmStaticAnnotation()) { modifiers.add(PsiModifier.STATIC) } if (functionSymbol.hasAnnotation("kotlin/jvm/Strictfp", null)) { From 3019f439fbe00020fdc0a352b0106d4fcee13fb4 Mon Sep 17 00:00:00 2001 From: Igor Yakovlev Date: Tue, 8 Dec 2020 04:03:58 +0300 Subject: [PATCH 050/196] [FIR IDE] LC More accurate processing for JvmSynthetic and JvmHidden annotations --- .../api/symbols/KtPropertyAccessorSymbol.kt | 4 +++- .../asJava/annotations/annotationsUtils.kt | 13 +++++++------ .../idea/asJava/classes/firLightClassUtils.kt | 18 +++++++++--------- .../fir/symbols/KtFirPropertyGetterSymbol.kt | 5 +++++ .../fir/symbols/KtFirPropertySetterSymbol.kt | 5 +++++ 5 files changed, 29 insertions(+), 16 deletions(-) diff --git a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/KtPropertyAccessorSymbol.kt b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/KtPropertyAccessorSymbol.kt index f3c0dbfcf73..1436b587b21 100644 --- a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/KtPropertyAccessorSymbol.kt +++ b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/KtPropertyAccessorSymbol.kt @@ -10,7 +10,9 @@ import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtSymbolPointer sealed class KtPropertyAccessorSymbol : KtCallableSymbol(), KtSymbolWithModality, - KtSymbolWithVisibility { + KtSymbolWithVisibility, + KtAnnotatedSymbol { + abstract val isDefault: Boolean abstract val isInline: Boolean abstract val isOverride: Boolean diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/annotations/annotationsUtils.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/annotations/annotationsUtils.kt index 37407e233d7..1042171a89e 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/annotations/annotationsUtils.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/annotations/annotationsUtils.kt @@ -16,11 +16,12 @@ import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.references.FirNamedReference import org.jetbrains.kotlin.idea.frontend.api.fir.symbols.KtFirSymbol import org.jetbrains.kotlin.idea.frontend.api.fir.utils.mapAnnotationParameters +import org.jetbrains.kotlin.idea.frontend.api.symbols.KtPropertySymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtAnnotatedSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSimpleConstantValue import org.jetbrains.kotlin.psi.KtFile -internal fun KtAnnotatedSymbol.hasJvmSyntheticAnnotation(annotationUseSiteTarget: AnnotationUseSiteTarget?): Boolean = +internal fun KtAnnotatedSymbol.hasJvmSyntheticAnnotation(annotationUseSiteTarget: AnnotationUseSiteTarget? = null): Boolean = hasAnnotation("kotlin/jvm/JvmSynthetic", annotationUseSiteTarget) internal fun KtAnnotatedSymbol.getJvmNameFromAnnotation(annotationUseSiteTarget: AnnotationUseSiteTarget? = null): String? { @@ -35,15 +36,14 @@ internal fun KtAnnotatedSymbol.getJvmNameFromAnnotation(annotationUseSiteTarget: } } -internal fun KtAnnotatedSymbol.isHiddenByDeprecation(annotationUseSiteTarget: AnnotationUseSiteTarget?): Boolean { +internal fun KtAnnotatedSymbol.isHiddenByDeprecation(annotationUseSiteTarget: AnnotationUseSiteTarget? = null): Boolean { require(this is KtFirSymbol<*>) return this.firRef.withFir(FirResolvePhase.TYPES) { if (it !is FirAnnotatedDeclaration) return@withFir false val deprecatedAnnotationCall = it.annotations.firstOrNull { annotationCall -> - val siteTarget = annotationCall.useSiteTarget - (siteTarget == null || siteTarget == annotationUseSiteTarget) && + annotationCall.useSiteTarget == annotationUseSiteTarget && annotationCall.classId?.asString() == "kotlin/Deprecated" } ?: return@withFir false @@ -56,6 +56,8 @@ internal fun KtAnnotatedSymbol.isHiddenByDeprecation(annotationUseSiteTarget: An } } +internal fun KtAnnotatedSymbol.isHiddenOrSynthetic(annotationUseSiteTarget: AnnotationUseSiteTarget? = null) = + isHiddenByDeprecation(annotationUseSiteTarget) || hasJvmSyntheticAnnotation(annotationUseSiteTarget) internal fun KtAnnotatedSymbol.hasJvmFieldAnnotation(): Boolean = hasAnnotation("kotlin/jvm/JvmField", null) @@ -77,8 +79,7 @@ internal fun KtAnnotatedSymbol.hasInlineOnlyAnnotation(): Boolean = internal fun KtAnnotatedSymbol.hasAnnotation(classIdString: String, annotationUseSiteTarget: AnnotationUseSiteTarget?): Boolean = annotations.any { - val siteTarget = it.useSiteTarget - (siteTarget == null || siteTarget == annotationUseSiteTarget) && it.classId?.asString() == classIdString + it.useSiteTarget == annotationUseSiteTarget && it.classId?.asString() == classIdString } internal fun KtAnnotatedSymbol.computeAnnotations( diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/firLightClassUtils.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/firLightClassUtils.kt index a3cfb594314..55328f2947a 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/firLightClassUtils.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/firLightClassUtils.kt @@ -104,14 +104,10 @@ internal fun FirLightClassBase.createMethods( ) { for (declaration in declarations) { - if (declaration is KtFunctionSymbol && declaration.isInline) continue - - if (declaration is KtAnnotatedSymbol && declaration.hasJvmSyntheticAnnotation(annotationUseSiteTarget = null)) continue - - if (declaration is KtAnnotatedSymbol && declaration.isHiddenByDeprecation(annotationUseSiteTarget = null)) continue - when (declaration) { is KtFunctionSymbol -> { + if (declaration.isInline || declaration.isHiddenOrSynthetic()) continue + var methodIndex = METHOD_INDEX_BASE result.add( FirLightSimpleMethodForSymbol( @@ -147,6 +143,7 @@ internal fun FirLightClassBase.createMethods( } } is KtConstructorSymbol -> { + if (declaration.isHiddenOrSynthetic()) continue result.add( FirLightConstructorForSymbol( constructorSymbol = declaration, @@ -164,8 +161,9 @@ internal fun FirLightClassBase.createMethods( fun KtPropertyAccessorSymbol.needToCreateAccessor(siteTarget: AnnotationUseSiteTarget): Boolean { if (isInline) return false if (!hasBody && visibility == KtSymbolVisibility.PRIVATE) return false - return !declaration.hasJvmSyntheticAnnotation(siteTarget) - && !declaration.isHiddenByDeprecation(siteTarget) + if (declaration.isHiddenOrSynthetic(siteTarget)) return false + if (isHiddenOrSynthetic()) return false + return true } val getter = declaration.getter?.takeIf { @@ -212,13 +210,15 @@ internal fun FirLightClassBase.createField( takePropertyVisibility: Boolean, result: MutableList ) { + fun hasBackingField(property: KtPropertySymbol): Boolean = when (property) { is KtSyntheticJavaPropertySymbol -> true is KtKotlinPropertySymbol -> when { property.modality == KtCommonSymbolModality.ABSTRACT -> false + property.isHiddenOrSynthetic() -> false property.isLateInit -> true //IS PARAMETER -> true - !property.hasGetter && !property.hasSetter -> true + property.getter == null && property.setter == null -> true property.hasJvmSyntheticAnnotation(AnnotationUseSiteTarget.FIELD) -> false else -> property.hasBackingField } diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirPropertyGetterSymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirPropertyGetterSymbol.kt index 6e462353a26..193eb71817b 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirPropertyGetterSymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirPropertyGetterSymbol.kt @@ -13,9 +13,11 @@ import org.jetbrains.kotlin.idea.fir.findPsi import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirModuleResolveState import org.jetbrains.kotlin.idea.frontend.api.ValidityToken import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder +import org.jetbrains.kotlin.idea.frontend.api.fir.utils.convertAnnotation import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef import org.jetbrains.kotlin.idea.frontend.api.symbols.KtParameterSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.KtPropertyGetterSymbol +import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtAnnotationCall import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtCommonSymbolModality import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolKind import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolVisibility @@ -52,6 +54,9 @@ internal class KtFirPropertyGetterSymbol( override val type: KtType by firRef.withFirAndCache { builder.buildKtType(it.returnTypeRef) } override val modality: KtCommonSymbolModality get() = firRef.withFir(FirResolvePhase.STATUS) { it.modality.getSymbolModality() } override val visibility: KtSymbolVisibility get() = firRef.withFir(FirResolvePhase.STATUS) { it.visibility.getSymbolVisibility() } + override val annotations: List by firRef.withFirAndCache(FirResolvePhase.TYPES) { + convertAnnotation(it) + } override fun createPointer(): KtSymbolPointer { KtPsiBasedSymbolPointer.createForSymbolFromSource(this)?.let { return it } diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirPropertySetterSymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirPropertySetterSymbol.kt index 067ccff9f76..0e4a239656c 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirPropertySetterSymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirPropertySetterSymbol.kt @@ -13,9 +13,11 @@ import org.jetbrains.kotlin.idea.fir.findPsi import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirModuleResolveState import org.jetbrains.kotlin.idea.frontend.api.ValidityToken import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder +import org.jetbrains.kotlin.idea.frontend.api.fir.utils.convertAnnotation import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef import org.jetbrains.kotlin.idea.frontend.api.symbols.KtPropertySetterSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.KtSetterParameterSymbol +import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtAnnotationCall import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtCommonSymbolModality import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolKind import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolVisibility @@ -43,6 +45,9 @@ internal class KtFirPropertySetterSymbol( override val modality: KtCommonSymbolModality get() = firRef.withFir(FirResolvePhase.STATUS) { it.modality.getSymbolModality() } override val visibility: KtSymbolVisibility get() = firRef.withFir(FirResolvePhase.STATUS) { it.visibility.getSymbolVisibility() } + override val annotations: List by firRef.withFirAndCache(FirResolvePhase.TYPES) { + convertAnnotation(it) + } override val parameter: KtSetterParameterSymbol by firRef.withFirAndCache { fir -> builder.buildFirSetterParameter(fir.valueParameters.single()) } From 2e7866ca866a21cb1804319f1aee2617d71818ac Mon Sep 17 00:00:00 2001 From: Igor Yakovlev Date: Thu, 10 Dec 2020 03:09:11 +0300 Subject: [PATCH 051/196] [FIR IDE] LC Fix annotations and modifiers for class members --- .../asJava/classes/FirLightClassForFacade.kt | 15 +++++- .../asJava/classes/FirLightClassForSymbol.kt | 7 +-- ...irLightInterfaceOrAnnotationClassSymbol.kt | 2 +- .../idea/asJava/classes/firLightClassUtils.kt | 13 +++-- .../fields/FirLightFieldForObjectSymbol.kt | 2 +- .../fields/FirLightFieldForPropertySymbol.kt | 4 +- .../kotlin/idea/asJava/firLightUtils.kt | 25 +++++----- .../FirLightAccessorMethodForSymbol.kt | 50 ++++++++++++------- .../methods/FirLightConstructorForSymbol.kt | 2 +- .../methods/FirLightSimpleMethodForSymbol.kt | 39 +++++++-------- .../FirLightParameterForReceiver.kt | 2 +- .../parameters/FirLightParameterForSymbol.kt | 12 ++++- 12 files changed, 105 insertions(+), 68 deletions(-) diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightClassForFacade.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightClassForFacade.kt index 081fa3f7f8b..df736dafef1 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightClassForFacade.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightClassForFacade.kt @@ -27,6 +27,7 @@ import org.jetbrains.kotlin.idea.frontend.api.analyze import org.jetbrains.kotlin.idea.frontend.api.symbols.KtCallableSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.KtKotlinPropertySymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.KtPropertySymbol +import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolVisibility import org.jetbrains.kotlin.lexer.KtTokens import org.jetbrains.kotlin.load.java.structure.LightClassOriginKind import org.jetbrains.kotlin.name.FqName @@ -117,8 +118,18 @@ class FirLightClassForFacade( } for (propertySymbol in propertySymbols) { - val forceStaticAndPropertyVisibility = propertySymbol is KtKotlinPropertySymbol && propertySymbol.isConst - || propertySymbol.hasJvmFieldAnnotation() + val isLateInitWithPublicAccessors = if (propertySymbol is KtKotlinPropertySymbol && propertySymbol.isLateInit) { + val getterIsPublic = propertySymbol.getter?.toPsiVisibilityForMember(isTopLevel = true) + ?.let { it == PsiModifier.PUBLIC } ?: true + val setterIsPublic = propertySymbol.setter?.toPsiVisibilityForMember(isTopLevel = true) + ?.let { it == PsiModifier.PUBLIC } ?: true + getterIsPublic && setterIsPublic + } else false + + val forceStaticAndPropertyVisibility = isLateInitWithPublicAccessors || + (propertySymbol is KtKotlinPropertySymbol && propertySymbol.isConst) || + propertySymbol.hasJvmFieldAnnotation() + createField( propertySymbol, nameGenerator, diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightClassForSymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightClassForSymbol.kt index ec7b25a4f6d..e6a752f217f 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightClassForSymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightClassForSymbol.kt @@ -23,7 +23,7 @@ import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolVisibility import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolWithVisibility import org.jetbrains.kotlin.load.java.JvmAbi -internal open class FirLightClassForSymbol( +internal class FirLightClassForSymbol( private val classOrObjectSymbol: KtClassOrObjectSymbol, manager: PsiManager ) : FirLightClassForClassOrObjectSymbol(classOrObjectSymbol, manager) { @@ -54,7 +54,7 @@ internal open class FirLightClassForSymbol( private val _modifierList: PsiModifierList? by lazyPub { - val modifiers = mutableSetOf(classOrObjectSymbol.computeVisibility(isTopLevel)) + val modifiers = mutableSetOf(classOrObjectSymbol.toPsiVisibilityForClass(isTopLevel)) classOrObjectSymbol.computeSimpleModality()?.run { modifiers.add(this) } @@ -185,8 +185,9 @@ internal open class FirLightClassForSymbol( for (propertySymbol in propertySymbols) { val isJvmField = propertySymbol.hasJvmFieldAnnotation() val isJvmStatic = propertySymbol.hasJvmStaticAnnotation() + val forceStatic = isObject && (propertySymbol is KtKotlinPropertySymbol && propertySymbol.isConst || isJvmStatic || isJvmField) - val takePropertyVisibility = !isCompanionObject && (isJvmField || (isObject && isJvmStatic)) + val takePropertyVisibility = !isCompanionObject && (isJvmField || forceStatic) createField( declaration = propertySymbol, diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightInterfaceOrAnnotationClassSymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightInterfaceOrAnnotationClassSymbol.kt index 400f73b6dc1..71b174a480c 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightInterfaceOrAnnotationClassSymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightInterfaceOrAnnotationClassSymbol.kt @@ -29,7 +29,7 @@ internal abstract class FirLightInterfaceOrAnnotationClassSymbol( val isTopLevel: Boolean = classOrObjectSymbol.symbolKind == KtSymbolKind.TOP_LEVEL - val modifiers = mutableSetOf(classOrObjectSymbol.computeVisibility(isTopLevel), PsiModifier.ABSTRACT) + val modifiers = mutableSetOf(classOrObjectSymbol.toPsiVisibilityForClass(isTopLevel), PsiModifier.ABSTRACT) val annotations = classOrObjectSymbol.computeAnnotations( parent = this@FirLightInterfaceOrAnnotationClassSymbol, diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/firLightClassUtils.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/firLightClassUtils.kt index 55328f2947a..9b70a5e70a8 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/firLightClassUtils.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/firLightClassUtils.kt @@ -22,7 +22,6 @@ import org.jetbrains.kotlin.idea.asJava.* import org.jetbrains.kotlin.idea.frontend.api.analyze import org.jetbrains.kotlin.idea.frontend.api.fir.analyzeWithSymbolAsContext import org.jetbrains.kotlin.idea.frontend.api.symbols.* -import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtAnnotatedSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtCommonSymbolModality import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolVisibility import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolWithDeclarations @@ -155,8 +154,14 @@ internal fun FirLightClassBase.createMethods( } is KtPropertySymbol -> { + if (declaration is KtKotlinPropertySymbol && declaration.isConst) continue + + if (declaration.visibility == KtSymbolVisibility.PRIVATE && + declaration.getter?.hasBody == false && + declaration.setter?.hasBody == false + ) continue + if (declaration.hasJvmFieldAnnotation()) continue - if (declaration.visibility == KtSymbolVisibility.PRIVATE) continue fun KtPropertyAccessorSymbol.needToCreateAccessor(siteTarget: AnnotationUseSiteTarget): Boolean { if (isInline) return false @@ -217,8 +222,8 @@ internal fun FirLightClassBase.createField( property.modality == KtCommonSymbolModality.ABSTRACT -> false property.isHiddenOrSynthetic() -> false property.isLateInit -> true - //IS PARAMETER -> true - property.getter == null && property.setter == null -> true + //TODO Fix it when KtFirConstructorValueParameterSymbol be ready + property.psi.let { it == null || it is KtParameter } -> true property.hasJvmSyntheticAnnotation(AnnotationUseSiteTarget.FIELD) -> false else -> property.hasBackingField } diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/fields/FirLightFieldForObjectSymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/fields/FirLightFieldForObjectSymbol.kt index 579ed610fef..c34f14f1fbe 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/fields/FirLightFieldForObjectSymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/fields/FirLightFieldForObjectSymbol.kt @@ -25,7 +25,7 @@ internal class FirLightFieldForObjectSymbol( override fun getName(): String = name private val _modifierList: PsiModifierList by lazyPub { - val modifiers = setOf(objectSymbol.computeVisibility(isTopLevel = false), PsiModifier.STATIC, PsiModifier.FINAL) + val modifiers = setOf(objectSymbol.toPsiVisibilityForMember(isTopLevel = false), PsiModifier.STATIC, PsiModifier.FINAL) val notNullAnnotation = FirLightSimpleAnnotation("org.jetbrains.annotations.NotNull", this) FirLightClassModifierList(this, modifiers, listOf(notNullAnnotation)) } diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/fields/FirLightFieldForPropertySymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/fields/FirLightFieldForPropertySymbol.kt index e883a8701a0..f6b67561033 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/fields/FirLightFieldForPropertySymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/fields/FirLightFieldForPropertySymbol.kt @@ -69,7 +69,7 @@ internal class FirLightFieldForPropertySymbol( } val visibility = - if (takePropertyVisibility) propertySymbol.computeVisibility(isTopLevel = false) else PsiModifier.PRIVATE + if (takePropertyVisibility) propertySymbol.toPsiVisibilityForMember(isTopLevel = false) else PsiModifier.PRIVATE modifiers.add(visibility) if (!suppressFinal) { @@ -82,7 +82,7 @@ internal class FirLightFieldForPropertySymbol( modifiers.add(PsiModifier.VOLATILE) } - val nullability = if (visibility != PsiModifier.PRIVATE) + val nullability = if (visibility != PsiModifier.PRIVATE && !(propertySymbol is KtKotlinPropertySymbol && propertySymbol.isLateInit)) propertySymbol.type.getTypeNullability(propertySymbol, FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) else NullabilityType.Unknown diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/firLightUtils.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/firLightUtils.kt index 18f4a28617e..1a91c52d042 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/firLightUtils.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/firLightUtils.kt @@ -38,6 +38,7 @@ import org.jetbrains.kotlin.idea.frontend.api.symbols.* import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.* import org.jetbrains.kotlin.idea.frontend.api.types.* import org.jetbrains.kotlin.load.kotlin.TypeMappingMode +import org.jetbrains.kotlin.load.kotlin.TypeMappingModeInternals import org.jetbrains.kotlin.name.SpecialNames import org.jetbrains.kotlin.types.model.SimpleTypeMarker import java.text.StringCharacterIterator @@ -120,6 +121,7 @@ private fun ConeKotlinType.asPsiType( val correctedType = AnonymousTypesSubstitutor(session, state).substituteOrSelf(this) val signatureWriter = BothSignatureWriter(BothSignatureWriter.Mode.SKIP_CHECKS) + //TODO Check thread safety session.jvmTypeMapper.mapType(correctedType, mode, signatureWriter) @@ -225,23 +227,20 @@ internal fun KtSymbolWithModality.computeModalityForMeth } } -internal fun FirMemberDeclaration.computeVisibility(isTopLevel: Boolean): String { - return when (this.visibility) { - // Top-level private class has PACKAGE_LOCAL visibility in Java - // Nested private class has PRIVATE visibility - Visibilities.Private -> if (isTopLevel) PsiModifier.PACKAGE_LOCAL else PsiModifier.PRIVATE - Visibilities.Protected -> PsiModifier.PROTECTED - else -> PsiModifier.PUBLIC - } -} -internal fun KtSymbolWithVisibility.computeVisibility(isTopLevel: Boolean): String = - visibility.toPsiVisibility(isTopLevel) +internal fun KtSymbolWithVisibility.toPsiVisibilityForMember(isTopLevel: Boolean): String = + visibility.toPsiVisibility(isTopLevel, forClass = false) -internal fun KtSymbolVisibility.toPsiVisibility(isTopLevel: Boolean): String = when (this) { +internal fun KtSymbolWithVisibility.toPsiVisibilityForClass(isTopLevel: Boolean): String = + visibility.toPsiVisibility(isTopLevel, forClass = true) + +internal fun KtSymbolVisibility.toPsiVisibilityForMember(isTopLevel: Boolean): String = + toPsiVisibility(isTopLevel, forClass = false) + +private fun KtSymbolVisibility.toPsiVisibility(isTopLevel: Boolean, forClass: Boolean): String = when (this) { // Top-level private class has PACKAGE_LOCAL visibility in Java // Nested private class has PRIVATE visibility - KtSymbolVisibility.PRIVATE -> if (isTopLevel) PsiModifier.PACKAGE_LOCAL else PsiModifier.PRIVATE + KtSymbolVisibility.PRIVATE -> if (forClass && isTopLevel) PsiModifier.PACKAGE_LOCAL else PsiModifier.PRIVATE KtSymbolVisibility.PROTECTED -> PsiModifier.PROTECTED else -> PsiModifier.PUBLIC } diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/methods/FirLightAccessorMethodForSymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/methods/FirLightAccessorMethodForSymbol.kt index 9282450897e..6c1a2023e1a 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/methods/FirLightAccessorMethodForSymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/methods/FirLightAccessorMethodForSymbol.kt @@ -14,21 +14,19 @@ import org.jetbrains.kotlin.asJava.classes.lazyPub import org.jetbrains.kotlin.asJava.elements.FirLightIdentifier import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget import org.jetbrains.kotlin.fir.declarations.FirResolvePhase -import org.jetbrains.kotlin.idea.frontend.api.symbols.KtPropertyAccessorSymbol -import org.jetbrains.kotlin.idea.frontend.api.symbols.KtPropertyGetterSymbol -import org.jetbrains.kotlin.idea.frontend.api.symbols.KtPropertySetterSymbol -import org.jetbrains.kotlin.idea.frontend.api.symbols.KtPropertySymbol +import org.jetbrains.kotlin.idea.frontend.api.symbols.* import org.jetbrains.kotlin.idea.util.ifTrue import org.jetbrains.kotlin.load.java.JvmAbi.getterName import org.jetbrains.kotlin.load.java.JvmAbi.setterName import org.jetbrains.kotlin.psi.KtDeclaration +import org.jetbrains.kotlin.psi.KtParameter internal class FirLightAccessorMethodForSymbol( private val propertyAccessorSymbol: KtPropertyAccessorSymbol, - containingPropertySymbol: KtPropertySymbol, + private val containingPropertySymbol: KtPropertySymbol, lightMemberOrigin: LightMemberOrigin?, containingClass: FirLightClassBase, - isTopLevel: Boolean, + private val isTopLevel: Boolean, ) : FirLightMethod( lightMemberOrigin, containingClass, @@ -40,10 +38,12 @@ internal class FirLightAccessorMethodForSymbol( if (isGetter) getterName(this) else setterName(this) private val _name: String by lazyPub { - val defaultName = containingPropertySymbol.name.identifier.let { - if (containingClass.isAnnotationType) it else it.abiName() + propertyAccessorSymbol.getJvmNameFromAnnotation() ?: run { + val defaultName = containingPropertySymbol.name.identifier.let { + if (containingClass.isAnnotationType) it else it.abiName() + } + containingPropertySymbol.computeJvmMethodName(defaultName, containingClass, accessorSite) } - containingPropertySymbol.computeJvmMethodName(defaultName, containingClass, accessorSite) } override fun getName(): String = _name @@ -62,20 +62,34 @@ internal class FirLightAccessorMethodForSymbol( if (propertyAccessorSymbol is KtPropertyGetterSymbol) AnnotationUseSiteTarget.PROPERTY_GETTER else AnnotationUseSiteTarget.PROPERTY_SETTER - private val _annotations: List by lazyPub { + //TODO Fix it when KtFirConstructorValueParameterSymbol be ready + private val isParameter: Boolean get() = containingPropertySymbol.psi.let { it == null || it is KtParameter } - val nullabilityType = if (isGetter) containingPropertySymbol.type + private fun computeAnnotations(isPrivate: Boolean): List { + val nullabilityApplicable = isGetter && + !isPrivate && + !(isParameter && (containingClass.isAnnotationType || containingClass.isEnum)) + + val nullabilityType = if (nullabilityApplicable) containingPropertySymbol.type .getTypeNullability(containingPropertySymbol, FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) else NullabilityType.Unknown - containingPropertySymbol.computeAnnotations( + val annotationsFromProperty = containingPropertySymbol.computeAnnotations( parent = this, nullability = nullabilityType, annotationUseSiteTarget = accessorSite, ) + + val annotationsFromAccessor = propertyAccessorSymbol.computeAnnotations( + parent = this, + nullability = NullabilityType.Unknown, + annotationUseSiteTarget = null, + ) + + return annotationsFromProperty + annotationsFromAccessor } - private val _modifiers: Set by lazyPub { + private fun computeModifiers(): Set { val isOverrideMethod = propertyAccessorSymbol.isOverride || containingPropertySymbol.isOverride val isInterfaceMethod = containingClass.isInterface @@ -90,8 +104,8 @@ internal class FirLightAccessorMethodForSymbol( val visibility = isOverrideMethod.ifTrue { (containingClass as? FirLightClassForSymbol) ?.tryGetEffectiveVisibility(containingPropertySymbol) - ?.toPsiVisibility(isTopLevel) - } ?: propertyAccessorSymbol.computeVisibility(isTopLevel) + ?.toPsiVisibilityForMember(isTopLevel) + } ?: propertyAccessorSymbol.toPsiVisibilityForMember(isTopLevel) modifiers.add(visibility) if (containingPropertySymbol.hasJvmStaticAnnotation(accessorSite)) { @@ -102,11 +116,13 @@ internal class FirLightAccessorMethodForSymbol( modifiers.add(PsiModifier.ABSTRACT) } - modifiers + return modifiers } private val _modifierList: PsiModifierList by lazyPub { - FirLightClassModifierList(this, _modifiers, _annotations) + val modifiers = computeModifiers() + val annotations = computeAnnotations(modifiers.contains(PsiModifier.PRIVATE)) + FirLightClassModifierList(this, modifiers, annotations) } override fun getModifierList(): PsiModifierList = _modifierList diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/methods/FirLightConstructorForSymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/methods/FirLightConstructorForSymbol.kt index ccc75eb7f6f..ec4c7c6abb0 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/methods/FirLightConstructorForSymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/methods/FirLightConstructorForSymbol.kt @@ -42,7 +42,7 @@ internal class FirLightConstructorForSymbol( override fun isDeprecated(): Boolean = _isDeprecated private val _modifiers: Set by lazyPub { - setOf(constructorSymbol.computeVisibility(isTopLevel = false)) + setOf(constructorSymbol.toPsiVisibilityForMember(isTopLevel = false)) } private val _modifierList: PsiModifierList by lazyPub { diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/methods/FirLightSimpleMethodForSymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/methods/FirLightSimpleMethodForSymbol.kt index f511a5089f4..2f65a0c48f1 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/methods/FirLightSimpleMethodForSymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/methods/FirLightSimpleMethodForSymbol.kt @@ -21,9 +21,9 @@ internal class FirLightSimpleMethodForSymbol( lightMemberOrigin: LightMemberOrigin?, containingClass: FirLightClassBase, methodIndex: Int, - isTopLevel: Boolean, + private val isTopLevel: Boolean, argumentsSkipMask: BitSet? = null, - suppressStatic: Boolean = false + private val suppressStatic: Boolean = false ) : FirLightMethodForSymbol( functionSymbol = functionSymbol, lightMemberOrigin = lightMemberOrigin, @@ -55,35 +55,24 @@ internal class FirLightSimpleMethodForSymbol( override fun getTypeParameters(): Array = _typeParameterList?.typeParameters ?: PsiTypeParameter.EMPTY_ARRAY - private val _annotations: List by lazyPub { - val needUnknownNullability = - isVoidReturnType || (_visibility == PsiModifier.PRIVATE) - - val nullability = if (needUnknownNullability) + private fun computeAnnotations(isPrivate: Boolean): List { + val nullability = if (isVoidReturnType || isPrivate) NullabilityType.Unknown else functionSymbol.type.getTypeNullability( context = functionSymbol, phase = FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE ) - functionSymbol.computeAnnotations( + return functionSymbol.computeAnnotations( parent = this, nullability = nullability, annotationUseSiteTarget = null, ) } - private val _visibility: String by lazyPub { - functionSymbol.isOverride.ifTrue { - (containingClass as? FirLightClassForSymbol) - ?.tryGetEffectiveVisibility(functionSymbol) - ?.toPsiVisibility(isTopLevel) - } ?: functionSymbol.computeVisibility(isTopLevel = isTopLevel) - } + private fun computeModifiers(): Set { - private val _modifiers: Set by lazyPub { - - if (functionSymbol.hasInlineOnlyAnnotation()) return@lazyPub setOf(PsiModifier.FINAL, PsiModifier.PRIVATE) + if (functionSymbol.hasInlineOnlyAnnotation()) return setOf(PsiModifier.FINAL, PsiModifier.PRIVATE) val finalModifier = kotlinOrigin?.hasModifier(KtTokens.FINAL_KEYWORD) == true @@ -95,7 +84,13 @@ internal class FirLightSimpleMethodForSymbol( result = modifiers ) - modifiers.add(_visibility) + val visibility: String = functionSymbol.isOverride.ifTrue { + (containingClass as? FirLightClassForSymbol) + ?.tryGetEffectiveVisibility(functionSymbol) + ?.toPsiVisibilityForMember(isTopLevel) + } ?: functionSymbol.toPsiVisibilityForMember(isTopLevel = isTopLevel) + + modifiers.add(visibility) if (!suppressStatic && functionSymbol.hasJvmStaticAnnotation()) { modifiers.add(PsiModifier.STATIC) @@ -107,7 +102,7 @@ internal class FirLightSimpleMethodForSymbol( modifiers.add(PsiModifier.SYNCHRONIZED) } - modifiers + return modifiers } private val _isDeprecated: Boolean by lazyPub { @@ -117,7 +112,9 @@ internal class FirLightSimpleMethodForSymbol( override fun isDeprecated(): Boolean = _isDeprecated private val _modifierList: PsiModifierList by lazyPub { - FirLightClassModifierList(this, _modifiers, _annotations) + val modifiers = computeModifiers() + val annotations = computeAnnotations(modifiers.contains(PsiModifier.PRIVATE)) + FirLightClassModifierList(this, modifiers, annotations) } override fun getModifierList(): PsiModifierList = _modifierList diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/parameters/FirLightParameterForReceiver.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/parameters/FirLightParameterForReceiver.kt index 3c4b006df35..80fdfacfee3 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/parameters/FirLightParameterForReceiver.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/parameters/FirLightParameterForReceiver.kt @@ -59,7 +59,7 @@ internal class FirLightParameterForReceiver private constructor( override fun getName(): String = _name override fun isVarArgs() = false - override fun hasModifierProperty(name: String): Boolean = false //TODO() + override fun hasModifierProperty(name: String): Boolean = false override val kotlinOrigin: KtParameter? = null diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/parameters/FirLightParameterForSymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/parameters/FirLightParameterForSymbol.kt index 16fef101818..3af7b62caca 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/parameters/FirLightParameterForSymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/parameters/FirLightParameterForSymbol.kt @@ -10,6 +10,7 @@ import org.jetbrains.kotlin.asJava.classes.lazyPub import org.jetbrains.kotlin.asJava.elements.FirLightIdentifier import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget import org.jetbrains.kotlin.fir.declarations.FirResolvePhase +import org.jetbrains.kotlin.idea.frontend.api.symbols.KtFunctionLikeSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.KtParameterSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolKind import org.jetbrains.kotlin.idea.util.ifTrue @@ -34,11 +35,18 @@ internal class FirLightParameterForSymbol( AnnotationUseSiteTarget.CONSTRUCTOR_PARAMETER } + val nullabilityApplicable = !containingMethod.containingClass.let { it.isAnnotationType || it.isEnum } && + !containingMethod.hasModifierProperty(PsiModifier.PRIVATE) + + val nullabilityType = if (nullabilityApplicable) + parameterSymbol.type.getTypeNullability(parameterSymbol, FirResolvePhase.TYPES) + else NullabilityType.Unknown + parameterSymbol.computeAnnotations( parent = this, - nullability = parameterSymbol.type.getTypeNullability(parameterSymbol, FirResolvePhase.TYPES), + nullability = nullabilityType, annotationUseSiteTarget = annotationSite, - includeAnnotationsWithoutSite = false + includeAnnotationsWithoutSite = true ) } From 46071c192572c31cb1b0eb25776e594068914249 Mon Sep 17 00:00:00 2001 From: Igor Yakovlev Date: Fri, 11 Dec 2020 17:42:37 +0300 Subject: [PATCH 052/196] [FIR IDE] LC fix annotations with special sites and nullability --- .../ultraLightClasses/simpleFunctions.java | 2 +- .../markers/KtPossibleExtensionSymbol.kt | 4 +- .../FirLightAccessorMethodForSymbol.kt | 4 +- .../FirLightParameterBaseForSymbol.kt | 59 +++++++++++++++++++ .../FirLightParameterForReceiver.kt | 30 ++++------ .../parameters/FirLightParameterForSymbol.kt | 48 +++------------ .../FirLightSetterParameterForSymbol.kt | 51 ++++++++++++++++ .../api/fir/symbols/KtFirFunctionSymbol.kt | 17 ++++-- .../fir/symbols/KtFirKotlinPropertySymbol.kt | 12 +++- .../KtFirSyntheticJavaPropertySymbol.kt | 10 +++- .../idea/frontend/api/fir/utils/firUtils.kt | 2 +- .../api/fir/AbstractResolveCallTest.kt | 4 +- 12 files changed, 173 insertions(+), 70 deletions(-) create mode 100644 idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/parameters/FirLightParameterBaseForSymbol.kt create mode 100644 idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/parameters/FirLightSetterParameterForSymbol.kt diff --git a/compiler/testData/asJava/ultraLightClasses/simpleFunctions.java b/compiler/testData/asJava/ultraLightClasses/simpleFunctions.java index beea600e819..50ae6148ae6 100644 --- a/compiler/testData/asJava/ultraLightClasses/simpleFunctions.java +++ b/compiler/testData/asJava/ultraLightClasses/simpleFunctions.java @@ -12,7 +12,7 @@ public final class Foo /* Foo*/ { public Foo();// .ctor() - public final /* vararg */ void nullableVararg(@org.jetbrains.annotations.Nullable() java.lang.Object...);// nullableVararg(java.lang.Object[]) + public final /* vararg */ void nullableVararg(@org.jetbrains.annotations.NotNull() java.lang.Object...);// nullableVararg(java.lang.Object[]) public final int bar4();// bar4() diff --git a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/markers/KtPossibleExtensionSymbol.kt b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/markers/KtPossibleExtensionSymbol.kt index a8ebdec3a2c..5c5f5d71ca8 100644 --- a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/markers/KtPossibleExtensionSymbol.kt +++ b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/markers/KtPossibleExtensionSymbol.kt @@ -8,9 +8,11 @@ package org.jetbrains.kotlin.idea.frontend.api.symbols.markers import org.jetbrains.kotlin.idea.frontend.api.symbols.KtCallableSymbol import org.jetbrains.kotlin.idea.frontend.api.types.KtType +data class ReceiverTypeAndAnnotations(val type: KtType, val annotations: List) + interface KtPossibleExtensionSymbol { + val receiverTypeAndAnnotations: ReceiverTypeAndAnnotations? val isExtension: Boolean - val receiverType: KtType? } val KtCallableSymbol.isExtension: Boolean diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/methods/FirLightAccessorMethodForSymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/methods/FirLightAccessorMethodForSymbol.kt index 6c1a2023e1a..ff69b173709 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/methods/FirLightAccessorMethodForSymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/methods/FirLightAccessorMethodForSymbol.kt @@ -14,6 +14,7 @@ import org.jetbrains.kotlin.asJava.classes.lazyPub import org.jetbrains.kotlin.asJava.elements.FirLightIdentifier import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget import org.jetbrains.kotlin.fir.declarations.FirResolvePhase +import org.jetbrains.kotlin.idea.asJava.parameters.FirLightSetterParameterForSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.* import org.jetbrains.kotlin.idea.util.ifTrue import org.jetbrains.kotlin.load.java.JvmAbi.getterName @@ -173,8 +174,9 @@ internal class FirLightAccessorMethodForSymbol( if (propertyParameter != null) { builder.addParameter( - FirLightParameterForSymbol( + FirLightSetterParameterForSymbol( parameterSymbol = propertyParameter, + containingPropertySymbol = containingPropertySymbol, containingMethod = this@FirLightAccessorMethodForSymbol ) ) diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/parameters/FirLightParameterBaseForSymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/parameters/FirLightParameterBaseForSymbol.kt new file mode 100644 index 00000000000..a82b8e16e1a --- /dev/null +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/parameters/FirLightParameterBaseForSymbol.kt @@ -0,0 +1,59 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.idea.asJava + +import com.intellij.psi.* +import org.jetbrains.kotlin.asJava.classes.lazyPub +import org.jetbrains.kotlin.asJava.elements.FirLightIdentifier +import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget +import org.jetbrains.kotlin.fir.declarations.FirResolvePhase +import org.jetbrains.kotlin.idea.frontend.api.symbols.* +import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolKind +import org.jetbrains.kotlin.idea.util.ifTrue +import org.jetbrains.kotlin.psi.KtParameter + +internal abstract class FirLightParameterBaseForSymbol( + private val parameterSymbol: KtParameterSymbol, + private val containingMethod: FirLightMethod +) : FirLightParameter(containingMethod) { + private val _name: String = parameterSymbol.name.asString() + override fun getName(): String = _name + + override fun hasModifierProperty(name: String): Boolean = + modifierList.hasModifierProperty(name) + + override val kotlinOrigin: KtParameter? = parameterSymbol.psi as? KtParameter + + abstract override fun getModifierList(): PsiModifierList + + private val _identifier: PsiIdentifier by lazyPub { + FirLightIdentifier(this, parameterSymbol) + } + + protected val nullabilityType: NullabilityType get() { + val nullabilityApplicable = !containingMethod.containingClass.let { it.isAnnotationType || it.isEnum } && + !containingMethod.hasModifierProperty(PsiModifier.PRIVATE) + + return if (nullabilityApplicable) parameterSymbol.type.getTypeNullability(parameterSymbol, FirResolvePhase.TYPES) + else NullabilityType.Unknown + } + + override fun getNameIdentifier(): PsiIdentifier = _identifier + + private val _type by lazyPub { + val convertedType = parameterSymbol.asPsiType(this, FirResolvePhase.TYPES) + + if (convertedType is PsiArrayType && parameterSymbol.isVararg) { + PsiEllipsisType(convertedType.componentType, convertedType.annotationProvider) + } else convertedType + } + + override fun getType(): PsiType = _type + + abstract override fun equals(other: Any?): Boolean + + abstract override fun hashCode(): Int +} \ No newline at end of file diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/parameters/FirLightParameterForReceiver.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/parameters/FirLightParameterForReceiver.kt index 80fdfacfee3..70d0009b084 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/parameters/FirLightParameterForReceiver.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/parameters/FirLightParameterForReceiver.kt @@ -11,19 +11,17 @@ import com.intellij.psi.PsiModifierList import com.intellij.psi.PsiType import org.jetbrains.kotlin.asJava.classes.lazyPub import org.jetbrains.kotlin.codegen.AsmUtil -import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget import org.jetbrains.kotlin.fir.declarations.FirResolvePhase import org.jetbrains.kotlin.idea.frontend.api.symbols.KtCallableSymbol -import org.jetbrains.kotlin.idea.frontend.api.symbols.KtFunctionLikeSymbol -import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtAnnotatedSymbol +import org.jetbrains.kotlin.idea.frontend.api.symbols.KtSymbol +import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.ReceiverTypeAndAnnotations import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtNamedSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtPossibleExtensionSymbol -import org.jetbrains.kotlin.idea.frontend.api.types.KtType import org.jetbrains.kotlin.psi.KtParameter internal class FirLightParameterForReceiver private constructor( - private val annotatedSymbol: KtAnnotatedSymbol, - type: KtType, + private val receiverTypeAndAnnotations: ReceiverTypeAndAnnotations, + private val context: KtSymbol, methodName: String, method: FirLightMethod ) : FirLightParameter(method) { @@ -35,15 +33,14 @@ internal class FirLightParameterForReceiver private constructor( ): FirLightParameterForReceiver? { if (callableSymbol !is KtNamedSymbol) return null - if (callableSymbol !is KtAnnotatedSymbol) return null if (callableSymbol !is KtPossibleExtensionSymbol) return null if (!callableSymbol.isExtension) return null - val receiverType = callableSymbol.receiverType ?: return null + val extensionTypeAndAnnotations = callableSymbol.receiverTypeAndAnnotations ?: return null return FirLightParameterForReceiver( - annotatedSymbol = callableSymbol, - type = receiverType, + receiverTypeAndAnnotations = extensionTypeAndAnnotations, + context = callableSymbol, methodName = callableSymbol.name.asString(), method = method ) @@ -64,11 +61,9 @@ internal class FirLightParameterForReceiver private constructor( override val kotlinOrigin: KtParameter? = null private val _annotations: List by lazyPub { - annotatedSymbol.computeAnnotations( - parent = this, - nullability = type.getTypeNullability(annotatedSymbol, FirResolvePhase.TYPES), - annotationUseSiteTarget = AnnotationUseSiteTarget.RECEIVER, - ) + receiverTypeAndAnnotations.annotations.map { + FirLightAnnotationForAnnotationCall(it, this) + } } override fun getModifierList(): PsiModifierList = _modifierList @@ -77,7 +72,7 @@ internal class FirLightParameterForReceiver private constructor( } private val _type: PsiType by lazyPub { - type.asPsiType(annotatedSymbol, method, FirResolvePhase.TYPES) + receiverTypeAndAnnotations.type.asPsiType(context, method, FirResolvePhase.TYPES) } override fun getType(): PsiType = _type @@ -85,8 +80,7 @@ internal class FirLightParameterForReceiver private constructor( override fun equals(other: Any?): Boolean = this === other || (other is FirLightParameterForReceiver && - kotlinOrigin == other.kotlinOrigin && - annotatedSymbol == other.annotatedSymbol) + receiverTypeAndAnnotations == other.receiverTypeAndAnnotations) override fun hashCode(): Int = kotlinOrigin.hashCode() } diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/parameters/FirLightParameterForSymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/parameters/FirLightParameterForSymbol.kt index 3af7b62caca..816679c1ad1 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/parameters/FirLightParameterForSymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/parameters/FirLightParameterForSymbol.kt @@ -5,46 +5,30 @@ package org.jetbrains.kotlin.idea.asJava -import com.intellij.psi.* +import com.intellij.psi.PsiAnnotation +import com.intellij.psi.PsiModifierList import org.jetbrains.kotlin.asJava.classes.lazyPub -import org.jetbrains.kotlin.asJava.elements.FirLightIdentifier import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget -import org.jetbrains.kotlin.fir.declarations.FirResolvePhase -import org.jetbrains.kotlin.idea.frontend.api.symbols.KtFunctionLikeSymbol +import org.jetbrains.kotlin.idea.frontend.api.symbols.KtConstructorParameterSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.KtParameterSymbol -import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolKind import org.jetbrains.kotlin.idea.util.ifTrue -import org.jetbrains.kotlin.psi.KtParameter internal class FirLightParameterForSymbol( private val parameterSymbol: KtParameterSymbol, containingMethod: FirLightMethod -) : FirLightParameter(containingMethod) { - private val _name: String = parameterSymbol.name.asString() - override fun getName(): String = _name - - private val _isVarArgs: Boolean = parameterSymbol.isVararg - override fun isVarArgs() = _isVarArgs - override fun hasModifierProperty(name: String): Boolean = - modifierList.hasModifierProperty(name) - - override val kotlinOrigin: KtParameter? = parameterSymbol.psi as? KtParameter +) : FirLightParameterBaseForSymbol(parameterSymbol, containingMethod) { private val _annotations: List by lazyPub { - val annotationSite = (containingMethod.isConstructor && parameterSymbol.symbolKind == KtSymbolKind.MEMBER).ifTrue { + + val annotationSite = (parameterSymbol is KtConstructorParameterSymbol).ifTrue { AnnotationUseSiteTarget.CONSTRUCTOR_PARAMETER } - val nullabilityApplicable = !containingMethod.containingClass.let { it.isAnnotationType || it.isEnum } && - !containingMethod.hasModifierProperty(PsiModifier.PRIVATE) - - val nullabilityType = if (nullabilityApplicable) - parameterSymbol.type.getTypeNullability(parameterSymbol, FirResolvePhase.TYPES) - else NullabilityType.Unknown + val nullability = if (parameterSymbol.isVararg) NullabilityType.NotNull else super.nullabilityType parameterSymbol.computeAnnotations( parent = this, - nullability = nullabilityType, + nullability = nullability, annotationUseSiteTarget = annotationSite, includeAnnotationsWithoutSite = true ) @@ -55,21 +39,7 @@ internal class FirLightParameterForSymbol( FirLightClassModifierList(this, emptySet(), _annotations) } - private val _identifier: PsiIdentifier by lazyPub { - FirLightIdentifier(this, parameterSymbol) - } - - override fun getNameIdentifier(): PsiIdentifier = _identifier - - private val _type by lazyPub { - val convertedType = parameterSymbol.asPsiType(this, FirResolvePhase.TYPES) - - if (convertedType is PsiArrayType && parameterSymbol.isVararg) { - PsiEllipsisType(convertedType.componentType, convertedType.annotationProvider) - } else convertedType - } - - override fun getType(): PsiType = _type + override fun isVarArgs() = parameterSymbol.isVararg override fun equals(other: Any?): Boolean = this === other || diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/parameters/FirLightSetterParameterForSymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/parameters/FirLightSetterParameterForSymbol.kt new file mode 100644 index 00000000000..7a5971a6bdc --- /dev/null +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/parameters/FirLightSetterParameterForSymbol.kt @@ -0,0 +1,51 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.idea.asJava.parameters + +import com.intellij.psi.PsiAnnotation +import com.intellij.psi.PsiModifierList +import org.jetbrains.kotlin.asJava.classes.lazyPub +import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget +import org.jetbrains.kotlin.idea.asJava.* +import org.jetbrains.kotlin.idea.frontend.api.symbols.KtParameterSymbol +import org.jetbrains.kotlin.idea.frontend.api.symbols.KtPropertySymbol + +internal class FirLightSetterParameterForSymbol( + private val containingPropertySymbol: KtPropertySymbol, + private val parameterSymbol: KtParameterSymbol, + containingMethod: FirLightMethod +) : FirLightParameterBaseForSymbol(parameterSymbol, containingMethod) { + + private val _annotations: List by lazyPub { + val annotationsFomSetter = parameterSymbol.computeAnnotations( + parent = this, + nullability = NullabilityType.Unknown, + annotationUseSiteTarget = null, + ) + + val annotationsFromProperty = containingPropertySymbol.computeAnnotations( + parent = this, + nullability = nullabilityType, + annotationUseSiteTarget = AnnotationUseSiteTarget.SETTER_PARAMETER, + includeAnnotationsWithoutSite = false + ) + + annotationsFomSetter + annotationsFromProperty + } + + override fun getModifierList(): PsiModifierList = _modifierList + private val _modifierList: PsiModifierList by lazyPub { + FirLightClassModifierList(this, emptySet(), _annotations) + } + + override fun isVarArgs() = false + + override fun equals(other: Any?): Boolean = + this === other || + (other is FirLightSetterParameterForSymbol && parameterSymbol == other.parameterSymbol) + + override fun hashCode(): Int = kotlinOrigin.hashCode() +} \ No newline at end of file diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirFunctionSymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirFunctionSymbol.kt index 3988cb6c273..dde0978d932 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirFunctionSymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirFunctionSymbol.kt @@ -18,10 +18,7 @@ import org.jetbrains.kotlin.idea.frontend.api.fir.symbols.pointers.createSignatu import org.jetbrains.kotlin.idea.frontend.api.fir.utils.convertAnnotation import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef import org.jetbrains.kotlin.idea.frontend.api.symbols.KtFunctionSymbol -import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtAnnotationCall -import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtCommonSymbolModality -import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolKind -import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolVisibility +import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.* import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.CanNotCreateSymbolPointerForLocalLibraryDeclarationException import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtPsiBasedSymbolPointer import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtSymbolPointer @@ -57,7 +54,17 @@ internal class KtFirFunctionSymbol( override val isSuspend: Boolean get() = firRef.withFir { it.isSuspend } override val isOverride: Boolean get() = firRef.withFir { it.isOverride } - override val receiverType: KtType? by firRef.withFirAndCache(FirResolvePhase.TYPES) { fir -> fir.receiverTypeRef?.let(builder::buildKtType) } + + override val receiverTypeAndAnnotations: ReceiverTypeAndAnnotations? by firRef.withFirAndCache(FirResolvePhase.TYPES) { fir -> + fir.receiverTypeRef?.let { typeRef -> + val type = builder.buildKtType(typeRef) + val annotations = typeRef.annotations.mapNotNull { + convertAnnotation(it, fir.session) + } + ReceiverTypeAndAnnotations(type, annotations) + } + } + override val isOperator: Boolean get() = firRef.withFir { it.isOperator } override val isExternal: Boolean get() = firRef.withFir { it.isExternal } override val isInline: Boolean get() = firRef.withFir { it.isInline } diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirKotlinPropertySymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirKotlinPropertySymbol.kt index 98dad745964..4b6b76392ab 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirKotlinPropertySymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirKotlinPropertySymbol.kt @@ -47,7 +47,17 @@ internal class KtFirKotlinPropertySymbol( override val isVal: Boolean get() = firRef.withFir { it.isVal } override val name: Name get() = firRef.withFir { it.name } override val type: KtType by firRef.withFirAndCache(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) { fir -> builder.buildKtType(fir.returnTypeRef) } - override val receiverType: KtType? by firRef.withFirAndCache(FirResolvePhase.TYPES) { fir -> fir.receiverTypeRef?.let(builder::buildKtType) } + + override val receiverTypeAndAnnotations: ReceiverTypeAndAnnotations? by firRef.withFirAndCache(FirResolvePhase.TYPES) { fir -> + fir.receiverTypeRef?.let { typeRef -> + val type = builder.buildKtType(typeRef) + val annotations = typeRef.annotations.mapNotNull { + convertAnnotation(it, fir.session) + } + ReceiverTypeAndAnnotations(type, annotations) + } + } + override val isExtension: Boolean get() = firRef.withFir { it.receiverTypeRef != null } override val initializer: KtConstantValue? by firRef.withFirAndCache(FirResolvePhase.BODY_RESOLVE) { fir -> fir.initializer?.convertConstantExpression() } override val symbolKind: KtSymbolKind diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirSyntheticJavaPropertySymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirSyntheticJavaPropertySymbol.kt index cc0d7697cc9..c926a7bdfe6 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirSyntheticJavaPropertySymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirSyntheticJavaPropertySymbol.kt @@ -42,7 +42,15 @@ internal class KtFirSyntheticJavaPropertySymbol( override val isVal: Boolean get() = firRef.withFir { it.isVal } override val name: Name get() = firRef.withFir { it.name } override val type: KtType by firRef.withFirAndCache(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) { fir -> builder.buildKtType(fir.returnTypeRef) } - override val receiverType: KtType? by firRef.withFirAndCache(FirResolvePhase.TYPES) { fir -> fir.receiverTypeRef?.let(builder::buildKtType) } + override val receiverTypeAndAnnotations: ReceiverTypeAndAnnotations? by firRef.withFirAndCache(FirResolvePhase.TYPES) { fir -> + fir.receiverTypeRef?.let { typeRef -> + val type = builder.buildKtType(typeRef) + val annotations = typeRef.annotations.mapNotNull { + convertAnnotation(it, fir.session) + } + ReceiverTypeAndAnnotations(type, annotations) + } + } override val isExtension: Boolean get() = firRef.withFir { it.receiverTypeRef != null } override val initializer: KtConstantValue? by firRef.withFirAndCache(FirResolvePhase.BODY_RESOLVE) { fir -> fir.initializer?.convertConstantExpression() } diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/utils/firUtils.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/utils/firUtils.kt index b8c7c98cdf6..93351990952 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/utils/firUtils.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/utils/firUtils.kt @@ -64,7 +64,7 @@ private fun ConeClassLikeType.expandTypeAliasIfNeeded(session: FirSession): Cone ?: return this } -private fun convertAnnotation( +internal fun convertAnnotation( annotationCall: FirAnnotationCall, session: FirSession ): KtFirAnnotationCall? { diff --git a/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/fir/AbstractResolveCallTest.kt b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/fir/AbstractResolveCallTest.kt index 622a493f1ec..496afa0cde9 100644 --- a/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/fir/AbstractResolveCallTest.kt +++ b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/fir/AbstractResolveCallTest.kt @@ -94,8 +94,8 @@ private fun KtCall.stringRepresentation(): String { is KtFunctionLikeSymbol -> buildString { append(if (this@stringValue is KtFunctionSymbol) callableIdIfNonLocal ?: name else "") append("(") - (this@stringValue as? KtFunctionSymbol)?.receiverType?.let { receiver -> - append(": ${receiver.render()}") + (this@stringValue as? KtFunctionSymbol)?.receiverTypeAndAnnotations?.let { receiver -> + append(": ${receiver.type.render()}") if (valueParameters.isNotEmpty()) append(", ") } valueParameters.joinTo(this) { parameter -> From fb63b74b37a6d2891cf70af787ac44db911066e4 Mon Sep 17 00:00:00 2001 From: Igor Yakovlev Date: Fri, 11 Dec 2020 20:18:27 +0300 Subject: [PATCH 053/196] [FIR IDE] LC Add KtFileSymbol and fix facade annotations --- .../idea/frontend/api/KtAnalysisSession.kt | 2 + .../idea/frontend/api/symbols/KtFileSymbol.kt | 13 ++++++ .../frontend/api/symbols/KtSymbolProvider.kt | 1 + .../asJava/annotations/annotationsUtils.kt | 13 +++--- .../asJava/classes/FirLightClassForFacade.kt | 21 ++++++++-- .../frontend/api/fir/KtSymbolByFirBuilder.kt | 9 ++++- .../api/fir/symbols/KtFirFileSymbol.kt | 40 +++++++++++++++++++ .../api/fir/symbols/KtFirSymbolProvider.kt | 5 +++ 8 files changed, 91 insertions(+), 13 deletions(-) create mode 100644 idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/KtFileSymbol.kt create mode 100644 idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirFileSymbol.kt diff --git a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/KtAnalysisSession.kt b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/KtAnalysisSession.kt index 87d92fa5959..cd6d5c9d1e7 100644 --- a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/KtAnalysisSession.kt +++ b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/KtAnalysisSession.kt @@ -121,6 +121,8 @@ abstract class KtAnalysisSession(final override val token: ValidityToken) : Vali fun KtPropertyAccessor.getPropertyAccessorSymbol(): KtPropertyAccessorSymbol = symbolProvider.getPropertyAccessorSymbol(this) + fun KtFile.getFileSymbol(): KtFileSymbol = symbolProvider.getFileSymbol(this) + /** * @return symbol with specified [this@getClassOrObjectSymbolByClassId] or `null` in case such symbol is not found */ diff --git a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/KtFileSymbol.kt b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/KtFileSymbol.kt new file mode 100644 index 00000000000..ecc70c37c8b --- /dev/null +++ b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/KtFileSymbol.kt @@ -0,0 +1,13 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.idea.frontend.api.symbols + +import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtAnnotatedSymbol +import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtSymbolPointer + +abstract class KtFileSymbol : KtAnnotatedSymbol { + abstract override fun createPointer(): KtSymbolPointer +} \ No newline at end of file diff --git a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/KtSymbolProvider.kt b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/KtSymbolProvider.kt index cbb9955aeb7..c4381a90d6e 100644 --- a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/KtSymbolProvider.kt +++ b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/KtSymbolProvider.kt @@ -30,6 +30,7 @@ abstract class KtSymbolProvider : KtAnalysisSessionComponent() { } abstract fun getParameterSymbol(psi: KtParameter): KtParameterSymbol + abstract fun getFileSymbol(psi: KtFile): KtFileSymbol abstract fun getFunctionSymbol(psi: KtNamedFunction): KtFunctionSymbol abstract fun getConstructorSymbol(psi: KtConstructor<*>): KtConstructorSymbol abstract fun getTypeParameterSymbol(psi: KtTypeParameter): KtTypeParameterSymbol diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/annotations/annotationsUtils.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/annotations/annotationsUtils.kt index 1042171a89e..6731923c6c5 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/annotations/annotationsUtils.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/annotations/annotationsUtils.kt @@ -16,6 +16,7 @@ import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.references.FirNamedReference import org.jetbrains.kotlin.idea.frontend.api.fir.symbols.KtFirSymbol import org.jetbrains.kotlin.idea.frontend.api.fir.utils.mapAnnotationParameters +import org.jetbrains.kotlin.idea.frontend.api.symbols.KtFileSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.KtPropertySymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtAnnotatedSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSimpleConstantValue @@ -24,6 +25,9 @@ import org.jetbrains.kotlin.psi.KtFile internal fun KtAnnotatedSymbol.hasJvmSyntheticAnnotation(annotationUseSiteTarget: AnnotationUseSiteTarget? = null): Boolean = hasAnnotation("kotlin/jvm/JvmSynthetic", annotationUseSiteTarget) +internal fun KtFileSymbol.hasJvmMultifileClassAnnotation(): Boolean = + hasAnnotation("kotlin/jvm/JvmMultifileClass", AnnotationUseSiteTarget.FILE) + internal fun KtAnnotatedSymbol.getJvmNameFromAnnotation(annotationUseSiteTarget: AnnotationUseSiteTarget? = null): String? { val annotation = annotations.firstOrNull { val siteTarget = it.useSiteTarget @@ -120,11 +124,4 @@ internal fun KtAnnotatedSymbol.computeAnnotations( } return result -} - -internal fun KtFile.hasJvmMultifileClassAnnotation(): Boolean = this.annotationEntries - .filter { - it.useSiteTarget?.getAnnotationUseSiteTarget() == AnnotationUseSiteTarget.FILE - }.any { - it.shortName?.asString() == "JvmMultifileClass" - } \ No newline at end of file +} \ No newline at end of file diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightClassForFacade.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightClassForFacade.kt index df736dafef1..d7e809829e4 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightClassForFacade.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightClassForFacade.kt @@ -20,6 +20,7 @@ import org.jetbrains.kotlin.asJava.classes.lazyPub import org.jetbrains.kotlin.asJava.elements.FakeFileForLightClass import org.jetbrains.kotlin.asJava.elements.KtLightField import org.jetbrains.kotlin.asJava.elements.KtLightMethod +import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget import org.jetbrains.kotlin.idea.KotlinLanguage import org.jetbrains.kotlin.idea.asJava.classes.createField import org.jetbrains.kotlin.idea.asJava.classes.createMethods @@ -51,14 +52,28 @@ class FirLightClassForFacade( override val clsDelegate: PsiClass get() = invalidAccess() + private val fileSymbols by lazyPub { + files.map { ktFile -> + analyze(ktFile) { + ktFile.getFileSymbol() + } + } + } + private val _modifierList: PsiModifierList by lazyPub { if (multiFileClass) return@lazyPub LightModifierList(manager, KotlinLanguage.INSTANCE, PsiModifier.PUBLIC, PsiModifier.FINAL) val modifiers = setOf(PsiModifier.PUBLIC, PsiModifier.FINAL) - //TODO make annotations for file site - val annotations: List = emptyList() + val annotations = fileSymbols.flatMap { + it.computeAnnotations( + this@FirLightClassForFacade, + NullabilityType.Unknown, + AnnotationUseSiteTarget.FILE, + includeAnnotationsWithoutSite = false + ) + } FirLightClassModifierList(this@FirLightClassForFacade, modifiers, annotations) } @@ -95,7 +110,7 @@ class FirLightClassForFacade( } private val multiFileClass: Boolean by lazyPub { - files.size > 1 || files.any { it.hasJvmMultifileClassAnnotation() } + files.size > 1 || fileSymbols.any { it.hasJvmMultifileClassAnnotation() } } private fun loadFieldsFromFile( diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/KtSymbolByFirBuilder.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/KtSymbolByFirBuilder.kt index edec83d27c8..bf887c7db11 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/KtSymbolByFirBuilder.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/KtSymbolByFirBuilder.kt @@ -40,6 +40,7 @@ internal class KtSymbolByFirBuilder private constructor( override val token: ValidityToken, val withReadOnlyCaching: Boolean, private val symbolsCache: BuilderCache, + private val filesCache: BuilderCache, private val typesCache: BuilderCache ) : ValidityTokenOwner { private val resolveState by weakRef(resolveState) @@ -56,7 +57,8 @@ internal class KtSymbolByFirBuilder private constructor( resolveState = resolveState, withReadOnlyCaching = false, symbolsCache = BuilderCache(), - typesCache = BuilderCache() + typesCache = BuilderCache(), + filesCache = BuilderCache(), ) @@ -68,7 +70,8 @@ internal class KtSymbolByFirBuilder private constructor( resolveState = newResolveState, withReadOnlyCaching = true, symbolsCache = symbolsCache.createReadOnlyCopy(), - typesCache = typesCache.createReadOnlyCopy() + typesCache = typesCache.createReadOnlyCopy(), + filesCache = filesCache.createReadOnlyCopy(), ) } @@ -139,6 +142,8 @@ internal class KtSymbolByFirBuilder private constructor( fun buildAnonymousFunctionSymbol(fir: FirAnonymousFunction) = symbolsCache.cache(fir) { KtFirAnonymousFunctionSymbol(fir, resolveState, token, this) } + fun buildFileSymbol(fir: FirFile) = filesCache.cache(fir) { KtFirFileSymbol(fir, resolveState, token, this) } + fun buildVariableSymbol(fir: FirProperty): KtVariableSymbol = symbolsCache.cache(fir) { when { fir.isLocal -> KtFirLocalVariableSymbol(fir, resolveState, token, this) diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirFileSymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirFileSymbol.kt new file mode 100644 index 00000000000..bc810e90b06 --- /dev/null +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirFileSymbol.kt @@ -0,0 +1,40 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.idea.frontend.api.fir.symbols + +import com.intellij.psi.PsiElement +import org.jetbrains.kotlin.fir.declarations.FirFile +import org.jetbrains.kotlin.fir.declarations.FirResolvePhase +import org.jetbrains.kotlin.idea.fir.findPsi +import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirModuleResolveState +import org.jetbrains.kotlin.idea.frontend.api.ValidityToken +import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder +import org.jetbrains.kotlin.idea.frontend.api.fir.utils.convertAnnotation +import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef +import org.jetbrains.kotlin.idea.frontend.api.symbols.KtFileSymbol +import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtAnnotationCall +import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtPsiBasedSymbolPointer +import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtSymbolPointer + +internal class KtFirFileSymbol( + fir: FirFile, + resolveState: FirModuleResolveState, + override val token: ValidityToken, + private val builder: KtSymbolByFirBuilder +) : KtFileSymbol(), KtFirSymbol { + + override val firRef = firRef(fir, resolveState) + override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.findPsi(fir.session) } + + override fun createPointer(): KtSymbolPointer { + KtPsiBasedSymbolPointer.createForSymbolFromSource(this)?.let { return it } + TODO("Creating pointers for files from library is not supported yet") + } + + override val annotations: List by firRef.withFirAndCache(FirResolvePhase.TYPES) { + convertAnnotation(it) + } +} \ No newline at end of file diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirSymbolProvider.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirSymbolProvider.kt index 027dbc18cd9..6ea38bc1d3a 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirSymbolProvider.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirSymbolProvider.kt @@ -9,6 +9,7 @@ import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirModuleResolveState +import org.jetbrains.kotlin.idea.fir.low.level.api.api.getFirFile import org.jetbrains.kotlin.idea.fir.low.level.api.api.getOrBuildFirOfType import org.jetbrains.kotlin.idea.fir.low.level.api.api.withFirDeclarationOfType import org.jetbrains.kotlin.idea.frontend.api.KtAnalysisSession @@ -38,6 +39,10 @@ internal class KtFirSymbolProvider( } } + override fun getFileSymbol(psi: KtFile): KtFileSymbol = withValidityAssertion { + firSymbolBuilder.buildFileSymbol(psi.getFirFile(resolveState)) + } + override fun getFunctionSymbol(psi: KtNamedFunction): KtFunctionSymbol = withValidityAssertion { psi.withFirDeclarationOfType(resolveState) { firSymbolBuilder.buildFunctionSymbol(it) From da54dbba8eff974b4f60dc5cd65ccb65197067ec Mon Sep 17 00:00:00 2001 From: Igor Yakovlev Date: Fri, 11 Dec 2020 21:11:41 +0300 Subject: [PATCH 054/196] [FIR IDE] LC Add callable declarations to KtFileSymbol --- .../idea/frontend/api/symbols/KtFileSymbol.kt | 3 + .../asJava/classes/FirLightClassForFacade.kt | 76 +++++++------------ .../api/fir/symbols/KtFirFileSymbol.kt | 10 ++- 3 files changed, 40 insertions(+), 49 deletions(-) diff --git a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/KtFileSymbol.kt b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/KtFileSymbol.kt index ecc70c37c8b..8be87b279e5 100644 --- a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/KtFileSymbol.kt +++ b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/KtFileSymbol.kt @@ -9,5 +9,8 @@ import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtAnnotatedSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtSymbolPointer abstract class KtFileSymbol : KtAnnotatedSymbol { + + abstract val topLevelCallableSymbols: List + abstract override fun createPointer(): KtSymbolPointer } \ No newline at end of file diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightClassForFacade.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightClassForFacade.kt index d7e809829e4..4dd067930bf 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightClassForFacade.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightClassForFacade.kt @@ -12,31 +12,26 @@ import com.intellij.psi.impl.light.LightEmptyImplementsList import com.intellij.psi.impl.light.LightModifierList import org.jetbrains.annotations.NonNls import org.jetbrains.kotlin.asJava.classes.* -import org.jetbrains.kotlin.asJava.elements.* -import org.jetbrains.kotlin.fileClasses.javaFileFacadeFqName -import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacade import org.jetbrains.kotlin.asJava.classes.lazyPub -import org.jetbrains.kotlin.asJava.elements.FakeFileForLightClass -import org.jetbrains.kotlin.asJava.elements.KtLightField -import org.jetbrains.kotlin.asJava.elements.KtLightMethod +import org.jetbrains.kotlin.asJava.elements.* import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget +import org.jetbrains.kotlin.fileClasses.javaFileFacadeFqName +import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.idea.KotlinLanguage import org.jetbrains.kotlin.idea.asJava.classes.createField import org.jetbrains.kotlin.idea.asJava.classes.createMethods import org.jetbrains.kotlin.idea.frontend.api.analyze import org.jetbrains.kotlin.idea.frontend.api.symbols.KtCallableSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.KtKotlinPropertySymbol +import org.jetbrains.kotlin.idea.frontend.api.symbols.KtFileSymbol +import org.jetbrains.kotlin.idea.frontend.api.symbols.KtFunctionSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.KtPropertySymbol -import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolVisibility -import org.jetbrains.kotlin.lexer.KtTokens +import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolWithVisibility import org.jetbrains.kotlin.load.java.structure.LightClassOriginKind import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.psi.KtClassOrObject import org.jetbrains.kotlin.psi.KtFile -import org.jetbrains.kotlin.psi.KtNamedDeclaration -import org.jetbrains.kotlin.psi.KtProperty -import org.jetbrains.kotlin.psi.psiUtil.isPrivate class FirLightClassForFacade( manager: PsiManager, @@ -80,32 +75,24 @@ class FirLightClassForFacade( override fun getModifierList(): PsiModifierList = _modifierList - override fun getScope(): PsiElement? = parent - - private fun loadMethodsFromFile( - file: KtFile, - result: MutableList - ) { - val declarations = file.declarations - .filterIsInstance() - .filterNot { multiFileClass && it.isPrivate() } - - if (declarations.isEmpty()) return - - val symbols = analyze(file) { - declarations.mapNotNull { - it.getSymbol() as? KtCallableSymbol - } - } - - createMethods(symbols.asSequence(), result, isTopLevel = true) - } + override fun getScope(): PsiElement = parent private val _ownMethods: List by lazyPub { val result = mutableListOf() - for (file in files) { - loadMethodsFromFile(file, result) + + val methodsAndProperties = sequence { + for (fileSymbol in fileSymbols) { + for (callableSymbol in fileSymbol.topLevelCallableSymbols) { + if (callableSymbol !is KtFunctionSymbol && callableSymbol !is KtPropertySymbol) continue + if (callableSymbol !is KtSymbolWithVisibility) continue + val isPrivate = callableSymbol.toPsiVisibilityForMember(isTopLevel = true) == PsiModifier.PRIVATE + if (isPrivate && multiFileClass) continue + yield(callableSymbol) + } + } } + createMethods(methodsAndProperties, result, isTopLevel = true) + result } @@ -114,25 +101,16 @@ class FirLightClassForFacade( } private fun loadFieldsFromFile( - file: KtFile, + fileSymbol: KtFileSymbol, nameGenerator: FirLightField.FieldNameGenerator, result: MutableList ) { - val properties = file.declarations - .filterIsInstance() - .applyIf(multiFileClass) { - filter { it.hasModifier(KtTokens.CONST_KEYWORD) } - } + for (propertySymbol in fileSymbol.topLevelCallableSymbols) { - if (properties.isEmpty()) return + if (propertySymbol !is KtPropertySymbol) continue - val propertySymbols = analyze(file) { - properties.mapNotNull { - it.getSymbol() as? KtPropertySymbol - } - } + if (propertySymbol is KtKotlinPropertySymbol && propertySymbol.isConst && multiFileClass) continue - for (propertySymbol in propertySymbols) { val isLateInitWithPublicAccessors = if (propertySymbol is KtKotlinPropertySymbol && propertySymbol.isLateInit) { val getterIsPublic = propertySymbol.getter?.toPsiVisibilityForMember(isTopLevel = true) ?.let { it == PsiModifier.PUBLIC } ?: true @@ -160,8 +138,8 @@ class FirLightClassForFacade( private val _ownFields: List by lazyPub { val result = mutableListOf() val nameGenerator = FirLightField.FieldNameGenerator() - for (file in files) { - loadFieldsFromFile(file, nameGenerator, result) + for (fileSymbol in fileSymbols) { + loadFieldsFromFile(fileSymbol, nameGenerator, result) } result } @@ -266,6 +244,8 @@ class FirLightClassForFacade( if (this.hashCode() != other.hashCode()) return false if (manager != other.manager) return false if (facadeClassFqName != other.facadeClassFqName) return false + if (!fileSymbols.containsAll(other.fileSymbols)) return false + if (!other.fileSymbols.containsAll(fileSymbols)) return false return true } diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirFileSymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirFileSymbol.kt index bc810e90b06..8e918f299dd 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirFileSymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirFileSymbol.kt @@ -6,6 +6,7 @@ package org.jetbrains.kotlin.idea.frontend.api.fir.symbols import com.intellij.psi.PsiElement +import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration import org.jetbrains.kotlin.fir.declarations.FirFile import org.jetbrains.kotlin.fir.declarations.FirResolvePhase import org.jetbrains.kotlin.idea.fir.findPsi @@ -14,6 +15,7 @@ import org.jetbrains.kotlin.idea.frontend.api.ValidityToken import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder import org.jetbrains.kotlin.idea.frontend.api.fir.utils.convertAnnotation import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef +import org.jetbrains.kotlin.idea.frontend.api.symbols.KtCallableSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.KtFileSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtAnnotationCall import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtPsiBasedSymbolPointer @@ -27,7 +29,13 @@ internal class KtFirFileSymbol( ) : KtFileSymbol(), KtFirSymbol { override val firRef = firRef(fir, resolveState) - override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.findPsi(fir.session) } + override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.findPsi(fir.session) } + + override val topLevelCallableSymbols: List by firRef.withFirAndCache { + it.declarations.mapNotNull { declaration -> + if (declaration is FirCallableDeclaration<*>) builder.buildCallableSymbol(declaration) else null + } + } override fun createPointer(): KtSymbolPointer { KtPsiBasedSymbolPointer.createForSymbolFromSource(this)?.let { return it } From f5d8ae0550a3eb0ed17422379237145741b1156b Mon Sep 17 00:00:00 2001 From: Igor Yakovlev Date: Fri, 11 Dec 2020 21:40:16 +0300 Subject: [PATCH 055/196] [FIR IDE] LC add caching to light facades --- .../caches/resolve/IDEKotlinAsJavaSupport.kt | 11 +++++++-- .../idea/asJava/classes/firLightClassUtils.kt | 24 +++++++++++++++++++ 2 files changed, 33 insertions(+), 2 deletions(-) diff --git a/idea/idea-fir/src/org/jetbrains/kotlin/idea/caches/resolve/IDEKotlinAsJavaSupport.kt b/idea/idea-fir/src/org/jetbrains/kotlin/idea/caches/resolve/IDEKotlinAsJavaSupport.kt index 32b6c3d11d9..320201609aa 100644 --- a/idea/idea-fir/src/org/jetbrains/kotlin/idea/caches/resolve/IDEKotlinAsJavaSupport.kt +++ b/idea/idea-fir/src/org/jetbrains/kotlin/idea/caches/resolve/IDEKotlinAsJavaSupport.kt @@ -6,25 +6,32 @@ package org.jetbrains.kotlin.idea.caches.resolve import com.intellij.openapi.project.Project +import com.intellij.openapi.util.Key +import com.intellij.openapi.util.UserDataHolder import com.intellij.psi.PsiManager import com.intellij.psi.search.GlobalSearchScope +import com.intellij.psi.util.CachedValueProvider +import com.intellij.psi.util.CachedValuesManager +import org.jetbrains.kotlin.analyzer.KotlinModificationTrackerService import org.jetbrains.kotlin.asJava.classes.KtLightClass import org.jetbrains.kotlin.idea.asJava.FirLightClassForFacade +import org.jetbrains.kotlin.idea.asJava.classes.createFirLightClassNoCache import org.jetbrains.kotlin.idea.asJava.classes.getOrCreateFirLightClass +import org.jetbrains.kotlin.idea.asJava.classes.getOrCreateFirLightFacade import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.psi.KtClassOrObject +import org.jetbrains.kotlin.psi.KtFile import org.jetbrains.kotlin.psi.KtScript class IDEKotlinAsJavaFirSupport(project: Project) : IDEKotlinAsJavaSupport(project) { - //TODO Make caching override fun createLightClassForFacade(manager: PsiManager, facadeClassFqName: FqName, searchScope: GlobalSearchScope): KtLightClass? { val sources = findFilesForFacade(facadeClassFqName, searchScope) .filterNot { it.isCompiled } if (sources.isEmpty()) return null - return FirLightClassForFacade(manager, facadeClassFqName, sources) + return getOrCreateFirLightFacade(sources, facadeClassFqName) } override fun createLightClassForScript(script: KtScript): KtLightClass? = null diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/firLightClassUtils.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/firLightClassUtils.kt index 9b70a5e70a8..269ab68bf8f 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/firLightClassUtils.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/firLightClassUtils.kt @@ -28,6 +28,7 @@ import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolWithDeclar import org.jetbrains.kotlin.idea.frontend.api.types.KtClassType import org.jetbrains.kotlin.idea.frontend.api.types.KtType import org.jetbrains.kotlin.lexer.KtTokens +import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.psi.* import org.jetbrains.kotlin.psi.psiUtil.containingClass import java.util.* @@ -79,6 +80,29 @@ fun createFirLightClassNoCache(classOrObject: KtClassOrObject): KtLightClass? { } } +fun getOrCreateFirLightFacade( + ktFiles: List, + facadeClassFqName: FqName, +): FirLightClassForFacade? { + val firstFile = ktFiles.firstOrNull() ?: return null + //TODO Make caching keyed by all files + return CachedValuesManager.getCachedValue(firstFile) { + CachedValueProvider.Result + .create( + getOrCreateFirLightFacadeNoCache(ktFiles, facadeClassFqName), + KotlinModificationTrackerService.getInstance(firstFile.project).outOfBlockModificationTracker + ) + } +} + +fun getOrCreateFirLightFacadeNoCache( + ktFiles: List, + facadeClassFqName: FqName, +): FirLightClassForFacade? { + val firstFile = ktFiles.firstOrNull() ?: return null + return FirLightClassForFacade(firstFile.manager, facadeClassFqName, ktFiles) +} + private fun lightClassForEnumEntry(ktEnumEntry: KtEnumEntry): KtLightClass? { if (ktEnumEntry.body == null) return null From f282b721bc5a6faa470c2bb8d6971a356931a541 Mon Sep 17 00:00:00 2001 From: Igor Yakovlev Date: Fri, 11 Dec 2020 21:40:36 +0300 Subject: [PATCH 056/196] [FIR IDE] LC Fix test data --- .../AnnotatedParameterInEnumConstructor.kt | 2 + ...notatedParameterInInnerClassConstructor.kt | 4 +- .../testData/asJava/lightClasses/JvmStatic.kt | 4 +- .../ActualTypeAliasCustomJvmPackageName.kt | 4 +- .../compilationErrors/JvmPackageName.kt | 4 +- .../asJava/lightClasses/facades/MultiFile.kt | 2 - .../facades/SingleJvmClassName.kt | 4 +- .../nullabilityAnnotations/PrivateInClass.kt | 4 +- .../api/symbols/DebugSymbolRenderer.kt | 2 +- .../testData/memberScopeByFqName/Int.txt | 122 +++++++++--------- .../memberScopeByFqName/MutableList.txt | 48 +++---- .../memberScopeByFqName/java.lang.String.txt | 116 ++++++++--------- .../memberFunction.txt | 2 +- .../memberFunctionWithOverloads.txt | 4 +- .../testData/symbolPointer/memberFunctions.kt | 4 +- .../symbolPointer/memberProperties.kt | 5 +- .../symbolPointer/topLevelFunctions.kt | 4 +- .../symbolPointer/topLevelProperties.kt | 5 +- .../symbolsByFqName/fileWalkDirectionEnum.txt | 6 +- .../testData/symbolsByPsi/annotations.kt | 2 +- .../testData/symbolsByPsi/anonymousObject.kt | 6 +- .../testData/symbolsByPsi/classMembes.kt | 4 +- .../symbolsByPsi/extensionFunction.kt | 2 +- .../testData/symbolsByPsi/function.kt | 2 +- .../symbolsByPsi/functionWithTypeParams.kt | 2 +- .../testData/symbolsByPsi/implicitReturn.kt | 2 +- .../symbolsByPsi/localDeclarations.kt | 4 +- .../findFunctionUsages/jvmStaticFun.0.kt | 4 +- .../jvmStaticJvmOverloadsFun.0.kt | 4 +- 29 files changed, 198 insertions(+), 180 deletions(-) diff --git a/compiler/testData/asJava/lightClasses/AnnotatedParameterInEnumConstructor.kt b/compiler/testData/asJava/lightClasses/AnnotatedParameterInEnumConstructor.kt index 84f0f47adf9..98c92e0a37f 100644 --- a/compiler/testData/asJava/lightClasses/AnnotatedParameterInEnumConstructor.kt +++ b/compiler/testData/asJava/lightClasses/AnnotatedParameterInEnumConstructor.kt @@ -6,3 +6,5 @@ annotation class Anno(val x: String) enum class AnnotatedParameterInEnumConstructor(@Anno("a") a: String, @Anno("b") b: String) { A("1", "b") } + +// FIR_COMPARISON \ No newline at end of file diff --git a/compiler/testData/asJava/lightClasses/AnnotatedParameterInInnerClassConstructor.kt b/compiler/testData/asJava/lightClasses/AnnotatedParameterInInnerClassConstructor.kt index 5845747652a..db5ee12ae42 100644 --- a/compiler/testData/asJava/lightClasses/AnnotatedParameterInInnerClassConstructor.kt +++ b/compiler/testData/asJava/lightClasses/AnnotatedParameterInInnerClassConstructor.kt @@ -12,4 +12,6 @@ class AnnotatedParameterInInnerClassConstructor { inner class InnerGeneric(@Anno("a") a: T, @Anno("b") b: String) { } -} \ No newline at end of file +} + +// FIR_COMPARISON \ No newline at end of file diff --git a/compiler/testData/asJava/lightClasses/JvmStatic.kt b/compiler/testData/asJava/lightClasses/JvmStatic.kt index b396085d4a4..767f12fa7bb 100644 --- a/compiler/testData/asJava/lightClasses/JvmStatic.kt +++ b/compiler/testData/asJava/lightClasses/JvmStatic.kt @@ -14,4 +14,6 @@ class A { } } -} \ No newline at end of file +} + +// FIR_COMPARISON \ No newline at end of file diff --git a/compiler/testData/asJava/lightClasses/compilationErrors/ActualTypeAliasCustomJvmPackageName.kt b/compiler/testData/asJava/lightClasses/compilationErrors/ActualTypeAliasCustomJvmPackageName.kt index 4524d818606..ef4652912a2 100644 --- a/compiler/testData/asJava/lightClasses/compilationErrors/ActualTypeAliasCustomJvmPackageName.kt +++ b/compiler/testData/asJava/lightClasses/compilationErrors/ActualTypeAliasCustomJvmPackageName.kt @@ -3,4 +3,6 @@ @file:JvmPackageName("a.b.c") package p -actual typealias B = List \ No newline at end of file +actual typealias B = List + +// FIR_COMPARISON \ No newline at end of file diff --git a/compiler/testData/asJava/lightClasses/compilationErrors/JvmPackageName.kt b/compiler/testData/asJava/lightClasses/compilationErrors/JvmPackageName.kt index 4fcd45800f5..d537c6c4132 100644 --- a/compiler/testData/asJava/lightClasses/compilationErrors/JvmPackageName.kt +++ b/compiler/testData/asJava/lightClasses/compilationErrors/JvmPackageName.kt @@ -5,4 +5,6 @@ package p fun f() { -} \ No newline at end of file +} + +// FIR_COMPARISON \ No newline at end of file diff --git a/compiler/testData/asJava/lightClasses/facades/MultiFile.kt b/compiler/testData/asJava/lightClasses/facades/MultiFile.kt index 3971075b6b4..a1b02f37ab1 100644 --- a/compiler/testData/asJava/lightClasses/facades/MultiFile.kt +++ b/compiler/testData/asJava/lightClasses/facades/MultiFile.kt @@ -8,5 +8,3 @@ package test val foo = 42 typealias A = String - -// FIR_COMPARISON \ No newline at end of file diff --git a/compiler/testData/asJava/lightClasses/facades/SingleJvmClassName.kt b/compiler/testData/asJava/lightClasses/facades/SingleJvmClassName.kt index 7cd6a0f07c8..63e44d1f030 100644 --- a/compiler/testData/asJava/lightClasses/facades/SingleJvmClassName.kt +++ b/compiler/testData/asJava/lightClasses/facades/SingleJvmClassName.kt @@ -4,4 +4,6 @@ fun foo() { -} \ No newline at end of file +} + +// FIR_COMPARISON \ No newline at end of file diff --git a/compiler/testData/asJava/lightClasses/nullabilityAnnotations/PrivateInClass.kt b/compiler/testData/asJava/lightClasses/nullabilityAnnotations/PrivateInClass.kt index b6b0bc50365..d5feda70e5b 100644 --- a/compiler/testData/asJava/lightClasses/nullabilityAnnotations/PrivateInClass.kt +++ b/compiler/testData/asJava/lightClasses/nullabilityAnnotations/PrivateInClass.kt @@ -7,4 +7,6 @@ class PrivateInClass private constructor (g: String?) { private val n: String? get() = "" private fun bar(a: String, b: String?): String? = null -} \ No newline at end of file +} + +// FIR_COMPARISON \ No newline at end of file diff --git a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/DebugSymbolRenderer.kt b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/DebugSymbolRenderer.kt index 3c88cbcb3e6..51849436dcc 100644 --- a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/DebugSymbolRenderer.kt +++ b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/DebugSymbolRenderer.kt @@ -62,7 +62,7 @@ object DebugSymbolRenderer { is KtNamedConstantValue -> "${renderValue(value.name)} = ${renderValue(value.expression)}" is KtAnnotationCall -> "${renderValue(value.classId)}${value.arguments.joinToString(prefix = "(", postfix = ")") { renderValue(it) }}" - + is ReceiverTypeAndAnnotations -> "${renderValue(value.annotations)} ${renderValue(value.type)}" else -> value::class.simpleName!! } diff --git a/idea/idea-frontend-fir/testData/memberScopeByFqName/Int.txt b/idea/idea-frontend-fir/testData/memberScopeByFqName/Int.txt index c26dab95452..4ba5de9ca15 100644 --- a/idea/idea-frontend-fir/testData/memberScopeByFqName/Int.txt +++ b/idea/idea-frontend-fir/testData/memberScopeByFqName/Int.txt @@ -13,7 +13,7 @@ KtFirFunctionSymbol: modality: FINAL name: and origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -32,7 +32,7 @@ KtFirFunctionSymbol: modality: FINAL name: compareTo origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -51,7 +51,7 @@ KtFirFunctionSymbol: modality: FINAL name: compareTo origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -70,7 +70,7 @@ KtFirFunctionSymbol: modality: FINAL name: compareTo origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -89,7 +89,7 @@ KtFirFunctionSymbol: modality: OPEN name: compareTo origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -108,7 +108,7 @@ KtFirFunctionSymbol: modality: FINAL name: compareTo origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -127,7 +127,7 @@ KtFirFunctionSymbol: modality: FINAL name: compareTo origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -146,7 +146,7 @@ KtFirFunctionSymbol: modality: FINAL name: dec origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -165,7 +165,7 @@ KtFirFunctionSymbol: modality: FINAL name: div origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -184,7 +184,7 @@ KtFirFunctionSymbol: modality: FINAL name: div origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Double typeParameters: [] @@ -203,7 +203,7 @@ KtFirFunctionSymbol: modality: FINAL name: div origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Float typeParameters: [] @@ -222,7 +222,7 @@ KtFirFunctionSymbol: modality: FINAL name: div origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -241,7 +241,7 @@ KtFirFunctionSymbol: modality: FINAL name: div origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Long typeParameters: [] @@ -260,7 +260,7 @@ KtFirFunctionSymbol: modality: FINAL name: div origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -279,7 +279,7 @@ KtFirFunctionSymbol: modality: FINAL name: inc origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -298,7 +298,7 @@ KtFirFunctionSymbol: modality: FINAL name: inv origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -317,7 +317,7 @@ KtFirFunctionSymbol: modality: FINAL name: minus origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -336,7 +336,7 @@ KtFirFunctionSymbol: modality: FINAL name: minus origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Double typeParameters: [] @@ -355,7 +355,7 @@ KtFirFunctionSymbol: modality: FINAL name: minus origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Float typeParameters: [] @@ -374,7 +374,7 @@ KtFirFunctionSymbol: modality: FINAL name: minus origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -393,7 +393,7 @@ KtFirFunctionSymbol: modality: FINAL name: minus origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Long typeParameters: [] @@ -412,7 +412,7 @@ KtFirFunctionSymbol: modality: FINAL name: minus origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -431,7 +431,7 @@ KtFirFunctionSymbol: modality: FINAL name: or origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -450,7 +450,7 @@ KtFirFunctionSymbol: modality: FINAL name: plus origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -469,7 +469,7 @@ KtFirFunctionSymbol: modality: FINAL name: plus origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Double typeParameters: [] @@ -488,7 +488,7 @@ KtFirFunctionSymbol: modality: FINAL name: plus origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Float typeParameters: [] @@ -507,7 +507,7 @@ KtFirFunctionSymbol: modality: FINAL name: plus origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -526,7 +526,7 @@ KtFirFunctionSymbol: modality: FINAL name: plus origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Long typeParameters: [] @@ -545,7 +545,7 @@ KtFirFunctionSymbol: modality: FINAL name: plus origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -564,7 +564,7 @@ KtFirFunctionSymbol: modality: FINAL name: rangeTo origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/ranges/IntRange typeParameters: [] @@ -583,7 +583,7 @@ KtFirFunctionSymbol: modality: FINAL name: rangeTo origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/ranges/IntRange typeParameters: [] @@ -602,7 +602,7 @@ KtFirFunctionSymbol: modality: FINAL name: rangeTo origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/ranges/LongRange typeParameters: [] @@ -621,7 +621,7 @@ KtFirFunctionSymbol: modality: FINAL name: rangeTo origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/ranges/IntRange typeParameters: [] @@ -640,7 +640,7 @@ KtFirFunctionSymbol: modality: FINAL name: rem origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -659,7 +659,7 @@ KtFirFunctionSymbol: modality: FINAL name: rem origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Double typeParameters: [] @@ -678,7 +678,7 @@ KtFirFunctionSymbol: modality: FINAL name: rem origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Float typeParameters: [] @@ -697,7 +697,7 @@ KtFirFunctionSymbol: modality: FINAL name: rem origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -716,7 +716,7 @@ KtFirFunctionSymbol: modality: FINAL name: rem origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Long typeParameters: [] @@ -735,7 +735,7 @@ KtFirFunctionSymbol: modality: FINAL name: rem origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -754,7 +754,7 @@ KtFirFunctionSymbol: modality: FINAL name: shl origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -773,7 +773,7 @@ KtFirFunctionSymbol: modality: FINAL name: shr origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -792,7 +792,7 @@ KtFirFunctionSymbol: modality: FINAL name: times origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -811,7 +811,7 @@ KtFirFunctionSymbol: modality: FINAL name: times origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Double typeParameters: [] @@ -830,7 +830,7 @@ KtFirFunctionSymbol: modality: FINAL name: times origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Float typeParameters: [] @@ -849,7 +849,7 @@ KtFirFunctionSymbol: modality: FINAL name: times origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -868,7 +868,7 @@ KtFirFunctionSymbol: modality: FINAL name: times origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Long typeParameters: [] @@ -887,7 +887,7 @@ KtFirFunctionSymbol: modality: FINAL name: times origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -906,7 +906,7 @@ KtFirFunctionSymbol: modality: OPEN name: toByte origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Byte typeParameters: [] @@ -925,7 +925,7 @@ KtFirFunctionSymbol: modality: OPEN name: toChar origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Char typeParameters: [] @@ -944,7 +944,7 @@ KtFirFunctionSymbol: modality: OPEN name: toDouble origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Double typeParameters: [] @@ -963,7 +963,7 @@ KtFirFunctionSymbol: modality: OPEN name: toFloat origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Float typeParameters: [] @@ -982,7 +982,7 @@ KtFirFunctionSymbol: modality: OPEN name: toInt origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -1001,7 +1001,7 @@ KtFirFunctionSymbol: modality: OPEN name: toLong origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Long typeParameters: [] @@ -1020,7 +1020,7 @@ KtFirFunctionSymbol: modality: OPEN name: toShort origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Short typeParameters: [] @@ -1039,7 +1039,7 @@ KtFirFunctionSymbol: modality: FINAL name: unaryMinus origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -1058,7 +1058,7 @@ KtFirFunctionSymbol: modality: FINAL name: unaryPlus origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -1077,7 +1077,7 @@ KtFirFunctionSymbol: modality: FINAL name: ushr origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -1096,7 +1096,7 @@ KtFirFunctionSymbol: modality: FINAL name: xor origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -1125,7 +1125,7 @@ KtFirFunctionSymbol: modality: OPEN name: equals origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Boolean typeParameters: [] @@ -1144,7 +1144,7 @@ KtFirFunctionSymbol: modality: OPEN name: hashCode origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -1163,7 +1163,7 @@ KtFirFunctionSymbol: modality: OPEN name: toString origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/String typeParameters: [] diff --git a/idea/idea-frontend-fir/testData/memberScopeByFqName/MutableList.txt b/idea/idea-frontend-fir/testData/memberScopeByFqName/MutableList.txt index a614fbd848b..9aec62a1556 100644 --- a/idea/idea-frontend-fir/testData/memberScopeByFqName/MutableList.txt +++ b/idea/idea-frontend-fir/testData/memberScopeByFqName/MutableList.txt @@ -13,7 +13,7 @@ KtFirFunctionSymbol: modality: ABSTRACT name: add origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Boolean typeParameters: [] @@ -32,7 +32,7 @@ KtFirFunctionSymbol: modality: ABSTRACT name: add origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Unit typeParameters: [] @@ -51,7 +51,7 @@ KtFirFunctionSymbol: modality: ABSTRACT name: addAll origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Boolean typeParameters: [] @@ -70,7 +70,7 @@ KtFirFunctionSymbol: modality: ABSTRACT name: addAll origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Boolean typeParameters: [] @@ -89,7 +89,7 @@ KtFirFunctionSymbol: modality: ABSTRACT name: clear origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Unit typeParameters: [] @@ -108,7 +108,7 @@ KtFirFunctionSymbol: modality: ABSTRACT name: listIterator origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/collections/MutableListIterator typeParameters: [] @@ -127,7 +127,7 @@ KtFirFunctionSymbol: modality: ABSTRACT name: listIterator origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/collections/MutableListIterator typeParameters: [] @@ -146,7 +146,7 @@ KtFirFunctionSymbol: modality: ABSTRACT name: remove origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Boolean typeParameters: [] @@ -165,7 +165,7 @@ KtFirFunctionSymbol: modality: ABSTRACT name: removeAll origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Boolean typeParameters: [] @@ -184,7 +184,7 @@ KtFirFunctionSymbol: modality: ABSTRACT name: removeAt origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: E typeParameters: [] @@ -203,7 +203,7 @@ KtFirFunctionSymbol: modality: ABSTRACT name: retainAll origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Boolean typeParameters: [] @@ -222,7 +222,7 @@ KtFirFunctionSymbol: modality: ABSTRACT name: set origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: E typeParameters: [] @@ -241,7 +241,7 @@ KtFirFunctionSymbol: modality: ABSTRACT name: subList origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/collections/MutableList typeParameters: [] @@ -260,7 +260,7 @@ KtFirFunctionSymbol: modality: ABSTRACT name: contains origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Boolean typeParameters: [] @@ -279,7 +279,7 @@ KtFirFunctionSymbol: modality: ABSTRACT name: containsAll origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Boolean typeParameters: [] @@ -298,7 +298,7 @@ KtFirFunctionSymbol: modality: ABSTRACT name: get origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: E typeParameters: [] @@ -317,7 +317,7 @@ KtFirFunctionSymbol: modality: ABSTRACT name: indexOf origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -336,7 +336,7 @@ KtFirFunctionSymbol: modality: ABSTRACT name: isEmpty origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Boolean typeParameters: [] @@ -355,7 +355,7 @@ KtFirFunctionSymbol: modality: ABSTRACT name: iterator origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/collections/MutableIterator typeParameters: [] @@ -374,7 +374,7 @@ KtFirFunctionSymbol: modality: ABSTRACT name: lastIndexOf origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -397,7 +397,7 @@ KtFirKotlinPropertySymbol: modality: ABSTRACT name: size origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null setter: null symbolKind: MEMBER type: kotlin/Int @@ -415,7 +415,7 @@ KtFirFunctionSymbol: modality: OPEN name: equals origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Boolean typeParameters: [] @@ -434,7 +434,7 @@ KtFirFunctionSymbol: modality: OPEN name: hashCode origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -453,7 +453,7 @@ KtFirFunctionSymbol: modality: OPEN name: toString origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/String typeParameters: [] diff --git a/idea/idea-frontend-fir/testData/memberScopeByFqName/java.lang.String.txt b/idea/idea-frontend-fir/testData/memberScopeByFqName/java.lang.String.txt index 818effe453b..d09ec1a6802 100644 --- a/idea/idea-frontend-fir/testData/memberScopeByFqName/java.lang.String.txt +++ b/idea/idea-frontend-fir/testData/memberScopeByFqName/java.lang.String.txt @@ -33,7 +33,7 @@ KtFirFunctionSymbol: modality: OPEN name: hash32 origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -62,7 +62,7 @@ KtFirFunctionSymbol: modality: OPEN name: length origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -85,7 +85,7 @@ KtFirKotlinPropertySymbol: modality: ABSTRACT name: length origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null setter: null symbolKind: MEMBER type: kotlin/Int @@ -103,7 +103,7 @@ KtFirFunctionSymbol: modality: OPEN name: isEmpty origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Boolean typeParameters: [] @@ -122,7 +122,7 @@ KtFirFunctionSymbol: modality: OPEN name: charAt origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Char typeParameters: [] @@ -141,7 +141,7 @@ KtFirFunctionSymbol: modality: OPEN name: codePointAt origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -160,7 +160,7 @@ KtFirFunctionSymbol: modality: OPEN name: codePointBefore origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -179,7 +179,7 @@ KtFirFunctionSymbol: modality: OPEN name: codePointCount origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -198,7 +198,7 @@ KtFirFunctionSymbol: modality: OPEN name: offsetByCodePoints origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -217,7 +217,7 @@ KtFirFunctionSymbol: modality: OPEN name: getChars origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Unit typeParameters: [] @@ -236,7 +236,7 @@ KtFirFunctionSymbol: modality: OPEN name: getChars origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Unit typeParameters: [] @@ -255,7 +255,7 @@ KtFirFunctionSymbol: modality: OPEN name: getBytes origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Unit typeParameters: [] @@ -274,7 +274,7 @@ KtFirFunctionSymbol: modality: OPEN name: getBytes origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: @EnhancedNullability kotlin/ByteArray typeParameters: [] @@ -293,7 +293,7 @@ KtFirFunctionSymbol: modality: OPEN name: getBytes origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: @EnhancedNullability kotlin/ByteArray typeParameters: [] @@ -312,7 +312,7 @@ KtFirFunctionSymbol: modality: OPEN name: getBytes origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: @EnhancedNullability kotlin/ByteArray typeParameters: [] @@ -331,7 +331,7 @@ KtFirFunctionSymbol: modality: OPEN name: equals origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Boolean typeParameters: [] @@ -350,7 +350,7 @@ KtFirFunctionSymbol: modality: OPEN name: contentEquals origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Boolean typeParameters: [] @@ -369,7 +369,7 @@ KtFirFunctionSymbol: modality: OPEN name: contentEquals origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Boolean typeParameters: [] @@ -388,7 +388,7 @@ KtFirFunctionSymbol: modality: OPEN name: equalsIgnoreCase origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Boolean typeParameters: [] @@ -407,7 +407,7 @@ KtFirFunctionSymbol: modality: OPEN name: compareTo origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -426,7 +426,7 @@ KtFirFunctionSymbol: modality: OPEN name: compareToIgnoreCase origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -445,7 +445,7 @@ KtFirFunctionSymbol: modality: OPEN name: regionMatches origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Boolean typeParameters: [] @@ -464,7 +464,7 @@ KtFirFunctionSymbol: modality: OPEN name: regionMatches origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Boolean typeParameters: [] @@ -483,7 +483,7 @@ KtFirFunctionSymbol: modality: OPEN name: startsWith origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Boolean typeParameters: [] @@ -502,7 +502,7 @@ KtFirFunctionSymbol: modality: OPEN name: startsWith origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Boolean typeParameters: [] @@ -521,7 +521,7 @@ KtFirFunctionSymbol: modality: OPEN name: endsWith origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Boolean typeParameters: [] @@ -540,7 +540,7 @@ KtFirFunctionSymbol: modality: OPEN name: hashCode origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -559,7 +559,7 @@ KtFirFunctionSymbol: modality: OPEN name: indexOf origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -578,7 +578,7 @@ KtFirFunctionSymbol: modality: OPEN name: indexOf origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -597,7 +597,7 @@ KtFirFunctionSymbol: modality: OPEN name: indexOf origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -616,7 +616,7 @@ KtFirFunctionSymbol: modality: OPEN name: indexOf origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -635,7 +635,7 @@ KtFirFunctionSymbol: modality: OPEN name: indexOfSupplementary origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -654,7 +654,7 @@ KtFirFunctionSymbol: modality: OPEN name: lastIndexOf origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -673,7 +673,7 @@ KtFirFunctionSymbol: modality: OPEN name: lastIndexOf origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -692,7 +692,7 @@ KtFirFunctionSymbol: modality: OPEN name: lastIndexOf origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -711,7 +711,7 @@ KtFirFunctionSymbol: modality: OPEN name: lastIndexOf origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -730,7 +730,7 @@ KtFirFunctionSymbol: modality: OPEN name: lastIndexOfSupplementary origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -749,7 +749,7 @@ KtFirFunctionSymbol: modality: OPEN name: substring origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: @EnhancedNullability kotlin/String typeParameters: [] @@ -768,7 +768,7 @@ KtFirFunctionSymbol: modality: OPEN name: substring origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: @EnhancedNullability kotlin/String typeParameters: [] @@ -787,7 +787,7 @@ KtFirFunctionSymbol: modality: OPEN name: subSequence origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: @EnhancedNullability kotlin/CharSequence typeParameters: [] @@ -806,7 +806,7 @@ KtFirFunctionSymbol: modality: OPEN name: concat origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: @EnhancedNullability kotlin/String typeParameters: [] @@ -825,7 +825,7 @@ KtFirFunctionSymbol: modality: OPEN name: replace origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: @EnhancedNullability kotlin/String typeParameters: [] @@ -844,7 +844,7 @@ KtFirFunctionSymbol: modality: OPEN name: replace origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: @EnhancedNullability kotlin/String typeParameters: [] @@ -863,7 +863,7 @@ KtFirFunctionSymbol: modality: OPEN name: matches origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Boolean typeParameters: [] @@ -882,7 +882,7 @@ KtFirFunctionSymbol: modality: OPEN name: contains origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Boolean typeParameters: [] @@ -901,7 +901,7 @@ KtFirFunctionSymbol: modality: OPEN name: replaceFirst origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: @EnhancedNullability kotlin/String typeParameters: [] @@ -920,7 +920,7 @@ KtFirFunctionSymbol: modality: OPEN name: replaceAll origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: @EnhancedNullability kotlin/String typeParameters: [] @@ -939,7 +939,7 @@ KtFirFunctionSymbol: modality: OPEN name: split origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: ft<@EnhancedNullability kotlin/Array!>, @EnhancedNullability kotlin/Array!>> typeParameters: [] @@ -958,7 +958,7 @@ KtFirFunctionSymbol: modality: OPEN name: split origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: ft<@EnhancedNullability kotlin/Array!>, @EnhancedNullability kotlin/Array!>> typeParameters: [] @@ -977,7 +977,7 @@ KtFirFunctionSymbol: modality: OPEN name: toLowerCase origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: @EnhancedNullability kotlin/String typeParameters: [] @@ -996,7 +996,7 @@ KtFirFunctionSymbol: modality: OPEN name: toLowerCase origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: @EnhancedNullability kotlin/String typeParameters: [] @@ -1015,7 +1015,7 @@ KtFirFunctionSymbol: modality: OPEN name: toUpperCase origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: @EnhancedNullability kotlin/String typeParameters: [] @@ -1034,7 +1034,7 @@ KtFirFunctionSymbol: modality: OPEN name: toUpperCase origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: @EnhancedNullability kotlin/String typeParameters: [] @@ -1053,7 +1053,7 @@ KtFirFunctionSymbol: modality: OPEN name: trim origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: @EnhancedNullability kotlin/String typeParameters: [] @@ -1072,7 +1072,7 @@ KtFirFunctionSymbol: modality: OPEN name: toString origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: @FlexibleNullability kotlin/String typeParameters: [] @@ -1091,7 +1091,7 @@ KtFirFunctionSymbol: modality: OPEN name: toCharArray origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: @EnhancedNullability kotlin/CharArray typeParameters: [] @@ -1110,7 +1110,7 @@ KtFirFunctionSymbol: modality: OPEN name: intern origin: JAVA - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: @EnhancedNullability kotlin/String typeParameters: [] @@ -1299,7 +1299,7 @@ KtFirFunctionSymbol: modality: ABSTRACT name: get origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Char typeParameters: [] diff --git a/idea/idea-frontend-fir/testData/resoreSymbolFromLibrary/memberFunction.txt b/idea/idea-frontend-fir/testData/resoreSymbolFromLibrary/memberFunction.txt index 9ba31bfd9c9..12db4e5291c 100644 --- a/idea/idea-frontend-fir/testData/resoreSymbolFromLibrary/memberFunction.txt +++ b/idea/idea-frontend-fir/testData/resoreSymbolFromLibrary/memberFunction.txt @@ -13,7 +13,7 @@ KtFirFunctionSymbol: modality: ABSTRACT name: get origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: E typeParameters: [] diff --git a/idea/idea-frontend-fir/testData/resoreSymbolFromLibrary/memberFunctionWithOverloads.txt b/idea/idea-frontend-fir/testData/resoreSymbolFromLibrary/memberFunctionWithOverloads.txt index a0568966067..8e85c70287f 100644 --- a/idea/idea-frontend-fir/testData/resoreSymbolFromLibrary/memberFunctionWithOverloads.txt +++ b/idea/idea-frontend-fir/testData/resoreSymbolFromLibrary/memberFunctionWithOverloads.txt @@ -13,7 +13,7 @@ KtFirFunctionSymbol: modality: ABSTRACT name: listIterator origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/collections/ListIterator typeParameters: [] @@ -32,7 +32,7 @@ KtFirFunctionSymbol: modality: ABSTRACT name: listIterator origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/collections/ListIterator typeParameters: [] diff --git a/idea/idea-frontend-fir/testData/symbolPointer/memberFunctions.kt b/idea/idea-frontend-fir/testData/symbolPointer/memberFunctions.kt index bc8e6474996..844c5a04c34 100644 --- a/idea/idea-frontend-fir/testData/symbolPointer/memberFunctions.kt +++ b/idea/idea-frontend-fir/testData/symbolPointer/memberFunctions.kt @@ -16,7 +16,7 @@ KtFirFunctionSymbol: modality: FINAL name: x origin: SOURCE - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] @@ -35,7 +35,7 @@ KtFirFunctionSymbol: modality: FINAL name: y origin: SOURCE - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Unit typeParameters: [] diff --git a/idea/idea-frontend-fir/testData/symbolPointer/memberProperties.kt b/idea/idea-frontend-fir/testData/symbolPointer/memberProperties.kt index a4abfb50b6d..9c46bf6f8d7 100644 --- a/idea/idea-frontend-fir/testData/symbolPointer/memberProperties.kt +++ b/idea/idea-frontend-fir/testData/symbolPointer/memberProperties.kt @@ -20,13 +20,14 @@ KtFirKotlinPropertySymbol: modality: FINAL name: x origin: SOURCE - receiverType: null + receiverTypeAndAnnotations: null setter: null symbolKind: MEMBER type: kotlin/Int visibility: PUBLIC KtFirPropertyGetterSymbol: + annotations: [] hasBody: true isDefault: false isInline: false @@ -53,7 +54,7 @@ KtFirKotlinPropertySymbol: modality: FINAL name: y origin: SOURCE - receiverType: kotlin/Int + receiverTypeAndAnnotations: [] kotlin/Int setter: null symbolKind: MEMBER type: kotlin/Int diff --git a/idea/idea-frontend-fir/testData/symbolPointer/topLevelFunctions.kt b/idea/idea-frontend-fir/testData/symbolPointer/topLevelFunctions.kt index 056966817f2..17777c8c6c9 100644 --- a/idea/idea-frontend-fir/testData/symbolPointer/topLevelFunctions.kt +++ b/idea/idea-frontend-fir/testData/symbolPointer/topLevelFunctions.kt @@ -14,7 +14,7 @@ KtFirFunctionSymbol: modality: FINAL name: x origin: SOURCE - receiverType: null + receiverTypeAndAnnotations: null symbolKind: TOP_LEVEL type: kotlin/Int typeParameters: [] @@ -33,7 +33,7 @@ KtFirFunctionSymbol: modality: FINAL name: y origin: SOURCE - receiverType: null + receiverTypeAndAnnotations: null symbolKind: TOP_LEVEL type: kotlin/Unit typeParameters: [] diff --git a/idea/idea-frontend-fir/testData/symbolPointer/topLevelProperties.kt b/idea/idea-frontend-fir/testData/symbolPointer/topLevelProperties.kt index 844e3c8751a..ad553f09584 100644 --- a/idea/idea-frontend-fir/testData/symbolPointer/topLevelProperties.kt +++ b/idea/idea-frontend-fir/testData/symbolPointer/topLevelProperties.kt @@ -18,13 +18,14 @@ KtFirKotlinPropertySymbol: modality: FINAL name: x origin: SOURCE - receiverType: null + receiverTypeAndAnnotations: null setter: null symbolKind: TOP_LEVEL type: kotlin/Int visibility: PUBLIC KtFirPropertyGetterSymbol: + annotations: [] hasBody: true isDefault: false isInline: false @@ -51,7 +52,7 @@ KtFirKotlinPropertySymbol: modality: FINAL name: y origin: SOURCE - receiverType: kotlin/Int + receiverTypeAndAnnotations: [] kotlin/Int setter: null symbolKind: TOP_LEVEL type: kotlin/Int diff --git a/idea/idea-frontend-fir/testData/symbolsByFqName/fileWalkDirectionEnum.txt b/idea/idea-frontend-fir/testData/symbolsByFqName/fileWalkDirectionEnum.txt index cbd871d78c6..02091117866 100644 --- a/idea/idea-frontend-fir/testData/symbolsByFqName/fileWalkDirectionEnum.txt +++ b/idea/idea-frontend-fir/testData/symbolsByFqName/fileWalkDirectionEnum.txt @@ -13,7 +13,7 @@ KtFirFunctionSymbol: modality: FINAL name: listOf origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: TOP_LEVEL type: kotlin/collections/List typeParameters: [KtFirTypeParameterSymbol(T)] @@ -32,7 +32,7 @@ KtFirFunctionSymbol: modality: FINAL name: listOf origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: TOP_LEVEL type: kotlin/collections/List typeParameters: [KtFirTypeParameterSymbol(T)] @@ -51,7 +51,7 @@ KtFirFunctionSymbol: modality: FINAL name: listOf origin: LIBRARY - receiverType: null + receiverTypeAndAnnotations: null symbolKind: TOP_LEVEL type: kotlin/collections/List typeParameters: [KtFirTypeParameterSymbol(T)] diff --git a/idea/idea-frontend-fir/testData/symbolsByPsi/annotations.kt b/idea/idea-frontend-fir/testData/symbolsByPsi/annotations.kt index 22b530ff6d7..15c53a7a7d4 100644 --- a/idea/idea-frontend-fir/testData/symbolsByPsi/annotations.kt +++ b/idea/idea-frontend-fir/testData/symbolsByPsi/annotations.kt @@ -66,7 +66,7 @@ KtFirFunctionSymbol: modality: FINAL name: x origin: SOURCE - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Unit typeParameters: [] diff --git a/idea/idea-frontend-fir/testData/symbolsByPsi/anonymousObject.kt b/idea/idea-frontend-fir/testData/symbolsByPsi/anonymousObject.kt index 00273c4e079..06443c07def 100644 --- a/idea/idea-frontend-fir/testData/symbolsByPsi/anonymousObject.kt +++ b/idea/idea-frontend-fir/testData/symbolsByPsi/anonymousObject.kt @@ -21,7 +21,7 @@ KtFirFunctionSymbol: modality: FINAL name: run origin: SOURCE - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Unit typeParameters: [] @@ -44,7 +44,7 @@ KtFirKotlinPropertySymbol: modality: FINAL name: data origin: SOURCE - receiverType: null + receiverTypeAndAnnotations: null setter: null symbolKind: MEMBER type: kotlin/Int @@ -72,7 +72,7 @@ KtFirKotlinPropertySymbol: modality: FINAL name: anonymousObject origin: SOURCE - receiverType: null + receiverTypeAndAnnotations: null setter: null symbolKind: MEMBER type: java/lang/Runnable diff --git a/idea/idea-frontend-fir/testData/symbolsByPsi/classMembes.kt b/idea/idea-frontend-fir/testData/symbolsByPsi/classMembes.kt index 09c1a8f21d3..a09e8d0f015 100644 --- a/idea/idea-frontend-fir/testData/symbolsByPsi/classMembes.kt +++ b/idea/idea-frontend-fir/testData/symbolsByPsi/classMembes.kt @@ -21,7 +21,7 @@ KtFirKotlinPropertySymbol: modality: FINAL name: a origin: SOURCE - receiverType: null + receiverTypeAndAnnotations: null setter: null symbolKind: MEMBER type: kotlin/Int @@ -39,7 +39,7 @@ KtFirFunctionSymbol: modality: FINAL name: x origin: SOURCE - receiverType: null + receiverTypeAndAnnotations: null symbolKind: MEMBER type: kotlin/Int typeParameters: [] diff --git a/idea/idea-frontend-fir/testData/symbolsByPsi/extensionFunction.kt b/idea/idea-frontend-fir/testData/symbolsByPsi/extensionFunction.kt index d9aaa3c8a13..b519d7d447e 100644 --- a/idea/idea-frontend-fir/testData/symbolsByPsi/extensionFunction.kt +++ b/idea/idea-frontend-fir/testData/symbolsByPsi/extensionFunction.kt @@ -14,7 +14,7 @@ KtFirFunctionSymbol: modality: FINAL name: foo origin: SOURCE - receiverType: kotlin/String + receiverTypeAndAnnotations: [] kotlin/String symbolKind: TOP_LEVEL type: kotlin/Int typeParameters: [] diff --git a/idea/idea-frontend-fir/testData/symbolsByPsi/function.kt b/idea/idea-frontend-fir/testData/symbolsByPsi/function.kt index fc02eb2f91b..a460b74a83e 100644 --- a/idea/idea-frontend-fir/testData/symbolsByPsi/function.kt +++ b/idea/idea-frontend-fir/testData/symbolsByPsi/function.kt @@ -23,7 +23,7 @@ KtFirFunctionSymbol: modality: FINAL name: foo origin: SOURCE - receiverType: null + receiverTypeAndAnnotations: null symbolKind: TOP_LEVEL type: kotlin/Unit typeParameters: [] diff --git a/idea/idea-frontend-fir/testData/symbolsByPsi/functionWithTypeParams.kt b/idea/idea-frontend-fir/testData/symbolsByPsi/functionWithTypeParams.kt index adbda64cf30..4ba2957b865 100644 --- a/idea/idea-frontend-fir/testData/symbolsByPsi/functionWithTypeParams.kt +++ b/idea/idea-frontend-fir/testData/symbolsByPsi/functionWithTypeParams.kt @@ -28,7 +28,7 @@ KtFirFunctionSymbol: modality: FINAL name: foo origin: SOURCE - receiverType: null + receiverTypeAndAnnotations: null symbolKind: TOP_LEVEL type: kotlin/Unit typeParameters: [KtFirTypeParameterSymbol(X)] diff --git a/idea/idea-frontend-fir/testData/symbolsByPsi/implicitReturn.kt b/idea/idea-frontend-fir/testData/symbolsByPsi/implicitReturn.kt index 309f6d8c489..f044fbf1734 100644 --- a/idea/idea-frontend-fir/testData/symbolsByPsi/implicitReturn.kt +++ b/idea/idea-frontend-fir/testData/symbolsByPsi/implicitReturn.kt @@ -14,7 +14,7 @@ KtFirFunctionSymbol: modality: FINAL name: foo origin: SOURCE - receiverType: null + receiverTypeAndAnnotations: null symbolKind: TOP_LEVEL type: kotlin/Int typeParameters: [] diff --git a/idea/idea-frontend-fir/testData/symbolsByPsi/localDeclarations.kt b/idea/idea-frontend-fir/testData/symbolsByPsi/localDeclarations.kt index 1eb884277e7..db3272312ed 100644 --- a/idea/idea-frontend-fir/testData/symbolsByPsi/localDeclarations.kt +++ b/idea/idea-frontend-fir/testData/symbolsByPsi/localDeclarations.kt @@ -26,7 +26,7 @@ KtFirFunctionSymbol: modality: FINAL name: aaa origin: SOURCE - receiverType: null + receiverTypeAndAnnotations: null symbolKind: LOCAL type: kotlin/Unit typeParameters: [] @@ -60,7 +60,7 @@ KtFirFunctionSymbol: modality: FINAL name: yyy origin: SOURCE - receiverType: null + receiverTypeAndAnnotations: null symbolKind: TOP_LEVEL type: kotlin/Unit typeParameters: [] diff --git a/idea/testData/findUsages/kotlin/findFunctionUsages/jvmStaticFun.0.kt b/idea/testData/findUsages/kotlin/findFunctionUsages/jvmStaticFun.0.kt index b71d57e7aa2..9121bc34072 100644 --- a/idea/testData/findUsages/kotlin/findFunctionUsages/jvmStaticFun.0.kt +++ b/idea/testData/findUsages/kotlin/findFunctionUsages/jvmStaticFun.0.kt @@ -6,4 +6,6 @@ class Foo { } } -} \ No newline at end of file +} + +// FIR_COMPARISON \ No newline at end of file diff --git a/idea/testData/findUsages/kotlin/findFunctionUsages/jvmStaticJvmOverloadsFun.0.kt b/idea/testData/findUsages/kotlin/findFunctionUsages/jvmStaticJvmOverloadsFun.0.kt index 37203fbd4c3..317211f6da9 100644 --- a/idea/testData/findUsages/kotlin/findFunctionUsages/jvmStaticJvmOverloadsFun.0.kt +++ b/idea/testData/findUsages/kotlin/findFunctionUsages/jvmStaticJvmOverloadsFun.0.kt @@ -8,4 +8,6 @@ class Foo { } } -} \ No newline at end of file +} + +// FIR_COMPARISON \ No newline at end of file From 2fa5ab6e313435cf3890b95d4e3054e330181de4 Mon Sep 17 00:00:00 2001 From: Igor Yakovlev Date: Fri, 11 Dec 2020 22:40:08 +0300 Subject: [PATCH 057/196] [FIR IDE] LC Remove difficult caching from FirLightClassBase --- .../classes/KotlinClassInnerStuffCache.kt | 61 +++------------- .../kotlin/asJava/classes/KtLightClassBase.kt | 5 +- .../KtLightClassForSourceDeclaration.kt | 5 +- .../asJava/classes/LightClassesLazyCreator.kt | 70 +++++++++++++++++++ .../KtLightClassForDecompiledDeclaration.kt | 4 +- .../idea/asJava/classes/FirLightClassBase.kt | 21 +++++- 6 files changed, 107 insertions(+), 59 deletions(-) create mode 100644 compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/LightClassesLazyCreator.kt diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/KotlinClassInnerStuffCache.kt b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/KotlinClassInnerStuffCache.kt index b737a77d9cc..442e9669d8c 100644 --- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/KotlinClassInnerStuffCache.kt +++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/KotlinClassInnerStuffCache.kt @@ -24,60 +24,20 @@ import org.jetbrains.kotlin.utils.SmartList import java.util.concurrent.TimeUnit import java.util.concurrent.locks.ReentrantLock -class KotlinClassInnerStuffCache(val myClass: PsiExtensibleClass, externalDependencies: List) { +class KotlinClassInnerStuffCache( + private val myClass: PsiExtensibleClass, + externalDependencies: List, + private val lazyCreator: LazyCreator, +) { private val myTracker = SimpleModificationTracker() private val dependencies: List = externalDependencies + myTracker - fun get(initializer: () -> T) = object : Lazy { - private val lock = ReentrantLock() - private val holder = lazyPub { - PsiCachedValueImpl(PsiManager.getInstance(myClass.project), - CachedValueProvider { - val v = initializer() - CachedValueProvider.Result.create(v, dependencies) - }) - } - - private fun computeValue(): T = holder.value.value ?: error("holder has not null in initializer") - - override val value: T - get() { - return if (holder.value.hasUpToDateValue()) { - computeValue() - } else { - // the idea behind this locking approach: - // Thread T1 starts to calculate value for A it acquires lock for A - // - // Assumption 1: Lets say A calculation requires another value e.g. B to be calculated - // Assumption 2: Thread T2 wants to calculate value for B - - // to avoid dead-lock - // - we mark thread as doing calculation and acquire lock only once per thread - // as a trade-off to prevent dependent value could be calculated several time - // due to CAS (within putUserDataIfAbsent etc) the same instance of calculated value will be used - - // TODO: NOTE: acquire lock for a several seconds to avoid dead-lock via resolve is a WORKAROUND - - if (!initIsRunning.get() && lock.tryLock(5, TimeUnit.SECONDS)) { - try { - initIsRunning.set(true) - try { - computeValue() - } finally { - initIsRunning.set(false) - } - } finally { - lock.unlock() - } - } else { - computeValue() - } - } - } - - override fun isInitialized() = holder.isInitialized() + abstract class LazyCreator { + abstract fun get(initializer: () -> T, dependencies: List): Lazy } + private fun get(initializer: () -> T): Lazy = lazyCreator.get(initializer, dependencies) + private val _getConstructors: Array by get { PsiImplUtil.getConstructors(myClass) } val constructors: Array @@ -235,9 +195,6 @@ class KotlinClassInnerStuffCache(val myClass: PsiExtensibleClass, externalDepend private const val VALUES_METHOD = "values" private const val VALUE_OF_METHOD = "valueOf" - @JvmStatic - private val initIsRunning: ThreadLocal = ThreadLocal.withInitial { false } - // Copy of PsiClassImplUtil.processDeclarationsInEnum for own cache class @JvmStatic fun processDeclarationsInEnum( diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/KtLightClassBase.kt b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/KtLightClassBase.kt index cef1846b358..2bc6b82178b 100644 --- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/KtLightClassBase.kt +++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/KtLightClassBase.kt @@ -31,7 +31,10 @@ import org.jetbrains.kotlin.idea.KotlinLanguage abstract class KtLightClassBase protected constructor(manager: PsiManager) : AbstractLightClass(manager, KotlinLanguage.INSTANCE), KtLightClass, PsiExtensibleClass { protected open val myInnersCache = KotlinClassInnerStuffCache( - this, listOf(KotlinModificationTrackerService.getInstance(manager.project).outOfBlockModificationTracker)) + myClass = this, + externalDependencies = listOf(KotlinModificationTrackerService.getInstance(manager.project).outOfBlockModificationTracker), + lazyCreator = LightClassesLazyCreator(project) + ) override fun getDelegate() = clsDelegate diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/KtLightClassForSourceDeclaration.kt b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/KtLightClassForSourceDeclaration.kt index e568c6c74b6..9bc019e3ae3 100644 --- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/KtLightClassForSourceDeclaration.kt +++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/KtLightClassForSourceDeclaration.kt @@ -72,8 +72,9 @@ abstract class KtLightClassForSourceDeclaration( StubBasedPsiElement> { override val myInnersCache: KotlinClassInnerStuffCache = KotlinClassInnerStuffCache( - this, - classOrObject.getExternalDependencies() + myClass = this, + externalDependencies = classOrObject.getExternalDependencies(), + lazyCreator = LightClassesLazyCreator(project) ) private val lightIdentifier = KtLightIdentifier(this, classOrObject) diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/LightClassesLazyCreator.kt b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/LightClassesLazyCreator.kt new file mode 100644 index 00000000000..297628e4fdc --- /dev/null +++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/classes/LightClassesLazyCreator.kt @@ -0,0 +1,70 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.asJava.classes + +import com.intellij.openapi.project.Project +import com.intellij.psi.PsiManager +import com.intellij.psi.impl.PsiCachedValueImpl +import com.intellij.psi.util.CachedValueProvider +import java.util.concurrent.TimeUnit +import java.util.concurrent.locks.ReentrantLock + +class LightClassesLazyCreator(private val project: Project) : KotlinClassInnerStuffCache.LazyCreator() { + override fun get(initializer: () -> T, dependencies: List) = object : Lazy { + private val lock = ReentrantLock() + private val holder = lazyPub { + PsiCachedValueImpl(PsiManager.getInstance(project), + CachedValueProvider { + val v = initializer() + CachedValueProvider.Result.create(v, dependencies) + }) + } + + private fun computeValue(): T = holder.value.value ?: error("holder has not null in initializer") + + override val value: T + get() { + return if (holder.value.hasUpToDateValue()) { + computeValue() + } else { + // the idea behind this locking approach: + // Thread T1 starts to calculate value for A it acquires lock for A + // + // Assumption 1: Lets say A calculation requires another value e.g. B to be calculated + // Assumption 2: Thread T2 wants to calculate value for B + + // to avoid dead-lock + // - we mark thread as doing calculation and acquire lock only once per thread + // as a trade-off to prevent dependent value could be calculated several time + // due to CAS (within putUserDataIfAbsent etc) the same instance of calculated value will be used + + // TODO: NOTE: acquire lock for a several seconds to avoid dead-lock via resolve is a WORKAROUND + + if (!initIsRunning.get() && lock.tryLock(5, TimeUnit.SECONDS)) { + try { + initIsRunning.set(true) + try { + computeValue() + } finally { + initIsRunning.set(false) + } + } finally { + lock.unlock() + } + } else { + computeValue() + } + } + } + + override fun isInitialized() = holder.isInitialized() + } + + companion object { + @JvmStatic + private val initIsRunning: ThreadLocal = ThreadLocal.withInitial { false } + } +} \ No newline at end of file diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/lightClasses/decompiledDeclarations/KtLightClassForDecompiledDeclaration.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/lightClasses/decompiledDeclarations/KtLightClassForDecompiledDeclaration.kt index 04803f5f3f0..9a6ad868b1a 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/lightClasses/decompiledDeclarations/KtLightClassForDecompiledDeclaration.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/lightClasses/decompiledDeclarations/KtLightClassForDecompiledDeclaration.kt @@ -18,6 +18,7 @@ import org.jetbrains.annotations.NonNls import org.jetbrains.kotlin.analyzer.KotlinModificationTrackerService import org.jetbrains.kotlin.asJava.classes.KotlinClassInnerStuffCache import org.jetbrains.kotlin.asJava.classes.KtLightClass +import org.jetbrains.kotlin.asJava.classes.LightClassesLazyCreator import org.jetbrains.kotlin.asJava.classes.lazyPub import org.jetbrains.kotlin.asJava.elements.KtLightElementBase import org.jetbrains.kotlin.idea.decompiler.classFile.KtClsFile @@ -34,7 +35,8 @@ open class KtLightClassForDecompiledDeclaration( private val myInnersCache = KotlinClassInnerStuffCache( myClass = this, - externalDependencies = listOf(KotlinModificationTrackerService.getInstance(manager.project).outOfBlockModificationTracker) + externalDependencies = listOf(KotlinModificationTrackerService.getInstance(manager.project).outOfBlockModificationTracker), + lazyCreator = LightClassesLazyCreator(project) ) override fun getOwnMethods(): MutableList = _methods diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightClassBase.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightClassBase.kt index d33adf7bde9..b422d36b3aa 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightClassBase.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightClassBase.kt @@ -18,8 +18,10 @@ package org.jetbrains.kotlin.idea.asJava import com.intellij.navigation.ItemPresentation import com.intellij.navigation.ItemPresentationProviders +import com.intellij.openapi.project.Project import com.intellij.openapi.util.Pair import com.intellij.psi.* +import com.intellij.psi.impl.PsiCachedValueImpl import com.intellij.psi.impl.PsiClassImplUtil import com.intellij.psi.impl.PsiImplUtil import com.intellij.psi.impl.PsiSuperMethodImplUtil @@ -27,6 +29,7 @@ import com.intellij.psi.impl.light.LightElement import com.intellij.psi.impl.source.PsiExtensibleClass import com.intellij.psi.javadoc.PsiDocComment import com.intellij.psi.scope.PsiScopeProcessor +import com.intellij.psi.util.CachedValueProvider import com.intellij.psi.util.PsiUtil import org.jetbrains.annotations.NonNls import org.jetbrains.kotlin.analyzer.KotlinModificationTrackerService @@ -34,7 +37,10 @@ import org.jetbrains.kotlin.asJava.classes.KotlinClassInnerStuffCache import org.jetbrains.kotlin.asJava.classes.KotlinClassInnerStuffCache.Companion.processDeclarationsInEnum import org.jetbrains.kotlin.asJava.classes.KtLightClass import org.jetbrains.kotlin.asJava.classes.cannotModify +import org.jetbrains.kotlin.asJava.classes.lazyPub import org.jetbrains.kotlin.idea.KotlinLanguage +import java.util.concurrent.TimeUnit +import java.util.concurrent.locks.ReentrantLock import javax.swing.Icon abstract class FirLightClassBase protected constructor(manager: PsiManager) : LightElement(manager, KotlinLanguage.INSTANCE), PsiClass, @@ -43,9 +49,18 @@ abstract class FirLightClassBase protected constructor(manager: PsiManager) : Li override val clsDelegate: PsiClass get() = invalidAccess() - protected open val myInnersCache = KotlinClassInnerStuffCache( - myClass = this, - externalDependencies = listOf(KotlinModificationTrackerService.getInstance(manager.project).outOfBlockModificationTracker) + private class FirLightClassesLazyCreator(private val project: Project) : KotlinClassInnerStuffCache.LazyCreator() { + override fun get(initializer: () -> T, dependencies: List): Lazy = lazyPub { + PsiCachedValueImpl(PsiManager.getInstance(project)) { + CachedValueProvider.Result.create(initializer(), dependencies) + }.value ?: error("initializer cannot return null") + } + } + + private val myInnersCache = KotlinClassInnerStuffCache( + myClass = this@FirLightClassBase, + externalDependencies = listOf(KotlinModificationTrackerService.getInstance(manager.project).outOfBlockModificationTracker), + lazyCreator = FirLightClassesLazyCreator(project) ) override fun getFields(): Array = myInnersCache.fields From 2f4842b2719c20d8cb491a226c360bb86dae2b67 Mon Sep 17 00:00:00 2001 From: Igor Yakovlev Date: Mon, 14 Dec 2020 18:27:56 +0300 Subject: [PATCH 058/196] [FIR IDE] Add KtFileScope to support KtFileSymbol --- .../idea/frontend/api/KtAnalysisSession.kt | 7 +- .../api/components/KtScopeProvider.kt | 7 +- .../idea/frontend/api/scopes/KtScope.kt | 14 ++- .../api/symbols/KtAnonymousObjectSymbol.kt | 4 +- .../frontend/api/symbols/KtClassLikeSymbol.kt | 3 +- .../idea/frontend/api/symbols/KtFileSymbol.kt | 3 - .../api/symbols/KtVariableLikeSymbol.kt | 2 +- ...Declarations.kt => KtSymbolWithMembers.kt} | 2 + .../asJava/classes/FirLightClassForFacade.kt | 34 ++++--- .../idea/asJava/classes/firLightClassUtils.kt | 4 +- .../api/fir/components/KtFirScopeProvider.kt | 21 +++- .../fir/scopes/KtFirDeclaredMemberScope.kt | 5 +- .../api/fir/scopes/KtFirEmptyMemberScope.kt | 4 +- .../frontend/api/fir/scopes/KtFirFileScope.kt | 95 +++++++++++++++++++ .../api/fir/scopes/KtFirMemberScope.kt | 5 +- .../api/fir/symbols/KtFirFileSymbol.kt | 11 +-- 16 files changed, 167 insertions(+), 54 deletions(-) rename idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/markers/{KtSymbolWithDeclarations.kt => KtSymbolWithMembers.kt} (86%) create mode 100644 idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/scopes/KtFirFileScope.kt diff --git a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/KtAnalysisSession.kt b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/KtAnalysisSession.kt index cd6d5c9d1e7..5d59a9e9b6a 100644 --- a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/KtAnalysisSession.kt +++ b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/KtAnalysisSession.kt @@ -12,6 +12,7 @@ import org.jetbrains.kotlin.idea.frontend.api.components.* import org.jetbrains.kotlin.idea.frontend.api.scopes.* import org.jetbrains.kotlin.idea.frontend.api.symbols.* import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolWithDeclarations +import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolWithMembers import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolWithKind import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtSymbolPointer import org.jetbrains.kotlin.idea.frontend.api.types.KtType @@ -82,9 +83,11 @@ abstract class KtAnalysisSession(final override val token: ValidityToken) : Vali fun KtSymbolWithKind.getContainingSymbol(): KtSymbolWithKind? = containingDeclarationProvider.getContainingDeclaration(this) - fun KtSymbolWithDeclarations.getMemberScope(): KtMemberScope = scopeProvider.getMemberScope(this) + fun KtSymbolWithMembers.getMemberScope(): KtMemberScope = scopeProvider.getMemberScope(this) - fun KtSymbolWithDeclarations.getDeclaredMemberScope(): KtDeclaredMemberScope = scopeProvider.getDeclaredMemberScope(this) + fun KtSymbolWithMembers.getDeclaredMemberScope(): KtDeclaredMemberScope = scopeProvider.getDeclaredMemberScope(this) + + fun KtFileSymbol.getFileScope(): KtDeclarationScope = scopeProvider.getFileScope(this) fun KtPackageSymbol.getPackageScope(): KtPackageScope = scopeProvider.getPackageScope(this) diff --git a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/components/KtScopeProvider.kt b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/components/KtScopeProvider.kt index 1a496ae71aa..169fe140677 100644 --- a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/components/KtScopeProvider.kt +++ b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/components/KtScopeProvider.kt @@ -6,15 +6,18 @@ package org.jetbrains.kotlin.idea.frontend.api.components import org.jetbrains.kotlin.idea.frontend.api.scopes.* +import org.jetbrains.kotlin.idea.frontend.api.symbols.KtFileSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.KtPackageSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolWithDeclarations +import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolWithMembers import org.jetbrains.kotlin.idea.frontend.api.types.KtType import org.jetbrains.kotlin.psi.KtElement import org.jetbrains.kotlin.psi.KtFile abstract class KtScopeProvider : KtAnalysisSessionComponent() { - abstract fun getMemberScope(classSymbol: KtSymbolWithDeclarations): KtMemberScope - abstract fun getDeclaredMemberScope(classSymbol: KtSymbolWithDeclarations): KtDeclaredMemberScope + abstract fun getMemberScope(classSymbol: KtSymbolWithMembers): KtMemberScope + abstract fun getDeclaredMemberScope(classSymbol: KtSymbolWithMembers): KtDeclaredMemberScope + abstract fun getFileScope(fileSymbol: KtFileSymbol): KtDeclarationScope abstract fun getPackageScope(packageSymbol: KtPackageSymbol): KtPackageScope abstract fun getCompositeScope(subScopes: List): KtCompositeScope diff --git a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/scopes/KtScope.kt b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/scopes/KtScope.kt index 24c363c9026..83a4ab18b4b 100644 --- a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/scopes/KtScope.kt +++ b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/scopes/KtScope.kt @@ -5,10 +5,10 @@ package org.jetbrains.kotlin.idea.frontend.api.scopes -import org.jetbrains.kotlin.idea.frontend.api.ValidityToken import org.jetbrains.kotlin.idea.frontend.api.ValidityTokenOwner import org.jetbrains.kotlin.idea.frontend.api.symbols.* import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolWithDeclarations +import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolWithMembers import org.jetbrains.kotlin.idea.frontend.api.withValidityAssertion import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name @@ -43,12 +43,16 @@ interface KtCompositeScope : KtScope { val subScopes: List } -interface KtMemberScope : KtScope { - val owner: KtSymbolWithDeclarations +interface KtMemberScope : KtDeclarationScope { + override val owner: KtSymbolWithMembers } -interface KtDeclaredMemberScope : KtScope { - val owner: KtSymbolWithDeclarations +interface KtDeclaredMemberScope : KtDeclarationScope { + override val owner: KtSymbolWithMembers +} + +interface KtDeclarationScope : KtScope { + val owner: T } interface KtPackageScope : KtScope, KtSubstitutedScope { diff --git a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/KtAnonymousObjectSymbol.kt b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/KtAnonymousObjectSymbol.kt index f2376418551..6c5db0b8210 100644 --- a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/KtAnonymousObjectSymbol.kt +++ b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/KtAnonymousObjectSymbol.kt @@ -6,12 +6,12 @@ package org.jetbrains.kotlin.idea.frontend.api.symbols import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtAnnotatedSymbol -import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolWithDeclarations +import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolWithMembers import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolWithKind import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtSymbolPointer import org.jetbrains.kotlin.idea.frontend.api.types.KtType -abstract class KtAnonymousObjectSymbol : KtSymbolWithKind, KtAnnotatedSymbol, KtSymbolWithDeclarations { +abstract class KtAnonymousObjectSymbol : KtSymbolWithKind, KtAnnotatedSymbol, KtSymbolWithMembers { abstract val superTypes: List abstract override fun createPointer(): KtSymbolPointer diff --git a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/KtClassLikeSymbol.kt b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/KtClassLikeSymbol.kt index 74de4964757..3aa75dc4ca6 100644 --- a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/KtClassLikeSymbol.kt +++ b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/KtClassLikeSymbol.kt @@ -7,7 +7,6 @@ package org.jetbrains.kotlin.idea.frontend.api.symbols import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.* import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtSymbolPointer -import org.jetbrains.kotlin.idea.frontend.api.types.KtClassType import org.jetbrains.kotlin.idea.frontend.api.types.KtType import org.jetbrains.kotlin.name.ClassId @@ -38,7 +37,7 @@ abstract class KtClassOrObjectSymbol : KtClassLikeSymbol(), KtSymbolWithModality, KtSymbolWithVisibility, KtAnnotatedSymbol, - KtSymbolWithDeclarations { + KtSymbolWithMembers { abstract val classKind: KtClassKind abstract val isInner: Boolean diff --git a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/KtFileSymbol.kt b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/KtFileSymbol.kt index 8be87b279e5..ecc70c37c8b 100644 --- a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/KtFileSymbol.kt +++ b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/KtFileSymbol.kt @@ -9,8 +9,5 @@ import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtAnnotatedSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtSymbolPointer abstract class KtFileSymbol : KtAnnotatedSymbol { - - abstract val topLevelCallableSymbols: List - abstract override fun createPointer(): KtSymbolPointer } \ No newline at end of file diff --git a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/KtVariableLikeSymbol.kt b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/KtVariableLikeSymbol.kt index d21d0ecbcb6..f0ada480843 100644 --- a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/KtVariableLikeSymbol.kt +++ b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/KtVariableLikeSymbol.kt @@ -15,7 +15,7 @@ sealed class KtVariableLikeSymbol : KtCallableSymbol(), KtTypedSymbol, KtNamedSy abstract override fun createPointer(): KtSymbolPointer } -abstract class KtEnumEntrySymbol : KtVariableLikeSymbol(), KtSymbolWithDeclarations, KtSymbolWithKind { +abstract class KtEnumEntrySymbol : KtVariableLikeSymbol(), KtSymbolWithMembers, KtSymbolWithKind { final override val symbolKind: KtSymbolKind get() = KtSymbolKind.MEMBER abstract val containingEnumClassIdIfNonLocal: ClassId? diff --git a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/markers/KtSymbolWithDeclarations.kt b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/markers/KtSymbolWithMembers.kt similarity index 86% rename from idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/markers/KtSymbolWithDeclarations.kt rename to idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/markers/KtSymbolWithMembers.kt index 6b9fc49461f..38bb73b26ae 100644 --- a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/markers/KtSymbolWithDeclarations.kt +++ b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/markers/KtSymbolWithMembers.kt @@ -7,4 +7,6 @@ package org.jetbrains.kotlin.idea.frontend.api.symbols.markers import org.jetbrains.kotlin.idea.frontend.api.symbols.KtSymbol +interface KtSymbolWithMembers : KtSymbolWithDeclarations + interface KtSymbolWithDeclarations : KtSymbol \ No newline at end of file diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightClassForFacade.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightClassForFacade.kt index 4dd067930bf..52850b5be27 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightClassForFacade.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightClassForFacade.kt @@ -22,11 +22,14 @@ import org.jetbrains.kotlin.idea.KotlinLanguage import org.jetbrains.kotlin.idea.asJava.classes.createField import org.jetbrains.kotlin.idea.asJava.classes.createMethods import org.jetbrains.kotlin.idea.frontend.api.analyze +import org.jetbrains.kotlin.idea.frontend.api.fir.analyzeWithSymbolAsContext +import org.jetbrains.kotlin.idea.frontend.api.scopes.KtDeclarationScope import org.jetbrains.kotlin.idea.frontend.api.symbols.KtCallableSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.KtKotlinPropertySymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.KtFileSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.KtFunctionSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.KtPropertySymbol +import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolWithDeclarations import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolWithVisibility import org.jetbrains.kotlin.load.java.structure.LightClassOriginKind import org.jetbrains.kotlin.name.FqName @@ -80,14 +83,17 @@ class FirLightClassForFacade( private val _ownMethods: List by lazyPub { val result = mutableListOf() + val methodsAndProperties = sequence { for (fileSymbol in fileSymbols) { - for (callableSymbol in fileSymbol.topLevelCallableSymbols) { - if (callableSymbol !is KtFunctionSymbol && callableSymbol !is KtPropertySymbol) continue - if (callableSymbol !is KtSymbolWithVisibility) continue - val isPrivate = callableSymbol.toPsiVisibilityForMember(isTopLevel = true) == PsiModifier.PRIVATE - if (isPrivate && multiFileClass) continue - yield(callableSymbol) + analyzeWithSymbolAsContext(fileSymbol) { + for (callableSymbol in fileSymbol.getFileScope().getCallableSymbols()) { + if (callableSymbol !is KtFunctionSymbol && callableSymbol !is KtKotlinPropertySymbol) continue + if (callableSymbol !is KtSymbolWithVisibility) continue + val isPrivate = callableSymbol.toPsiVisibilityForMember(isTopLevel = true) == PsiModifier.PRIVATE + if (isPrivate && multiFileClass) continue + yield(callableSymbol) + } } } } @@ -101,17 +107,17 @@ class FirLightClassForFacade( } private fun loadFieldsFromFile( - fileSymbol: KtFileSymbol, + fileScope: KtDeclarationScope, nameGenerator: FirLightField.FieldNameGenerator, result: MutableList ) { - for (propertySymbol in fileSymbol.topLevelCallableSymbols) { + for (propertySymbol in fileScope.getCallableSymbols()) { - if (propertySymbol !is KtPropertySymbol) continue + if (propertySymbol !is KtKotlinPropertySymbol) continue - if (propertySymbol is KtKotlinPropertySymbol && propertySymbol.isConst && multiFileClass) continue + if (propertySymbol.isConst && multiFileClass) continue - val isLateInitWithPublicAccessors = if (propertySymbol is KtKotlinPropertySymbol && propertySymbol.isLateInit) { + val isLateInitWithPublicAccessors = if (propertySymbol.isLateInit) { val getterIsPublic = propertySymbol.getter?.toPsiVisibilityForMember(isTopLevel = true) ?.let { it == PsiModifier.PUBLIC } ?: true val setterIsPublic = propertySymbol.setter?.toPsiVisibilityForMember(isTopLevel = true) @@ -120,7 +126,7 @@ class FirLightClassForFacade( } else false val forceStaticAndPropertyVisibility = isLateInitWithPublicAccessors || - (propertySymbol is KtKotlinPropertySymbol && propertySymbol.isConst) || + (propertySymbol.isConst) || propertySymbol.hasJvmFieldAnnotation() createField( @@ -139,7 +145,9 @@ class FirLightClassForFacade( val result = mutableListOf() val nameGenerator = FirLightField.FieldNameGenerator() for (fileSymbol in fileSymbols) { - loadFieldsFromFile(fileSymbol, nameGenerator, result) + analyzeWithSymbolAsContext(fileSymbol) { + loadFieldsFromFile(fileSymbol.getFileScope(), nameGenerator, result) + } } result } diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/firLightClassUtils.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/firLightClassUtils.kt index 269ab68bf8f..e7e95670fd4 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/firLightClassUtils.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/firLightClassUtils.kt @@ -24,7 +24,7 @@ import org.jetbrains.kotlin.idea.frontend.api.fir.analyzeWithSymbolAsContext import org.jetbrains.kotlin.idea.frontend.api.symbols.* import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtCommonSymbolModality import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolVisibility -import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolWithDeclarations +import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolWithMembers import org.jetbrains.kotlin.idea.frontend.api.types.KtClassType import org.jetbrains.kotlin.idea.frontend.api.types.KtType import org.jetbrains.kotlin.lexer.KtTokens @@ -304,7 +304,7 @@ internal fun FirLightClassBase.createInheritanceList(forExtendsList: Boolean, su return listBuilder } -internal fun KtSymbolWithDeclarations.createInnerClasses(manager: PsiManager): List { +internal fun KtSymbolWithMembers.createInnerClasses(manager: PsiManager): List { val result = ArrayList() // workaround for ClassInnerStuffCache not supporting classes with null names, see KT-13927 diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirScopeProvider.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirScopeProvider.kt index ad299016598..e579f4860c3 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirScopeProvider.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirScopeProvider.kt @@ -28,13 +28,16 @@ import org.jetbrains.kotlin.idea.frontend.api.fir.scopes.* import org.jetbrains.kotlin.idea.frontend.api.fir.symbols.KtFirAnonymousObjectSymbol import org.jetbrains.kotlin.idea.frontend.api.fir.symbols.KtFirClassOrObjectSymbol import org.jetbrains.kotlin.idea.frontend.api.fir.symbols.KtFirEnumEntrySymbol +import org.jetbrains.kotlin.idea.frontend.api.fir.symbols.KtFirFileSymbol import org.jetbrains.kotlin.idea.frontend.api.fir.types.KtFirType import org.jetbrains.kotlin.idea.frontend.api.fir.utils.EnclosingDeclarationContext import org.jetbrains.kotlin.idea.frontend.api.fir.utils.buildCompletionContext import org.jetbrains.kotlin.idea.frontend.api.fir.utils.weakRef import org.jetbrains.kotlin.idea.frontend.api.scopes.* +import org.jetbrains.kotlin.idea.frontend.api.symbols.KtFileSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.KtPackageSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolWithDeclarations +import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolWithMembers import org.jetbrains.kotlin.idea.frontend.api.types.KtType import org.jetbrains.kotlin.idea.frontend.api.withValidityAssertion import org.jetbrains.kotlin.psi.KtElement @@ -53,11 +56,12 @@ internal class KtFirScopeProvider( private val firResolveState by weakRef(firResolveState) private val firScopeStorage = FirScopeRegistry() - private val memberScopeCache = IdentityHashMap() - private val declaredMemberScopeCache = IdentityHashMap() + private val memberScopeCache = IdentityHashMap() + private val declaredMemberScopeCache = IdentityHashMap() + private val fileScopeCache = IdentityHashMap>() private val packageMemberScopeCache = IdentityHashMap() - private inline fun KtSymbolWithDeclarations.withFirForScope(crossinline body: (FirClass<*>) -> T): T? = when (this) { + private inline fun KtSymbolWithMembers.withFirForScope(crossinline body: (FirClass<*>) -> T): T? = when (this) { is KtFirClassOrObjectSymbol -> firRef.withFir(FirResolvePhase.SUPER_TYPES, body) is KtFirAnonymousObjectSymbol -> firRef.withFir(FirResolvePhase.SUPER_TYPES, body) is KtFirEnumEntrySymbol -> firRef.withFir(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) { @@ -68,7 +72,7 @@ internal class KtFirScopeProvider( else -> error { "Unknown KtSymbolWithDeclarations implementation ${this::class.qualifiedName}" } } - override fun getMemberScope(classSymbol: KtSymbolWithDeclarations): KtMemberScope = withValidityAssertion { + override fun getMemberScope(classSymbol: KtSymbolWithMembers): KtMemberScope = withValidityAssertion { memberScopeCache.getOrPut(classSymbol) { val firScope = classSymbol.withFirForScope { fir -> @@ -86,7 +90,7 @@ internal class KtFirScopeProvider( } } - override fun getDeclaredMemberScope(classSymbol: KtSymbolWithDeclarations): KtDeclaredMemberScope = withValidityAssertion { + override fun getDeclaredMemberScope(classSymbol: KtSymbolWithMembers): KtDeclaredMemberScope = withValidityAssertion { declaredMemberScopeCache.getOrPut(classSymbol) { val firScope = classSymbol.withFirForScope { declaredMemberScope(it) @@ -98,6 +102,13 @@ internal class KtFirScopeProvider( } } + override fun getFileScope(fileSymbol: KtFileSymbol): KtDeclarationScope = withValidityAssertion { + fileScopeCache.getOrPut(fileSymbol) { + check(fileSymbol is KtFirFileSymbol) { "KtFirScopeProvider can only work with KtFirFileSymbol, but ${fileSymbol::class} was provided" } + KtFirFileScope(fileSymbol, token, builder) + } + } + override fun getPackageScope(packageSymbol: KtPackageSymbol): KtPackageScope = withValidityAssertion { packageMemberScopeCache.getOrPut(packageSymbol) { val firPackageScope = diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/scopes/KtFirDeclaredMemberScope.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/scopes/KtFirDeclaredMemberScope.kt index 3455178df3e..342e22d978d 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/scopes/KtFirDeclaredMemberScope.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/scopes/KtFirDeclaredMemberScope.kt @@ -9,14 +9,13 @@ import org.jetbrains.kotlin.fir.scopes.impl.FirClassDeclaredMemberScope import org.jetbrains.kotlin.idea.frontend.api.ValidityToken import org.jetbrains.kotlin.idea.frontend.api.ValidityTokenOwner import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder -import org.jetbrains.kotlin.idea.frontend.api.fir.symbols.KtFirClassOrObjectSymbol import org.jetbrains.kotlin.idea.frontend.api.fir.utils.weakRef import org.jetbrains.kotlin.idea.frontend.api.scopes.KtDeclaredMemberScope import org.jetbrains.kotlin.idea.frontend.api.scopes.KtUnsubstitutedScope -import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolWithDeclarations +import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolWithMembers internal class KtFirDeclaredMemberScope( - override val owner: KtSymbolWithDeclarations, + override val owner: KtSymbolWithMembers, firScope: FirClassDeclaredMemberScope, token: ValidityToken, builder: KtSymbolByFirBuilder diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/scopes/KtFirEmptyMemberScope.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/scopes/KtFirEmptyMemberScope.kt index b356db91188..48dc5c95104 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/scopes/KtFirEmptyMemberScope.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/scopes/KtFirEmptyMemberScope.kt @@ -12,10 +12,10 @@ import org.jetbrains.kotlin.idea.frontend.api.scopes.KtMemberScope import org.jetbrains.kotlin.idea.frontend.api.scopes.KtScopeNameFilter import org.jetbrains.kotlin.idea.frontend.api.symbols.KtCallableSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.KtClassifierSymbol -import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolWithDeclarations +import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolWithMembers import org.jetbrains.kotlin.name.Name -internal class KtFirEmptyMemberScope(override val owner: KtSymbolWithDeclarations) : KtMemberScope, KtDeclaredMemberScope, ValidityTokenOwner { +internal class KtFirEmptyMemberScope(override val owner: KtSymbolWithMembers) : KtMemberScope, KtDeclaredMemberScope, ValidityTokenOwner { override fun getCallableNames(): Set = emptySet() override fun getClassifierNames(): Set = emptySet() diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/scopes/KtFirFileScope.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/scopes/KtFirFileScope.kt new file mode 100644 index 00000000000..1a388473b9f --- /dev/null +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/scopes/KtFirFileScope.kt @@ -0,0 +1,95 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.idea.frontend.api.fir.scopes + +import org.jetbrains.kotlin.fir.declarations.FirProperty +import org.jetbrains.kotlin.fir.declarations.FirRegularClass +import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction +import org.jetbrains.kotlin.idea.frontend.api.ValidityToken +import org.jetbrains.kotlin.idea.frontend.api.ValidityTokenOwner +import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder +import org.jetbrains.kotlin.idea.frontend.api.fir.symbols.KtFirFileSymbol +import org.jetbrains.kotlin.idea.frontend.api.fir.utils.cached +import org.jetbrains.kotlin.idea.frontend.api.scopes.KtDeclarationScope +import org.jetbrains.kotlin.idea.frontend.api.scopes.KtScopeNameFilter +import org.jetbrains.kotlin.idea.frontend.api.symbols.KtCallableSymbol +import org.jetbrains.kotlin.idea.frontend.api.symbols.KtClassifierSymbol +import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolWithDeclarations +import org.jetbrains.kotlin.idea.frontend.api.withValidityAssertion +import org.jetbrains.kotlin.name.Name + +internal class KtFirFileScope( + override val owner: KtFirFileSymbol, + override val token: ValidityToken, + private val builder: KtSymbolByFirBuilder +) : KtDeclarationScope, + ValidityTokenOwner { + + private val allNamesCached by cached { + _callableNames + _classifierNames + } + + override fun getAllNames(): Set = allNamesCached + + private val _callableNames: Set by cached { + val result = mutableSetOf() + owner.firRef.withFir { + it.declarations.mapNotNullTo(result) { firDeclaration -> + when (firDeclaration) { + is FirSimpleFunction -> firDeclaration.name + is FirProperty -> firDeclaration.name + else -> null + } + } + } + result + } + + override fun getCallableNames(): Set = _callableNames + + private val _classifierNames: Set by cached { + val result = mutableSetOf() + owner.firRef.withFir { + it.declarations.mapNotNullTo(result) { firDeclaration -> + (firDeclaration as? FirRegularClass)?.name + } + } + result + } + + override fun getClassifierNames(): Set = _classifierNames + + override fun getCallableSymbols(nameFilter: KtScopeNameFilter): Sequence = withValidityAssertion { + owner.firRef.withFir { + sequence { + it.declarations.forEach { firDeclaration -> + val callableDeclaration = when (firDeclaration) { + is FirSimpleFunction -> firDeclaration.takeIf { nameFilter(firDeclaration.name) } + is FirProperty -> firDeclaration.takeIf { nameFilter(firDeclaration.name) } + else -> null + } + + if (callableDeclaration != null) { + yield(builder.buildCallableSymbol(callableDeclaration)) + } + } + } + } + } + + override fun getClassifierSymbols(nameFilter: KtScopeNameFilter): Sequence = withValidityAssertion { + owner.firRef.withFir { + sequence { + it.declarations.forEach { firDeclaration -> + val classLikeDeclaration = (firDeclaration as? FirRegularClass)?.takeIf { klass -> nameFilter(klass.name) } + if (classLikeDeclaration != null) { + yield(builder.buildClassLikeSymbol(classLikeDeclaration)) + } + } + } + } + } +} \ No newline at end of file diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/scopes/KtFirMemberScope.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/scopes/KtFirMemberScope.kt index 20b9356aa25..6f8d327cbb7 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/scopes/KtFirMemberScope.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/scopes/KtFirMemberScope.kt @@ -9,14 +9,13 @@ import org.jetbrains.kotlin.fir.scopes.FirTypeScope import org.jetbrains.kotlin.idea.frontend.api.ValidityToken import org.jetbrains.kotlin.idea.frontend.api.ValidityTokenOwner import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder -import org.jetbrains.kotlin.idea.frontend.api.fir.symbols.KtFirClassOrObjectSymbol import org.jetbrains.kotlin.idea.frontend.api.fir.utils.weakRef import org.jetbrains.kotlin.idea.frontend.api.scopes.KtMemberScope import org.jetbrains.kotlin.idea.frontend.api.scopes.KtUnsubstitutedScope -import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolWithDeclarations +import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolWithMembers internal class KtFirMemberScope( - override val owner: KtSymbolWithDeclarations, + override val owner: KtSymbolWithMembers, firScope: FirTypeScope, token: ValidityToken, builder: KtSymbolByFirBuilder diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirFileSymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirFileSymbol.kt index 8e918f299dd..dadc3bff508 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirFileSymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirFileSymbol.kt @@ -6,7 +6,6 @@ package org.jetbrains.kotlin.idea.frontend.api.fir.symbols import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration import org.jetbrains.kotlin.fir.declarations.FirFile import org.jetbrains.kotlin.fir.declarations.FirResolvePhase import org.jetbrains.kotlin.idea.fir.findPsi @@ -15,9 +14,9 @@ import org.jetbrains.kotlin.idea.frontend.api.ValidityToken import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder import org.jetbrains.kotlin.idea.frontend.api.fir.utils.convertAnnotation import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef -import org.jetbrains.kotlin.idea.frontend.api.symbols.KtCallableSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.KtFileSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtAnnotationCall +import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolWithDeclarations import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtPsiBasedSymbolPointer import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtSymbolPointer @@ -26,17 +25,11 @@ internal class KtFirFileSymbol( resolveState: FirModuleResolveState, override val token: ValidityToken, private val builder: KtSymbolByFirBuilder -) : KtFileSymbol(), KtFirSymbol { +) : KtFileSymbol(), KtSymbolWithDeclarations, KtFirSymbol { override val firRef = firRef(fir, resolveState) override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.findPsi(fir.session) } - override val topLevelCallableSymbols: List by firRef.withFirAndCache { - it.declarations.mapNotNull { declaration -> - if (declaration is FirCallableDeclaration<*>) builder.buildCallableSymbol(declaration) else null - } - } - override fun createPointer(): KtSymbolPointer { KtPsiBasedSymbolPointer.createForSymbolFromSource(this)?.let { return it } TODO("Creating pointers for files from library is not supported yet") From c2bf124d8624efdc570f657db56ba081e13dba49 Mon Sep 17 00:00:00 2001 From: Igor Yakovlev Date: Tue, 15 Dec 2020 17:28:49 +0300 Subject: [PATCH 059/196] [FIR IDE] File symbol scope and symbol test --- .../kotlin/generators/tests/GenerateTests.kt | 5 ++ .../testData/fileScopeTest/simpleFileScope.kt | 11 +++ .../fileScopeTest/simpleFileScope.kt.result | 83 +++++++++++++++++++ .../api/scopes/AbstractFileScopeTest.kt | 43 ++++++++++ .../api/scopes/FileScopeTestGenerated.java | 35 ++++++++ 5 files changed, 177 insertions(+) create mode 100644 idea/idea-frontend-fir/testData/fileScopeTest/simpleFileScope.kt create mode 100644 idea/idea-frontend-fir/testData/fileScopeTest/simpleFileScope.kt.result create mode 100644 idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/scopes/AbstractFileScopeTest.kt create mode 100644 idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/scopes/FileScopeTestGenerated.java diff --git a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt index b05d4a0f326..6546fe93f51 100644 --- a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt +++ b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt @@ -92,6 +92,7 @@ import org.jetbrains.kotlin.idea.folding.AbstractKotlinFoldingTest import org.jetbrains.kotlin.idea.frontend.api.components.AbstractExpectedExpressionTypeTest import org.jetbrains.kotlin.idea.frontend.api.components.AbstractReturnExpressionTargetTest import org.jetbrains.kotlin.idea.frontend.api.fir.AbstractResolveCallTest +import org.jetbrains.kotlin.idea.frontend.api.scopes.AbstractFileScopeTest import org.jetbrains.kotlin.idea.frontend.api.scopes.AbstractMemberScopeByFqNameTest import org.jetbrains.kotlin.idea.frontend.api.symbols.* import org.jetbrains.kotlin.idea.hierarchy.AbstractHierarchyTest @@ -1013,6 +1014,10 @@ fun main(args: Array) { model("memberScopeByFqName", extension = "txt") } + testClass { + model("fileScopeTest", extension = "kt") + } + testClass { model("symbolPointer", extension = "kt") } diff --git a/idea/idea-frontend-fir/testData/fileScopeTest/simpleFileScope.kt b/idea/idea-frontend-fir/testData/fileScopeTest/simpleFileScope.kt new file mode 100644 index 00000000000..0a9c291a6a4 --- /dev/null +++ b/idea/idea-frontend-fir/testData/fileScopeTest/simpleFileScope.kt @@ -0,0 +1,11 @@ +fun test(): Int = 3 + +val testVal: Int = 2 + +class C { + fun r() { + + } +} + +interface I diff --git a/idea/idea-frontend-fir/testData/fileScopeTest/simpleFileScope.kt.result b/idea/idea-frontend-fir/testData/fileScopeTest/simpleFileScope.kt.result new file mode 100644 index 00000000000..02f237af8fd --- /dev/null +++ b/idea/idea-frontend-fir/testData/fileScopeTest/simpleFileScope.kt.result @@ -0,0 +1,83 @@ +FILE SYMBOL: +KtFirFileSymbol: + annotations: [] + origin: SOURCE + +CALLABLE NAMES: +[test, testVal] + +CALLABLE SYMBOLS: +KtFirFunctionSymbol: + annotations: [] + callableIdIfNonLocal: test + isExtension: false + isExternal: false + isInline: false + isOperator: false + isOverride: false + isSuspend: false + modality: FINAL + name: test + origin: SOURCE + receiverTypeAndAnnotations: null + symbolKind: TOP_LEVEL + type: kotlin/Int + typeParameters: [] + valueParameters: [] + visibility: PUBLIC + +KtFirKotlinPropertySymbol: + annotations: [] + callableIdIfNonLocal: testVal + getter: KtFirPropertyGetterSymbol() + hasBackingField: true + hasGetter: true + hasSetter: false + initializer: 2 + isConst: false + isExtension: false + isLateInit: false + isOverride: false + isVal: true + modality: FINAL + name: testVal + origin: SOURCE + receiverTypeAndAnnotations: null + setter: null + symbolKind: TOP_LEVEL + type: kotlin/Int + visibility: PUBLIC + +CLASSIFIER NAMES: +[C, I] + +CLASSIFIER SYMBOLS: +KtFirClassOrObjectSymbol: + annotations: [] + classIdIfNonLocal: C + classKind: CLASS + companionObject: null + isInner: false + modality: FINAL + name: C + origin: SOURCE + primaryConstructor: KtFirConstructorSymbol() + superTypes: [kotlin/Any] + symbolKind: TOP_LEVEL + typeParameters: [] + visibility: PUBLIC + +KtFirClassOrObjectSymbol: + annotations: [] + classIdIfNonLocal: I + classKind: INTERFACE + companionObject: null + isInner: false + modality: ABSTRACT + name: I + origin: SOURCE + primaryConstructor: null + superTypes: [kotlin/Any] + symbolKind: TOP_LEVEL + typeParameters: [] + visibility: PUBLIC diff --git a/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/scopes/AbstractFileScopeTest.kt b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/scopes/AbstractFileScopeTest.kt new file mode 100644 index 00000000000..43508cd439f --- /dev/null +++ b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/scopes/AbstractFileScopeTest.kt @@ -0,0 +1,43 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.idea.frontend.api.scopes + +import com.intellij.openapi.util.io.FileUtil +import org.jetbrains.kotlin.idea.executeOnPooledThreadInReadAction +import org.jetbrains.kotlin.idea.frontend.api.analyze +import org.jetbrains.kotlin.idea.frontend.api.symbols.DebugSymbolRenderer +import org.jetbrains.kotlin.idea.test.KotlinLightCodeInsightFixtureTestCase +import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.test.KotlinTestUtils +import java.io.File + +abstract class AbstractFileScopeTest : KotlinLightCodeInsightFixtureTestCase() { + + protected fun doTest(path: String) { + val ktFile = myFixture.configureByText("file.kt", FileUtil.loadFile(File(path))) as KtFile + + val actual = executeOnPooledThreadInReadAction { + analyze(ktFile) { + val symbol = ktFile.getFileSymbol() + val scope = symbol.getFileScope() + + val renderedSymbol = DebugSymbolRenderer.render(symbol) + val callableNames = scope.getCallableNames() + val renderedCallables = scope.getCallableSymbols().map { DebugSymbolRenderer.render(it) } + val classifierNames = scope.getClassifierNames() + val renderedClassifiers = scope.getClassifierSymbols().map { DebugSymbolRenderer.render(it) } + + "FILE SYMBOL:\n" + renderedSymbol + + "\nCALLABLE NAMES:\n" + callableNames.joinToString(prefix = "[", postfix = "]\n", separator = ", ") + + "\nCALLABLE SYMBOLS:\n" + renderedCallables.joinToString(separator = "\n") + + "\nCLASSIFIER NAMES:\n" + classifierNames.joinToString(prefix = "[", postfix = "]\n", separator = ", ") + + "\nCLASSIFIER SYMBOLS:\n" + renderedClassifiers.joinToString(separator = "\n") + } + } + + KotlinTestUtils.assertEqualsToFile(File("$path.result"), actual) + } +} \ No newline at end of file diff --git a/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/scopes/FileScopeTestGenerated.java b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/scopes/FileScopeTestGenerated.java new file mode 100644 index 00000000000..abd237e6f29 --- /dev/null +++ b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/scopes/FileScopeTestGenerated.java @@ -0,0 +1,35 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.idea.frontend.api.scopes; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; +import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.runner.RunWith; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("idea/idea-frontend-fir/testData/fileScopeTest") +@TestDataPath("$PROJECT_ROOT") +@RunWith(JUnit3RunnerWithInners.class) +public class FileScopeTestGenerated extends AbstractFileScopeTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); + } + + public void testAllFilesPresentInFileScopeTest() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-frontend-fir/testData/fileScopeTest"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @TestMetadata("simpleFileScope.kt") + public void testSimpleFileScope() throws Exception { + runTest("idea/idea-frontend-fir/testData/fileScopeTest/simpleFileScope.kt"); + } +} From 2b3fc330ad5a18a9cb2414d8aafba908b7605bd6 Mon Sep 17 00:00:00 2001 From: Andrei Klunnyi Date: Wed, 16 Dec 2020 11:33:41 +0100 Subject: [PATCH 060/196] KTIJ-664 [SealedClassInheritorsProvider]: test fixes --- idea/testData/checker/sealed/SealedDeclaration.kt | 2 +- idea/testData/checker/sealed/SealedInheritors.kt | 2 +- idea/testData/checker/sealed/SealedOutsidePackageInheritors.kt | 2 +- idea/testData/quickfix/when/addRemainingBranchesSealed.kt.after | 2 +- .../quickfix/when/addRemainingBranchesSealedBackTicks.kt.after | 2 +- .../quickfix/when/addRemainingBranchesSealedStatement.kt.after | 2 +- 6 files changed, 6 insertions(+), 6 deletions(-) diff --git a/idea/testData/checker/sealed/SealedDeclaration.kt b/idea/testData/checker/sealed/SealedDeclaration.kt index f56775bc907..24c6260ffa2 100644 --- a/idea/testData/checker/sealed/SealedDeclaration.kt +++ b/idea/testData/checker/sealed/SealedDeclaration.kt @@ -1,4 +1,4 @@ -// COMPILER_ARGUMENTS: -XXLanguage:+SealedInterfaces -XXLanguage:+FreedomForSealedClasses +// COMPILER_ARGUMENTS: -XXLanguage:+SealedInterfaces -XXLanguage:+AllowSealedInheritorsInDifferentFilesOfSamePackage package sealed diff --git a/idea/testData/checker/sealed/SealedInheritors.kt b/idea/testData/checker/sealed/SealedInheritors.kt index 3b399c28141..234612271ab 100644 --- a/idea/testData/checker/sealed/SealedInheritors.kt +++ b/idea/testData/checker/sealed/SealedInheritors.kt @@ -1,4 +1,4 @@ -// COMPILER_ARGUMENTS: -XXLanguage:+SealedInterfaces -XXLanguage:+FreedomForSealedClasses +// COMPILER_ARGUMENTS: -XXLanguage:+SealedInterfaces -XXLanguage:+AllowSealedInheritorsInDifferentFilesOfSamePackage package sealed class C: SealedDeclarationInterface {} diff --git a/idea/testData/checker/sealed/SealedOutsidePackageInheritors.kt b/idea/testData/checker/sealed/SealedOutsidePackageInheritors.kt index 8a8913fd11f..d41af6d0112 100644 --- a/idea/testData/checker/sealed/SealedOutsidePackageInheritors.kt +++ b/idea/testData/checker/sealed/SealedOutsidePackageInheritors.kt @@ -1,4 +1,4 @@ -// COMPILER_ARGUMENTS: -XXLanguage:+SealedInterfaces -XXLanguage:+FreedomForSealedClasses +// COMPILER_ARGUMENTS: -XXLanguage:+SealedInterfaces -XXLanguage:+AllowSealedInheritorsInDifferentFilesOfSamePackage package sealed.otherpackage import sealed.SealedDeclarationInterface import sealed.SealedDeclarationClass diff --git a/idea/testData/quickfix/when/addRemainingBranchesSealed.kt.after b/idea/testData/quickfix/when/addRemainingBranchesSealed.kt.after index a8c8961cbe3..ef3d03c8d8c 100644 --- a/idea/testData/quickfix/when/addRemainingBranchesSealed.kt.after +++ b/idea/testData/quickfix/when/addRemainingBranchesSealed.kt.after @@ -11,7 +11,7 @@ sealed class Variant { } fun test(v: Variant?) = when(v) { Variant.Singleton -> "s" - is Variant.Something -> TODO() Variant.Another -> TODO() + is Variant.Something -> TODO() null -> TODO() } diff --git a/idea/testData/quickfix/when/addRemainingBranchesSealedBackTicks.kt.after b/idea/testData/quickfix/when/addRemainingBranchesSealedBackTicks.kt.after index c26a61bb144..67407e074bd 100644 --- a/idea/testData/quickfix/when/addRemainingBranchesSealedBackTicks.kt.after +++ b/idea/testData/quickfix/when/addRemainingBranchesSealedBackTicks.kt.after @@ -15,8 +15,8 @@ fun test(foo: FooSealed?) = when (foo) { B -> TODO() C -> TODO() is D -> TODO() - is `true` -> TODO() is `false` -> TODO() `null` -> TODO() + is `true` -> TODO() null -> TODO() } \ No newline at end of file diff --git a/idea/testData/quickfix/when/addRemainingBranchesSealedStatement.kt.after b/idea/testData/quickfix/when/addRemainingBranchesSealedStatement.kt.after index 81475ff6a45..6456b3bf9e5 100644 --- a/idea/testData/quickfix/when/addRemainingBranchesSealedStatement.kt.after +++ b/idea/testData/quickfix/when/addRemainingBranchesSealedStatement.kt.after @@ -12,8 +12,8 @@ sealed class Variant { fun test(v: Variant?) { when(v) { Variant.Singleton -> "s" - is Variant.Something -> TODO() Variant.Another -> TODO() + is Variant.Something -> TODO() null -> TODO() } } From 7ed3860c7050d6e6d9bd4f7074e9d98bc9fc13e6 Mon Sep 17 00:00:00 2001 From: Dmitry Petrov Date: Wed, 16 Dec 2020 11:58:46 +0300 Subject: [PATCH 061/196] JVM_IR KT-43043 fix nullability annotations for inline class members --- .../backend/jvm/codegen/AnnotationCodegen.kt | 26 ++++----- .../jvmDefaultAll_ir.txt | 53 ------------------- .../jvmDefaultEnable_ir.txt | 53 ------------------- .../inlineClasses/inlineCharSequence_ir.txt | 6 +-- .../UIntArrayWithFullJdk_ir.txt | 10 ++-- ...labilityAnnotationsOnInlineClassMembers.kt | 19 +++++++ ...abilityAnnotationsOnInlineClassMembers.txt | 26 +++++++++ .../codegen/BytecodeListingTestGenerated.java | 5 ++ .../ir/IrBytecodeListingTestGenerated.java | 5 ++ 9 files changed, 77 insertions(+), 126 deletions(-) delete mode 100644 compiler/testData/codegen/bytecodeListing/inlineClasses/defaultInterfaceMembers/jvmDefaultAll_ir.txt delete mode 100644 compiler/testData/codegen/bytecodeListing/inlineClasses/defaultInterfaceMembers/jvmDefaultEnable_ir.txt create mode 100644 compiler/testData/codegen/bytecodeListing/inlineClasses/nullabilityAnnotationsOnInlineClassMembers.kt create mode 100644 compiler/testData/codegen/bytecodeListing/inlineClasses/nullabilityAnnotationsOnInlineClassMembers.txt diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/AnnotationCodegen.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/AnnotationCodegen.kt index 3767620c87e..a36bfd41d89 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/AnnotationCodegen.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/AnnotationCodegen.kt @@ -57,7 +57,11 @@ abstract class AnnotationCodegen( /** * @param returnType can be null if not applicable (e.g. [annotated] is a class) */ - fun genAnnotations(annotated: IrAnnotationContainer?, returnType: Type?, typeForTypeAnnotations: IrType?) { + fun genAnnotations( + annotated: IrAnnotationContainer?, + returnType: Type?, + typeForTypeAnnotations: IrType? + ) { if (annotated == null) return val annotationDescriptorsAlreadyPresent = mutableSetOf() @@ -94,7 +98,10 @@ abstract class AnnotationCodegen( } } - generateAdditionalAnnotations(annotated, returnType, annotationDescriptorsAlreadyPresent) + if (!skipNullabilityAnnotations && annotated is IrDeclaration && returnType != null && !AsmUtil.isPrimitive(returnType)) { + generateNullabilityAnnotationForCallable(annotated, annotationDescriptorsAlreadyPresent) + } + generateTypeAnnotations(annotated, typeForTypeAnnotations) } @@ -109,16 +116,6 @@ abstract class AnnotationCodegen( } - private fun generateAdditionalAnnotations( - annotated: IrAnnotationContainer, - returnType: Type?, - annotationDescriptorsAlreadyPresent: MutableSet - ) { - if (!skipNullabilityAnnotations && annotated is IrDeclaration && returnType != null && !AsmUtil.isPrimitive(returnType)) { - generateNullabilityAnnotationForCallable(annotated, annotationDescriptorsAlreadyPresent) - } - } - private fun generateNullabilityAnnotationForCallable( declaration: IrDeclaration, // There is no superclass that encompasses IrFunction, IrField and nothing else. annotationDescriptorsAlreadyPresent: MutableSet @@ -127,6 +124,7 @@ abstract class AnnotationCodegen( if (declaration is IrValueParameter) { val parent = declaration.parent as IrDeclaration if (isInvisibleForNullabilityAnalysis(parent)) return + if (isMovedReceiverParameterOfStaticInlineClassReplacement(declaration, parent)) return } // No need to annotate annotation methods since they're always non-null @@ -167,6 +165,10 @@ abstract class AnnotationCodegen( generateAnnotationIfNotPresent(annotationDescriptorsAlreadyPresent, annotationClass) } + private fun isMovedReceiverParameterOfStaticInlineClassReplacement(parameter: IrValueParameter, parent: IrDeclaration): Boolean = + parent.origin == JvmLoweredDeclarationOrigin.STATIC_INLINE_CLASS_REPLACEMENT && + parameter.origin == IrDeclarationOrigin.MOVED_DISPATCH_RECEIVER + private fun generateAnnotationIfNotPresent(annotationDescriptorsAlreadyPresent: MutableSet, annotationClass: Class<*>) { val descriptor = Type.getType(annotationClass).descriptor if (!annotationDescriptorsAlreadyPresent.contains(descriptor)) { diff --git a/compiler/testData/codegen/bytecodeListing/inlineClasses/defaultInterfaceMembers/jvmDefaultAll_ir.txt b/compiler/testData/codegen/bytecodeListing/inlineClasses/defaultInterfaceMembers/jvmDefaultAll_ir.txt deleted file mode 100644 index 0d942d45dc1..00000000000 --- a/compiler/testData/codegen/bytecodeListing/inlineClasses/defaultInterfaceMembers/jvmDefaultAll_ir.txt +++ /dev/null @@ -1,53 +0,0 @@ -@kotlin.Metadata -public interface IFooBar { - // source: 'jvmDefaultAll.kt' - public @org.jetbrains.annotations.NotNull method bar(): java.lang.String - public @org.jetbrains.annotations.NotNull method foo(): java.lang.String -} - -@kotlin.Metadata -public interface IFooBar2 { - // source: 'jvmDefaultAll.kt' -} - -@kotlin.jvm.JvmInline -@kotlin.Metadata -public final class Test1 { - // source: 'jvmDefaultAll.kt' - private final @org.jetbrains.annotations.NotNull field k: java.lang.String - private synthetic method (p0: java.lang.String): void - public @org.jetbrains.annotations.NotNull method bar(): java.lang.String - public static @org.jetbrains.annotations.NotNull method bar-impl(@org.jetbrains.annotations.NotNull p0: java.lang.String): java.lang.String - public synthetic final static method box-impl(p0: java.lang.String): Test1 - public static @org.jetbrains.annotations.NotNull method constructor-impl(@org.jetbrains.annotations.NotNull p0: java.lang.String): java.lang.String - public method equals(p0: java.lang.Object): boolean - public static method equals-impl(p0: java.lang.String, p1: java.lang.Object): boolean - public final static method equals-impl0(p0: java.lang.String, p1: java.lang.String): boolean - public final @org.jetbrains.annotations.NotNull method getK(): java.lang.String - public method hashCode(): int - public static method hashCode-impl(p0: java.lang.String): int - public method toString(): java.lang.String - public static method toString-impl(p0: java.lang.String): java.lang.String - public synthetic final method unbox-impl(): java.lang.String -} - -@kotlin.jvm.JvmInline -@kotlin.Metadata -public final class Test2 { - // source: 'jvmDefaultAll.kt' - private final @org.jetbrains.annotations.NotNull field k: java.lang.String - private synthetic method (p0: java.lang.String): void - public @org.jetbrains.annotations.NotNull method bar(): java.lang.String - public static @org.jetbrains.annotations.NotNull method bar-impl(@org.jetbrains.annotations.NotNull p0: java.lang.String): java.lang.String - public synthetic final static method box-impl(p0: java.lang.String): Test2 - public static @org.jetbrains.annotations.NotNull method constructor-impl(@org.jetbrains.annotations.NotNull p0: java.lang.String): java.lang.String - public method equals(p0: java.lang.Object): boolean - public static method equals-impl(p0: java.lang.String, p1: java.lang.Object): boolean - public final static method equals-impl0(p0: java.lang.String, p1: java.lang.String): boolean - public final @org.jetbrains.annotations.NotNull method getK(): java.lang.String - public method hashCode(): int - public static method hashCode-impl(p0: java.lang.String): int - public method toString(): java.lang.String - public static method toString-impl(p0: java.lang.String): java.lang.String - public synthetic final method unbox-impl(): java.lang.String -} diff --git a/compiler/testData/codegen/bytecodeListing/inlineClasses/defaultInterfaceMembers/jvmDefaultEnable_ir.txt b/compiler/testData/codegen/bytecodeListing/inlineClasses/defaultInterfaceMembers/jvmDefaultEnable_ir.txt deleted file mode 100644 index 20c34e9f340..00000000000 --- a/compiler/testData/codegen/bytecodeListing/inlineClasses/defaultInterfaceMembers/jvmDefaultEnable_ir.txt +++ /dev/null @@ -1,53 +0,0 @@ -@kotlin.Metadata -public interface IFooBar { - // source: 'jvmDefaultEnable.kt' - public @kotlin.jvm.JvmDefault @org.jetbrains.annotations.NotNull method bar(): java.lang.String - public @kotlin.jvm.JvmDefault @org.jetbrains.annotations.NotNull method foo(): java.lang.String -} - -@kotlin.Metadata -public interface IFooBar2 { - // source: 'jvmDefaultEnable.kt' -} - -@kotlin.jvm.JvmInline -@kotlin.Metadata -public final class Test1 { - // source: 'jvmDefaultEnable.kt' - private final @org.jetbrains.annotations.NotNull field k: java.lang.String - private synthetic method (p0: java.lang.String): void - public @org.jetbrains.annotations.NotNull method bar(): java.lang.String - public static @org.jetbrains.annotations.NotNull method bar-impl(@org.jetbrains.annotations.NotNull p0: java.lang.String): java.lang.String - public synthetic final static method box-impl(p0: java.lang.String): Test1 - public static @org.jetbrains.annotations.NotNull method constructor-impl(@org.jetbrains.annotations.NotNull p0: java.lang.String): java.lang.String - public method equals(p0: java.lang.Object): boolean - public static method equals-impl(p0: java.lang.String, p1: java.lang.Object): boolean - public final static method equals-impl0(p0: java.lang.String, p1: java.lang.String): boolean - public final @org.jetbrains.annotations.NotNull method getK(): java.lang.String - public method hashCode(): int - public static method hashCode-impl(p0: java.lang.String): int - public method toString(): java.lang.String - public static method toString-impl(p0: java.lang.String): java.lang.String - public synthetic final method unbox-impl(): java.lang.String -} - -@kotlin.jvm.JvmInline -@kotlin.Metadata -public final class Test2 { - // source: 'jvmDefaultEnable.kt' - private final @org.jetbrains.annotations.NotNull field k: java.lang.String - private synthetic method (p0: java.lang.String): void - public @org.jetbrains.annotations.NotNull method bar(): java.lang.String - public static @org.jetbrains.annotations.NotNull method bar-impl(@org.jetbrains.annotations.NotNull p0: java.lang.String): java.lang.String - public synthetic final static method box-impl(p0: java.lang.String): Test2 - public static @org.jetbrains.annotations.NotNull method constructor-impl(@org.jetbrains.annotations.NotNull p0: java.lang.String): java.lang.String - public method equals(p0: java.lang.Object): boolean - public static method equals-impl(p0: java.lang.String, p1: java.lang.Object): boolean - public final static method equals-impl0(p0: java.lang.String, p1: java.lang.String): boolean - public final @org.jetbrains.annotations.NotNull method getK(): java.lang.String - public method hashCode(): int - public static method hashCode-impl(p0: java.lang.String): int - public method toString(): java.lang.String - public static method toString-impl(p0: java.lang.String): java.lang.String - public synthetic final method unbox-impl(): java.lang.String -} diff --git a/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCharSequence_ir.txt b/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCharSequence_ir.txt index 1f3d6f5832a..4cf80234401 100644 --- a/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCharSequence_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCharSequence_ir.txt @@ -11,14 +11,14 @@ public final class InlineCharSequence { public static method equals-impl(p0: java.lang.CharSequence, p1: java.lang.Object): boolean public final static method equals-impl0(p0: java.lang.CharSequence, p1: java.lang.CharSequence): boolean public method get(p0: int): char - public static method get-impl(@org.jetbrains.annotations.NotNull p0: java.lang.CharSequence, p1: int): char + public static method get-impl(p0: java.lang.CharSequence, p1: int): char public method getLength(): int - public static method getLength-impl(@org.jetbrains.annotations.NotNull p0: java.lang.CharSequence): int + public static method getLength-impl(p0: java.lang.CharSequence): int public method hashCode(): int public static method hashCode-impl(p0: java.lang.CharSequence): int public synthetic bridge method length(): int public @org.jetbrains.annotations.NotNull method subSequence(p0: int, p1: int): java.lang.CharSequence - public static @org.jetbrains.annotations.NotNull method subSequence-impl(@org.jetbrains.annotations.NotNull p0: java.lang.CharSequence, p1: int, p2: int): java.lang.CharSequence + public static @org.jetbrains.annotations.NotNull method subSequence-impl(p0: java.lang.CharSequence, p1: int, p2: int): java.lang.CharSequence public method toString(): java.lang.String public static method toString-impl(p0: java.lang.CharSequence): java.lang.String public synthetic final method unbox-impl(): java.lang.CharSequence diff --git a/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollection/UIntArrayWithFullJdk_ir.txt b/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollection/UIntArrayWithFullJdk_ir.txt index 8f0a0a75320..44b3d3082ac 100644 --- a/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollection/UIntArrayWithFullJdk_ir.txt +++ b/compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollection/UIntArrayWithFullJdk_ir.txt @@ -30,22 +30,22 @@ public final class UIntArray { public method clear(): void public static @org.jetbrains.annotations.NotNull method constructor-impl(@org.jetbrains.annotations.NotNull p0: int[]): int[] public synthetic bridge method contains(p0: java.lang.Object): boolean - public static method contains-fLmw4x8(@org.jetbrains.annotations.NotNull p0: int[], p1: int): boolean public method contains-fLmw4x8(p0: int): boolean + public static method contains-fLmw4x8(p0: int[], p1: int): boolean public method containsAll(@org.jetbrains.annotations.NotNull p0: java.util.Collection): boolean - public static method containsAll-impl(@org.jetbrains.annotations.NotNull p0: int[], @org.jetbrains.annotations.NotNull p1: java.util.Collection): boolean + public static method containsAll-impl(p0: int[], @org.jetbrains.annotations.NotNull p1: java.util.Collection): boolean public method equals(p0: java.lang.Object): boolean public static method equals-impl(p0: int[], p1: java.lang.Object): boolean public final static method equals-impl0(p0: int[], p1: int[]): boolean public method getSize(): int - public static method getSize-impl(@org.jetbrains.annotations.NotNull p0: int[]): int + public static method getSize-impl(p0: int[]): int public method hashCode(): int public static method hashCode-impl(p0: int[]): int public method isEmpty(): boolean - public static method isEmpty-impl(@org.jetbrains.annotations.NotNull p0: int[]): boolean + public static method isEmpty-impl(p0: int[]): boolean public @org.jetbrains.annotations.NotNull method iterator(): java.lang.Void public synthetic bridge method iterator(): java.util.Iterator - public static @org.jetbrains.annotations.NotNull method iterator-impl(@org.jetbrains.annotations.NotNull p0: int[]): java.lang.Void + public static @org.jetbrains.annotations.NotNull method iterator-impl(p0: int[]): java.lang.Void public method remove(p0: java.lang.Object): boolean public method removeAll(p0: java.util.Collection): boolean public method removeIf(p0: java.util.function.Predicate): boolean diff --git a/compiler/testData/codegen/bytecodeListing/inlineClasses/nullabilityAnnotationsOnInlineClassMembers.kt b/compiler/testData/codegen/bytecodeListing/inlineClasses/nullabilityAnnotationsOnInlineClassMembers.kt new file mode 100644 index 00000000000..bfb5140ff61 --- /dev/null +++ b/compiler/testData/codegen/bytecodeListing/inlineClasses/nullabilityAnnotationsOnInlineClassMembers.kt @@ -0,0 +1,19 @@ +inline class Test(val s: String) { + fun memberFun(x: String) = s + + fun String.memberExtFun() = s + + val memberVal + get() = s + + val String.memberExtVal + get() = s + + var memberVar + get() = s + set(value) {} + + var String.memberExtVar + get() = s + set(value) {} +} \ No newline at end of file diff --git a/compiler/testData/codegen/bytecodeListing/inlineClasses/nullabilityAnnotationsOnInlineClassMembers.txt b/compiler/testData/codegen/bytecodeListing/inlineClasses/nullabilityAnnotationsOnInlineClassMembers.txt new file mode 100644 index 00000000000..e7824b55a7f --- /dev/null +++ b/compiler/testData/codegen/bytecodeListing/inlineClasses/nullabilityAnnotationsOnInlineClassMembers.txt @@ -0,0 +1,26 @@ +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class Test { + // source: 'nullabilityAnnotationsOnInlineClassMembers.kt' + private final @org.jetbrains.annotations.NotNull field s: java.lang.String + private synthetic method (p0: java.lang.String): void + public synthetic final static method box-impl(p0: java.lang.String): Test + public static @org.jetbrains.annotations.NotNull method constructor-impl(@org.jetbrains.annotations.NotNull p0: java.lang.String): java.lang.String + public method equals(p0: java.lang.Object): boolean + public static method equals-impl(p0: java.lang.String, p1: java.lang.Object): boolean + public final static method equals-impl0(p0: java.lang.String, p1: java.lang.String): boolean + public final static @org.jetbrains.annotations.NotNull method getMemberExtVal-impl(p0: java.lang.String, @org.jetbrains.annotations.NotNull p1: java.lang.String): java.lang.String + public final static @org.jetbrains.annotations.NotNull method getMemberExtVar-impl(p0: java.lang.String, @org.jetbrains.annotations.NotNull p1: java.lang.String): java.lang.String + public final static @org.jetbrains.annotations.NotNull method getMemberVal-impl(p0: java.lang.String): java.lang.String + public final static @org.jetbrains.annotations.NotNull method getMemberVar-impl(p0: java.lang.String): java.lang.String + public final @org.jetbrains.annotations.NotNull method getS(): java.lang.String + public method hashCode(): int + public static method hashCode-impl(p0: java.lang.String): int + public final static @org.jetbrains.annotations.NotNull method memberExtFun-impl(p0: java.lang.String, @org.jetbrains.annotations.NotNull p1: java.lang.String): java.lang.String + public final static @org.jetbrains.annotations.NotNull method memberFun-impl(p0: java.lang.String, @org.jetbrains.annotations.NotNull p1: java.lang.String): java.lang.String + public final static method setMemberExtVar-impl(p0: java.lang.String, @org.jetbrains.annotations.NotNull p1: java.lang.String, @org.jetbrains.annotations.NotNull p2: java.lang.String): void + public final static method setMemberVar-impl(p0: java.lang.String, @org.jetbrains.annotations.NotNull p1: java.lang.String): void + public method toString(): java.lang.String + public static method toString-impl(p0: java.lang.String): java.lang.String + public synthetic final method unbox-impl(): java.lang.String +} diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/BytecodeListingTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/BytecodeListingTestGenerated.java index a0df878ef93..4a6242c1ee5 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/BytecodeListingTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/BytecodeListingTestGenerated.java @@ -1046,6 +1046,11 @@ public class BytecodeListingTestGenerated extends AbstractBytecodeListingTest { runTest("compiler/testData/codegen/bytecodeListing/inlineClasses/noBridgesForErasedInlineClass.kt"); } + @TestMetadata("nullabilityAnnotationsOnInlineClassMembers.kt") + public void testNullabilityAnnotationsOnInlineClassMembers() throws Exception { + runTest("compiler/testData/codegen/bytecodeListing/inlineClasses/nullabilityAnnotationsOnInlineClassMembers.kt"); + } + @TestMetadata("nullabilityInExpansion.kt") public void testNullabilityInExpansion() throws Exception { runTest("compiler/testData/codegen/bytecodeListing/inlineClasses/nullabilityInExpansion.kt"); diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrBytecodeListingTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrBytecodeListingTestGenerated.java index ee3806fb430..62eeda4bd02 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrBytecodeListingTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrBytecodeListingTestGenerated.java @@ -1046,6 +1046,11 @@ public class IrBytecodeListingTestGenerated extends AbstractIrBytecodeListingTes runTest("compiler/testData/codegen/bytecodeListing/inlineClasses/noBridgesForErasedInlineClass.kt"); } + @TestMetadata("nullabilityAnnotationsOnInlineClassMembers.kt") + public void testNullabilityAnnotationsOnInlineClassMembers() throws Exception { + runTest("compiler/testData/codegen/bytecodeListing/inlineClasses/nullabilityAnnotationsOnInlineClassMembers.kt"); + } + @TestMetadata("nullabilityInExpansion.kt") public void testNullabilityInExpansion() throws Exception { runTest("compiler/testData/codegen/bytecodeListing/inlineClasses/nullabilityInExpansion.kt"); From 8999fd88b1ad6b2424a36c002365e90110c564ff Mon Sep 17 00:00:00 2001 From: Dmitry Petrov Date: Wed, 16 Dec 2020 14:10:36 +0300 Subject: [PATCH 062/196] JVM_IR KT-43401 KT-43518 fix ACC_STRICT and ACC_SYNCHRONIZED flags --- .../backend/jvm/codegen/FunctionCodegen.kt | 4 +- .../codegen/bytecodeListing/strictfpFlag.kt | 23 +++++++ .../codegen/bytecodeListing/strictfpFlag.txt | 61 +++++++++++++++++++ .../bytecodeListing/synchronizedFlag.kt | 23 +++++++ .../bytecodeListing/synchronizedFlag.txt | 61 +++++++++++++++++++ .../codegen/BytecodeListingTestGenerated.java | 10 +++ .../ir/IrBytecodeListingTestGenerated.java | 10 +++ 7 files changed, 190 insertions(+), 2 deletions(-) create mode 100644 compiler/testData/codegen/bytecodeListing/strictfpFlag.kt create mode 100644 compiler/testData/codegen/bytecodeListing/strictfpFlag.txt create mode 100644 compiler/testData/codegen/bytecodeListing/synchronizedFlag.kt create mode 100644 compiler/testData/codegen/bytecodeListing/synchronizedFlag.txt diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/FunctionCodegen.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/FunctionCodegen.kt index 24bfaf5740c..44e2ff2661c 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/FunctionCodegen.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/FunctionCodegen.kt @@ -169,8 +169,8 @@ class FunctionCodegen( isReifiable() || isDeprecatedHidden() - val isStrict = hasAnnotation(STRICTFP_ANNOTATION_FQ_NAME) - val isSynchronized = hasAnnotation(SYNCHRONIZED_ANNOTATION_FQ_NAME) + val isStrict = hasAnnotation(STRICTFP_ANNOTATION_FQ_NAME) && origin != JvmLoweredDeclarationOrigin.JVM_OVERLOADS_WRAPPER + val isSynchronized = hasAnnotation(SYNCHRONIZED_ANNOTATION_FQ_NAME) && origin != JvmLoweredDeclarationOrigin.JVM_OVERLOADS_WRAPPER return getVisibilityAccessFlag() or modalityFlag or (if (isDeprecatedFunction(context)) Opcodes.ACC_DEPRECATED else 0) or diff --git a/compiler/testData/codegen/bytecodeListing/strictfpFlag.kt b/compiler/testData/codegen/bytecodeListing/strictfpFlag.kt new file mode 100644 index 00000000000..bba32a3de7c --- /dev/null +++ b/compiler/testData/codegen/bytecodeListing/strictfpFlag.kt @@ -0,0 +1,23 @@ +// WITH_RUNTIME + +@Strictfp +@JvmOverloads +fun testJvmOverloads(a: Int = 0) {} + +class C { + @Strictfp + private fun testAccessor() {} + + fun lambda() = { -> testAccessor() } + + companion object { + @Strictfp + @JvmStatic + fun testJvmStatic() {} + } +} + +inline class IC(val x: Int) { + @Strictfp + fun testInlineClassFun() {} +} \ No newline at end of file diff --git a/compiler/testData/codegen/bytecodeListing/strictfpFlag.txt b/compiler/testData/codegen/bytecodeListing/strictfpFlag.txt new file mode 100644 index 00000000000..d5df5cb8688 --- /dev/null +++ b/compiler/testData/codegen/bytecodeListing/strictfpFlag.txt @@ -0,0 +1,61 @@ +@kotlin.Metadata +public final class C$Companion { + // source: 'strictfpFlag.kt' + private method (): void + public synthetic method (p0: kotlin.jvm.internal.DefaultConstructorMarker): void + public final strict @kotlin.jvm.JvmStatic method testJvmStatic(): void + public final inner class C$Companion +} + +@kotlin.Metadata +final class C$lambda$1 { + // source: 'strictfpFlag.kt' + enclosing method C.lambda()Lkotlin/jvm/functions/Function0; + synthetic final field this$0: C + inner (anonymous) class C$lambda$1 + method (p0: C): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +public final class C { + // source: 'strictfpFlag.kt' + public final static @org.jetbrains.annotations.NotNull field Companion: C$Companion + inner (anonymous) class C$lambda$1 + static method (): void + public method (): void + public synthetic final static method access$testAccessor(p0: C): void + public final @org.jetbrains.annotations.NotNull method lambda(): kotlin.jvm.functions.Function0 + private final strict method testAccessor(): void + public final strict static @kotlin.jvm.JvmStatic method testJvmStatic(): void + public final inner class C$Companion +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class IC { + // source: 'strictfpFlag.kt' + private final field x: int + private synthetic method (p0: int): void + public synthetic final static method box-impl(p0: int): IC + public static method constructor-impl(p0: int): int + public method equals(p0: java.lang.Object): boolean + public static method equals-impl(p0: int, p1: java.lang.Object): boolean + public final static method equals-impl0(p0: int, p1: int): boolean + public final method getX(): int + public method hashCode(): int + public static method hashCode-impl(p0: int): int + public final strict static method testInlineClassFun-impl(p0: int): void + public method toString(): java.lang.String + public static method toString-impl(p0: int): java.lang.String + public synthetic final method unbox-impl(): int +} + +@kotlin.Metadata +public final class StrictfpFlagKt { + // source: 'strictfpFlag.kt' + public synthetic static method testJvmOverloads$default(p0: int, p1: int, p2: java.lang.Object): void + public final static @kotlin.jvm.JvmOverloads method testJvmOverloads(): void + public final strict static @kotlin.jvm.JvmOverloads method testJvmOverloads(p0: int): void +} diff --git a/compiler/testData/codegen/bytecodeListing/synchronizedFlag.kt b/compiler/testData/codegen/bytecodeListing/synchronizedFlag.kt new file mode 100644 index 00000000000..744e27b6fde --- /dev/null +++ b/compiler/testData/codegen/bytecodeListing/synchronizedFlag.kt @@ -0,0 +1,23 @@ +// WITH_RUNTIME + +@Synchronized +@JvmOverloads +fun testJvmOverloads(a: Int = 0) {} + +class C { + @Synchronized + private fun testAccessor() {} + + fun lambda() = { -> testAccessor() } + + companion object { + @Synchronized + @JvmStatic + fun testJvmStatic() {} + } +} + +inline class IC(val x: Int) { + @Synchronized + fun testInlineClassFun() {} +} \ No newline at end of file diff --git a/compiler/testData/codegen/bytecodeListing/synchronizedFlag.txt b/compiler/testData/codegen/bytecodeListing/synchronizedFlag.txt new file mode 100644 index 00000000000..21c217080e1 --- /dev/null +++ b/compiler/testData/codegen/bytecodeListing/synchronizedFlag.txt @@ -0,0 +1,61 @@ +@kotlin.Metadata +public final class C$Companion { + // source: 'synchronizedFlag.kt' + private method (): void + public synthetic method (p0: kotlin.jvm.internal.DefaultConstructorMarker): void + public synchronized final @kotlin.jvm.JvmStatic method testJvmStatic(): void + public final inner class C$Companion +} + +@kotlin.Metadata +final class C$lambda$1 { + // source: 'synchronizedFlag.kt' + enclosing method C.lambda()Lkotlin/jvm/functions/Function0; + synthetic final field this$0: C + inner (anonymous) class C$lambda$1 + method (p0: C): void + public synthetic bridge method invoke(): java.lang.Object + public final method invoke(): void +} + +@kotlin.Metadata +public final class C { + // source: 'synchronizedFlag.kt' + public final static @org.jetbrains.annotations.NotNull field Companion: C$Companion + inner (anonymous) class C$lambda$1 + static method (): void + public method (): void + public synthetic final static method access$testAccessor(p0: C): void + public final @org.jetbrains.annotations.NotNull method lambda(): kotlin.jvm.functions.Function0 + private synchronized final method testAccessor(): void + public synchronized final static @kotlin.jvm.JvmStatic method testJvmStatic(): void + public final inner class C$Companion +} + +@kotlin.jvm.JvmInline +@kotlin.Metadata +public final class IC { + // source: 'synchronizedFlag.kt' + private final field x: int + private synthetic method (p0: int): void + public synthetic final static method box-impl(p0: int): IC + public static method constructor-impl(p0: int): int + public method equals(p0: java.lang.Object): boolean + public static method equals-impl(p0: int, p1: java.lang.Object): boolean + public final static method equals-impl0(p0: int, p1: int): boolean + public final method getX(): int + public method hashCode(): int + public static method hashCode-impl(p0: int): int + public synchronized final static method testInlineClassFun-impl(p0: int): void + public method toString(): java.lang.String + public static method toString-impl(p0: int): java.lang.String + public synthetic final method unbox-impl(): int +} + +@kotlin.Metadata +public final class SynchronizedFlagKt { + // source: 'synchronizedFlag.kt' + public synthetic static method testJvmOverloads$default(p0: int, p1: int, p2: java.lang.Object): void + public final static @kotlin.jvm.JvmOverloads method testJvmOverloads(): void + public synchronized final static @kotlin.jvm.JvmOverloads method testJvmOverloads(p0: int): void +} diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/BytecodeListingTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/BytecodeListingTestGenerated.java index 4a6242c1ee5..ac103ade528 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/BytecodeListingTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/BytecodeListingTestGenerated.java @@ -214,6 +214,16 @@ public class BytecodeListingTestGenerated extends AbstractBytecodeListingTest { runTest("compiler/testData/codegen/bytecodeListing/rawTypeInSignature.kt"); } + @TestMetadata("strictfpFlag.kt") + public void testStrictfpFlag() throws Exception { + runTest("compiler/testData/codegen/bytecodeListing/strictfpFlag.kt"); + } + + @TestMetadata("synchronizedFlag.kt") + public void testSynchronizedFlag() throws Exception { + runTest("compiler/testData/codegen/bytecodeListing/synchronizedFlag.kt"); + } + @TestMetadata("varargsBridge.kt") public void testVarargsBridge() throws Exception { runTest("compiler/testData/codegen/bytecodeListing/varargsBridge.kt"); diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrBytecodeListingTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrBytecodeListingTestGenerated.java index 62eeda4bd02..63f4250d5ac 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrBytecodeListingTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrBytecodeListingTestGenerated.java @@ -214,6 +214,16 @@ public class IrBytecodeListingTestGenerated extends AbstractIrBytecodeListingTes runTest("compiler/testData/codegen/bytecodeListing/rawTypeInSignature.kt"); } + @TestMetadata("strictfpFlag.kt") + public void testStrictfpFlag() throws Exception { + runTest("compiler/testData/codegen/bytecodeListing/strictfpFlag.kt"); + } + + @TestMetadata("synchronizedFlag.kt") + public void testSynchronizedFlag() throws Exception { + runTest("compiler/testData/codegen/bytecodeListing/synchronizedFlag.kt"); + } + @TestMetadata("varargsBridge.kt") public void testVarargsBridge() throws Exception { runTest("compiler/testData/codegen/bytecodeListing/varargsBridge.kt"); From 329066a4f383a51eeca44e669f606a8ab56d3497 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Wed, 16 Dec 2020 14:47:54 +0300 Subject: [PATCH 063/196] [Parser] Fix parsing of unfinished dot access in string template Problem appeared in cases like this: "{someVar.}" #KT-34440 Fixed --- .../FirOldFrontendDiagnosticsTestGenerated.java | 5 +++++ .../kotlin/parsing/AbstractKotlinParsing.java | 2 +- .../testData/diagnostics/tests/kt34440.fir.kt | 9 +++++++++ compiler/testData/diagnostics/tests/kt34440.kt | 9 +++++++++ compiler/testData/diagnostics/tests/kt34440.txt | 17 +++++++++++++++++ .../checkers/DiagnosticsTestGenerated.java | 5 +++++ .../DiagnosticsUsingJavacTestGenerated.java | 5 +++++ 7 files changed, 51 insertions(+), 1 deletion(-) create mode 100644 compiler/testData/diagnostics/tests/kt34440.fir.kt create mode 100644 compiler/testData/diagnostics/tests/kt34440.kt create mode 100644 compiler/testData/diagnostics/tests/kt34440.txt diff --git a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/FirOldFrontendDiagnosticsTestGenerated.java b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/FirOldFrontendDiagnosticsTestGenerated.java index 5eadec45ee5..c7d398a3239 100644 --- a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/FirOldFrontendDiagnosticsTestGenerated.java +++ b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/FirOldFrontendDiagnosticsTestGenerated.java @@ -328,6 +328,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte runTest("compiler/testData/diagnostics/tests/kt310.kt"); } + @TestMetadata("kt34440.kt") + public void testKt34440() throws Exception { + runTest("compiler/testData/diagnostics/tests/kt34440.kt"); + } + @TestMetadata("kt34857.kt") public void testKt34857() throws Exception { runTest("compiler/testData/diagnostics/tests/kt34857.kt"); diff --git a/compiler/psi/src/org/jetbrains/kotlin/parsing/AbstractKotlinParsing.java b/compiler/psi/src/org/jetbrains/kotlin/parsing/AbstractKotlinParsing.java index 0af6879e70c..b262daab95c 100644 --- a/compiler/psi/src/org/jetbrains/kotlin/parsing/AbstractKotlinParsing.java +++ b/compiler/psi/src/org/jetbrains/kotlin/parsing/AbstractKotlinParsing.java @@ -105,7 +105,7 @@ import static org.jetbrains.kotlin.lexer.KtTokens.*; IElementType tt = tt(); if (recoverySet == null || recoverySet.contains(tt) || - tt == LBRACE || tt == RBRACE || + tt == LBRACE || tt == RBRACE || tt == LONG_TEMPLATE_ENTRY_END || (recoverySet.contains(EOL_OR_SEMICOLON) && (eof() || tt == SEMICOLON || myBuilder.newlineBeforeCurrentToken()))) { error(message); } diff --git a/compiler/testData/diagnostics/tests/kt34440.fir.kt b/compiler/testData/diagnostics/tests/kt34440.fir.kt new file mode 100644 index 00000000000..0d2e2a2c894 --- /dev/null +++ b/compiler/testData/diagnostics/tests/kt34440.fir.kt @@ -0,0 +1,9 @@ +// ISSUE: KT-34440 + +class BufferUtil { + fun isDirect(cond: Boolean): Boolean = + when (cond) { + else -> throw Exception("${buf.}") + } + private class BufferInfo(private val type: Class<*>) +} diff --git a/compiler/testData/diagnostics/tests/kt34440.kt b/compiler/testData/diagnostics/tests/kt34440.kt new file mode 100644 index 00000000000..bc4e307b475 --- /dev/null +++ b/compiler/testData/diagnostics/tests/kt34440.kt @@ -0,0 +1,9 @@ +// ISSUE: KT-34440 + +class BufferUtil { + fun isDirect(cond: Boolean): Boolean = + when (cond) { + else -> throw Exception("${buf.}") + } + private class BufferInfo(private val type: Class<*>) +} diff --git a/compiler/testData/diagnostics/tests/kt34440.txt b/compiler/testData/diagnostics/tests/kt34440.txt new file mode 100644 index 00000000000..ae461cc5456 --- /dev/null +++ b/compiler/testData/diagnostics/tests/kt34440.txt @@ -0,0 +1,17 @@ +package + +public final class BufferUtil { + public constructor BufferUtil() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public final fun isDirect(/*0*/ cond: kotlin.Boolean): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + private final class BufferInfo { + public constructor BufferInfo(/*0*/ type: java.lang.Class<*>) + private final val type: java.lang.Class<*> + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} diff --git a/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java index c2d9b7057ba..cb8ec64cf4f 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java @@ -330,6 +330,11 @@ public class DiagnosticsTestGenerated extends AbstractDiagnosticsTestWithFirVali runTest("compiler/testData/diagnostics/tests/kt310.kt"); } + @TestMetadata("kt34440.kt") + public void testKt34440() throws Exception { + runTest("compiler/testData/diagnostics/tests/kt34440.kt"); + } + @TestMetadata("kt34857.kt") public void testKt34857() throws Exception { runTest("compiler/testData/diagnostics/tests/kt34857.kt"); diff --git a/compiler/tests-gen/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java index c48401eb6d1..6c5f6fceffd 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java @@ -330,6 +330,11 @@ public class DiagnosticsUsingJavacTestGenerated extends AbstractDiagnosticsUsing runTest("compiler/testData/diagnostics/tests/kt310.kt"); } + @TestMetadata("kt34440.kt") + public void testKt34440() throws Exception { + runTest("compiler/testData/diagnostics/tests/kt34440.kt"); + } + @TestMetadata("kt34857.kt") public void testKt34857() throws Exception { runTest("compiler/testData/diagnostics/tests/kt34857.kt"); From 44948aa9a2b90ad8aaf6ef2d326a1c79c55fd87b Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Wed, 16 Dec 2020 16:10:40 +0300 Subject: [PATCH 064/196] [FE] Properly report diagnostics about type arguments of implicit invoke #KT-40396 Fixed --- ...irOldFrontendDiagnosticsTestGenerated.java | 5 +++++ .../DiagnosticReporterByTrackingStrategy.kt | 2 +- .../calls/checkers/OperatorCallChecker.kt | 11 ++-------- .../tests/inference/kt40396.fir.kt | 13 ++++++++++++ .../diagnostics/tests/inference/kt40396.kt | 13 ++++++++++++ .../diagnostics/tests/inference/kt40396.txt | 20 +++++++++++++++++++ .../checkers/DiagnosticsTestGenerated.java | 5 +++++ .../DiagnosticsUsingJavacTestGenerated.java | 5 +++++ 8 files changed, 64 insertions(+), 10 deletions(-) create mode 100644 compiler/testData/diagnostics/tests/inference/kt40396.fir.kt create mode 100644 compiler/testData/diagnostics/tests/inference/kt40396.kt create mode 100644 compiler/testData/diagnostics/tests/inference/kt40396.txt diff --git a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/FirOldFrontendDiagnosticsTestGenerated.java b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/FirOldFrontendDiagnosticsTestGenerated.java index c7d398a3239..06163a0605c 100644 --- a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/FirOldFrontendDiagnosticsTestGenerated.java +++ b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/FirOldFrontendDiagnosticsTestGenerated.java @@ -10447,6 +10447,11 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte runTest("compiler/testData/diagnostics/tests/inference/kt39220.kt"); } + @TestMetadata("kt40396.kt") + public void testKt40396() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/kt40396.kt"); + } + @TestMetadata("kt6175.kt") public void testKt6175() throws Exception { runTest("compiler/testData/diagnostics/tests/inference/kt6175.kt"); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/DiagnosticReporterByTrackingStrategy.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/DiagnosticReporterByTrackingStrategy.kt index 4069520529c..3ff54236166 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/DiagnosticReporterByTrackingStrategy.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/DiagnosticReporterByTrackingStrategy.kt @@ -436,8 +436,8 @@ class DiagnosticReporterByTrackingStrategy( if (isSpecialFunction(error.resolvedAtom)) return - val expression = when (val atom = error.resolvedAtom.atom) { + is PSIKotlinCallForInvoke -> (atom.psiCall as? CallTransformer.CallForImplicitInvoke)?.outerCall?.calleeExpression is PSIKotlinCall -> atom.psiCall.calleeExpression is PSIKotlinCallArgument -> atom.valueArgument.getArgumentExpression() else -> call.calleeExpression diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/OperatorCallChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/OperatorCallChecker.kt index beb528f59ae..a7eef6f2422 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/OperatorCallChecker.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/OperatorCallChecker.kt @@ -24,10 +24,7 @@ import org.jetbrains.kotlin.config.LanguageVersionSettings import org.jetbrains.kotlin.descriptors.FunctionDescriptor import org.jetbrains.kotlin.diagnostics.DiagnosticSink import org.jetbrains.kotlin.diagnostics.Errors -import org.jetbrains.kotlin.psi.Call -import org.jetbrains.kotlin.psi.KtArrayAccessExpression -import org.jetbrains.kotlin.psi.KtDestructuringDeclarationEntry -import org.jetbrains.kotlin.psi.KtOperationReferenceExpression +import org.jetbrains.kotlin.psi.* import org.jetbrains.kotlin.resolve.calls.CallTransformer import org.jetbrains.kotlin.resolve.calls.callResolverUtil.isConventionCall import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall @@ -52,11 +49,7 @@ class OperatorCallChecker : CallChecker { val containingDeclarationName = functionDescriptor.containingDeclaration.fqNameUnsafe.asString() context.trace.report(Errors.PROPERTY_AS_OPERATOR.on(reportOn, functionDescriptor, containingDeclarationName)) } else if (isWrongCallWithExplicitTypeArguments(resolvedCall, outerCall)) { - throw AssertionError( - "Illegal resolved call to variable with invoke for $outerCall. " + - "Variable: ${resolvedCall.variableCall.resultingDescriptor}" + - "Invoke: ${resolvedCall.functionCall.resultingDescriptor}" - ) + context.trace.report(Errors.TYPE_ARGUMENTS_NOT_ALLOWED.on(reportOn as KtElement, "on implicit invoke call")) } } diff --git a/compiler/testData/diagnostics/tests/inference/kt40396.fir.kt b/compiler/testData/diagnostics/tests/inference/kt40396.fir.kt new file mode 100644 index 00000000000..c5f56f12b7c --- /dev/null +++ b/compiler/testData/diagnostics/tests/inference/kt40396.fir.kt @@ -0,0 +1,13 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER +// ISSUE: KT-40396 + +val C.foo get() = Foo() + +class Foo { + operator fun invoke(body: () -> Unit) {} +} + +class Bar { + val bar = foo {} + val baz = foo {} +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/inference/kt40396.kt b/compiler/testData/diagnostics/tests/inference/kt40396.kt new file mode 100644 index 00000000000..5b9fe4df45a --- /dev/null +++ b/compiler/testData/diagnostics/tests/inference/kt40396.kt @@ -0,0 +1,13 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER +// ISSUE: KT-40396 + +val C.foo get() = Foo() + +class Foo { + operator fun invoke(body: () -> Unit) {} +} + +class Bar { + val bar = foo {} + val baz = foo {} +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/inference/kt40396.txt b/compiler/testData/diagnostics/tests/inference/kt40396.txt new file mode 100644 index 00000000000..d9ba8fcae8b --- /dev/null +++ b/compiler/testData/diagnostics/tests/inference/kt40396.txt @@ -0,0 +1,20 @@ +package + +public val C.foo: Foo + +public final class Bar { + public constructor Bar() + public final val bar: kotlin.Unit + public final val baz: kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public final class Foo { + public constructor Foo() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public final operator fun invoke(/*0*/ body: () -> kotlin.Unit): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} diff --git a/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java index cb8ec64cf4f..9b634e16da3 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java @@ -10454,6 +10454,11 @@ public class DiagnosticsTestGenerated extends AbstractDiagnosticsTestWithFirVali runTest("compiler/testData/diagnostics/tests/inference/kt39220.kt"); } + @TestMetadata("kt40396.kt") + public void testKt40396() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/kt40396.kt"); + } + @TestMetadata("kt6175.kt") public void testKt6175() throws Exception { runTest("compiler/testData/diagnostics/tests/inference/kt6175.kt"); diff --git a/compiler/tests-gen/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java index 6c5f6fceffd..52520f545d7 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java @@ -10449,6 +10449,11 @@ public class DiagnosticsUsingJavacTestGenerated extends AbstractDiagnosticsUsing runTest("compiler/testData/diagnostics/tests/inference/kt39220.kt"); } + @TestMetadata("kt40396.kt") + public void testKt40396() throws Exception { + runTest("compiler/testData/diagnostics/tests/inference/kt40396.kt"); + } + @TestMetadata("kt6175.kt") public void testKt6175() throws Exception { runTest("compiler/testData/diagnostics/tests/inference/kt6175.kt"); From 0e43eaa6629204e06e50739f4f15f297ef6ebe4a Mon Sep 17 00:00:00 2001 From: Mikhail Glukhikh Date: Thu, 10 Dec 2020 12:24:41 +0300 Subject: [PATCH 065/196] Don't call possibleGetterNamesByPropertyName without a reason --- .../scopes/JavaClassUseSiteMemberScope.kt | 75 +++++++++---------- 1 file changed, 36 insertions(+), 39 deletions(-) diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassUseSiteMemberScope.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassUseSiteMemberScope.kt index 1a442177c27..545ccce2980 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassUseSiteMemberScope.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/scopes/JavaClassUseSiteMemberScope.kt @@ -81,54 +81,51 @@ class JavaClassUseSiteMemberScope( processor: (FirVariableSymbol<*>) -> Unit ) { val overrideCandidates = mutableSetOf>() - val klass = symbol.fir declaredMemberScope.processPropertiesByName(propertyName) { variableSymbol -> if (variableSymbol.isStatic) return@processPropertiesByName overrideCandidates += variableSymbol processor(variableSymbol) } - if (klass is FirJavaClass) { - for (getterName in getterNames) { - var getterSymbol: FirNamedFunctionSymbol? = null - var setterSymbol: FirNamedFunctionSymbol? = null - declaredMemberScope.processFunctionsByName(getterName) { functionSymbol -> - if (getterSymbol == null) { - val function = functionSymbol.fir - if (!function.isStatic && function.valueParameters.isEmpty()) { - getterSymbol = functionSymbol - } + for (getterName in getterNames) { + var getterSymbol: FirNamedFunctionSymbol? = null + var setterSymbol: FirNamedFunctionSymbol? = null + declaredMemberScope.processFunctionsByName(getterName) { functionSymbol -> + if (getterSymbol == null) { + val function = functionSymbol.fir + if (!function.isStatic && function.valueParameters.isEmpty()) { + getterSymbol = functionSymbol } } - val setterName = session.syntheticNamesProvider.setterNameByGetterName(getterName) - if (getterSymbol != null && setterName != null) { - declaredMemberScope.processFunctionsByName(setterName) { functionSymbol -> - if (setterSymbol == null) { - val function = functionSymbol.fir - if (!function.isStatic && function.valueParameters.size == 1) { - val returnTypeRef = function.returnTypeRef - if (returnTypeRef.isUnit) { - // Unit return type - setterSymbol = functionSymbol - } else if (returnTypeRef is FirJavaTypeRef) { - // Void/void return type - when (val returnType = returnTypeRef.type) { - is JavaPrimitiveTypeImpl -> - if (returnType.psi.kind == JvmPrimitiveTypeKind.VOID) { - setterSymbol = functionSymbol - } - is JavaPrimitiveType -> - if (returnType.type == null) { - setterSymbol = functionSymbol - } - } + } + val setterName = session.syntheticNamesProvider.setterNameByGetterName(getterName) + if (getterSymbol != null && setterName != null) { + declaredMemberScope.processFunctionsByName(setterName) { functionSymbol -> + if (setterSymbol == null) { + val function = functionSymbol.fir + if (!function.isStatic && function.valueParameters.size == 1) { + val returnTypeRef = function.returnTypeRef + if (returnTypeRef.isUnit) { + // Unit return type + setterSymbol = functionSymbol + } else if (returnTypeRef is FirJavaTypeRef) { + // Void/void return type + when (val returnType = returnTypeRef.type) { + is JavaPrimitiveTypeImpl -> + if (returnType.psi.kind == JvmPrimitiveTypeKind.VOID) { + setterSymbol = functionSymbol + } + is JavaPrimitiveType -> + if (returnType.type == null) { + setterSymbol = functionSymbol + } } } } } - val accessorSymbol = generateAccessorSymbol(getterSymbol!!, setterSymbol, propertyName) - overrideCandidates += accessorSymbol } + val accessorSymbol = generateAccessorSymbol(getterSymbol!!, setterSymbol, propertyName) + overrideCandidates += accessorSymbol } } @@ -144,11 +141,11 @@ class JavaClassUseSiteMemberScope( } override fun processPropertiesByName(name: Name, processor: (FirVariableSymbol<*>) -> Unit) { - // Do not generate accessors at all? - if (name.isSpecial) { - return processAccessorFunctionsAndPropertiesByName(name, emptyList(), processor) + val getterNames = if (symbol.fir is FirJavaClass) { + FirJavaSyntheticNamesProvider.possibleGetterNamesByPropertyName(name) + } else { + emptyList() } - val getterNames = FirJavaSyntheticNamesProvider.possibleGetterNamesByPropertyName(name) return processAccessorFunctionsAndPropertiesByName(name, getterNames, processor) } From 580d2ed693d5c728b15c6eff761516633a6cef30 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Fri, 6 Nov 2020 17:30:29 +0300 Subject: [PATCH 066/196] [TEST-GEN] Add some comments to TestGenerationDSL --- .../generators/tests/generator/TestGenerationDSL.kt | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/TestGenerationDSL.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/TestGenerationDSL.kt index e0d31bd80a6..3437fa9e181 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/TestGenerationDSL.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/TestGenerationDSL.kt @@ -60,13 +60,15 @@ class TestGroup( pattern: String = if (extension == null) """^([^\.]+)$""" else "^(.+)\\.$extension\$", excludedPattern: String? = null, testMethod: String = "doTest", - singleClass: Boolean = false, - testClassName: String? = null, + singleClass: Boolean = false, // if true then tests from subdirectories will be flattern to single class + testClassName: String? = null, // specific name for generated test class + // which backend will be used in test. Specifying value may affect some test with + // directives TARGET_BACKEND/DONT_TARGET_EXACT_BACKEND won't be generated targetBackend: TargetBackend = TargetBackend.ANY, excludeDirs: List = listOf(), - filenameStartsLowerCase: Boolean? = null, - skipIgnored: Boolean = false, - deep: Int? = null + filenameStartsLowerCase: Boolean? = null, // assert that file is properly named + skipIgnored: Boolean = false, // pretty meaningless flag, affects only few test names in one test runner + deep: Int? = null, // specifies how deep recursive search will follow directory with testdata ) { val rootFile = File("$testDataRoot/$relativeRootPath") val compiledPattern = Pattern.compile(pattern) From 31bccb4fb036b6f5d37f753268cd311e1e56cb2d Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Fri, 6 Nov 2020 18:08:25 +0300 Subject: [PATCH 067/196] [TEST-GEN] Rename .java to .kt --- ...{DelegatingTestClassModel.java => DelegatingTestClassModel.kt} | 0 .../{SimpleTestClassModel.java => SimpleTestClassModel.kt} | 0 .../{SimpleTestMethodModel.java => SimpleTestMethodModel.kt} | 0 .../{SingleClassTestModel.java => SingleClassTestModel.kt} | 0 .../generator/{TestGeneratorUtil.java => TestGeneratorUtil.kt} | 0 5 files changed, 0 insertions(+), 0 deletions(-) rename generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/{DelegatingTestClassModel.java => DelegatingTestClassModel.kt} (100%) rename generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/{SimpleTestClassModel.java => SimpleTestClassModel.kt} (100%) rename generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/{SimpleTestMethodModel.java => SimpleTestMethodModel.kt} (100%) rename generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/{SingleClassTestModel.java => SingleClassTestModel.kt} (100%) rename generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/{TestGeneratorUtil.java => TestGeneratorUtil.kt} (100%) diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/DelegatingTestClassModel.java b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/DelegatingTestClassModel.kt similarity index 100% rename from generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/DelegatingTestClassModel.java rename to generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/DelegatingTestClassModel.kt diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/SimpleTestClassModel.java b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/SimpleTestClassModel.kt similarity index 100% rename from generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/SimpleTestClassModel.java rename to generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/SimpleTestClassModel.kt diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/SimpleTestMethodModel.java b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/SimpleTestMethodModel.kt similarity index 100% rename from generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/SimpleTestMethodModel.java rename to generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/SimpleTestMethodModel.kt diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/SingleClassTestModel.java b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/SingleClassTestModel.kt similarity index 100% rename from generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/SingleClassTestModel.java rename to generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/SingleClassTestModel.kt diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/TestGeneratorUtil.java b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/TestGeneratorUtil.kt similarity index 100% rename from generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/TestGeneratorUtil.java rename to generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/TestGeneratorUtil.kt From 2acbe96f15d29729fede44ed4526153b4276c499 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Fri, 6 Nov 2020 18:08:26 +0300 Subject: [PATCH 068/196] [TEST-GEN] Convert Test Generation DSL classes from java to kotlin --- .../generator/DelegatingTestClassModel.kt | 63 +-- .../tests/generator/SimpleTestClassModel.kt | 397 +++++++----------- .../tests/generator/SimpleTestMethodModel.kt | 135 +++--- .../tests/generator/SingleClassTestModel.kt | 234 ++++------- .../tests/generator/TestGeneratorUtil.kt | 38 +- 5 files changed, 315 insertions(+), 552 deletions(-) diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/DelegatingTestClassModel.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/DelegatingTestClassModel.kt index 92e5603e98e..b1449f0bba8 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/DelegatingTestClassModel.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/DelegatingTestClassModel.kt @@ -13,58 +13,27 @@ * See the License for the specific language governing permissions and * limitations under the License. */ +package org.jetbrains.kotlin.generators.tests.generator -package org.jetbrains.kotlin.generators.tests.generator; +open class DelegatingTestClassModel(private val delegate: TestClassModel) : TestClassModel() { + override val name: String + get() = delegate.name -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; + override val innerTestClasses: Collection + get() = delegate.innerTestClasses -import java.util.Collection; + override val methods: Collection + get() = delegate.methods -public class DelegatingTestClassModel extends TestClassModel { - private final TestClassModel delegate; + override val isEmpty: Boolean + get() = delegate.isEmpty - public DelegatingTestClassModel(TestClassModel delegate) { - this.delegate = delegate; - } + override val dataPathRoot: String? + get() = delegate.dataPathRoot - @NotNull - @Override - public String getName() { - return delegate.getName(); - } + override val dataString: String? + get() = delegate.dataString - @NotNull - @Override - public Collection getInnerTestClasses() { - return delegate.getInnerTestClasses(); - } - - @NotNull - @Override - public Collection getMethods() { - return delegate.getMethods(); - } - - @Override - public boolean isEmpty() { - return delegate.isEmpty(); - } - - @Nullable - @Override - public String getDataPathRoot() { - return delegate.getDataPathRoot(); - } - - @Override - public String getDataString() { - return delegate.getDataString(); - } - - @NotNull - @Override - public Collection getAnnotations() { - return delegate.getAnnotations(); - } + override val annotations: Collection + get() = delegate.annotations } diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/SimpleTestClassModel.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/SimpleTestClassModel.kt index dbe9a2f1700..61b783a9a4b 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/SimpleTestClassModel.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/SimpleTestClassModel.kt @@ -2,268 +2,189 @@ * Copyright 2010-2018 JetBrains s.r.o. and Kotlin Programming Language contributors. * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ +package org.jetbrains.kotlin.generators.tests.generator -package org.jetbrains.kotlin.generators.tests.generator; +import com.intellij.openapi.util.io.FileUtil +import com.intellij.openapi.util.text.StringUtil +import org.jetbrains.kotlin.generators.tests.generator.TestGeneratorUtil.fileNameToJavaIdentifier +import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.TargetBackend +import org.jetbrains.kotlin.utils.Printer +import java.io.File +import java.util.* +import java.util.regex.Pattern -import com.intellij.openapi.util.io.FileUtil; -import com.intellij.openapi.util.text.StringUtil; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.kotlin.test.KotlinTestUtils; -import org.jetbrains.kotlin.test.TargetBackend; -import org.jetbrains.kotlin.utils.Printer; +class SimpleTestClassModel( + private val rootFile: File, + private val recursive: Boolean, + private val excludeParentDirs: Boolean, + private val filenamePattern: Pattern, + private val excludePattern: Pattern?, + private val checkFilenameStartsLowerCase: Boolean?, + private val doTestMethodName: String, + private val testClassName: String, + private val targetBackend: TargetBackend, + excludeDirs: Collection, + private val skipIgnored: Boolean, + private val testRunnerMethodName: String, + private val additionalRunnerArguments: List, + private val deep: Int?, + override val annotations: Collection, +) : TestClassModel() { + override val name: String + get() = testClassName -import java.io.File; -import java.util.*; -import java.util.regex.Pattern; + private val excludeDirs: Set = excludeDirs.toSet() -public class SimpleTestClassModel extends TestClassModel { - private static final Comparator BY_NAME = Comparator.comparing(TestEntityModel::getName); - - @NotNull - private final File rootFile; - private final boolean recursive; - private final boolean excludeParentDirs; - @NotNull - private final Pattern filenamePattern; - @Nullable - private final Pattern excludePattern; - @Nullable - private final Boolean checkFilenameStartsLowerCase; - @NotNull - private final String doTestMethodName; - @NotNull - private final String testClassName; - private final Integer deep; - @NotNull - private final TargetBackend targetBackend; - @NotNull - private final Set excludeDirs; - @Nullable - private Collection innerTestClasses; - @Nullable - private Collection testMethods; - - @NotNull - private final Collection annotations; - - private final boolean skipIgnored; - private final String testRunnerMethodName; - private final List additionalRunnerArguments; - - public SimpleTestClassModel( - @NotNull File rootFile, - boolean recursive, - boolean excludeParentDirs, - @NotNull Pattern filenamePattern, - @Nullable Pattern excludedPattern, - @Nullable Boolean checkFilenameStartsLowerCase, - @NotNull String doTestMethodName, - @NotNull String testClassName, - @NotNull TargetBackend targetBackend, - @NotNull Collection excludeDirs, - boolean skipIgnored, - String testRunnerMethodName, - List additionalRunnerArguments, - Integer deep, - @NotNull Collection annotations - ) { - this.rootFile = rootFile; - this.recursive = recursive; - this.excludeParentDirs = excludeParentDirs; - this.filenamePattern = filenamePattern; - this.excludePattern = excludedPattern; - this.doTestMethodName = doTestMethodName; - this.testClassName = testClassName; - this.targetBackend = targetBackend; - this.checkFilenameStartsLowerCase = checkFilenameStartsLowerCase; - this.excludeDirs = excludeDirs.isEmpty() ? Collections.emptySet() : new LinkedHashSet<>(excludeDirs); - this.skipIgnored = skipIgnored; - this.testRunnerMethodName = testRunnerMethodName; - this.additionalRunnerArguments = additionalRunnerArguments; - this.deep = deep; - this.annotations = annotations; + override val innerTestClasses: Collection by lazy { + if (!rootFile.isDirectory || !recursive || deep != null && deep < 1) { + return@lazy emptyList() + } + val children = mutableListOf() + val files = rootFile.listFiles() ?: return@lazy emptyList() + for (file in files) { + if (file.isDirectory && dirHasFilesInside(file) && !excludeDirs.contains(file.name)) { + val innerTestClassName = fileNameToJavaIdentifier(file) + children.add( + SimpleTestClassModel( + file, + true, + excludeParentDirs, + filenamePattern, + excludePattern, + checkFilenameStartsLowerCase, + doTestMethodName, + innerTestClassName, + targetBackend, + excludesStripOneDirectory(file.name), + skipIgnored, + testRunnerMethodName, + additionalRunnerArguments, + if (deep != null) deep - 1 else null, + annotations, + ) + ) + } + } + children.sortWith(BY_NAME) + children } - @NotNull - @Override - public Collection getInnerTestClasses() { - if (!rootFile.isDirectory() || !recursive || deep != null && deep < 1) { - return Collections.emptyList(); + + private fun excludesStripOneDirectory(directoryName: String): Set { + if (excludeDirs.isEmpty()) return excludeDirs + val result: MutableSet = LinkedHashSet() + for (excludeDir in excludeDirs) { + val firstSlash = excludeDir.indexOf('/') + if (firstSlash >= 0 && excludeDir.substring(0, firstSlash) == directoryName) { + result.add(excludeDir.substring(firstSlash + 1)) + } } + return result + } - if (innerTestClasses == null) { - List children = new ArrayList<>(); - File[] files = rootFile.listFiles(); - if (files != null) { - for (File file : files) { - if (file.isDirectory() && dirHasFilesInside(file) && !excludeDirs.contains(file.getName())) { - String innerTestClassName = TestGeneratorUtil.fileNameToJavaIdentifier(file); - children.add(new SimpleTestClassModel( - file, true, excludeParentDirs, filenamePattern, excludePattern, checkFilenameStartsLowerCase, - doTestMethodName, innerTestClassName, targetBackend, excludesStripOneDirectory(file.getName()), - skipIgnored, testRunnerMethodName, additionalRunnerArguments, deep != null ? deep - 1 : null, annotations - ) - ); - + override val methods: Collection by lazy { + if (!rootFile.isDirectory) { + return@lazy listOf( + SimpleTestMethodModel( + rootFile, rootFile, filenamePattern, checkFilenameStartsLowerCase, targetBackend, skipIgnored + ) + ) + } + val result = mutableListOf() + result.add(RunTestMethodModel(targetBackend, doTestMethodName, testRunnerMethodName, additionalRunnerArguments)) + result.add(TestAllFilesPresentMethodModel()) + val listFiles = rootFile.listFiles() + if (listFiles != null && (deep == null || deep == 0)) { + for (file in listFiles) { + val excluded = excludePattern != null && excludePattern.matcher(file.name).matches() + if (filenamePattern.matcher(file.name).matches() && !excluded) { + if (file.isDirectory && excludeParentDirs && dirHasSubDirs(file)) { + continue } + result.add( + SimpleTestMethodModel( + rootFile, file, filenamePattern, + checkFilenameStartsLowerCase, targetBackend, skipIgnored + ) + ) } } - children.sort(BY_NAME); - innerTestClasses = children; } - return innerTestClasses; + result.sortWith(BY_NAME) + result } - @NotNull - private Set excludesStripOneDirectory(@NotNull String directoryName) { - if (excludeDirs.isEmpty()) return excludeDirs; + override val isEmpty: Boolean + get() { + val noTestMethods = methods.size == 1 + return noTestMethods && innerTestClasses.isEmpty() + } - Set result = new LinkedHashSet<>(); - for (String excludeDir : excludeDirs) { - int firstSlash = excludeDir.indexOf('/'); - if (firstSlash >= 0 && excludeDir.substring(0, firstSlash).equals(directoryName)) { - result.add(excludeDir.substring(firstSlash + 1)); + override val dataString: String + get() = KotlinTestUtils.getFilePath(rootFile) + + override val dataPathRoot: String + get() = "\$PROJECT_ROOT" + + private inner class TestAllFilesPresentMethodModel : TestMethodModel() { + override val name: String + get() = "testAllFilesPresentIn$testClassName" + + override val dataString: String? + get() = null + + override fun generateBody(p: Printer) { + val exclude = StringBuilder() + for (dir in excludeDirs) { + exclude.append(", \"") + exclude.append(StringUtil.escapeStringCharacters(dir)) + exclude.append("\"") } - } - - return result; - } - - private static boolean dirHasFilesInside(@NotNull File dir) { - return !FileUtil.processFilesRecursively(dir, File::isDirectory); - } - - private static boolean dirHasSubDirs(@NotNull File dir) { - File[] listFiles = dir.listFiles(); - if (listFiles == null) { - return false; - } - for (File file : listFiles) { - if (file.isDirectory()) { - return true; + val excludedArgument = if (excludePattern != null) { + String.format("Pattern.compile(\"%s\")", StringUtil.escapeStringCharacters(excludePattern.pattern())) + } else { + null } + val assertTestsPresentStr = if (targetBackend === TargetBackend.ANY) { + String.format( + "KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File(\"%s\"), Pattern.compile(\"%s\"), %s, %s%s);", + KotlinTestUtils.getFilePath(rootFile), + StringUtil.escapeStringCharacters(filenamePattern.pattern()), + excludedArgument, + recursive, + exclude + ) + } else { + String.format( + "KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File(\"%s\"), Pattern.compile(\"%s\"), %s, %s.%s, %s%s);", + KotlinTestUtils.getFilePath(rootFile), StringUtil.escapeStringCharacters(filenamePattern.pattern()), + excludedArgument, TargetBackend::class.java.simpleName, targetBackend.toString(), recursive, exclude + ) + } + p.println(assertTestsPresentStr) + } + + override fun shouldBeGenerated(): Boolean { + return true } - return false; } - @NotNull - @Override - public Collection getMethods() { - if (testMethods == null) { - if (!rootFile.isDirectory()) { - testMethods = Collections.singletonList(new SimpleTestMethodModel( - rootFile, rootFile, filenamePattern, checkFilenameStartsLowerCase, targetBackend, skipIgnored - )); - } - else { - List result = new ArrayList<>(); + companion object { + private val BY_NAME = Comparator.comparing(TestEntityModel::name) - result.add(new RunTestMethodModel(targetBackend, doTestMethodName, testRunnerMethodName, additionalRunnerArguments)); + private fun dirHasFilesInside(dir: File): Boolean { + return !FileUtil.processFilesRecursively(dir) { obj: File -> obj.isDirectory } + } - result.add(new TestAllFilesPresentMethodModel()); - - File[] listFiles = rootFile.listFiles(); - - if (listFiles != null && (deep == null || deep == 0)) { - for (File file : listFiles) { - boolean excluded = excludePattern != null && excludePattern.matcher(file.getName()).matches(); - if (filenamePattern.matcher(file.getName()).matches() && !excluded) { - - if (file.isDirectory() && excludeParentDirs && dirHasSubDirs(file)) { - continue; - } - result.add(new SimpleTestMethodModel(rootFile, file, filenamePattern, checkFilenameStartsLowerCase, targetBackend, skipIgnored)); - } - } + private fun dirHasSubDirs(dir: File): Boolean { + val listFiles = dir.listFiles() ?: return false + for (file in listFiles) { + if (file.isDirectory) { + return true } - - result.sort(BY_NAME); - - testMethods = result; } - } - return testMethods; - } - - @Override - public boolean isEmpty() { - boolean noTestMethods = getMethods().size() == 1; - return noTestMethods && getInnerTestClasses().isEmpty(); - } - - @Override - public String getDataString() { - return KotlinTestUtils.getFilePath(rootFile); - } - - @Nullable - @Override - public String getDataPathRoot() { - return "$PROJECT_ROOT"; - } - - @NotNull - @Override - public String getName() { - return testClassName; - } - - @NotNull - @Override - public Collection getAnnotations() { - return annotations; - } - - private class TestAllFilesPresentMethodModel extends TestMethodModel { - @NotNull - @Override - public String getName() { - return "testAllFilesPresentIn" + testClassName; - } - - @Override - public void generateBody(@NotNull Printer p) { - StringBuilder exclude = new StringBuilder(); - for (String dir : excludeDirs) { - exclude.append(", \""); - exclude.append(StringUtil.escapeStringCharacters(dir)); - exclude.append("\""); - } - - String excludedArgument; - if (excludePattern != null) { - excludedArgument = String.format("Pattern.compile(\"%s\")", StringUtil.escapeStringCharacters(excludePattern.pattern())); - } else { - excludedArgument = null; - } - - String assertTestsPresentStr; - - if (targetBackend == TargetBackend.ANY) { - assertTestsPresentStr = String.format( - "KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File(\"%s\"), Pattern.compile(\"%s\"), %s, %s%s);", - KotlinTestUtils.getFilePath(rootFile), StringUtil.escapeStringCharacters(filenamePattern.pattern()), excludedArgument, recursive, exclude - ); - } else { - assertTestsPresentStr = String.format( - "KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File(\"%s\"), Pattern.compile(\"%s\"), %s, %s.%s, %s%s);", - KotlinTestUtils.getFilePath(rootFile), StringUtil.escapeStringCharacters(filenamePattern.pattern()), - excludedArgument, TargetBackend.class.getSimpleName(), targetBackend.toString(), recursive, exclude - ); - } - - p.println(assertTestsPresentStr); - } - - @Override - public String getDataString() { - return null; - } - - @Override - public boolean shouldBeGenerated() { - return true; + return false } } } diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/SimpleTestMethodModel.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/SimpleTestMethodModel.kt index b606d735317..61d2657e704 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/SimpleTestMethodModel.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/SimpleTestMethodModel.kt @@ -2,100 +2,65 @@ * Copyright 2010-2018 JetBrains s.r.o. and Kotlin Programming Language contributors. * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ +package org.jetbrains.kotlin.generators.tests.generator -package org.jetbrains.kotlin.generators.tests.generator; +import com.intellij.openapi.util.io.FileUtil +import org.jetbrains.kotlin.generators.tests.generator.TestGeneratorUtil.escapeForJavaIdentifier +import org.jetbrains.kotlin.test.InTextDirectivesUtils +import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.TargetBackend +import org.jetbrains.kotlin.utils.Printer +import java.io.File +import java.util.regex.Pattern -import com.intellij.openapi.util.io.FileUtil; -import kotlin.text.StringsKt; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.kotlin.test.InTextDirectivesUtils; -import org.jetbrains.kotlin.test.KotlinTestUtils; -import org.jetbrains.kotlin.test.TargetBackend; -import org.jetbrains.kotlin.utils.Printer; +open class SimpleTestMethodModel( + private val rootDir: File, + protected val file: File, + private val filenamePattern: Pattern, + checkFilenameStartsLowerCase: Boolean?, + protected val targetBackend: TargetBackend, + private val skipIgnored: Boolean +) : TestMethodModel() { + override fun generateBody(p: Printer) { + val filePath = KotlinTestUtils.getFilePath(file) + if (file.isDirectory) "/" else "" + p.println(RunTestMethodModel.METHOD_NAME, "(\"", filePath, "\");") + } -import java.io.File; -import java.util.regex.Matcher; -import java.util.regex.Pattern; + override val dataString: String + get() { + val path = FileUtil.getRelativePath(rootDir, file)!! + return KotlinTestUtils.getFilePath(File(path)) + } -import static org.jetbrains.kotlin.test.InTextDirectivesUtils.isIgnoredTarget; + override fun shouldBeGenerated(): Boolean { + return InTextDirectivesUtils.isCompatibleTarget(targetBackend, file) + } -public class SimpleTestMethodModel extends TestMethodModel { - - @NotNull - private final File rootDir; - @NotNull - protected final File file; - @NotNull - private final Pattern filenamePattern; - @NotNull - protected final TargetBackend targetBackend; - - private final boolean skipIgnored; - - public SimpleTestMethodModel( - @NotNull File rootDir, - @NotNull File file, - @NotNull Pattern filenamePattern, - @Nullable Boolean checkFilenameStartsLowerCase, - @NotNull TargetBackend targetBackend, - boolean skipIgnored - ) { - this.rootDir = rootDir; - this.file = file; - this.filenamePattern = filenamePattern; - this.targetBackend = targetBackend; - this.skipIgnored = skipIgnored; + override val name: String + get() { + val matcher = filenamePattern.matcher(file.name) + val found = matcher.find() + assert(found) { file.name + " isn't matched by regex " + filenamePattern.pattern() } + assert(matcher.groupCount() >= 1) { filenamePattern.pattern() } + val extractedName = matcher.group(1) ?: error("extractedName should not be null: " + filenamePattern.pattern()) + val unescapedName = if (rootDir == file.parentFile) { + extractedName + } else { + val relativePath = FileUtil.getRelativePath(rootDir, file.parentFile) + relativePath + "-" + extractedName.capitalize() + } + val ignored = skipIgnored && InTextDirectivesUtils.isIgnoredTarget(targetBackend, file) + return (if (ignored) "ignore" else "test") + escapeForJavaIdentifier(unescapedName).capitalize() + } + init { if (checkFilenameStartsLowerCase != null) { - char c = file.getName().charAt(0); + val c = file.name[0] if (checkFilenameStartsLowerCase) { - assert Character.isLowerCase(c) : "Invalid file name '" + file + "', file name should start with lower-case letter"; - } - else { - assert Character.isUpperCase(c) : "Invalid file name '" + file + "', file name should start with upper-case letter"; + assert(Character.isLowerCase(c)) { "Invalid file name '$file', file name should start with lower-case letter" } + } else { + assert(Character.isUpperCase(c)) { "Invalid file name '$file', file name should start with upper-case letter" } } } } - - @Override - public void generateBody(@NotNull Printer p) { - String filePath = KotlinTestUtils.getFilePath(file) + (file.isDirectory() ? "/" : ""); - p.println(RunTestMethodModel.METHOD_NAME, "(\"", filePath, "\");"); - } - - @Override - public String getDataString() { - String path = FileUtil.getRelativePath(rootDir, file); - assert path != null; - return KotlinTestUtils.getFilePath(new File(path)); - } - - @Override - public boolean shouldBeGenerated() { - return InTextDirectivesUtils.isCompatibleTarget(targetBackend, file); - } - - @NotNull - @Override - public String getName() { - Matcher matcher = filenamePattern.matcher(file.getName()); - boolean found = matcher.find(); - assert found : file.getName() + " isn't matched by regex " + filenamePattern.pattern(); - assert matcher.groupCount() >= 1 : filenamePattern.pattern(); - String extractedName = matcher.group(1); - assert extractedName != null : "extractedName should not be null: " + filenamePattern.pattern(); - - String unescapedName; - if (rootDir.equals(file.getParentFile())) { - unescapedName = extractedName; - } - else { - String relativePath = FileUtil.getRelativePath(rootDir, file.getParentFile()); - unescapedName = relativePath + "-" + StringsKt.capitalize(extractedName); - } - - boolean ignored = skipIgnored && isIgnoredTarget(targetBackend, file); - return (ignored ? "ignore" : "test") + StringsKt.capitalize(TestGeneratorUtil.escapeForJavaIdentifier(unescapedName)); - } } diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/SingleClassTestModel.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/SingleClassTestModel.kt index b39ec23f6ed..da80591a7ab 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/SingleClassTestModel.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/SingleClassTestModel.kt @@ -13,184 +13,96 @@ * See the License for the specific language governing permissions and * limitations under the License. */ +package org.jetbrains.kotlin.generators.tests.generator -package org.jetbrains.kotlin.generators.tests.generator; +import com.intellij.openapi.util.io.FileUtil +import com.intellij.openapi.util.text.StringUtil +import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.TargetBackend +import org.jetbrains.kotlin.utils.Printer +import java.io.File +import java.util.* +import java.util.regex.Pattern -import com.intellij.openapi.util.io.FileUtil; -import com.intellij.openapi.util.text.StringUtil; -import kotlin.collections.CollectionsKt; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.kotlin.test.KotlinTestUtils; -import org.jetbrains.kotlin.test.TargetBackend; -import org.jetbrains.kotlin.utils.Printer; +class SingleClassTestModel( + private val rootFile: File, + private val filenamePattern: Pattern, + private val excludePattern: Pattern?, + private val checkFilenameStartsLowerCase: Boolean?, + private val doTestMethodName: String, + private val testClassName: String, + private val targetBackend: TargetBackend, + private val skipIgnored: Boolean, + private val testRunnerMethodName: String, + private val additionalRunnerArguments: List, + override val annotations: List +) : TestClassModel() { + override val name: String + get() = testClassName -import java.io.File; -import java.util.ArrayList; -import java.util.Collection; -import java.util.Collections; -import java.util.List; -import java.util.regex.Pattern; -import java.util.stream.Collectors; - -public class SingleClassTestModel extends TestClassModel { - @NotNull - private final File rootFile; - @NotNull - private final Pattern filenamePattern; - @Nullable - private final Pattern excludePattern; - @Nullable - private final Boolean checkFilenameStartsLowerCase; - @NotNull - private final String doTestMethodName; - @NotNull - private final String testClassName; - @NotNull - private final TargetBackend targetBackend; - @Nullable - private Collection methods; - - private final boolean skipIgnored; - private final String testRunnerMethodName; - private final List additionalRunnerArguments; - - @NotNull - private final List annotations; - - public SingleClassTestModel( - @NotNull File rootFile, - @NotNull Pattern filenamePattern, - @Nullable Pattern excludePattern, - @Nullable Boolean checkFilenameStartsLowerCase, - @NotNull String doTestMethodName, - @NotNull String testClassName, - @NotNull TargetBackend targetBackend, - boolean skipIgnored, - String testRunnerMethodName, - List additionalRunnerArguments, - @NotNull List annotations - ) { - this.rootFile = rootFile; - this.filenamePattern = filenamePattern; - this.excludePattern = excludePattern; - this.checkFilenameStartsLowerCase = checkFilenameStartsLowerCase; - this.doTestMethodName = doTestMethodName; - this.testClassName = testClassName; - this.targetBackend = targetBackend; - this.skipIgnored = skipIgnored; - this.testRunnerMethodName = testRunnerMethodName; - this.additionalRunnerArguments = additionalRunnerArguments; - this.annotations = annotations; - } - - @NotNull - @Override - public final Collection getInnerTestClasses() { - return Collections.emptyList(); - } - - @NotNull - @Override - public Collection getMethods() { - if (methods == null) { - List result = new ArrayList<>(); - - result.add(new RunTestMethodModel(targetBackend, doTestMethodName, testRunnerMethodName, additionalRunnerArguments)); - - result.add(new TestAllFilesPresentMethodModel()); - - FileUtil.processFilesRecursively(rootFile, file -> { - if (!file.isDirectory() && filenamePattern.matcher(file.getName()).matches()) { - result.addAll(getTestMethodsFromFile(file)); - } - - return true; - }); - - methods = CollectionsKt.sortedWith(result, (o1, o2) -> o1.getName().compareToIgnoreCase(o2.getName())); + override val methods: Collection by lazy { + val result: MutableList = ArrayList() + result.add(RunTestMethodModel(targetBackend, doTestMethodName, testRunnerMethodName, additionalRunnerArguments)) + result.add(TestAllFilesPresentMethodModel()) + FileUtil.processFilesRecursively(rootFile) { file: File -> + if (!file.isDirectory && filenamePattern.matcher(file.name).matches()) { + result.addAll(getTestMethodsFromFile(file)) + } + true } - - return methods; + result.sortedWith { o1: MethodModel, o2: MethodModel -> o1.name.compareTo(o2.name, ignoreCase = true) } } - @NotNull - private Collection getTestMethodsFromFile(File file) { - return Collections.singletonList(new SimpleTestMethodModel( + override val innerTestClasses: Collection + get() = emptyList() + + private fun getTestMethodsFromFile(file: File): Collection { + return listOf( + SimpleTestMethodModel( rootFile, file, filenamePattern, checkFilenameStartsLowerCase, targetBackend, skipIgnored - )); + ) + ) } - @Override - public boolean isEmpty() { - // There's always one test for checking if all tests are present - return getMethods().size() <= 1; - } + // There's always one test for checking if all tests are present + override val isEmpty: Boolean + get() = methods.size <= 1 + override val dataString: String = KotlinTestUtils.getFilePath(rootFile) + override val dataPathRoot: String = "\$PROJECT_ROOT" - @Override - public String getDataString() { - return KotlinTestUtils.getFilePath(rootFile); - } + private inner class TestAllFilesPresentMethodModel : TestMethodModel() { + override val name: String = "testAllFilesPresentIn$testClassName" + override val dataString: String? + get() = null - @Nullable - @Override - public String getDataPathRoot() { - return "$PROJECT_ROOT"; - } - - @NotNull - @Override - public String getName() { - return testClassName; - } - - @NotNull - @Override - public Collection getAnnotations() { - return annotations; - } - - private class TestAllFilesPresentMethodModel extends TestMethodModel { - @NotNull - @Override - public String getName() { - return "testAllFilesPresentIn" + testClassName; - } - - @Override - public void generateBody(@NotNull Printer p) { - String assertTestsPresentStr; - - String excludedArgument; - if (excludePattern != null) { - excludedArgument = String.format("Pattern.compile(\"%s\")", StringUtil.escapeStringCharacters(excludePattern.pattern())); + override fun generateBody(p: Printer) { + val assertTestsPresentStr: String + val excludedArgument = if (excludePattern != null) { + String.format( + "Pattern.compile(\"%s\")", StringUtil.escapeStringCharacters( + excludePattern.pattern() + ) + ) } else { - excludedArgument = null; + null } - - if (targetBackend != TargetBackend.ANY) { - assertTestsPresentStr = String.format( - "KotlinTestUtils.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File(\"%s\"), Pattern.compile(\"%s\"), %s, %s.%s);", - KotlinTestUtils.getFilePath(rootFile), StringUtil.escapeStringCharacters(filenamePattern.pattern()), - excludedArgument, TargetBackend.class.getSimpleName(), targetBackend.toString() - ); + assertTestsPresentStr = if (targetBackend !== TargetBackend.ANY) { + String.format( + "KotlinTestUtils.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File(\"%s\"), Pattern.compile(\"%s\"), %s, %s.%s);", + KotlinTestUtils.getFilePath(rootFile), StringUtil.escapeStringCharacters(filenamePattern.pattern()), + excludedArgument, TargetBackend::class.java.simpleName, targetBackend.toString() + ) } else { - assertTestsPresentStr = String.format( - "KotlinTestUtils.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File(\"%s\"), Pattern.compile(\"%s\"), %s);", - KotlinTestUtils.getFilePath(rootFile), StringUtil.escapeStringCharacters(filenamePattern.pattern()), excludedArgument - ); + String.format( + "KotlinTestUtils.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File(\"%s\"), Pattern.compile(\"%s\"), %s);", + KotlinTestUtils.getFilePath(rootFile), StringUtil.escapeStringCharacters(filenamePattern.pattern()), excludedArgument + ) } - p.println(assertTestsPresentStr); + p.println(assertTestsPresentStr) } - @Override - public String getDataString() { - return null; - } - - @Override - public boolean shouldBeGenerated() { - return true; + override fun shouldBeGenerated(): Boolean { + return true } } } diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/TestGeneratorUtil.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/TestGeneratorUtil.kt index cb907cb6024..30f02201653 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/TestGeneratorUtil.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/TestGeneratorUtil.kt @@ -13,34 +13,30 @@ * See the License for the specific language governing permissions and * limitations under the License. */ +package org.jetbrains.kotlin.generators.tests.generator -package org.jetbrains.kotlin.generators.tests.generator; +import kotlin.text.capitalize +import org.jetbrains.kotlin.generators.tests.generator.TestGeneratorUtil +import java.io.File +import java.lang.StringBuilder -import kotlin.text.StringsKt; -import org.jetbrains.annotations.NotNull; - -import java.io.File; - -public class TestGeneratorUtil { - @NotNull - public static String escapeForJavaIdentifier(String fileName) { +object TestGeneratorUtil { + @JvmStatic + fun escapeForJavaIdentifier(fileName: String): String { // A file name may contain characters (like ".") that can't be a part of method name - StringBuilder result = new StringBuilder(); - for (int i = 0; i < fileName.length(); i++) { - char c = fileName.charAt(i); - + val result = StringBuilder() + for (c in fileName) { if (Character.isJavaIdentifierPart(c)) { - result.append(c); - } - else { - result.append("_"); + result.append(c) + } else { + result.append("_") } } - return result.toString(); + return result.toString() } - @NotNull - public static String fileNameToJavaIdentifier(@NotNull File file) { - return StringsKt.capitalize(escapeForJavaIdentifier(file.getName())); + @JvmStatic + fun fileNameToJavaIdentifier(file: File): String { + return escapeForJavaIdentifier(file.name).capitalize() } } From d45fb4dfd81802ee92506b13118a4a6a986ae81d Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Mon, 9 Nov 2020 11:08:57 +0300 Subject: [PATCH 069/196] [TEST-GEN] Extract logic of generating test methods into separate abstraction MethodGenerator --- .../tests/generator/RunTestMethodModel.kt | 34 ++++------- .../tests/generator/SimpleTestClassModel.kt | 53 +++++------------- .../tests/generator/SimpleTestMethodModel.kt | 12 ++-- .../tests/generator/SingleClassTestModel.kt | 46 +++++---------- .../tests/generator/TestGenerationDSL.kt | 11 +++- .../tests/generator/TestGenerator.kt | 44 +++++++++------ .../generators/tests/generator/TestModel.kt | 11 +--- .../generator/generators/MethodGenerator.kt | 22 ++++++++ .../generators/impl/RunTestMethodGenerator.kt | 35 ++++++++++++ ...ModelTestAllFilesPresentMethodGenerator.kt | 56 +++++++++++++++++++ .../impl/SimpleTestMethodGenerator.kt | 29 ++++++++++ ...stModelAllFilesPresentedMethodGenerator.kt | 56 +++++++++++++++++++ .../util/CoroutinesTestMethodModel.kt | 37 ++++++++++++ 13 files changed, 318 insertions(+), 128 deletions(-) create mode 100644 generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/MethodGenerator.kt create mode 100644 generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/impl/RunTestMethodGenerator.kt create mode 100644 generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/impl/SimpleTestClassModelTestAllFilesPresentMethodGenerator.kt create mode 100644 generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/impl/SimpleTestMethodGenerator.kt create mode 100644 generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/impl/SingleClassTestModelAllFilesPresentedMethodGenerator.kt create mode 100644 generators/test-generator/tests/org/jetbrains/kotlin/generators/util/CoroutinesTestMethodModel.kt diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/RunTestMethodModel.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/RunTestMethodModel.kt index f0678cda35c..f321bb7cb5e 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/RunTestMethodModel.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/RunTestMethodModel.kt @@ -6,42 +6,30 @@ package org.jetbrains.kotlin.generators.tests.generator import org.jetbrains.kotlin.test.TargetBackend -import org.jetbrains.kotlin.utils.Printer class RunTestMethodModel( - private val targetBackend: TargetBackend, - private val testMethodName: String, - private val testRunnerMethodName: String, - private val additionalRunnerArguments: List = emptyList() + val targetBackend: TargetBackend, + val testMethodName: String, + val testRunnerMethodName: String, + val additionalRunnerArguments: List = emptyList() ) : MethodModel { + object Kind : MethodModel.Kind() + + override val kind: MethodModel.Kind + get() = Kind + override val name = METHOD_NAME override val dataString: String? = null - override fun generateSignature(p: Printer) { - p.print("private void $name(String testDataFilePath) throws Exception") - } - - override fun generateBody(p: Printer) { - if (!isWithTargetBackend()) { - p.println("KotlinTestUtils.$testRunnerMethodName(this::$testMethodName, this, testDataFilePath);") - } else { - val className = TargetBackend::class.java.simpleName - val additionalArguments = if (additionalRunnerArguments.isNotEmpty()) - additionalRunnerArguments.joinToString(separator = ", ", prefix = ", ") - else "" - p.println("KotlinTestUtils.$testRunnerMethodName(this::$testMethodName, $className.$targetBackend, testDataFilePath$additionalArguments);") - } - } - override fun imports(): Collection> { return super.imports() + if (isWithTargetBackend()) setOf(TargetBackend::class.java) else emptySet() } - private fun isWithTargetBackend(): Boolean { + fun isWithTargetBackend(): Boolean { return !(targetBackend == TargetBackend.ANY && additionalRunnerArguments.isEmpty() && testRunnerMethodName == METHOD_NAME) } companion object { const val METHOD_NAME = "runTest" } -} \ No newline at end of file +} diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/SimpleTestClassModel.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/SimpleTestClassModel.kt index 61b783a9a4b..e5c5ef79ca4 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/SimpleTestClassModel.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/SimpleTestClassModel.kt @@ -5,25 +5,23 @@ package org.jetbrains.kotlin.generators.tests.generator import com.intellij.openapi.util.io.FileUtil -import com.intellij.openapi.util.text.StringUtil import org.jetbrains.kotlin.generators.tests.generator.TestGeneratorUtil.fileNameToJavaIdentifier import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.TargetBackend -import org.jetbrains.kotlin.utils.Printer import java.io.File import java.util.* import java.util.regex.Pattern class SimpleTestClassModel( - private val rootFile: File, - private val recursive: Boolean, + val rootFile: File, + val recursive: Boolean, private val excludeParentDirs: Boolean, - private val filenamePattern: Pattern, - private val excludePattern: Pattern?, + val filenamePattern: Pattern, + val excludePattern: Pattern?, private val checkFilenameStartsLowerCase: Boolean?, private val doTestMethodName: String, private val testClassName: String, - private val targetBackend: TargetBackend, + val targetBackend: TargetBackend, excludeDirs: Collection, private val skipIgnored: Boolean, private val testRunnerMethodName: String, @@ -34,7 +32,7 @@ class SimpleTestClassModel( override val name: String get() = testClassName - private val excludeDirs: Set = excludeDirs.toSet() + val excludeDirs: Set = excludeDirs.toSet() override val innerTestClasses: Collection by lazy { if (!rootFile.isDirectory || !recursive || deep != null && deep < 1) { @@ -127,43 +125,20 @@ class SimpleTestClassModel( override val dataPathRoot: String get() = "\$PROJECT_ROOT" - private inner class TestAllFilesPresentMethodModel : TestMethodModel() { + object TestAllFilesPresentMethodKind : MethodModel.Kind() + + inner class TestAllFilesPresentMethodModel : MethodModel { + override val kind: MethodModel.Kind + get() = TestAllFilesPresentMethodKind + override val name: String get() = "testAllFilesPresentIn$testClassName" override val dataString: String? get() = null - override fun generateBody(p: Printer) { - val exclude = StringBuilder() - for (dir in excludeDirs) { - exclude.append(", \"") - exclude.append(StringUtil.escapeStringCharacters(dir)) - exclude.append("\"") - } - val excludedArgument = if (excludePattern != null) { - String.format("Pattern.compile(\"%s\")", StringUtil.escapeStringCharacters(excludePattern.pattern())) - } else { - null - } - val assertTestsPresentStr = if (targetBackend === TargetBackend.ANY) { - String.format( - "KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File(\"%s\"), Pattern.compile(\"%s\"), %s, %s%s);", - KotlinTestUtils.getFilePath(rootFile), - StringUtil.escapeStringCharacters(filenamePattern.pattern()), - excludedArgument, - recursive, - exclude - ) - } else { - String.format( - "KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File(\"%s\"), Pattern.compile(\"%s\"), %s, %s.%s, %s%s);", - KotlinTestUtils.getFilePath(rootFile), StringUtil.escapeStringCharacters(filenamePattern.pattern()), - excludedArgument, TargetBackend::class.java.simpleName, targetBackend.toString(), recursive, exclude - ) - } - p.println(assertTestsPresentStr) - } + val classModel: SimpleTestClassModel + get() = this@SimpleTestClassModel override fun shouldBeGenerated(): Boolean { return true diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/SimpleTestMethodModel.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/SimpleTestMethodModel.kt index 61d2657e704..204d91f1cd2 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/SimpleTestMethodModel.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/SimpleTestMethodModel.kt @@ -15,16 +15,16 @@ import java.util.regex.Pattern open class SimpleTestMethodModel( private val rootDir: File, - protected val file: File, + val file: File, private val filenamePattern: Pattern, checkFilenameStartsLowerCase: Boolean?, protected val targetBackend: TargetBackend, private val skipIgnored: Boolean -) : TestMethodModel() { - override fun generateBody(p: Printer) { - val filePath = KotlinTestUtils.getFilePath(file) + if (file.isDirectory) "/" else "" - p.println(RunTestMethodModel.METHOD_NAME, "(\"", filePath, "\");") - } +) : MethodModel { + object Kind : MethodModel.Kind() + + override val kind: MethodModel.Kind + get() = Kind override val dataString: String get() { diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/SingleClassTestModel.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/SingleClassTestModel.kt index da80591a7ab..fa1ab0d32f2 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/SingleClassTestModel.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/SingleClassTestModel.kt @@ -16,22 +16,20 @@ package org.jetbrains.kotlin.generators.tests.generator import com.intellij.openapi.util.io.FileUtil -import com.intellij.openapi.util.text.StringUtil import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.TargetBackend -import org.jetbrains.kotlin.utils.Printer import java.io.File import java.util.* import java.util.regex.Pattern class SingleClassTestModel( - private val rootFile: File, - private val filenamePattern: Pattern, - private val excludePattern: Pattern?, + val rootFile: File, + val filenamePattern: Pattern, + val excludePattern: Pattern?, private val checkFilenameStartsLowerCase: Boolean?, private val doTestMethodName: String, private val testClassName: String, - private val targetBackend: TargetBackend, + val targetBackend: TargetBackend, private val skipIgnored: Boolean, private val testRunnerMethodName: String, private val additionalRunnerArguments: List, @@ -56,7 +54,7 @@ class SingleClassTestModel( override val innerTestClasses: Collection get() = emptyList() - private fun getTestMethodsFromFile(file: File): Collection { + private fun getTestMethodsFromFile(file: File): Collection { return listOf( SimpleTestMethodModel( rootFile, file, filenamePattern, checkFilenameStartsLowerCase, targetBackend, skipIgnored @@ -70,36 +68,18 @@ class SingleClassTestModel( override val dataString: String = KotlinTestUtils.getFilePath(rootFile) override val dataPathRoot: String = "\$PROJECT_ROOT" - private inner class TestAllFilesPresentMethodModel : TestMethodModel() { + object AllFilesPresentedMethodKind : MethodModel.Kind() + + inner class TestAllFilesPresentMethodModel : MethodModel { override val name: String = "testAllFilesPresentIn$testClassName" override val dataString: String? get() = null - override fun generateBody(p: Printer) { - val assertTestsPresentStr: String - val excludedArgument = if (excludePattern != null) { - String.format( - "Pattern.compile(\"%s\")", StringUtil.escapeStringCharacters( - excludePattern.pattern() - ) - ) - } else { - null - } - assertTestsPresentStr = if (targetBackend !== TargetBackend.ANY) { - String.format( - "KotlinTestUtils.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File(\"%s\"), Pattern.compile(\"%s\"), %s, %s.%s);", - KotlinTestUtils.getFilePath(rootFile), StringUtil.escapeStringCharacters(filenamePattern.pattern()), - excludedArgument, TargetBackend::class.java.simpleName, targetBackend.toString() - ) - } else { - String.format( - "KotlinTestUtils.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File(\"%s\"), Pattern.compile(\"%s\"), %s);", - KotlinTestUtils.getFilePath(rootFile), StringUtil.escapeStringCharacters(filenamePattern.pattern()), excludedArgument - ) - } - p.println(assertTestsPresentStr) - } + val classModel: SingleClassTestModel + get() = this@SingleClassTestModel + + override val kind: MethodModel.Kind + get() = AllFilesPresentedMethodKind override fun shouldBeGenerated(): Boolean { return true diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/TestGenerationDSL.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/TestGenerationDSL.kt index 3437fa9e181..1b86ade0fda 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/TestGenerationDSL.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/TestGenerationDSL.kt @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.generators.tests.generator import junit.framework.TestCase import org.jetbrains.kotlin.generators.tests.generator.InconsistencyChecker.Companion.hasDryRunArg import org.jetbrains.kotlin.generators.tests.generator.InconsistencyChecker.Companion.inconsistencyChecker +import org.jetbrains.kotlin.generators.tests.generator.generators.impl.* import org.jetbrains.kotlin.test.TargetBackend import java.io.File import java.util.* @@ -42,7 +43,15 @@ class TestGroup( suiteTestClassName, baseTestClassName, TestClass(annotations).apply(init).testModels, - useJunit4 + useJunit4, + methodGenerators = listOf( + CoroutinesTestMethodGenerator, + RunTestMethodGenerator, + RunTestMethodWithPackageReplacementGenerator, + SimpleTestClassModelTestAllFilesPresentMethodGenerator, + SimpleTestMethodGenerator, + SingleClassTestModelAllFilesPresentedMethodGenerator + ) ) if (testGenerator.generateAndSave(dryRun)) { inconsistencyChecker(dryRun).add(testGenerator.testSourceFilePath) diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/TestGenerator.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/TestGenerator.kt index a800aab5f01..3f6e770969d 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/TestGenerator.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/TestGenerator.kt @@ -5,6 +5,7 @@ package org.jetbrains.kotlin.generators.tests.generator +import org.jetbrains.kotlin.generators.tests.generator.generators.MethodGenerator import org.jetbrains.kotlin.generators.util.GeneratorsFileUtil import org.jetbrains.kotlin.test.JUnit3RunnerWithInners import org.jetbrains.kotlin.test.KotlinTestUtils @@ -22,8 +23,12 @@ class TestGenerator( suiteTestClassFqName: String, baseTestClassFqName: String, testClassModels: Collection, - useJunit4: Boolean + useJunit4: Boolean, + methodGenerators: List> ) { + private val methodGenerators: Map> = + methodGenerators.associateBy { it.kind }.withDefault { error("Generator for method with kind $it not found") } + private val baseTestClassPackage: String private val suiteClassPackage: String private val suiteClassName: String @@ -188,28 +193,31 @@ class TestGenerator( p.println("}") } + private fun generateTestMethod(p: Printer, methodModel: MethodModel, useJunit4: Boolean) { + if (useJunit4 && (methodModel !is RunTestMethodModel)) { + p.println("@Test") + } + + val generator = methodGenerators.getValue(methodModel.kind) + + generateMetadata(p, methodModel) + generator.generateSignature(methodModel, p) + p.printWithNoIndent(" {") + p.println() + + p.pushIndent() + + generator.generateBody(methodModel, p) + + p.popIndent() + p.println("}") + } + companion object { private val GENERATED_FILES = HashSet() private val RUNNER = JUnit3RunnerWithInners::class.java private val JUNIT4_RUNNER = BlockJUnit4ClassRunner::class.java - private fun generateTestMethod(p: Printer, methodModel: MethodModel, useJunit4: Boolean) { - if (useJunit4 && (methodModel !is RunTestMethodModel)) { - p.println("@Test") - } - generateMetadata(p, methodModel) - - methodModel.generateSignature(p) - p.printWithNoIndent(" {") - p.println() - - p.pushIndent() - - methodModel.generateBody(p) - - p.popIndent() - p.println("}") - } private fun generateMetadata(p: Printer, testDataSource: TestEntityModel) { val dataString = testDataSource.dataString diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/TestModel.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/TestModel.kt index e91c9ddfb58..64dcc101889 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/TestModel.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/TestModel.kt @@ -44,14 +44,9 @@ abstract class TestClassModel : ClassModel { } interface MethodModel : TestEntityModel { + abstract class Kind + + val kind: Kind fun shouldBeGenerated(): Boolean = true - fun generateSignature(p: Printer) - fun generateBody(p: Printer) fun imports(): Collection> = emptyList() } - -abstract class TestMethodModel : MethodModel { - override fun generateSignature(p: Printer) { - p.print("public void $name() throws Exception") - } -} diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/MethodGenerator.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/MethodGenerator.kt new file mode 100644 index 00000000000..7a3f60da356 --- /dev/null +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/MethodGenerator.kt @@ -0,0 +1,22 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.generators.tests.generator.generators + +import org.jetbrains.kotlin.generators.tests.generator.MethodModel +import org.jetbrains.kotlin.utils.Printer + +abstract class MethodGenerator { + companion object { + fun generateDefaultSignature(method: MethodModel, p: Printer) { + p.print("public void ${method.name}() throws Exception") + } + } + + abstract val kind: MethodModel.Kind + + abstract fun generateSignature(method: @UnsafeVariance T, p: Printer) + abstract fun generateBody(method: @UnsafeVariance T, p: Printer) +} diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/impl/RunTestMethodGenerator.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/impl/RunTestMethodGenerator.kt new file mode 100644 index 00000000000..3398b8e1adf --- /dev/null +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/impl/RunTestMethodGenerator.kt @@ -0,0 +1,35 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.generators.tests.generator.generators.impl + +import org.jetbrains.kotlin.generators.tests.generator.MethodModel +import org.jetbrains.kotlin.generators.tests.generator.RunTestMethodModel +import org.jetbrains.kotlin.generators.tests.generator.generators.MethodGenerator +import org.jetbrains.kotlin.test.TargetBackend +import org.jetbrains.kotlin.utils.Printer + +object RunTestMethodGenerator : MethodGenerator() { + override val kind: MethodModel.Kind + get() = RunTestMethodModel.Kind + + override fun generateBody(method: RunTestMethodModel, p: Printer) { + with(method) { + if (!isWithTargetBackend()) { + p.println("KotlinTestUtils.${method.testRunnerMethodName}(this::$testMethodName, this, testDataFilePath);") + } else { + val className = TargetBackend::class.java.simpleName + val additionalArguments = if (additionalRunnerArguments.isNotEmpty()) + additionalRunnerArguments.joinToString(separator = ", ", prefix = ", ") + else "" + p.println("KotlinTestUtils.$testRunnerMethodName(this::$testMethodName, $className.$targetBackend, testDataFilePath$additionalArguments);") + } + } + } + + override fun generateSignature(method: RunTestMethodModel, p: Printer) { + p.print("private void ${method.name}(String testDataFilePath) throws Exception") + } +} diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/impl/SimpleTestClassModelTestAllFilesPresentMethodGenerator.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/impl/SimpleTestClassModelTestAllFilesPresentMethodGenerator.kt new file mode 100644 index 00000000000..0e9d959920f --- /dev/null +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/impl/SimpleTestClassModelTestAllFilesPresentMethodGenerator.kt @@ -0,0 +1,56 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.generators.tests.generator.generators.impl + +import com.intellij.openapi.util.text.StringUtil +import org.jetbrains.kotlin.generators.tests.generator.MethodModel +import org.jetbrains.kotlin.generators.tests.generator.SimpleTestClassModel +import org.jetbrains.kotlin.generators.tests.generator.generators.MethodGenerator +import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.TargetBackend +import org.jetbrains.kotlin.utils.Printer +import org.jetbrains.kotlin.utils.addToStdlib.runIf + +object SimpleTestClassModelTestAllFilesPresentMethodGenerator : MethodGenerator() { + override val kind: MethodModel.Kind + get() = SimpleTestClassModel.TestAllFilesPresentMethodKind + + override fun generateSignature(method: SimpleTestClassModel.TestAllFilesPresentMethodModel, p: Printer) { + generateDefaultSignature(method, p) + } + + override fun generateBody(method: SimpleTestClassModel.TestAllFilesPresentMethodModel, p: Printer) { + with(method) { + val exclude = StringBuilder() + for (dir in classModel.excludeDirs) { + exclude.append(", \"") + exclude.append(StringUtil.escapeStringCharacters(dir)) + exclude.append("\"") + } + val excludedArgument = runIf(classModel.excludePattern != null) { + String.format("Pattern.compile(\"%s\")", StringUtil.escapeStringCharacters(classModel.excludePattern!!.pattern())) + } + val assertTestsPresentStr = if (classModel.targetBackend === TargetBackend.ANY) { + String.format( + "KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File(\"%s\"), Pattern.compile(\"%s\"), %s, %s%s);", + KotlinTestUtils.getFilePath(classModel.rootFile), + StringUtil.escapeStringCharacters(classModel.filenamePattern.pattern()), + excludedArgument, + classModel.recursive, + exclude + ) + } else { + String.format( + "KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File(\"%s\"), Pattern.compile(\"%s\"), %s, %s.%s, %s%s);", + KotlinTestUtils.getFilePath(classModel.rootFile), + StringUtil.escapeStringCharacters(classModel.filenamePattern.pattern()), + excludedArgument, TargetBackend::class.java.simpleName, classModel.targetBackend.toString(), classModel.recursive, exclude + ) + } + p.println(assertTestsPresentStr) + } + } +} diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/impl/SimpleTestMethodGenerator.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/impl/SimpleTestMethodGenerator.kt new file mode 100644 index 00000000000..f805a88a64b --- /dev/null +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/impl/SimpleTestMethodGenerator.kt @@ -0,0 +1,29 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.generators.tests.generator.generators.impl + +import org.jetbrains.kotlin.generators.tests.generator.MethodModel +import org.jetbrains.kotlin.generators.tests.generator.RunTestMethodModel +import org.jetbrains.kotlin.generators.tests.generator.SimpleTestMethodModel +import org.jetbrains.kotlin.generators.tests.generator.generators.MethodGenerator +import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.utils.Printer + +object SimpleTestMethodGenerator : MethodGenerator() { + override val kind: MethodModel.Kind + get() = SimpleTestMethodModel.Kind + + override fun generateSignature(method: SimpleTestMethodModel, p: Printer) { + generateDefaultSignature(method, p) + } + + override fun generateBody(method: SimpleTestMethodModel, p: Printer) { + with(method) { + val filePath = KotlinTestUtils.getFilePath(file) + if (file.isDirectory) "/" else "" + p.println(RunTestMethodModel.METHOD_NAME, "(\"", filePath, "\");") + } + } +} diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/impl/SingleClassTestModelAllFilesPresentedMethodGenerator.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/impl/SingleClassTestModelAllFilesPresentedMethodGenerator.kt new file mode 100644 index 00000000000..87798da2012 --- /dev/null +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/impl/SingleClassTestModelAllFilesPresentedMethodGenerator.kt @@ -0,0 +1,56 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.generators.tests.generator.generators.impl + +import com.intellij.openapi.util.text.StringUtil +import org.jetbrains.kotlin.generators.tests.generator.MethodModel +import org.jetbrains.kotlin.generators.tests.generator.SingleClassTestModel +import org.jetbrains.kotlin.generators.tests.generator.generators.MethodGenerator +import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.TargetBackend +import org.jetbrains.kotlin.utils.Printer + +object SingleClassTestModelAllFilesPresentedMethodGenerator : MethodGenerator() { + override val kind: MethodModel.Kind + get() = SingleClassTestModel.AllFilesPresentedMethodKind + + override fun generateSignature(method: SingleClassTestModel.TestAllFilesPresentMethodModel, p: Printer) { + generateDefaultSignature(method, p) + } + + override fun generateBody(method: SingleClassTestModel.TestAllFilesPresentMethodModel, p: Printer) { + with(method) { + with(classModel) { + val assertTestsPresentStr: String + val excludedArgument = if (excludePattern != null) { + String.format( + "Pattern.compile(\"%s\")", StringUtil.escapeStringCharacters( + excludePattern.pattern() + ) + ) + } else { + null + } + assertTestsPresentStr = if (targetBackend !== TargetBackend.ANY) { + String.format( + "KotlinTestUtils.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File(\"%s\"), Pattern.compile(\"%s\"), %s, %s.%s);", + KotlinTestUtils.getFilePath(rootFile), StringUtil.escapeStringCharacters(filenamePattern.pattern()), + excludedArgument, TargetBackend::class.java.simpleName, targetBackend.toString() + ) + } else { + String.format( + "KotlinTestUtils.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File(\"%s\"), Pattern.compile(\"%s\"), %s);", + KotlinTestUtils.getFilePath(rootFile), + StringUtil.escapeStringCharacters(filenamePattern.pattern()), + excludedArgument + ) + } + p.println(assertTestsPresentStr) + } + } + + } +} diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/util/CoroutinesTestMethodModel.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/util/CoroutinesTestMethodModel.kt new file mode 100644 index 00000000000..bf0160a2651 --- /dev/null +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/util/CoroutinesTestMethodModel.kt @@ -0,0 +1,37 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.generators.util + +import org.jetbrains.kotlin.generators.tests.generator.MethodModel +import org.jetbrains.kotlin.generators.tests.generator.SimpleTestMethodModel +import org.jetbrains.kotlin.test.TargetBackend +import java.io.File +import java.util.regex.Pattern + +class CoroutinesTestMethodModel( + rootDir: File, + file: File, + filenamePattern: Pattern, + checkFilenameStartsLowerCase: Boolean?, + targetBackend: TargetBackend, + skipIgnored: Boolean, + val isLanguageVersion1_3: Boolean +) : SimpleTestMethodModel( + rootDir, + file, + filenamePattern, + checkFilenameStartsLowerCase, + targetBackend, + skipIgnored +) { + object Kind : MethodModel.Kind() + + override val kind: MethodModel.Kind + get() = Kind + + override val name: String + get() = super.name + if (isLanguageVersion1_3) "_1_3" else "_1_2" +} From c51ea6b142162a3cb59b6e69b8dbf9e026506b8b Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Mon, 9 Nov 2020 11:30:37 +0300 Subject: [PATCH 070/196] [TEST-GEN] Create abstract TestGenerator and move current generator logic to TestGeneratorImpl --- .../tests/generator/TestGenerationDSL.kt | 18 +-- .../generator/generators/MethodGenerator.kt | 4 +- .../generator/generators/TestGenerator.kt | 29 ++++ .../impl/TestGeneratorImpl.kt} | 138 ++++++++++-------- 4 files changed, 114 insertions(+), 75 deletions(-) create mode 100644 generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/TestGenerator.kt rename generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/{TestGenerator.kt => generators/impl/TestGeneratorImpl.kt} (74%) diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/TestGenerationDSL.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/TestGenerationDSL.kt index 1b86ade0fda..9e5fa863078 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/TestGenerationDSL.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/TestGenerationDSL.kt @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.generators.tests.generator import junit.framework.TestCase import org.jetbrains.kotlin.generators.tests.generator.InconsistencyChecker.Companion.hasDryRunArg import org.jetbrains.kotlin.generators.tests.generator.InconsistencyChecker.Companion.inconsistencyChecker +import org.jetbrains.kotlin.generators.tests.generator.generators.TestGenerator import org.jetbrains.kotlin.generators.tests.generator.generators.impl.* import org.jetbrains.kotlin.test.TargetBackend import java.io.File @@ -38,23 +39,16 @@ class TestGroup( annotations: List = emptyList(), init: TestClass.() -> Unit ) { - val testGenerator = TestGenerator( + val generationData = TestGenerator.GenerationData( testsRoot, suiteTestClassName, baseTestClassName, TestClass(annotations).apply(init).testModels, useJunit4, - methodGenerators = listOf( - CoroutinesTestMethodGenerator, - RunTestMethodGenerator, - RunTestMethodWithPackageReplacementGenerator, - SimpleTestClassModelTestAllFilesPresentMethodGenerator, - SimpleTestMethodGenerator, - SingleClassTestModelAllFilesPresentedMethodGenerator - ) ) - if (testGenerator.generateAndSave(dryRun)) { - inconsistencyChecker(dryRun).add(testGenerator.testSourceFilePath) + val (changed, testSourceFilePath) = TestGeneratorImpl.generateAndSave(generationData, dryRun) + if (changed) { + inconsistencyChecker(dryRun).add(testSourceFilePath) } } @@ -69,7 +63,7 @@ class TestGroup( pattern: String = if (extension == null) """^([^\.]+)$""" else "^(.+)\\.$extension\$", excludedPattern: String? = null, testMethod: String = "doTest", - singleClass: Boolean = false, // if true then tests from subdirectories will be flattern to single class + singleClass: Boolean = false, // if true then tests from subdirectories will be flatten to single class testClassName: String? = null, // specific name for generated test class // which backend will be used in test. Specifying value may affect some test with // directives TARGET_BACKEND/DONT_TARGET_EXACT_BACKEND won't be generated diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/MethodGenerator.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/MethodGenerator.kt index 7a3f60da356..7b8bbac5fe0 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/MethodGenerator.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/MethodGenerator.kt @@ -17,6 +17,6 @@ abstract class MethodGenerator { abstract val kind: MethodModel.Kind - abstract fun generateSignature(method: @UnsafeVariance T, p: Printer) - abstract fun generateBody(method: @UnsafeVariance T, p: Printer) + abstract fun generateSignature(method: T, p: Printer) + abstract fun generateBody(method: T, p: Printer) } diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/TestGenerator.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/TestGenerator.kt new file mode 100644 index 00000000000..5c717493a36 --- /dev/null +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/TestGenerator.kt @@ -0,0 +1,29 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.generators.tests.generator.generators + +import org.jetbrains.kotlin.generators.tests.generator.MethodModel +import org.jetbrains.kotlin.generators.tests.generator.TestClassModel + +abstract class TestGenerator( + methodGenerators: List> +) { + protected val methodGenerators: Map> = + methodGenerators.associateBy { it.kind }.withDefault { error("Generator for method with kind $it not found") } + + abstract fun generateAndSave(data: GenerationData, dryRun: Boolean): GenerationResult + + data class GenerationData( + val baseDir: String, + val suiteTestClassFqName: String, + val baseTestClassFqName: String, + val testClassModels: Collection, + val useJunit4: Boolean + ) + + data class GenerationResult(val newFileGenerated: Boolean, val testSourceFilePath: String) +} + diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/TestGenerator.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/impl/TestGeneratorImpl.kt similarity index 74% rename from generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/TestGenerator.kt rename to generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/impl/TestGeneratorImpl.kt index 3f6e770969d..31a25535eb6 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/TestGenerator.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/impl/TestGeneratorImpl.kt @@ -1,11 +1,13 @@ /* - * Copyright 2000-2018 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ -package org.jetbrains.kotlin.generators.tests.generator +package org.jetbrains.kotlin.generators.tests.generator.generators.impl +import org.jetbrains.kotlin.generators.tests.generator.* import org.jetbrains.kotlin.generators.tests.generator.generators.MethodGenerator +import org.jetbrains.kotlin.generators.tests.generator.generators.TestGenerator import org.jetbrains.kotlin.generators.util.GeneratorsFileUtil import org.jetbrains.kotlin.test.JUnit3RunnerWithInners import org.jetbrains.kotlin.test.KotlinTestUtils @@ -18,45 +20,81 @@ import java.io.File import java.io.IOException import java.util.* -class TestGenerator( +private val METHOD_GENERATORS = listOf( + RunTestMethodGenerator, + SimpleTestClassModelTestAllFilesPresentMethodGenerator, + SimpleTestMethodGenerator, + SingleClassTestModelAllFilesPresentedMethodGenerator +) + +object TestGeneratorImpl : TestGenerator(METHOD_GENERATORS) { + override fun generateAndSave(data: GenerationData, dryRun: Boolean): GenerationResult { + val (baseDir, suiteTestClassFqName, baseTestClassFqName, testClassModels, useJunit4) = data + val generatorInstance = TestGeneratorImplInstance( + baseDir, + suiteTestClassFqName, + baseTestClassFqName, + testClassModels, + useJunit4, + methodGenerators + ) + return generatorInstance.generateAndSave(dryRun) + } +} + +private class TestGeneratorImplInstance( baseDir: String, suiteTestClassFqName: String, baseTestClassFqName: String, - testClassModels: Collection, - useJunit4: Boolean, - methodGenerators: List> + private val testClassModels: Collection, + private val useJunit4: Boolean, + private val methodGenerators: Map> ) { - private val methodGenerators: Map> = - methodGenerators.associateBy { it.kind }.withDefault { error("Generator for method with kind $it not found") } + companion object { + private val GENERATED_FILES = HashSet() + private val RUNNER = JUnit3RunnerWithInners::class.java + private val JUNIT4_RUNNER = BlockJUnit4ClassRunner::class.java - private val baseTestClassPackage: String - private val suiteClassPackage: String - private val suiteClassName: String - private val baseTestClassName: String - private val testClassModels: Collection - private val useJunit4: Boolean - internal val testSourceFilePath: String + private fun generateMetadata(p: Printer, testDataSource: TestEntityModel) { + val dataString = testDataSource.dataString + if (dataString != null) { + p.println("@TestMetadata(\"", dataString, "\")") + } + } - init { - this.baseTestClassPackage = baseTestClassFqName.substringBeforeLast('.', "") - this.baseTestClassName = baseTestClassFqName.substringAfterLast('.', baseTestClassFqName) - this.suiteClassPackage = suiteTestClassFqName.substringBeforeLast('.', baseTestClassPackage) - this.suiteClassName = suiteTestClassFqName.substringAfterLast('.', suiteTestClassFqName) - this.testClassModels = ArrayList(testClassModels) - this.useJunit4 = useJunit4 + private fun generateTestDataPath(p: Printer, testClassModel: TestClassModel) { + val dataPathRoot = testClassModel.dataPathRoot + if (dataPathRoot != null) { + p.println("@TestDataPath(\"", dataPathRoot, "\")") + } + } - this.testSourceFilePath = baseDir + "/" + this.suiteClassPackage.replace(".", "/") + "/" + this.suiteClassName + ".java" + private fun generateParameterAnnotations(p: Printer, testClassModel: TestClassModel) { + for (annotationModel in testClassModel.annotations) { + annotationModel.generate(p) + p.println() + } + } - if (!GENERATED_FILES.add(testSourceFilePath)) { - throw IllegalArgumentException("Same test file already generated in current session: " + testSourceFilePath) + private fun generateSuppressAllWarnings(p: Printer) { + p.println("@SuppressWarnings(\"all\")") + } + } + + private val baseTestClassPackage: String = baseTestClassFqName.substringBeforeLast('.', "") + private val baseTestClassName: String = baseTestClassFqName.substringAfterLast('.', baseTestClassFqName) + private val suiteClassPackage: String = suiteTestClassFqName.substringBeforeLast('.', baseTestClassPackage) + private val suiteClassName: String = suiteTestClassFqName.substringAfterLast('.', suiteTestClassFqName) + private val testSourceFilePath: String = baseDir + "/" + this.suiteClassPackage.replace(".", "/") + "/" + this.suiteClassName + ".java" + + init { + if (!GENERATED_FILES.add(testSourceFilePath)) { + throw IllegalArgumentException("Same test file already generated in current session: $testSourceFilePath") } } - /** - * @return true if a new file is generated - */ @Throws(IOException::class) - fun generateAndSave(dryRun: Boolean): Boolean { + fun generateAndSave(dryRun: Boolean): TestGenerator.GenerationResult { val generatedCode = generate() val testSourceFile = File(testSourceFilePath) @@ -65,7 +103,7 @@ class TestGenerator( if (!dryRun) { GeneratorsFileUtil.writeFileIfContentChanged(testSourceFile, generatedCode, false) } - return changed + return TestGenerator.GenerationResult(changed, testSourceFilePath) } private fun generate(): String { @@ -201,47 +239,25 @@ class TestGenerator( val generator = methodGenerators.getValue(methodModel.kind) generateMetadata(p, methodModel) - generator.generateSignature(methodModel, p) + generator.hackyGenerateSignature(methodModel, p) p.printWithNoIndent(" {") p.println() p.pushIndent() - generator.generateBody(methodModel, p) + generator.hackyGenerateBody(methodModel, p) p.popIndent() p.println("}") } - companion object { - private val GENERATED_FILES = HashSet() - private val RUNNER = JUnit3RunnerWithInners::class.java - private val JUNIT4_RUNNER = BlockJUnit4ClassRunner::class.java + private fun MethodGenerator.hackyGenerateBody(method: MethodModel, p: Printer) { + @Suppress("UNCHECKED_CAST") + generateBody(method as T, p) + } - - private fun generateMetadata(p: Printer, testDataSource: TestEntityModel) { - val dataString = testDataSource.dataString - if (dataString != null) { - p.println("@TestMetadata(\"", dataString, "\")") - } - } - - private fun generateTestDataPath(p: Printer, testClassModel: TestClassModel) { - val dataPathRoot = testClassModel.dataPathRoot - if (dataPathRoot != null) { - p.println("@TestDataPath(\"", dataPathRoot, "\")") - } - } - - private fun generateParameterAnnotations(p: Printer, testClassModel: TestClassModel) { - for (annotationModel in testClassModel.annotations) { - annotationModel.generate(p); - p.println() - } - } - - private fun generateSuppressAllWarnings(p: Printer) { - p.println("@SuppressWarnings(\"all\")") - } + private fun MethodGenerator.hackyGenerateSignature(method: MethodModel, p: Printer) { + @Suppress("UNCHECKED_CAST") + generateSignature(method as T, p) } } From 2a73aaba4d279bb42ae4c8d0500ecb1d0bfbd00d Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Mon, 9 Nov 2020 11:45:24 +0300 Subject: [PATCH 071/196] [TEST-GEN] Move all generation data to `TestGroup.TestClass` --- .../tests/generator/TestGenerationDSL.kt | 20 ++++++++++--------- .../generator/generators/TestGenerator.kt | 12 ++--------- .../generators/impl/TestGeneratorImpl.kt | 13 ++++++------ 3 files changed, 19 insertions(+), 26 deletions(-) diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/TestGenerationDSL.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/TestGenerationDSL.kt index 9e5fa863078..9d8b5b5d1a3 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/TestGenerationDSL.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/TestGenerationDSL.kt @@ -39,20 +39,22 @@ class TestGroup( annotations: List = emptyList(), init: TestClass.() -> Unit ) { - val generationData = TestGenerator.GenerationData( - testsRoot, - suiteTestClassName, - baseTestClassName, - TestClass(annotations).apply(init).testModels, - useJunit4, - ) - val (changed, testSourceFilePath) = TestGeneratorImpl.generateAndSave(generationData, dryRun) + val testClass = TestClass(baseTestClassName, suiteTestClassName, useJunit4, annotations).apply(init) + val (changed, testSourceFilePath) = TestGeneratorImpl.generateAndSave(testClass, dryRun) if (changed) { inconsistencyChecker(dryRun).add(testSourceFilePath) } } - inner class TestClass(val annotations: List) { + inner class TestClass( + val baseTestClassName: String, + val suiteTestClassName: String, + val useJunit4: Boolean, + val annotations: List + ) { + val baseDir: String + get() = this@TestGroup.testsRoot + val testModels = ArrayList() fun model( diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/TestGenerator.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/TestGenerator.kt index 5c717493a36..f7f80dc2be6 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/TestGenerator.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/TestGenerator.kt @@ -6,7 +6,7 @@ package org.jetbrains.kotlin.generators.tests.generator.generators import org.jetbrains.kotlin.generators.tests.generator.MethodModel -import org.jetbrains.kotlin.generators.tests.generator.TestClassModel +import org.jetbrains.kotlin.generators.tests.generator.TestGroup abstract class TestGenerator( methodGenerators: List> @@ -14,15 +14,7 @@ abstract class TestGenerator( protected val methodGenerators: Map> = methodGenerators.associateBy { it.kind }.withDefault { error("Generator for method with kind $it not found") } - abstract fun generateAndSave(data: GenerationData, dryRun: Boolean): GenerationResult - - data class GenerationData( - val baseDir: String, - val suiteTestClassFqName: String, - val baseTestClassFqName: String, - val testClassModels: Collection, - val useJunit4: Boolean - ) + abstract fun generateAndSave(testClass: TestGroup.TestClass, dryRun: Boolean): GenerationResult data class GenerationResult(val newFileGenerated: Boolean, val testSourceFilePath: String) } diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/impl/TestGeneratorImpl.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/impl/TestGeneratorImpl.kt index 31a25535eb6..c6f4b94aa46 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/impl/TestGeneratorImpl.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/impl/TestGeneratorImpl.kt @@ -28,14 +28,13 @@ private val METHOD_GENERATORS = listOf( ) object TestGeneratorImpl : TestGenerator(METHOD_GENERATORS) { - override fun generateAndSave(data: GenerationData, dryRun: Boolean): GenerationResult { - val (baseDir, suiteTestClassFqName, baseTestClassFqName, testClassModels, useJunit4) = data + override fun generateAndSave(testClass: TestGroup.TestClass, dryRun: Boolean): GenerationResult { val generatorInstance = TestGeneratorImplInstance( - baseDir, - suiteTestClassFqName, - baseTestClassFqName, - testClassModels, - useJunit4, + testClass.baseDir, + testClass.suiteTestClassName, + testClass.baseTestClassName, + testClass.testModels, + testClass.useJunit4, methodGenerators ) return generatorInstance.generateAndSave(dryRun) From 380e8a3814521bfc76722c9f09bcb217cdbb1dc3 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Mon, 9 Nov 2020 12:10:00 +0300 Subject: [PATCH 072/196] [TEST-GEN] Extract run of TestGenerator to top of test generation DSL --- .../tests/GenerateCompilerTestsAgainstKlib.kt | 4 +- .../generators/tests/GenerateJava8Tests.kt | 4 +- .../spec/utils/tasks/GenerateSpecTests.kt | 4 +- .../generators/tests/GenerateCompilerTests.kt | 4 +- .../tests/GenerateRuntimeDescriptorTests.kt | 4 +- .../tests/generator/TestGenerationDSL.kt | 43 +++++++++++++------ .../kotlin/generators/tests/GenerateTests.kt | 4 +- .../generators/tests/GenerateTests.kt.as41 | 4 +- .../generators/tests/GenerateJsTests.kt | 4 +- .../kotlinp/test/GenerateKotlinpTests.kt | 4 +- 10 files changed, 47 insertions(+), 32 deletions(-) diff --git a/compiler/tests-against-klib/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTestsAgainstKlib.kt b/compiler/tests-against-klib/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTestsAgainstKlib.kt index 0aa0b6811e3..a626b5eeb46 100644 --- a/compiler/tests-against-klib/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTestsAgainstKlib.kt +++ b/compiler/tests-against-klib/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTestsAgainstKlib.kt @@ -6,13 +6,13 @@ package org.jetbrains.kotlin.generators.tests import org.jetbrains.kotlin.codegen.ir.AbstractCompileKotlinAgainstKlibTest -import org.jetbrains.kotlin.generators.tests.generator.testGroupSuite +import org.jetbrains.kotlin.generators.tests.generator.generateTestGroupSuite import org.jetbrains.kotlin.test.TargetBackend fun main(args: Array) { System.setProperty("java.awt.headless", "true") - testGroupSuite(args) { + generateTestGroupSuite(args) { testGroup("compiler/tests-against-klib/tests", "compiler/testData") { testClass { model("codegen/boxKlib", targetBackend = TargetBackend.JVM_IR) diff --git a/compiler/tests-java8/tests/org/jetbrains/kotlin/generators/tests/GenerateJava8Tests.kt b/compiler/tests-java8/tests/org/jetbrains/kotlin/generators/tests/GenerateJava8Tests.kt index 4bcae72e317..6b3ea576df3 100644 --- a/compiler/tests-java8/tests/org/jetbrains/kotlin/generators/tests/GenerateJava8Tests.kt +++ b/compiler/tests-java8/tests/org/jetbrains/kotlin/generators/tests/GenerateJava8Tests.kt @@ -21,7 +21,7 @@ import org.jetbrains.kotlin.checkers.AbstractForeignJava8AnnotationsNoAnnotation import org.jetbrains.kotlin.checkers.AbstractForeignJava8AnnotationsTest import org.jetbrains.kotlin.checkers.AbstractJspecifyAnnotationsTest import org.jetbrains.kotlin.checkers.javac.AbstractJavacForeignJava8AnnotationsTest -import org.jetbrains.kotlin.generators.tests.generator.testGroupSuite +import org.jetbrains.kotlin.generators.tests.generator.generateTestGroupSuite import org.jetbrains.kotlin.jvm.compiler.AbstractLoadJava8Test import org.jetbrains.kotlin.jvm.compiler.AbstractLoadJava8WithPsiClassReadingTest import org.jetbrains.kotlin.jvm.compiler.javac.AbstractLoadJava8UsingJavacTest @@ -30,7 +30,7 @@ import org.jetbrains.kotlin.resolve.calls.AbstractEnhancedSignaturesResolvedCall fun main(args: Array) { System.setProperty("java.awt.headless", "true") - testGroupSuite(args) { + generateTestGroupSuite(args) { testGroup("compiler/tests-java8/tests", "compiler/testData") { testClass { model("foreignAnnotationsJava8/tests", excludeDirs = listOf("jspecify")) diff --git a/compiler/tests-spec/tests/org/jetbrains/kotlin/spec/utils/tasks/GenerateSpecTests.kt b/compiler/tests-spec/tests/org/jetbrains/kotlin/spec/utils/tasks/GenerateSpecTests.kt index 9c00eefb727..911ab6d5df2 100644 --- a/compiler/tests-spec/tests/org/jetbrains/kotlin/spec/utils/tasks/GenerateSpecTests.kt +++ b/compiler/tests-spec/tests/org/jetbrains/kotlin/spec/utils/tasks/GenerateSpecTests.kt @@ -5,7 +5,7 @@ package org.jetbrains.kotlin.spec.utils.tasks -import org.jetbrains.kotlin.generators.tests.generator.testGroupSuite +import org.jetbrains.kotlin.generators.tests.generator.generateTestGroupSuite import org.jetbrains.kotlin.spec.checkers.AbstractDiagnosticsTestSpec import org.jetbrains.kotlin.spec.checkers.AbstractFirDiagnosticsTestSpec import org.jetbrains.kotlin.spec.codegen.AbstractBlackBoxCodegenTestSpec @@ -39,7 +39,7 @@ fun detectDirsWithTestsMapFileOnly(dirName: String): List { fun generateTests() { val excludedFirTestdataPattern = "^(.+)\\.fir\\.kts?\$" - testGroupSuite { + generateTestGroupSuite { testGroup(SPEC_TEST_PATH, SPEC_TESTDATA_PATH) { testClass { model( diff --git a/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt b/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt index 74186a873d9..e5c647abf35 100644 --- a/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt +++ b/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt @@ -30,7 +30,7 @@ import org.jetbrains.kotlin.fir.java.AbstractFirOldFrontendLightClassesTest import org.jetbrains.kotlin.fir.java.AbstractFirTypeEnhancementTest import org.jetbrains.kotlin.fir.java.AbstractOwnFirTypeEnhancementTest import org.jetbrains.kotlin.fir.lightTree.AbstractLightTree2FirConverterTestCase -import org.jetbrains.kotlin.generators.tests.generator.testGroupSuite +import org.jetbrains.kotlin.generators.tests.generator.generateTestGroupSuite import org.jetbrains.kotlin.generators.util.KT_OR_KTS_WITHOUT_DOTS_IN_NAME import org.jetbrains.kotlin.generators.util.KT_WITHOUT_DOTS_IN_NAME import org.jetbrains.kotlin.integration.AbstractAntTaskTest @@ -68,7 +68,7 @@ fun main(args: Array) { val excludedFirTestdataPattern = "^(.+)\\.fir\\.kts?\$" - testGroupSuite(args) { + generateTestGroupSuite(args) { testGroup("compiler/tests-gen", "compiler/testData") { testClass(suiteTestClassName = "DiagnosticsTestGenerated") { model("diagnostics/tests", pattern = "^(.*)\\.kts?$", excludedPattern = excludedFirTestdataPattern) diff --git a/core/descriptors.runtime/tests/org/jetbrains/kotlin/generators/tests/GenerateRuntimeDescriptorTests.kt b/core/descriptors.runtime/tests/org/jetbrains/kotlin/generators/tests/GenerateRuntimeDescriptorTests.kt index 1820496d249..8be52e056a7 100644 --- a/core/descriptors.runtime/tests/org/jetbrains/kotlin/generators/tests/GenerateRuntimeDescriptorTests.kt +++ b/core/descriptors.runtime/tests/org/jetbrains/kotlin/generators/tests/GenerateRuntimeDescriptorTests.kt @@ -16,14 +16,14 @@ package org.jetbrains.kotlin.generators.tests -import org.jetbrains.kotlin.generators.tests.generator.testGroupSuite +import org.jetbrains.kotlin.generators.tests.generator.generateTestGroupSuite import org.jetbrains.kotlin.jvm.runtime.AbstractJvm8RuntimeDescriptorLoaderTest import org.jetbrains.kotlin.jvm.runtime.AbstractJvmRuntimeDescriptorLoaderTest fun main(args: Array) { System.setProperty("java.awt.headless", "true") - testGroupSuite(args) { + generateTestGroupSuite(args) { testGroup("core/descriptors.runtime/tests", "compiler/testData") { testClass { model("loadJava/compiledKotlin") diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/TestGenerationDSL.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/TestGenerationDSL.kt index 9d8b5b5d1a3..2e7c0a75ab6 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/TestGenerationDSL.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/TestGenerationDSL.kt @@ -8,7 +8,6 @@ package org.jetbrains.kotlin.generators.tests.generator import junit.framework.TestCase import org.jetbrains.kotlin.generators.tests.generator.InconsistencyChecker.Companion.hasDryRunArg import org.jetbrains.kotlin.generators.tests.generator.InconsistencyChecker.Companion.inconsistencyChecker -import org.jetbrains.kotlin.generators.tests.generator.generators.TestGenerator import org.jetbrains.kotlin.generators.tests.generator.generators.impl.* import org.jetbrains.kotlin.test.TargetBackend import java.io.File @@ -21,8 +20,11 @@ class TestGroup( val testRunnerMethodName: String, val additionalRunnerArguments: List = emptyList(), val annotations: List = emptyList(), - private val dryRun: Boolean = false ) { + private val _testClasses: MutableList = mutableListOf() + val testClasses: List + get() = _testClasses + inline fun testClass( suiteTestClassName: String = getDefaultSuiteTestClassName(T::class.java.simpleName), useJunit4: Boolean = false, @@ -39,11 +41,7 @@ class TestGroup( annotations: List = emptyList(), init: TestClass.() -> Unit ) { - val testClass = TestClass(baseTestClassName, suiteTestClassName, useJunit4, annotations).apply(init) - val (changed, testSourceFilePath) = TestGeneratorImpl.generateAndSave(testClass, dryRun) - if (changed) { - inconsistencyChecker(dryRun).add(testSourceFilePath) - } + _testClasses += TestClass(baseTestClassName, suiteTestClassName, useJunit4, annotations).apply(init) } inner class TestClass( @@ -99,20 +97,38 @@ class TestGroup( } fun testGroupSuite( + init: TestGroupSuite.() -> Unit +): TestGroupSuite { + return TestGroupSuite().apply(init) +} + +fun generateTestGroupSuite( args: Array, init: TestGroupSuite.() -> Unit ) { - testGroupSuite(hasDryRunArg(args), init) + generateTestGroupSuite(hasDryRunArg(args), init) } -fun testGroupSuite( +fun generateTestGroupSuite( dryRun: Boolean = false, init: TestGroupSuite.() -> Unit ) { - TestGroupSuite(dryRun).init() + val suite = testGroupSuite(init) + for (testGroup in suite.testGroups) { + for (testClass in testGroup.testClasses) { + val (changed, testSourceFilePath) = TestGeneratorImpl.generateAndSave(testClass, dryRun) + if (changed) { + inconsistencyChecker(dryRun).add(testSourceFilePath) + } + } + } } -class TestGroupSuite(private val dryRun: Boolean) { +class TestGroupSuite { + private val _testGroups = mutableListOf() + val testGroups: List + get() = _testGroups + fun testGroup( testsRoot: String, testDataRoot: String, @@ -120,13 +136,12 @@ class TestGroupSuite(private val dryRun: Boolean) { additionalRunnerArguments: List = emptyList(), init: TestGroup.() -> Unit ) { - TestGroup( + _testGroups += TestGroup( testsRoot, testDataRoot, testRunnerMethodName, additionalRunnerArguments, - dryRun = dryRun - ).init() + ).apply(init) } } diff --git a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt index 6546fe93f51..0c357ac10e4 100644 --- a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt +++ b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt @@ -26,7 +26,7 @@ import org.jetbrains.kotlin.formatter.AbstractFormatterTest import org.jetbrains.kotlin.formatter.AbstractTypingIndentationTestBase import org.jetbrains.kotlin.generators.tests.generator.TestGroup import org.jetbrains.kotlin.generators.tests.generator.muteExtraSuffix -import org.jetbrains.kotlin.generators.tests.generator.testGroupSuite +import org.jetbrains.kotlin.generators.tests.generator.generateTestGroupSuite import org.jetbrains.kotlin.generators.util.KT_OR_KTS import org.jetbrains.kotlin.generators.util.KT_OR_KTS_WITHOUT_DOTS_IN_NAME import org.jetbrains.kotlin.generators.util.KT_WITHOUT_DOTS_IN_NAME @@ -195,7 +195,7 @@ import org.jetbrains.kotlinx.serialization.AbstractSerializationPluginDiagnostic fun main(args: Array) { System.setProperty("java.awt.headless", "true") - testGroupSuite(args) { + generateTestGroupSuite(args) { testGroup("idea/jvm-debugger/jvm-debugger-test/test", "idea/jvm-debugger/jvm-debugger-test/testData") { testClass { model( diff --git a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.as41 b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.as41 index 12c50084cc5..a63098ddd2d 100644 --- a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.as41 +++ b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.as41 @@ -31,7 +31,7 @@ import org.jetbrains.kotlin.formatter.AbstractFormatterTest import org.jetbrains.kotlin.formatter.AbstractTypingIndentationTestBase import org.jetbrains.kotlin.generators.tests.generator.TestGroup import org.jetbrains.kotlin.generators.tests.generator.muteExtraSuffix -import org.jetbrains.kotlin.generators.tests.generator.testGroupSuite +import org.jetbrains.kotlin.generators.tests.generator.generateTestGroupSuite import org.jetbrains.kotlin.generators.util.KT_OR_KTS import org.jetbrains.kotlin.generators.util.KT_OR_KTS_WITHOUT_DOTS_IN_NAME import org.jetbrains.kotlin.generators.util.KT_WITHOUT_DOTS_IN_NAME @@ -167,7 +167,7 @@ import org.jetbrains.kotlinx.serialization.AbstractSerializationIrBytecodeListin fun main(args: Array) { System.setProperty("java.awt.headless", "true") - testGroupSuite(args) { + generateTestGroupSuite(args) { testGroup("idea/jvm-debugger/jvm-debugger-test/test", "idea/jvm-debugger/jvm-debugger-test/testData") { testClass { model( diff --git a/js/js.tests/test/org/jetbrains/kotlin/generators/tests/GenerateJsTests.kt b/js/js.tests/test/org/jetbrains/kotlin/generators/tests/GenerateJsTests.kt index e341e544492..31eee6f2f80 100644 --- a/js/js.tests/test/org/jetbrains/kotlin/generators/tests/GenerateJsTests.kt +++ b/js/js.tests/test/org/jetbrains/kotlin/generators/tests/GenerateJsTests.kt @@ -5,7 +5,7 @@ package org.jetbrains.kotlin.generators.tests -import org.jetbrains.kotlin.generators.tests.generator.testGroupSuite +import org.jetbrains.kotlin.generators.tests.generator.generateTestGroupSuite import org.jetbrains.kotlin.js.test.AbstractDceTest import org.jetbrains.kotlin.js.test.AbstractJsLineNumberTest import org.jetbrains.kotlin.js.test.es6.semantics.* @@ -20,7 +20,7 @@ fun main(args: Array) { // TODO: repair these tests //generateTestDataForReservedWords() - testGroupSuite(args) { + generateTestGroupSuite(args) { testGroup("js/js.tests/tests-gen", "js/js.translator/testData", testRunnerMethodName = "runTest0") { testClass { model("box/", pattern = "^([^_](.+))\\.kt$", targetBackend = TargetBackend.JS) diff --git a/libraries/tools/kotlinp/test/org/jetbrains/kotlin/kotlinp/test/GenerateKotlinpTests.kt b/libraries/tools/kotlinp/test/org/jetbrains/kotlin/kotlinp/test/GenerateKotlinpTests.kt index fe977b1279a..d8447c04020 100644 --- a/libraries/tools/kotlinp/test/org/jetbrains/kotlin/kotlinp/test/GenerateKotlinpTests.kt +++ b/libraries/tools/kotlinp/test/org/jetbrains/kotlin/kotlinp/test/GenerateKotlinpTests.kt @@ -5,12 +5,12 @@ package org.jetbrains.kotlin.kotlinp.test -import org.jetbrains.kotlin.generators.tests.generator.testGroupSuite +import org.jetbrains.kotlin.generators.tests.generator.generateTestGroupSuite fun main(args: Array) { System.setProperty("java.awt.headless", "true") - testGroupSuite(args) { + generateTestGroupSuite(args) { testGroup("libraries/tools/kotlinp/test", "libraries/tools/kotlinp/testData") { testClass { model("") From 23c088afd64564b839b3682d0afb8c726c2bfca4 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Tue, 10 Nov 2020 11:58:45 +0300 Subject: [PATCH 073/196] [TEST-GEN] Reorganize package structure in `:generators:test-generator` module --- .../tests/GenerateCompilerTestsAgainstKlib.kt | 2 +- .../generators/tests/GenerateJava8Tests.kt | 2 +- .../spec/utils/tasks/GenerateSpecTests.kt | 2 +- .../generators/tests/GenerateCompilerTests.kt | 6 +- .../tests/GenerateRuntimeDescriptorTests.kt | 2 +- .../kotlin/generators/InconsistencyChecker.kt | 37 +++++ .../generators => }/MethodGenerator.kt | 4 +- .../generator => }/TestGenerationDSL.kt | 141 +++++++----------- .../generators => }/TestGenerator.kt | 5 +- .../impl/RunTestMethodGenerator.kt | 8 +- ...ModelTestAllFilesPresentMethodGenerator.kt | 8 +- .../impl/SimpleTestMethodGenerator.kt | 10 +- ...stModelAllFilesPresentedMethodGenerator.kt | 8 +- .../generators => }/impl/TestGeneratorImpl.kt | 9 +- .../generator => model}/AnnotationModel.kt | 4 +- .../CoroutinesTestMethodModel.kt | 4 +- .../DelegatingTestClassModel.kt | 17 +-- .../generator => model}/RunTestMethodModel.kt | 4 +- .../SimpleTestClassModel.kt | 6 +- .../SimpleTestMethodModel.kt | 7 +- .../SingleClassTestModel.kt | 17 +-- .../{tests/generator => model}/TestModel.kt | 19 +-- .../tests/generator/TestGeneratorUtil.kt | 42 ------ .../generators/util/TestGeneratorUtil.kt | 36 +++++ .../kotlin/generators/util/generatorUtil.kt | 24 --- .../kotlin/generators/tests/GenerateTests.kt | 12 +- .../generators/tests/GenerateTests.kt.as41 | 12 +- .../generators/tests/GenerateTests.kt.as42 | 12 +- .../generators/tests/GenerateJsTests.kt | 2 +- .../kotlinp/test/GenerateKotlinpTests.kt | 2 +- .../kotlin/pill/generateAllTests/Main.java | 2 +- 31 files changed, 203 insertions(+), 263 deletions(-) create mode 100644 generators/test-generator/tests/org/jetbrains/kotlin/generators/InconsistencyChecker.kt rename generators/test-generator/tests/org/jetbrains/kotlin/generators/{tests/generator/generators => }/MethodGenerator.kt (82%) rename generators/test-generator/tests/org/jetbrains/kotlin/generators/{tests/generator => }/TestGenerationDSL.kt (83%) rename generators/test-generator/tests/org/jetbrains/kotlin/generators/{tests/generator/generators => }/TestGenerator.kt (77%) rename generators/test-generator/tests/org/jetbrains/kotlin/generators/{tests/generator/generators => }/impl/RunTestMethodGenerator.kt (82%) rename generators/test-generator/tests/org/jetbrains/kotlin/generators/{tests/generator/generators => }/impl/SimpleTestClassModelTestAllFilesPresentMethodGenerator.kt (89%) rename generators/test-generator/tests/org/jetbrains/kotlin/generators/{tests/generator/generators => }/impl/SimpleTestMethodGenerator.kt (70%) rename generators/test-generator/tests/org/jetbrains/kotlin/generators/{tests/generator/generators => }/impl/SingleClassTestModelAllFilesPresentedMethodGenerator.kt (89%) rename generators/test-generator/tests/org/jetbrains/kotlin/generators/{tests/generator/generators => }/impl/TestGeneratorImpl.kt (96%) rename generators/test-generator/tests/org/jetbrains/kotlin/generators/{tests/generator => model}/AnnotationModel.kt (84%) rename generators/test-generator/tests/org/jetbrains/kotlin/generators/{util => model}/CoroutinesTestMethodModel.kt (82%) rename generators/test-generator/tests/org/jetbrains/kotlin/generators/{tests/generator => model}/DelegatingTestClassModel.kt (50%) rename generators/test-generator/tests/org/jetbrains/kotlin/generators/{tests/generator => model}/RunTestMethodModel.kt (89%) rename generators/test-generator/tests/org/jetbrains/kotlin/generators/{tests/generator => model}/SimpleTestClassModel.kt (96%) rename generators/test-generator/tests/org/jetbrains/kotlin/generators/{tests/generator => model}/SimpleTestMethodModel.kt (90%) rename generators/test-generator/tests/org/jetbrains/kotlin/generators/{tests/generator => model}/SingleClassTestModel.kt (80%) rename generators/test-generator/tests/org/jetbrains/kotlin/generators/{tests/generator => model}/TestModel.kt (57%) delete mode 100644 generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/TestGeneratorUtil.kt create mode 100644 generators/test-generator/tests/org/jetbrains/kotlin/generators/util/TestGeneratorUtil.kt delete mode 100644 generators/test-generator/tests/org/jetbrains/kotlin/generators/util/generatorUtil.kt diff --git a/compiler/tests-against-klib/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTestsAgainstKlib.kt b/compiler/tests-against-klib/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTestsAgainstKlib.kt index a626b5eeb46..72096fe2337 100644 --- a/compiler/tests-against-klib/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTestsAgainstKlib.kt +++ b/compiler/tests-against-klib/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTestsAgainstKlib.kt @@ -6,7 +6,7 @@ package org.jetbrains.kotlin.generators.tests import org.jetbrains.kotlin.codegen.ir.AbstractCompileKotlinAgainstKlibTest -import org.jetbrains.kotlin.generators.tests.generator.generateTestGroupSuite +import org.jetbrains.kotlin.generators.generateTestGroupSuite import org.jetbrains.kotlin.test.TargetBackend fun main(args: Array) { diff --git a/compiler/tests-java8/tests/org/jetbrains/kotlin/generators/tests/GenerateJava8Tests.kt b/compiler/tests-java8/tests/org/jetbrains/kotlin/generators/tests/GenerateJava8Tests.kt index 6b3ea576df3..f7dcd0b338f 100644 --- a/compiler/tests-java8/tests/org/jetbrains/kotlin/generators/tests/GenerateJava8Tests.kt +++ b/compiler/tests-java8/tests/org/jetbrains/kotlin/generators/tests/GenerateJava8Tests.kt @@ -21,7 +21,7 @@ import org.jetbrains.kotlin.checkers.AbstractForeignJava8AnnotationsNoAnnotation import org.jetbrains.kotlin.checkers.AbstractForeignJava8AnnotationsTest import org.jetbrains.kotlin.checkers.AbstractJspecifyAnnotationsTest import org.jetbrains.kotlin.checkers.javac.AbstractJavacForeignJava8AnnotationsTest -import org.jetbrains.kotlin.generators.tests.generator.generateTestGroupSuite +import org.jetbrains.kotlin.generators.generateTestGroupSuite import org.jetbrains.kotlin.jvm.compiler.AbstractLoadJava8Test import org.jetbrains.kotlin.jvm.compiler.AbstractLoadJava8WithPsiClassReadingTest import org.jetbrains.kotlin.jvm.compiler.javac.AbstractLoadJava8UsingJavacTest diff --git a/compiler/tests-spec/tests/org/jetbrains/kotlin/spec/utils/tasks/GenerateSpecTests.kt b/compiler/tests-spec/tests/org/jetbrains/kotlin/spec/utils/tasks/GenerateSpecTests.kt index 911ab6d5df2..9c981538503 100644 --- a/compiler/tests-spec/tests/org/jetbrains/kotlin/spec/utils/tasks/GenerateSpecTests.kt +++ b/compiler/tests-spec/tests/org/jetbrains/kotlin/spec/utils/tasks/GenerateSpecTests.kt @@ -5,7 +5,7 @@ package org.jetbrains.kotlin.spec.utils.tasks -import org.jetbrains.kotlin.generators.tests.generator.generateTestGroupSuite +import org.jetbrains.kotlin.generators.generateTestGroupSuite import org.jetbrains.kotlin.spec.checkers.AbstractDiagnosticsTestSpec import org.jetbrains.kotlin.spec.checkers.AbstractFirDiagnosticsTestSpec import org.jetbrains.kotlin.spec.codegen.AbstractBlackBoxCodegenTestSpec diff --git a/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt b/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt index e5c647abf35..b5b3545ac57 100644 --- a/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt +++ b/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt @@ -30,9 +30,9 @@ import org.jetbrains.kotlin.fir.java.AbstractFirOldFrontendLightClassesTest import org.jetbrains.kotlin.fir.java.AbstractFirTypeEnhancementTest import org.jetbrains.kotlin.fir.java.AbstractOwnFirTypeEnhancementTest import org.jetbrains.kotlin.fir.lightTree.AbstractLightTree2FirConverterTestCase -import org.jetbrains.kotlin.generators.tests.generator.generateTestGroupSuite -import org.jetbrains.kotlin.generators.util.KT_OR_KTS_WITHOUT_DOTS_IN_NAME -import org.jetbrains.kotlin.generators.util.KT_WITHOUT_DOTS_IN_NAME +import org.jetbrains.kotlin.generators.generateTestGroupSuite +import org.jetbrains.kotlin.generators.util.TestGeneratorUtil.KT_OR_KTS_WITHOUT_DOTS_IN_NAME +import org.jetbrains.kotlin.generators.util.TestGeneratorUtil.KT_WITHOUT_DOTS_IN_NAME import org.jetbrains.kotlin.integration.AbstractAntTaskTest import org.jetbrains.kotlin.ir.AbstractIrCfgTestCase import org.jetbrains.kotlin.ir.AbstractIrJsTextTestCase diff --git a/core/descriptors.runtime/tests/org/jetbrains/kotlin/generators/tests/GenerateRuntimeDescriptorTests.kt b/core/descriptors.runtime/tests/org/jetbrains/kotlin/generators/tests/GenerateRuntimeDescriptorTests.kt index 8be52e056a7..2836c757ddf 100644 --- a/core/descriptors.runtime/tests/org/jetbrains/kotlin/generators/tests/GenerateRuntimeDescriptorTests.kt +++ b/core/descriptors.runtime/tests/org/jetbrains/kotlin/generators/tests/GenerateRuntimeDescriptorTests.kt @@ -16,7 +16,7 @@ package org.jetbrains.kotlin.generators.tests -import org.jetbrains.kotlin.generators.tests.generator.generateTestGroupSuite +import org.jetbrains.kotlin.generators.generateTestGroupSuite import org.jetbrains.kotlin.jvm.runtime.AbstractJvm8RuntimeDescriptorLoaderTest import org.jetbrains.kotlin.jvm.runtime.AbstractJvmRuntimeDescriptorLoaderTest diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/InconsistencyChecker.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/InconsistencyChecker.kt new file mode 100644 index 00000000000..4281c4044d5 --- /dev/null +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/InconsistencyChecker.kt @@ -0,0 +1,37 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.generators + +interface InconsistencyChecker { + fun add(affectedFile: String) + + val affectedFiles: List + + companion object { + fun hasDryRunArg(args: Array) = args.any { it == "dryRun" } + + fun inconsistencyChecker(dryRun: Boolean) = if (dryRun) DefaultInconsistencyChecker else EmptyInconsistencyChecker + } +} + +object DefaultInconsistencyChecker : InconsistencyChecker { + private val files = mutableListOf() + + override fun add(affectedFile: String) { + files.add(affectedFile) + } + + override val affectedFiles: List + get() = files +} + +object EmptyInconsistencyChecker : InconsistencyChecker { + override fun add(affectedFile: String) { + } + + override val affectedFiles: List + get() = emptyList() +} diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/MethodGenerator.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/MethodGenerator.kt similarity index 82% rename from generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/MethodGenerator.kt rename to generators/test-generator/tests/org/jetbrains/kotlin/generators/MethodGenerator.kt index 7b8bbac5fe0..6da9a8f7cba 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/MethodGenerator.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/MethodGenerator.kt @@ -3,9 +3,9 @@ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ -package org.jetbrains.kotlin.generators.tests.generator.generators +package org.jetbrains.kotlin.generators -import org.jetbrains.kotlin.generators.tests.generator.MethodModel +import org.jetbrains.kotlin.generators.model.MethodModel import org.jetbrains.kotlin.utils.Printer abstract class MethodGenerator { diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/TestGenerationDSL.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/TestGenerationDSL.kt similarity index 83% rename from generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/TestGenerationDSL.kt rename to generators/test-generator/tests/org/jetbrains/kotlin/generators/TestGenerationDSL.kt index 2e7c0a75ab6..9cb4a090161 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/TestGenerationDSL.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/TestGenerationDSL.kt @@ -1,19 +1,70 @@ /* - * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ -package org.jetbrains.kotlin.generators.tests.generator +package org.jetbrains.kotlin.generators import junit.framework.TestCase -import org.jetbrains.kotlin.generators.tests.generator.InconsistencyChecker.Companion.hasDryRunArg -import org.jetbrains.kotlin.generators.tests.generator.InconsistencyChecker.Companion.inconsistencyChecker -import org.jetbrains.kotlin.generators.tests.generator.generators.impl.* +import org.jetbrains.kotlin.generators.impl.TestGeneratorImpl +import org.jetbrains.kotlin.generators.model.* +import org.jetbrains.kotlin.generators.InconsistencyChecker.Companion.hasDryRunArg +import org.jetbrains.kotlin.generators.InconsistencyChecker.Companion.inconsistencyChecker +import org.jetbrains.kotlin.generators.util.TestGeneratorUtil import org.jetbrains.kotlin.test.TargetBackend import java.io.File import java.util.* import java.util.regex.Pattern +fun testGroupSuite( + init: TestGroupSuite.() -> Unit +): TestGroupSuite { + return TestGroupSuite().apply(init) +} + +fun generateTestGroupSuite( + args: Array, + init: TestGroupSuite.() -> Unit +) { + generateTestGroupSuite(hasDryRunArg(args), init) +} + +fun generateTestGroupSuite( + dryRun: Boolean = false, + init: TestGroupSuite.() -> Unit +) { + val suite = testGroupSuite(init) + for (testGroup in suite.testGroups) { + for (testClass in testGroup.testClasses) { + val (changed, testSourceFilePath) = TestGeneratorImpl.generateAndSave(testClass, dryRun) + if (changed) { + inconsistencyChecker(dryRun).add(testSourceFilePath) + } + } + } +} + +class TestGroupSuite { + private val _testGroups = mutableListOf() + val testGroups: List + get() = _testGroups + + fun testGroup( + testsRoot: String, + testDataRoot: String, + testRunnerMethodName: String = RunTestMethodModel.METHOD_NAME, + additionalRunnerArguments: List = emptyList(), + init: TestGroup.() -> Unit + ) { + _testGroups += TestGroup( + testsRoot, + testDataRoot, + testRunnerMethodName, + additionalRunnerArguments, + ).apply(init) + } +} + class TestGroup( private val testsRoot: String, val testDataRoot: String, @@ -96,86 +147,6 @@ class TestGroup( } } -fun testGroupSuite( - init: TestGroupSuite.() -> Unit -): TestGroupSuite { - return TestGroupSuite().apply(init) -} - -fun generateTestGroupSuite( - args: Array, - init: TestGroupSuite.() -> Unit -) { - generateTestGroupSuite(hasDryRunArg(args), init) -} - -fun generateTestGroupSuite( - dryRun: Boolean = false, - init: TestGroupSuite.() -> Unit -) { - val suite = testGroupSuite(init) - for (testGroup in suite.testGroups) { - for (testClass in testGroup.testClasses) { - val (changed, testSourceFilePath) = TestGeneratorImpl.generateAndSave(testClass, dryRun) - if (changed) { - inconsistencyChecker(dryRun).add(testSourceFilePath) - } - } - } -} - -class TestGroupSuite { - private val _testGroups = mutableListOf() - val testGroups: List - get() = _testGroups - - fun testGroup( - testsRoot: String, - testDataRoot: String, - testRunnerMethodName: String = RunTestMethodModel.METHOD_NAME, - additionalRunnerArguments: List = emptyList(), - init: TestGroup.() -> Unit - ) { - _testGroups += TestGroup( - testsRoot, - testDataRoot, - testRunnerMethodName, - additionalRunnerArguments, - ).apply(init) - } -} - -interface InconsistencyChecker { - fun add(affectedFile: String) - - val affectedFiles: List - - companion object { - fun hasDryRunArg(args: Array) = args.any { it == "dryRun" } - - fun inconsistencyChecker(dryRun: Boolean) = if (dryRun) DefaultInconsistencyChecker else EmptyInconsistencyChecker - } -} - -object DefaultInconsistencyChecker : InconsistencyChecker { - private val files = mutableListOf() - - override fun add(affectedFile: String) { - files.add(affectedFile) - } - - override val affectedFiles: List - get() = files -} - -object EmptyInconsistencyChecker : InconsistencyChecker { - override fun add(affectedFile: String) { - } - - override val affectedFiles: List - get() = emptyList() -} - fun getDefaultSuiteTestClassName(baseTestClassName: String): String { require(baseTestClassName.startsWith("Abstract")) { "Doesn't start with \"Abstract\": $baseTestClassName" } return baseTestClassName.substringAfter("Abstract") + "Generated" diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/TestGenerator.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/TestGenerator.kt similarity index 77% rename from generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/TestGenerator.kt rename to generators/test-generator/tests/org/jetbrains/kotlin/generators/TestGenerator.kt index f7f80dc2be6..f17535d5b98 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/TestGenerator.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/TestGenerator.kt @@ -3,10 +3,9 @@ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ -package org.jetbrains.kotlin.generators.tests.generator.generators +package org.jetbrains.kotlin.generators -import org.jetbrains.kotlin.generators.tests.generator.MethodModel -import org.jetbrains.kotlin.generators.tests.generator.TestGroup +import org.jetbrains.kotlin.generators.model.MethodModel abstract class TestGenerator( methodGenerators: List> diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/impl/RunTestMethodGenerator.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/impl/RunTestMethodGenerator.kt similarity index 82% rename from generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/impl/RunTestMethodGenerator.kt rename to generators/test-generator/tests/org/jetbrains/kotlin/generators/impl/RunTestMethodGenerator.kt index 3398b8e1adf..6dd71d49783 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/impl/RunTestMethodGenerator.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/impl/RunTestMethodGenerator.kt @@ -3,11 +3,11 @@ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ -package org.jetbrains.kotlin.generators.tests.generator.generators.impl +package org.jetbrains.kotlin.generators.impl -import org.jetbrains.kotlin.generators.tests.generator.MethodModel -import org.jetbrains.kotlin.generators.tests.generator.RunTestMethodModel -import org.jetbrains.kotlin.generators.tests.generator.generators.MethodGenerator +import org.jetbrains.kotlin.generators.model.MethodModel +import org.jetbrains.kotlin.generators.MethodGenerator +import org.jetbrains.kotlin.generators.model.RunTestMethodModel import org.jetbrains.kotlin.test.TargetBackend import org.jetbrains.kotlin.utils.Printer diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/impl/SimpleTestClassModelTestAllFilesPresentMethodGenerator.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/impl/SimpleTestClassModelTestAllFilesPresentMethodGenerator.kt similarity index 89% rename from generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/impl/SimpleTestClassModelTestAllFilesPresentMethodGenerator.kt rename to generators/test-generator/tests/org/jetbrains/kotlin/generators/impl/SimpleTestClassModelTestAllFilesPresentMethodGenerator.kt index 0e9d959920f..f5aad1e0d61 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/impl/SimpleTestClassModelTestAllFilesPresentMethodGenerator.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/impl/SimpleTestClassModelTestAllFilesPresentMethodGenerator.kt @@ -3,12 +3,12 @@ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ -package org.jetbrains.kotlin.generators.tests.generator.generators.impl +package org.jetbrains.kotlin.generators.impl import com.intellij.openapi.util.text.StringUtil -import org.jetbrains.kotlin.generators.tests.generator.MethodModel -import org.jetbrains.kotlin.generators.tests.generator.SimpleTestClassModel -import org.jetbrains.kotlin.generators.tests.generator.generators.MethodGenerator +import org.jetbrains.kotlin.generators.model.MethodModel +import org.jetbrains.kotlin.generators.MethodGenerator +import org.jetbrains.kotlin.generators.model.SimpleTestClassModel import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.TargetBackend import org.jetbrains.kotlin.utils.Printer diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/impl/SimpleTestMethodGenerator.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/impl/SimpleTestMethodGenerator.kt similarity index 70% rename from generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/impl/SimpleTestMethodGenerator.kt rename to generators/test-generator/tests/org/jetbrains/kotlin/generators/impl/SimpleTestMethodGenerator.kt index f805a88a64b..bd0cb8b5983 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/impl/SimpleTestMethodGenerator.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/impl/SimpleTestMethodGenerator.kt @@ -3,12 +3,12 @@ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ -package org.jetbrains.kotlin.generators.tests.generator.generators.impl +package org.jetbrains.kotlin.generators.impl -import org.jetbrains.kotlin.generators.tests.generator.MethodModel -import org.jetbrains.kotlin.generators.tests.generator.RunTestMethodModel -import org.jetbrains.kotlin.generators.tests.generator.SimpleTestMethodModel -import org.jetbrains.kotlin.generators.tests.generator.generators.MethodGenerator +import org.jetbrains.kotlin.generators.model.MethodModel +import org.jetbrains.kotlin.generators.MethodGenerator +import org.jetbrains.kotlin.generators.model.RunTestMethodModel +import org.jetbrains.kotlin.generators.model.SimpleTestMethodModel import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.utils.Printer diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/impl/SingleClassTestModelAllFilesPresentedMethodGenerator.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/impl/SingleClassTestModelAllFilesPresentedMethodGenerator.kt similarity index 89% rename from generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/impl/SingleClassTestModelAllFilesPresentedMethodGenerator.kt rename to generators/test-generator/tests/org/jetbrains/kotlin/generators/impl/SingleClassTestModelAllFilesPresentedMethodGenerator.kt index 87798da2012..21fcadf6fbb 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/impl/SingleClassTestModelAllFilesPresentedMethodGenerator.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/impl/SingleClassTestModelAllFilesPresentedMethodGenerator.kt @@ -3,12 +3,12 @@ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ -package org.jetbrains.kotlin.generators.tests.generator.generators.impl +package org.jetbrains.kotlin.generators.impl import com.intellij.openapi.util.text.StringUtil -import org.jetbrains.kotlin.generators.tests.generator.MethodModel -import org.jetbrains.kotlin.generators.tests.generator.SingleClassTestModel -import org.jetbrains.kotlin.generators.tests.generator.generators.MethodGenerator +import org.jetbrains.kotlin.generators.model.MethodModel +import org.jetbrains.kotlin.generators.MethodGenerator +import org.jetbrains.kotlin.generators.model.SingleClassTestModel import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.TargetBackend import org.jetbrains.kotlin.utils.Printer diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/impl/TestGeneratorImpl.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/impl/TestGeneratorImpl.kt similarity index 96% rename from generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/impl/TestGeneratorImpl.kt rename to generators/test-generator/tests/org/jetbrains/kotlin/generators/impl/TestGeneratorImpl.kt index c6f4b94aa46..c2e33314dd9 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/generators/impl/TestGeneratorImpl.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/impl/TestGeneratorImpl.kt @@ -3,11 +3,12 @@ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ -package org.jetbrains.kotlin.generators.tests.generator.generators.impl +package org.jetbrains.kotlin.generators.impl -import org.jetbrains.kotlin.generators.tests.generator.* -import org.jetbrains.kotlin.generators.tests.generator.generators.MethodGenerator -import org.jetbrains.kotlin.generators.tests.generator.generators.TestGenerator +import org.jetbrains.kotlin.generators.MethodGenerator +import org.jetbrains.kotlin.generators.TestGenerator +import org.jetbrains.kotlin.generators.TestGroup +import org.jetbrains.kotlin.generators.model.* import org.jetbrains.kotlin.generators.util.GeneratorsFileUtil import org.jetbrains.kotlin.test.JUnit3RunnerWithInners import org.jetbrains.kotlin.test.KotlinTestUtils diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/AnnotationModel.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/model/AnnotationModel.kt similarity index 84% rename from generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/AnnotationModel.kt rename to generators/test-generator/tests/org/jetbrains/kotlin/generators/model/AnnotationModel.kt index dc0b941152f..79dfe7945b6 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/AnnotationModel.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/model/AnnotationModel.kt @@ -1,9 +1,9 @@ /* - * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ -package org.jetbrains.kotlin.generators.tests.generator +package org.jetbrains.kotlin.generators.model import org.jetbrains.kotlin.test.MuteExtraSuffix import org.jetbrains.kotlin.utils.Printer diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/util/CoroutinesTestMethodModel.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/model/CoroutinesTestMethodModel.kt similarity index 82% rename from generators/test-generator/tests/org/jetbrains/kotlin/generators/util/CoroutinesTestMethodModel.kt rename to generators/test-generator/tests/org/jetbrains/kotlin/generators/model/CoroutinesTestMethodModel.kt index bf0160a2651..0ae612dab1f 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/util/CoroutinesTestMethodModel.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/model/CoroutinesTestMethodModel.kt @@ -3,10 +3,8 @@ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ -package org.jetbrains.kotlin.generators.util +package org.jetbrains.kotlin.generators.model -import org.jetbrains.kotlin.generators.tests.generator.MethodModel -import org.jetbrains.kotlin.generators.tests.generator.SimpleTestMethodModel import org.jetbrains.kotlin.test.TargetBackend import java.io.File import java.util.regex.Pattern diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/DelegatingTestClassModel.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/model/DelegatingTestClassModel.kt similarity index 50% rename from generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/DelegatingTestClassModel.kt rename to generators/test-generator/tests/org/jetbrains/kotlin/generators/model/DelegatingTestClassModel.kt index b1449f0bba8..f3a7f9318da 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/DelegatingTestClassModel.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/model/DelegatingTestClassModel.kt @@ -1,19 +1,8 @@ /* - * Copyright 2010-2015 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. + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ -package org.jetbrains.kotlin.generators.tests.generator +package org.jetbrains.kotlin.generators.model open class DelegatingTestClassModel(private val delegate: TestClassModel) : TestClassModel() { override val name: String diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/RunTestMethodModel.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/model/RunTestMethodModel.kt similarity index 89% rename from generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/RunTestMethodModel.kt rename to generators/test-generator/tests/org/jetbrains/kotlin/generators/model/RunTestMethodModel.kt index f321bb7cb5e..6329901aa2a 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/RunTestMethodModel.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/model/RunTestMethodModel.kt @@ -1,9 +1,9 @@ /* - * Copyright 2010-2018 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ -package org.jetbrains.kotlin.generators.tests.generator +package org.jetbrains.kotlin.generators.model import org.jetbrains.kotlin.test.TargetBackend diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/SimpleTestClassModel.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/model/SimpleTestClassModel.kt similarity index 96% rename from generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/SimpleTestClassModel.kt rename to generators/test-generator/tests/org/jetbrains/kotlin/generators/model/SimpleTestClassModel.kt index e5c5ef79ca4..a8564a70546 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/SimpleTestClassModel.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/model/SimpleTestClassModel.kt @@ -1,11 +1,11 @@ /* - * Copyright 2010-2018 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ -package org.jetbrains.kotlin.generators.tests.generator +package org.jetbrains.kotlin.generators.model import com.intellij.openapi.util.io.FileUtil -import org.jetbrains.kotlin.generators.tests.generator.TestGeneratorUtil.fileNameToJavaIdentifier +import org.jetbrains.kotlin.generators.util.TestGeneratorUtil.fileNameToJavaIdentifier import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.TargetBackend import java.io.File diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/SimpleTestMethodModel.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/model/SimpleTestMethodModel.kt similarity index 90% rename from generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/SimpleTestMethodModel.kt rename to generators/test-generator/tests/org/jetbrains/kotlin/generators/model/SimpleTestMethodModel.kt index 204d91f1cd2..304ce4ac499 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/SimpleTestMethodModel.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/model/SimpleTestMethodModel.kt @@ -1,15 +1,14 @@ /* - * Copyright 2010-2018 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ -package org.jetbrains.kotlin.generators.tests.generator +package org.jetbrains.kotlin.generators.model import com.intellij.openapi.util.io.FileUtil -import org.jetbrains.kotlin.generators.tests.generator.TestGeneratorUtil.escapeForJavaIdentifier +import org.jetbrains.kotlin.generators.util.TestGeneratorUtil.escapeForJavaIdentifier import org.jetbrains.kotlin.test.InTextDirectivesUtils import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.TargetBackend -import org.jetbrains.kotlin.utils.Printer import java.io.File import java.util.regex.Pattern diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/SingleClassTestModel.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/model/SingleClassTestModel.kt similarity index 80% rename from generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/SingleClassTestModel.kt rename to generators/test-generator/tests/org/jetbrains/kotlin/generators/model/SingleClassTestModel.kt index fa1ab0d32f2..abb6e76d6c3 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/SingleClassTestModel.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/model/SingleClassTestModel.kt @@ -1,19 +1,8 @@ /* - * Copyright 2010-2015 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. + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ -package org.jetbrains.kotlin.generators.tests.generator +package org.jetbrains.kotlin.generators.model import com.intellij.openapi.util.io.FileUtil import org.jetbrains.kotlin.test.KotlinTestUtils diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/TestModel.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/model/TestModel.kt similarity index 57% rename from generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/TestModel.kt rename to generators/test-generator/tests/org/jetbrains/kotlin/generators/model/TestModel.kt index 64dcc101889..539002d2041 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/TestModel.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/model/TestModel.kt @@ -1,22 +1,9 @@ /* - * Copyright 2010-2015 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. + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ -package org.jetbrains.kotlin.generators.tests.generator - -import org.jetbrains.kotlin.utils.Printer +package org.jetbrains.kotlin.generators.model interface TestEntityModel { val name: String diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/TestGeneratorUtil.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/TestGeneratorUtil.kt deleted file mode 100644 index 30f02201653..00000000000 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/tests/generator/TestGeneratorUtil.kt +++ /dev/null @@ -1,42 +0,0 @@ -/* - * Copyright 2010-2015 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.generators.tests.generator - -import kotlin.text.capitalize -import org.jetbrains.kotlin.generators.tests.generator.TestGeneratorUtil -import java.io.File -import java.lang.StringBuilder - -object TestGeneratorUtil { - @JvmStatic - fun escapeForJavaIdentifier(fileName: String): String { - // A file name may contain characters (like ".") that can't be a part of method name - val result = StringBuilder() - for (c in fileName) { - if (Character.isJavaIdentifierPart(c)) { - result.append(c) - } else { - result.append("_") - } - } - return result.toString() - } - - @JvmStatic - fun fileNameToJavaIdentifier(file: File): String { - return escapeForJavaIdentifier(file.name).capitalize() - } -} diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/util/TestGeneratorUtil.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/util/TestGeneratorUtil.kt new file mode 100644 index 00000000000..2766a4b4235 --- /dev/null +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/util/TestGeneratorUtil.kt @@ -0,0 +1,36 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ +package org.jetbrains.kotlin.generators.util + +import org.intellij.lang.annotations.Language +import kotlin.text.capitalize +import java.io.File +import java.lang.StringBuilder + +object TestGeneratorUtil { + @Language("RegExp") const val KT_OR_KTS = """^(.+)\.(kt|kts)$""" + @Language("RegExp") const val KT_OR_KTS_WITHOUT_DOTS_IN_NAME = """^([^.]+)\.(kt|kts)$""" + + @Language("RegExp") const val KT_WITHOUT_DOTS_IN_NAME = """^([^.]+)\.kt$""" + + @JvmStatic + fun escapeForJavaIdentifier(fileName: String): String { + // A file name may contain characters (like ".") that can't be a part of method name + val result = StringBuilder() + for (c in fileName) { + if (Character.isJavaIdentifierPart(c)) { + result.append(c) + } else { + result.append("_") + } + } + return result.toString() + } + + @JvmStatic + fun fileNameToJavaIdentifier(file: File): String { + return escapeForJavaIdentifier(file.name).capitalize() + } +} diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/util/generatorUtil.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/util/generatorUtil.kt deleted file mode 100644 index f63c8311e58..00000000000 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/util/generatorUtil.kt +++ /dev/null @@ -1,24 +0,0 @@ -/* - * Copyright 2010-2017 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.generators.util - -import org.intellij.lang.annotations.Language - -@Language("RegExp") const val KT_OR_KTS = """^(.+)\.(kt|kts)$""" -@Language("RegExp") const val KT_OR_KTS_WITHOUT_DOTS_IN_NAME = """^([^.]+)\.(kt|kts)$""" - -@Language("RegExp") const val KT_WITHOUT_DOTS_IN_NAME = """^([^.]+)\.kt$""" diff --git a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt index 0c357ac10e4..066125041f5 100644 --- a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt +++ b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt @@ -24,12 +24,12 @@ import org.jetbrains.kotlin.findUsages.* import org.jetbrains.kotlin.fir.plugin.AbstractFirAllOpenDiagnosticTest import org.jetbrains.kotlin.formatter.AbstractFormatterTest import org.jetbrains.kotlin.formatter.AbstractTypingIndentationTestBase -import org.jetbrains.kotlin.generators.tests.generator.TestGroup -import org.jetbrains.kotlin.generators.tests.generator.muteExtraSuffix -import org.jetbrains.kotlin.generators.tests.generator.generateTestGroupSuite -import org.jetbrains.kotlin.generators.util.KT_OR_KTS -import org.jetbrains.kotlin.generators.util.KT_OR_KTS_WITHOUT_DOTS_IN_NAME -import org.jetbrains.kotlin.generators.util.KT_WITHOUT_DOTS_IN_NAME +import org.jetbrains.kotlin.generators.TestGroup +import org.jetbrains.kotlin.generators.generateTestGroupSuite +import org.jetbrains.kotlin.generators.model.muteExtraSuffix +import org.jetbrains.kotlin.generators.util.TestGeneratorUtil.KT_OR_KTS +import org.jetbrains.kotlin.generators.util.TestGeneratorUtil.KT_OR_KTS_WITHOUT_DOTS_IN_NAME +import org.jetbrains.kotlin.generators.util.TestGeneratorUtil.KT_WITHOUT_DOTS_IN_NAME import org.jetbrains.kotlin.idea.AbstractExpressionSelectionTest import org.jetbrains.kotlin.idea.AbstractSmartSelectionTest import org.jetbrains.kotlin.idea.actions.AbstractGotoTestOrCodeActionTest diff --git a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.as41 b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.as41 index a63098ddd2d..bf16f61fa92 100644 --- a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.as41 +++ b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.as41 @@ -29,12 +29,12 @@ import org.jetbrains.kotlin.findUsages.AbstractFindUsagesTest import org.jetbrains.kotlin.findUsages.AbstractKotlinFindUsagesWithLibraryTest import org.jetbrains.kotlin.formatter.AbstractFormatterTest import org.jetbrains.kotlin.formatter.AbstractTypingIndentationTestBase -import org.jetbrains.kotlin.generators.tests.generator.TestGroup -import org.jetbrains.kotlin.generators.tests.generator.muteExtraSuffix -import org.jetbrains.kotlin.generators.tests.generator.generateTestGroupSuite -import org.jetbrains.kotlin.generators.util.KT_OR_KTS -import org.jetbrains.kotlin.generators.util.KT_OR_KTS_WITHOUT_DOTS_IN_NAME -import org.jetbrains.kotlin.generators.util.KT_WITHOUT_DOTS_IN_NAME +import org.jetbrains.kotlin.generators.TestGroup +import org.jetbrains.kotlin.generators.generateTestGroupSuite +import org.jetbrains.kotlin.generators.model.muteExtraSuffix +import org.jetbrains.kotlin.generators.util.TestGeneratorUtil.KT_OR_KTS +import org.jetbrains.kotlin.generators.util.TestGeneratorUtil.KT_OR_KTS_WITHOUT_DOTS_IN_NAME +import org.jetbrains.kotlin.generators.util.TestGeneratorUtil.KT_WITHOUT_DOTS_IN_NAME import org.jetbrains.kotlin.idea.AbstractExpressionSelectionTest import org.jetbrains.kotlin.idea.index.AbstractKotlinTypeAliasByExpansionShortNameIndexTest import org.jetbrains.kotlin.idea.AbstractSmartSelectionTest diff --git a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.as42 b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.as42 index d4d273fb092..03b01f09375 100644 --- a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.as42 +++ b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.as42 @@ -29,12 +29,12 @@ import org.jetbrains.kotlin.findUsages.AbstractFindUsagesTest import org.jetbrains.kotlin.findUsages.AbstractKotlinFindUsagesWithLibraryTest import org.jetbrains.kotlin.formatter.AbstractFormatterTest import org.jetbrains.kotlin.formatter.AbstractTypingIndentationTestBase -import org.jetbrains.kotlin.generators.tests.generator.TestGroup -import org.jetbrains.kotlin.generators.tests.generator.muteExtraSuffix -import org.jetbrains.kotlin.generators.tests.generator.testGroup -import org.jetbrains.kotlin.generators.util.KT_OR_KTS -import org.jetbrains.kotlin.generators.util.KT_OR_KTS_WITHOUT_DOTS_IN_NAME -import org.jetbrains.kotlin.generators.util.KT_WITHOUT_DOTS_IN_NAME +import org.jetbrains.kotlin.generators.TestGroup +import org.jetbrains.kotlin.generators.generateTestGroupSuite +import org.jetbrains.kotlin.generators.model.muteExtraSuffix +import org.jetbrains.kotlin.generators.util.TestGeneratorUtil.KT_OR_KTS +import org.jetbrains.kotlin.generators.util.TestGeneratorUtil.KT_OR_KTS_WITHOUT_DOTS_IN_NAME +import org.jetbrains.kotlin.generators.util.TestGeneratorUtil.KT_WITHOUT_DOTS_IN_NAME import org.jetbrains.kotlin.idea.AbstractExpressionSelectionTest import org.jetbrains.kotlin.idea.index.AbstractKotlinTypeAliasByExpansionShortNameIndexTest import org.jetbrains.kotlin.idea.AbstractSmartSelectionTest diff --git a/js/js.tests/test/org/jetbrains/kotlin/generators/tests/GenerateJsTests.kt b/js/js.tests/test/org/jetbrains/kotlin/generators/tests/GenerateJsTests.kt index 31eee6f2f80..c87be5fad87 100644 --- a/js/js.tests/test/org/jetbrains/kotlin/generators/tests/GenerateJsTests.kt +++ b/js/js.tests/test/org/jetbrains/kotlin/generators/tests/GenerateJsTests.kt @@ -5,7 +5,7 @@ package org.jetbrains.kotlin.generators.tests -import org.jetbrains.kotlin.generators.tests.generator.generateTestGroupSuite +import org.jetbrains.kotlin.generators.generateTestGroupSuite import org.jetbrains.kotlin.js.test.AbstractDceTest import org.jetbrains.kotlin.js.test.AbstractJsLineNumberTest import org.jetbrains.kotlin.js.test.es6.semantics.* diff --git a/libraries/tools/kotlinp/test/org/jetbrains/kotlin/kotlinp/test/GenerateKotlinpTests.kt b/libraries/tools/kotlinp/test/org/jetbrains/kotlin/kotlinp/test/GenerateKotlinpTests.kt index d8447c04020..4246f620da1 100644 --- a/libraries/tools/kotlinp/test/org/jetbrains/kotlin/kotlinp/test/GenerateKotlinpTests.kt +++ b/libraries/tools/kotlinp/test/org/jetbrains/kotlin/kotlinp/test/GenerateKotlinpTests.kt @@ -5,7 +5,7 @@ package org.jetbrains.kotlin.kotlinp.test -import org.jetbrains.kotlin.generators.tests.generator.generateTestGroupSuite +import org.jetbrains.kotlin.generators.generateTestGroupSuite fun main(args: Array) { System.setProperty("java.awt.headless", "true") diff --git a/plugins/pill/generate-all-tests/test/org/jetbrains/kotlin/pill/generateAllTests/Main.java b/plugins/pill/generate-all-tests/test/org/jetbrains/kotlin/pill/generateAllTests/Main.java index 0d3b5a1b9ce..d714adf624e 100644 --- a/plugins/pill/generate-all-tests/test/org/jetbrains/kotlin/pill/generateAllTests/Main.java +++ b/plugins/pill/generate-all-tests/test/org/jetbrains/kotlin/pill/generateAllTests/Main.java @@ -6,7 +6,7 @@ package org.jetbrains.kotlin.pill.generateAllTests; import org.jetbrains.kotlin.generators.tests.*; -import org.jetbrains.kotlin.generators.tests.generator.InconsistencyChecker; +import org.jetbrains.kotlin.generators.InconsistencyChecker; import java.util.List; From 4ad9f486420620e322f19edfb5932d5df63fe164 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Tue, 3 Nov 2020 12:31:23 +0300 Subject: [PATCH 074/196] [CMI] Cleanup code of CodeMetaInfo --- .../codeMetaInfo/AbstractCodeMetaInfoTest.kt | 2 +- .../idea/codeMetaInfo/models/CodeMetaInfo.kt | 29 ++++++++++++------- ...AbstractCodeMetaInfoRenderConfiguration.kt | 6 ++-- 3 files changed, 23 insertions(+), 14 deletions(-) diff --git a/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/AbstractCodeMetaInfoTest.kt b/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/AbstractCodeMetaInfoTest.kt index b7f5bf28cd6..32de9fc1d22 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/AbstractCodeMetaInfoTest.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/AbstractCodeMetaInfoTest.kt @@ -67,7 +67,7 @@ class CodeMetaInfoTestCase( ): List { val tempSourceKtFile = PsiManager.getInstance(project).findFile(file.virtualFile) as KtFile val resolutionFacade = tempSourceKtFile.getResolutionFacade() - val (bindingContext, moduleDescriptor) = resolutionFacade.analyzeWithAllCompilerChecks(listOf(tempSourceKtFile)) + val (bindingContext, moduleDescriptor, _) = resolutionFacade.analyzeWithAllCompilerChecks(listOf(tempSourceKtFile)) val directives = KotlinTestUtils.parseDirectives(file.text) val diagnosticsFilter = BaseDiagnosticsTest.parseDiagnosticFilterDirective(directives, allowUnderscoreUsage = false) val diagnostics = CheckerTestUtil.getDiagnosticsIncludingSyntaxErrors( diff --git a/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/models/CodeMetaInfo.kt b/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/models/CodeMetaInfo.kt index 8e483721a5a..81e670030e7 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/models/CodeMetaInfo.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/models/CodeMetaInfo.kt @@ -29,18 +29,18 @@ interface CodeMetaInfo { class DiagnosticCodeMetaInfo( override val start: Int, override val end: Int, - override val renderConfiguration: AbstractCodeMetaInfoRenderConfiguration, + override val renderConfiguration: DiagnosticCodeMetaInfoRenderConfiguration, val diagnostic: Diagnostic ) : CodeMetaInfo { override val platforms: MutableList = mutableListOf() - override fun asString() = renderConfiguration.asString(this) + override fun asString(): String = renderConfiguration.asString(this) - override fun getTag() = (renderConfiguration as DiagnosticCodeMetaInfoRenderConfiguration).getTag(this) + override fun getTag(): String = renderConfiguration.getTag(this) } class LineMarkerCodeMetaInfo( - override val renderConfiguration: AbstractCodeMetaInfoRenderConfiguration, + override val renderConfiguration: LineMarkerRenderConfiguration, val lineMarker: LineMarkerInfo<*> ) : CodeMetaInfo { override val start: Int @@ -49,13 +49,13 @@ class LineMarkerCodeMetaInfo( get() = lineMarker.endOffset override val platforms: MutableList = mutableListOf() - override fun asString() = renderConfiguration.asString(this) + override fun asString(): String = renderConfiguration.asString(this) - override fun getTag() = (renderConfiguration as LineMarkerRenderConfiguration).getTag() + override fun getTag(): String = renderConfiguration.getTag() } class HighlightingCodeMetaInfo( - override val renderConfiguration: AbstractCodeMetaInfoRenderConfiguration, + override val renderConfiguration: HighlightingRenderConfiguration, val highlightingInfo: HighlightInfo ) : CodeMetaInfo { override val start: Int @@ -64,9 +64,9 @@ class HighlightingCodeMetaInfo( get() = highlightingInfo.endOffset override val platforms: MutableList = mutableListOf() - override fun asString() = renderConfiguration.asString(this) + override fun asString(): String = renderConfiguration.asString(this) - override fun getTag() = (renderConfiguration as HighlightingRenderConfiguration).getTag() + override fun getTag(): String = renderConfiguration.getTag() } class ParsedCodeMetaInfo( @@ -77,14 +77,21 @@ class ParsedCodeMetaInfo( ) : CodeMetaInfo { override val renderConfiguration = object : AbstractCodeMetaInfoRenderConfiguration(false) {} - override fun asString() = renderConfiguration.asString(this) + override fun asString(): String = renderConfiguration.asString(this) + + override fun getTag(): String = tag override fun equals(other: Any?): Boolean { if (other == null || other !is CodeMetaInfo) return false return this.tag == other.getTag() && this.start == other.start && this.end == other.end } - override fun getTag() = tag + override fun hashCode(): Int { + var result = start + result = 31 * result + end + result = 31 * result + tag.hashCode() + return result + } } fun createCodeMetaInfo(obj: Any, renderConfiguration: AbstractCodeMetaInfoRenderConfiguration): List { diff --git a/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/renderConfigurations/AbstractCodeMetaInfoRenderConfiguration.kt b/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/renderConfigurations/AbstractCodeMetaInfoRenderConfiguration.kt index 4500557b0e0..f0b135a2a1b 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/renderConfigurations/AbstractCodeMetaInfoRenderConfiguration.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/renderConfigurations/AbstractCodeMetaInfoRenderConfiguration.kt @@ -17,7 +17,7 @@ import org.jetbrains.kotlin.idea.codeMetaInfo.models.LineMarkerCodeMetaInfo abstract class AbstractCodeMetaInfoRenderConfiguration(var renderParams: Boolean = true) { - private val clickOrPressRegex = "Click or press (.*)to navigate".toRegex() //We have different hotkeys on different platforms + private val clickOrPressRegex = "Click or press (.*)to navigate".toRegex() // We have different hotkeys on different platforms open fun asString(codeMetaInfo: CodeMetaInfo) = codeMetaInfo.getTag() + getPlatformsString(codeMetaInfo) open fun getAdditionalParams(codeMetaInfo: CodeMetaInfo) = "" @@ -62,6 +62,8 @@ open class DiagnosticCodeMetaInfoRenderConfiguration( private fun getParamsString(codeMetaInfo: DiagnosticCodeMetaInfo): String { if (!renderParams) return "" val params = mutableListOf() + + @Suppress("UNCHECKED_CAST") val renderer = when (codeMetaInfo.diagnostic.factory) { is DebugInfoDiagnosticFactory1 -> DiagnosticWithParameters1Renderer( "{0}", @@ -137,4 +139,4 @@ open class HighlightingRenderConfiguration( return if (paramsString.isEmpty()) "" else "(\"$paramsString\")" } -} \ No newline at end of file +} From 25c011ca40b13b3763beacd342a6677ed341ad3f Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Tue, 3 Nov 2020 12:55:44 +0300 Subject: [PATCH 075/196] [CMI] Extract core of CodeMetaInfo to :compiler:tests-common --- .../codeMetaInfo/CodeMetaInfoParser.kt | 28 ++-- .../codeMetaInfo/CodeMetaInfoRenderer.kt | 6 +- .../kotlin/codeMetaInfo/model/CodeMetaInfo.kt | 18 +++ .../model/DiagnosticCodeMetaInfo.kt | 22 +++ .../codeMetaInfo/model/ParsedCodeMetaInfo.kt | 33 ++++ ...AbstractCodeMetaInfoRenderConfiguration.kt | 38 +++++ ...agnosticCodeMetaInfoRenderConfiguration.kt | 56 +++++++ .../codeMetaInfo/AbstractCodeMetaInfoTest.kt | 15 +- .../idea/codeMetaInfo/models/CodeMetaInfo.kt | 125 --------------- .../models/CodeMetaInfoFactory.kt | 49 ++++++ .../models/HighlightingCodeMetaInfo.kt | 25 +++ .../models/LineMarkerCodeMetaInfo.kt | 25 +++ ...AbstractCodeMetaInfoRenderConfiguration.kt | 142 ------------------ .../HighlightingRenderConfiguration.kt | 41 +++++ .../LineMarkerRenderConfiguration.kt | 32 ++++ 15 files changed, 364 insertions(+), 291 deletions(-) rename {idea/tests/org/jetbrains/kotlin/idea => compiler/tests-common/tests/org/jetbrains/kotlin}/codeMetaInfo/CodeMetaInfoParser.kt (72%) rename {idea/tests/org/jetbrains/kotlin/idea => compiler/tests-common/tests/org/jetbrains/kotlin}/codeMetaInfo/CodeMetaInfoRenderer.kt (94%) create mode 100644 compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/CodeMetaInfo.kt create mode 100644 compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/DiagnosticCodeMetaInfo.kt create mode 100644 compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/ParsedCodeMetaInfo.kt create mode 100644 compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/renderConfigurations/AbstractCodeMetaInfoRenderConfiguration.kt create mode 100644 compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/renderConfigurations/DiagnosticCodeMetaInfoRenderConfiguration.kt delete mode 100644 idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/models/CodeMetaInfo.kt create mode 100644 idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/models/CodeMetaInfoFactory.kt create mode 100644 idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/models/HighlightingCodeMetaInfo.kt create mode 100644 idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/models/LineMarkerCodeMetaInfo.kt delete mode 100644 idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/renderConfigurations/AbstractCodeMetaInfoRenderConfiguration.kt create mode 100644 idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/renderConfigurations/HighlightingRenderConfiguration.kt create mode 100644 idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/renderConfigurations/LineMarkerRenderConfiguration.kt diff --git a/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/CodeMetaInfoParser.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoParser.kt similarity index 72% rename from idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/CodeMetaInfoParser.kt rename to compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoParser.kt index 0888b5b084e..45d44a5d788 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/CodeMetaInfoParser.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoParser.kt @@ -3,11 +3,9 @@ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ -package org.jetbrains.kotlin.idea.codeMetaInfo +package org.jetbrains.kotlin.codeMetaInfo -import com.intellij.util.containers.Stack -import org.jetbrains.kotlin.idea.codeMetaInfo.models.ParsedCodeMetaInfo -import org.junit.Assert +import org.jetbrains.kotlin.codeMetaInfo.model.ParsedCodeMetaInfo object CodeMetaInfoParser { private val openingRegex = "(]+?)!>)".toRegex() @@ -18,8 +16,8 @@ object CodeMetaInfoParser { fun getCodeMetaInfoFromText(renderedText: String): List { var text = renderedText - val openingMatchResults = Stack() - val closingMatchResults = Stack() + val openingMatchResults = ArrayDeque() + val closingMatchResults = ArrayDeque() val result = mutableListOf() while (true) { @@ -35,19 +33,21 @@ object CodeMetaInfoParser { closingStartOffset = closing.range.first text = if (openingStartOffset < closingStartOffset) { - openingMatchResults.push(opening) - text.removeRange(openingStartOffset, opening!!.range.last + 1) + requireNotNull(opening) + openingMatchResults.addLast(opening) + text.removeRange(openingStartOffset, opening.range.last + 1) } else { - closingMatchResults.push(closing) - text.removeRange(closingStartOffset, closing!!.range.last + 1) + requireNotNull(closing) + closingMatchResults.addLast(closing) + text.removeRange(closingStartOffset, closing.range.last + 1) } } if (openingMatchResults.size != closingMatchResults.size) { - Assert.fail("Opening and closing tags counts are not equals") + error("Opening and closing tags counts are not equals") } while (!openingMatchResults.isEmpty()) { - val openingMatchResult = openingMatchResults.pop() - val closingMatchResult = closingMatchResults.pop() + val openingMatchResult = openingMatchResults.removeLast() + val closingMatchResult = closingMatchResults.removeLast() val metaInfoWithoutParams = openingMatchResult.groups[2]!!.value.replace(descriptionRegex, "") metaInfoWithoutParams.split(",").forEach { val tag = platformRegex.replace(it, "").trim() @@ -62,4 +62,4 @@ object CodeMetaInfoParser { } return result } -} \ No newline at end of file +} diff --git a/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/CodeMetaInfoRenderer.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoRenderer.kt similarity index 94% rename from idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/CodeMetaInfoRenderer.kt rename to compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoRenderer.kt index a1f6da6e64f..20684f1b177 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/CodeMetaInfoRenderer.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoRenderer.kt @@ -3,11 +3,11 @@ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ -package org.jetbrains.kotlin.idea.codeMetaInfo +package org.jetbrains.kotlin.codeMetaInfo import com.intellij.util.containers.Stack import org.jetbrains.kotlin.checkers.utils.CheckerTestUtil -import org.jetbrains.kotlin.idea.codeMetaInfo.models.CodeMetaInfo +import org.jetbrains.kotlin.codeMetaInfo.model.CodeMetaInfo import java.io.File object CodeMetaInfoRenderer { @@ -77,4 +77,4 @@ fun clearFileFromDiagnosticMarkup(file: File) { file.writeText(cleanText) } -fun clearTextFromDiagnosticMarkup(text: String): String = CheckerTestUtil.rangeStartOrEndPattern.matcher(text).replaceAll("") \ No newline at end of file +fun clearTextFromDiagnosticMarkup(text: String): String = CheckerTestUtil.rangeStartOrEndPattern.matcher(text).replaceAll("") diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/CodeMetaInfo.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/CodeMetaInfo.kt new file mode 100644 index 00000000000..a50d791152e --- /dev/null +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/CodeMetaInfo.kt @@ -0,0 +1,18 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.codeMetaInfo.model + +import org.jetbrains.kotlin.codeMetaInfo.renderConfigurations.AbstractCodeMetaInfoRenderConfiguration + +interface CodeMetaInfo { + val start: Int + val end: Int + val renderConfiguration: AbstractCodeMetaInfoRenderConfiguration + val platforms: MutableList + + fun asString(): String + fun getTag(): String +} diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/DiagnosticCodeMetaInfo.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/DiagnosticCodeMetaInfo.kt new file mode 100644 index 00000000000..2a262659015 --- /dev/null +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/DiagnosticCodeMetaInfo.kt @@ -0,0 +1,22 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.codeMetaInfo.model + +import org.jetbrains.kotlin.codeMetaInfo.renderConfigurations.DiagnosticCodeMetaInfoRenderConfiguration +import org.jetbrains.kotlin.diagnostics.Diagnostic + +class DiagnosticCodeMetaInfo( + override val start: Int, + override val end: Int, + override val renderConfiguration: DiagnosticCodeMetaInfoRenderConfiguration, + val diagnostic: Diagnostic +) : CodeMetaInfo { + override val platforms: MutableList = mutableListOf() + + override fun asString(): String = renderConfiguration.asString(this) + + override fun getTag(): String = renderConfiguration.getTag(this) +} diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/ParsedCodeMetaInfo.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/ParsedCodeMetaInfo.kt new file mode 100644 index 00000000000..d90342af2bd --- /dev/null +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/ParsedCodeMetaInfo.kt @@ -0,0 +1,33 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.codeMetaInfo.model + +import org.jetbrains.kotlin.codeMetaInfo.renderConfigurations.AbstractCodeMetaInfoRenderConfiguration + +class ParsedCodeMetaInfo( + override val start: Int, + override val end: Int, + override val platforms: MutableList, + private val tag: String +) : CodeMetaInfo { + override val renderConfiguration = object : AbstractCodeMetaInfoRenderConfiguration(false) {} + + override fun asString(): String = renderConfiguration.asString(this) + + override fun getTag(): String = tag + + override fun equals(other: Any?): Boolean { + if (other == null || other !is CodeMetaInfo) return false + return this.tag == other.getTag() && this.start == other.start && this.end == other.end + } + + override fun hashCode(): Int { + var result = start + result = 31 * result + end + result = 31 * result + tag.hashCode() + return result + } +} diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/renderConfigurations/AbstractCodeMetaInfoRenderConfiguration.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/renderConfigurations/AbstractCodeMetaInfoRenderConfiguration.kt new file mode 100644 index 00000000000..e76f705402f --- /dev/null +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/renderConfigurations/AbstractCodeMetaInfoRenderConfiguration.kt @@ -0,0 +1,38 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.codeMetaInfo.renderConfigurations + +import com.intellij.openapi.util.text.StringUtil +import org.jetbrains.kotlin.codeMetaInfo.model.CodeMetaInfo + +abstract class AbstractCodeMetaInfoRenderConfiguration(var renderParams: Boolean = true) { + private val clickOrPressRegex = "Click or press (.*)to navigate".toRegex() // We have different hotkeys on different platforms + open fun asString(codeMetaInfo: CodeMetaInfo) = codeMetaInfo.getTag() + getPlatformsString(codeMetaInfo) + + open fun getAdditionalParams(codeMetaInfo: CodeMetaInfo) = "" + + protected fun sanitizeLineMarkerTooltip(originalText: String?): String { + if (originalText == null) return "null" + val noHtmlTags = StringUtil.removeHtmlTags(originalText) + .replace(" ", "") + .replace(clickOrPressRegex, "") + .trim() + return sanitizeLineBreaks(noHtmlTags) + } + + protected fun sanitizeLineBreaks(originalText: String): String { + var sanitizedText = originalText + sanitizedText = StringUtil.replace(sanitizedText, "\r\n", " ") + sanitizedText = StringUtil.replace(sanitizedText, "\n", " ") + sanitizedText = StringUtil.replace(sanitizedText, "\r", " ") + return sanitizedText + } + + protected fun getPlatformsString(codeMetaInfo: CodeMetaInfo): String { + if (codeMetaInfo.platforms.isEmpty()) return "" + return "{${codeMetaInfo.platforms.joinToString(";")}}" + } +} diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/renderConfigurations/DiagnosticCodeMetaInfoRenderConfiguration.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/renderConfigurations/DiagnosticCodeMetaInfoRenderConfiguration.kt new file mode 100644 index 00000000000..6357a18f5cd --- /dev/null +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/renderConfigurations/DiagnosticCodeMetaInfoRenderConfiguration.kt @@ -0,0 +1,56 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.codeMetaInfo.renderConfigurations + +import com.intellij.util.containers.ContainerUtil +import org.jetbrains.kotlin.checkers.diagnostics.factories.DebugInfoDiagnosticFactory1 +import org.jetbrains.kotlin.codeMetaInfo.model.CodeMetaInfo +import org.jetbrains.kotlin.codeMetaInfo.model.DiagnosticCodeMetaInfo +import org.jetbrains.kotlin.diagnostics.Diagnostic +import org.jetbrains.kotlin.diagnostics.rendering.* + +open class DiagnosticCodeMetaInfoRenderConfiguration( + val withNewInference: Boolean = true, + val renderSeverity: Boolean = false +) : AbstractCodeMetaInfoRenderConfiguration() { + private val crossPlatformLineBreak = """\r?\n""".toRegex() + + override fun asString(codeMetaInfo: CodeMetaInfo): String { + if (codeMetaInfo !is DiagnosticCodeMetaInfo) return "" + return (getTag(codeMetaInfo) + + getPlatformsString(codeMetaInfo) + + getParamsString(codeMetaInfo)) + .replace(crossPlatformLineBreak, "") + } + + private fun getParamsString(codeMetaInfo: DiagnosticCodeMetaInfo): String { + if (!renderParams) return "" + val params = mutableListOf() + + @Suppress("UNCHECKED_CAST") + val renderer = when (codeMetaInfo.diagnostic.factory) { + is DebugInfoDiagnosticFactory1 -> DiagnosticWithParameters1Renderer( + "{0}", + Renderers.TO_STRING + ) as DiagnosticRenderer + else -> DefaultErrorMessages.getRendererForDiagnostic(codeMetaInfo.diagnostic) + } + if (renderer is AbstractDiagnosticWithParametersRenderer) { + val renderParameters = renderer.renderParameters(codeMetaInfo.diagnostic) + params.addAll(ContainerUtil.map(renderParameters) { it.toString() }) + } + if (renderSeverity) + params.add("severity='${codeMetaInfo.diagnostic.severity}'") + + params.add(getAdditionalParams(codeMetaInfo)) + + return "(\"${params.filter { it.isNotEmpty() }.joinToString("; ")}\")" + } + + fun getTag(codeMetaInfo: DiagnosticCodeMetaInfo): String { + return codeMetaInfo.diagnostic.factory.name + } +} diff --git a/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/AbstractCodeMetaInfoTest.kt b/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/AbstractCodeMetaInfoTest.kt index 32de9fc1d22..17ce19618b9 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/AbstractCodeMetaInfoTest.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/AbstractCodeMetaInfoTest.kt @@ -34,14 +34,18 @@ import org.jetbrains.kotlin.checkers.diagnostics.SyntaxErrorDiagnostic import org.jetbrains.kotlin.checkers.diagnostics.factories.DebugInfoDiagnosticFactory0 import org.jetbrains.kotlin.checkers.utils.CheckerTestUtil import org.jetbrains.kotlin.checkers.utils.DiagnosticsRenderingConfiguration +import org.jetbrains.kotlin.codeMetaInfo.CodeMetaInfoParser +import org.jetbrains.kotlin.codeMetaInfo.CodeMetaInfoRenderer +import org.jetbrains.kotlin.codeMetaInfo.model.CodeMetaInfo +import org.jetbrains.kotlin.codeMetaInfo.model.DiagnosticCodeMetaInfo +import org.jetbrains.kotlin.codeMetaInfo.renderConfigurations.AbstractCodeMetaInfoRenderConfiguration +import org.jetbrains.kotlin.codeMetaInfo.renderConfigurations.DiagnosticCodeMetaInfoRenderConfiguration import org.jetbrains.kotlin.daemon.common.OSKind import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl import org.jetbrains.kotlin.diagnostics.AbstractDiagnostic import org.jetbrains.kotlin.diagnostics.Severity import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade import org.jetbrains.kotlin.idea.codeMetaInfo.models.* -import org.jetbrains.kotlin.idea.codeMetaInfo.renderConfigurations.AbstractCodeMetaInfoRenderConfiguration -import org.jetbrains.kotlin.idea.codeMetaInfo.renderConfigurations.DiagnosticCodeMetaInfoRenderConfiguration import org.jetbrains.kotlin.idea.codeMetaInfo.renderConfigurations.HighlightingRenderConfiguration import org.jetbrains.kotlin.idea.codeMetaInfo.renderConfigurations.LineMarkerRenderConfiguration import org.jetbrains.kotlin.idea.multiplatform.setupMppProjectFromTextFile @@ -193,17 +197,14 @@ class CodeMetaInfoTestCase( assert( diagnostics.any { diagnosticCodeMetaInfo -> diagnosticCodeMetaInfo.start == highlightingCodeMetaInfo.start && - when (diagnosticCodeMetaInfo.diagnostic) { + when (val diagnostic = diagnosticCodeMetaInfo.diagnostic) { is SyntaxErrorDiagnostic -> { - val diagnostic: SyntaxErrorDiagnostic = diagnosticCodeMetaInfo.diagnostic (highlightingCodeMetaInfo as HighlightingCodeMetaInfo).highlightingInfo.description in (diagnostic.psiElement as PsiErrorElementImpl).errorDescription } is AbstractDiagnostic<*> -> { - val diagnostic: AbstractDiagnostic<*> = diagnosticCodeMetaInfo.diagnostic diagnostic.factory.toString() in (highlightingCodeMetaInfo as HighlightingCodeMetaInfo).highlightingInfo.description } is DebugInfoDiagnostic -> { - val diagnostic: DebugInfoDiagnostic = diagnosticCodeMetaInfo.diagnostic diagnostic.factory == DebugInfoDiagnosticFactory0.MISSING_UNRESOLVED && "[DEBUG] Reference is not resolved to anything, but is not marked unresolved" in (highlightingCodeMetaInfo as HighlightingCodeMetaInfo).highlightingInfo.description } @@ -279,4 +280,4 @@ abstract class AbstractCodeMetaInfoTest : AbstractMultiModuleTest() { } return testSourcePath.toFile() } -} \ No newline at end of file +} diff --git a/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/models/CodeMetaInfo.kt b/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/models/CodeMetaInfo.kt deleted file mode 100644 index 81e670030e7..00000000000 --- a/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/models/CodeMetaInfo.kt +++ /dev/null @@ -1,125 +0,0 @@ -/* - * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. - * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. - */ - -package org.jetbrains.kotlin.idea.codeMetaInfo.models - -import com.intellij.codeInsight.daemon.LineMarkerInfo -import com.intellij.codeInsight.daemon.impl.HighlightInfo -import org.jetbrains.kotlin.checkers.diagnostics.ActualDiagnostic -import org.jetbrains.kotlin.diagnostics.Diagnostic -import org.jetbrains.kotlin.idea.codeMetaInfo.renderConfigurations.AbstractCodeMetaInfoRenderConfiguration -import org.jetbrains.kotlin.idea.codeMetaInfo.renderConfigurations.DiagnosticCodeMetaInfoRenderConfiguration -import org.jetbrains.kotlin.idea.codeMetaInfo.renderConfigurations.HighlightingRenderConfiguration -import org.jetbrains.kotlin.idea.codeMetaInfo.renderConfigurations.LineMarkerRenderConfiguration -import org.jetbrains.kotlin.idea.editor.fixers.end -import org.jetbrains.kotlin.idea.editor.fixers.start - -interface CodeMetaInfo { - val start: Int - val end: Int - val renderConfiguration: AbstractCodeMetaInfoRenderConfiguration - val platforms: MutableList - - fun asString(): String - fun getTag(): String -} - -class DiagnosticCodeMetaInfo( - override val start: Int, - override val end: Int, - override val renderConfiguration: DiagnosticCodeMetaInfoRenderConfiguration, - val diagnostic: Diagnostic -) : CodeMetaInfo { - override val platforms: MutableList = mutableListOf() - - override fun asString(): String = renderConfiguration.asString(this) - - override fun getTag(): String = renderConfiguration.getTag(this) -} - -class LineMarkerCodeMetaInfo( - override val renderConfiguration: LineMarkerRenderConfiguration, - val lineMarker: LineMarkerInfo<*> -) : CodeMetaInfo { - override val start: Int - get() = lineMarker.startOffset - override val end: Int - get() = lineMarker.endOffset - override val platforms: MutableList = mutableListOf() - - override fun asString(): String = renderConfiguration.asString(this) - - override fun getTag(): String = renderConfiguration.getTag() -} - -class HighlightingCodeMetaInfo( - override val renderConfiguration: HighlightingRenderConfiguration, - val highlightingInfo: HighlightInfo -) : CodeMetaInfo { - override val start: Int - get() = highlightingInfo.startOffset - override val end: Int - get() = highlightingInfo.endOffset - override val platforms: MutableList = mutableListOf() - - override fun asString(): String = renderConfiguration.asString(this) - - override fun getTag(): String = renderConfiguration.getTag() -} - -class ParsedCodeMetaInfo( - override val start: Int, - override val end: Int, - override val platforms: MutableList, - private val tag: String -) : CodeMetaInfo { - override val renderConfiguration = object : AbstractCodeMetaInfoRenderConfiguration(false) {} - - override fun asString(): String = renderConfiguration.asString(this) - - override fun getTag(): String = tag - - override fun equals(other: Any?): Boolean { - if (other == null || other !is CodeMetaInfo) return false - return this.tag == other.getTag() && this.start == other.start && this.end == other.end - } - - override fun hashCode(): Int { - var result = start - result = 31 * result + end - result = 31 * result + tag.hashCode() - return result - } -} - -fun createCodeMetaInfo(obj: Any, renderConfiguration: AbstractCodeMetaInfoRenderConfiguration): List { - fun errorMessage() = "Unexpected render configuration for object $obj" - return when (obj) { - is Diagnostic -> { - require(renderConfiguration is DiagnosticCodeMetaInfoRenderConfiguration, ::errorMessage) - obj.textRanges.map { DiagnosticCodeMetaInfo(it.start, it.end, renderConfiguration, obj) } - } - is ActualDiagnostic -> { - require(renderConfiguration is DiagnosticCodeMetaInfoRenderConfiguration, ::errorMessage) - obj.diagnostic.textRanges.map { DiagnosticCodeMetaInfo(it.start, it.end, renderConfiguration, obj.diagnostic) } - } - is HighlightInfo -> { - require(renderConfiguration is HighlightingRenderConfiguration, ::errorMessage) - listOf(HighlightingCodeMetaInfo(renderConfiguration, obj)) - } - is LineMarkerInfo<*> -> { - require(renderConfiguration is LineMarkerRenderConfiguration, ::errorMessage) - listOf(LineMarkerCodeMetaInfo(renderConfiguration, obj)) - } - else -> throw IllegalArgumentException("Unknown type for creating CodeMetaInfo object $obj") - } -} - -fun getCodeMetaInfo( - objects: List, - renderConfiguration: AbstractCodeMetaInfoRenderConfiguration -): List { - return objects.flatMap { createCodeMetaInfo(it, renderConfiguration) } -} diff --git a/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/models/CodeMetaInfoFactory.kt b/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/models/CodeMetaInfoFactory.kt new file mode 100644 index 00000000000..aabf7375acf --- /dev/null +++ b/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/models/CodeMetaInfoFactory.kt @@ -0,0 +1,49 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.idea.codeMetaInfo.models + +import com.intellij.codeInsight.daemon.LineMarkerInfo +import com.intellij.codeInsight.daemon.impl.HighlightInfo +import org.jetbrains.kotlin.checkers.diagnostics.ActualDiagnostic +import org.jetbrains.kotlin.codeMetaInfo.model.CodeMetaInfo +import org.jetbrains.kotlin.codeMetaInfo.model.DiagnosticCodeMetaInfo +import org.jetbrains.kotlin.codeMetaInfo.renderConfigurations.AbstractCodeMetaInfoRenderConfiguration +import org.jetbrains.kotlin.codeMetaInfo.renderConfigurations.DiagnosticCodeMetaInfoRenderConfiguration +import org.jetbrains.kotlin.diagnostics.Diagnostic +import org.jetbrains.kotlin.idea.codeMetaInfo.renderConfigurations.HighlightingRenderConfiguration +import org.jetbrains.kotlin.idea.codeMetaInfo.renderConfigurations.LineMarkerRenderConfiguration +import org.jetbrains.kotlin.idea.editor.fixers.end +import org.jetbrains.kotlin.idea.editor.fixers.start + +fun createCodeMetaInfo(obj: Any, renderConfiguration: AbstractCodeMetaInfoRenderConfiguration): List { + fun errorMessage() = "Unexpected render configuration for object $obj" + return when (obj) { + is Diagnostic -> { + require(renderConfiguration is DiagnosticCodeMetaInfoRenderConfiguration, ::errorMessage) + obj.textRanges.map { DiagnosticCodeMetaInfo(it.start, it.end, renderConfiguration, obj) } + } + is ActualDiagnostic -> { + require(renderConfiguration is DiagnosticCodeMetaInfoRenderConfiguration, ::errorMessage) + obj.diagnostic.textRanges.map { DiagnosticCodeMetaInfo(it.start, it.end, renderConfiguration, obj.diagnostic) } + } + is HighlightInfo -> { + require(renderConfiguration is HighlightingRenderConfiguration, ::errorMessage) + listOf(HighlightingCodeMetaInfo(renderConfiguration, obj)) + } + is LineMarkerInfo<*> -> { + require(renderConfiguration is LineMarkerRenderConfiguration, ::errorMessage) + listOf(LineMarkerCodeMetaInfo(renderConfiguration, obj)) + } + else -> throw IllegalArgumentException("Unknown type for creating CodeMetaInfo object $obj") + } +} + +fun getCodeMetaInfo( + objects: List, + renderConfiguration: AbstractCodeMetaInfoRenderConfiguration +): List { + return objects.flatMap { createCodeMetaInfo(it, renderConfiguration) } +} diff --git a/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/models/HighlightingCodeMetaInfo.kt b/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/models/HighlightingCodeMetaInfo.kt new file mode 100644 index 00000000000..8c6b456b257 --- /dev/null +++ b/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/models/HighlightingCodeMetaInfo.kt @@ -0,0 +1,25 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.idea.codeMetaInfo.models + +import com.intellij.codeInsight.daemon.impl.HighlightInfo +import org.jetbrains.kotlin.codeMetaInfo.model.CodeMetaInfo +import org.jetbrains.kotlin.idea.codeMetaInfo.renderConfigurations.HighlightingRenderConfiguration + +class HighlightingCodeMetaInfo( + override val renderConfiguration: HighlightingRenderConfiguration, + val highlightingInfo: HighlightInfo +) : CodeMetaInfo { + override val start: Int + get() = highlightingInfo.startOffset + override val end: Int + get() = highlightingInfo.endOffset + override val platforms: MutableList = mutableListOf() + + override fun asString(): String = renderConfiguration.asString(this) + + override fun getTag(): String = renderConfiguration.getTag() +} diff --git a/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/models/LineMarkerCodeMetaInfo.kt b/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/models/LineMarkerCodeMetaInfo.kt new file mode 100644 index 00000000000..4ae09ef6735 --- /dev/null +++ b/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/models/LineMarkerCodeMetaInfo.kt @@ -0,0 +1,25 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.idea.codeMetaInfo.models + +import com.intellij.codeInsight.daemon.LineMarkerInfo +import org.jetbrains.kotlin.codeMetaInfo.model.CodeMetaInfo +import org.jetbrains.kotlin.idea.codeMetaInfo.renderConfigurations.LineMarkerRenderConfiguration + +class LineMarkerCodeMetaInfo( + override val renderConfiguration: LineMarkerRenderConfiguration, + val lineMarker: LineMarkerInfo<*> +) : CodeMetaInfo { + override val start: Int + get() = lineMarker.startOffset + override val end: Int + get() = lineMarker.endOffset + override val platforms: MutableList = mutableListOf() + + override fun asString(): String = renderConfiguration.asString(this) + + override fun getTag(): String = renderConfiguration.getTag() +} diff --git a/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/renderConfigurations/AbstractCodeMetaInfoRenderConfiguration.kt b/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/renderConfigurations/AbstractCodeMetaInfoRenderConfiguration.kt deleted file mode 100644 index f0b135a2a1b..00000000000 --- a/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/renderConfigurations/AbstractCodeMetaInfoRenderConfiguration.kt +++ /dev/null @@ -1,142 +0,0 @@ -/* - * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. - * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. - */ - -package org.jetbrains.kotlin.idea.codeMetaInfo.renderConfigurations - -import com.intellij.openapi.util.text.StringUtil -import com.intellij.util.containers.ContainerUtil -import org.jetbrains.kotlin.checkers.diagnostics.factories.DebugInfoDiagnosticFactory1 -import org.jetbrains.kotlin.diagnostics.Diagnostic -import org.jetbrains.kotlin.diagnostics.rendering.* -import org.jetbrains.kotlin.idea.codeMetaInfo.models.DiagnosticCodeMetaInfo -import org.jetbrains.kotlin.idea.codeMetaInfo.models.HighlightingCodeMetaInfo -import org.jetbrains.kotlin.idea.codeMetaInfo.models.CodeMetaInfo -import org.jetbrains.kotlin.idea.codeMetaInfo.models.LineMarkerCodeMetaInfo - - -abstract class AbstractCodeMetaInfoRenderConfiguration(var renderParams: Boolean = true) { - private val clickOrPressRegex = "Click or press (.*)to navigate".toRegex() // We have different hotkeys on different platforms - open fun asString(codeMetaInfo: CodeMetaInfo) = codeMetaInfo.getTag() + getPlatformsString(codeMetaInfo) - - open fun getAdditionalParams(codeMetaInfo: CodeMetaInfo) = "" - - protected fun sanitizeLineMarkerTooltip(originalText: String?): String { - if (originalText == null) return "null" - val noHtmlTags = StringUtil.removeHtmlTags(originalText) - .replace(" ", "") - .replace(clickOrPressRegex, "") - .trim() - return sanitizeLineBreaks(noHtmlTags) - } - - protected fun sanitizeLineBreaks(originalText: String): String { - var sanitizedText = originalText - sanitizedText = StringUtil.replace(sanitizedText, "\r\n", " ") - sanitizedText = StringUtil.replace(sanitizedText, "\n", " ") - sanitizedText = StringUtil.replace(sanitizedText, "\r", " ") - return sanitizedText - } - - protected fun getPlatformsString(codeMetaInfo: CodeMetaInfo): String { - if (codeMetaInfo.platforms.isEmpty()) return "" - return "{${codeMetaInfo.platforms.joinToString(";")}}" - } -} - -open class DiagnosticCodeMetaInfoRenderConfiguration( - val withNewInference: Boolean = true, - val renderSeverity: Boolean = false -) : AbstractCodeMetaInfoRenderConfiguration() { - private val crossPlatformLineBreak = """\r?\n""".toRegex() - - override fun asString(codeMetaInfo: CodeMetaInfo): String { - if (codeMetaInfo !is DiagnosticCodeMetaInfo) return "" - return (getTag(codeMetaInfo) - + getPlatformsString(codeMetaInfo) - + getParamsString(codeMetaInfo)) - .replace(crossPlatformLineBreak, "") - } - - private fun getParamsString(codeMetaInfo: DiagnosticCodeMetaInfo): String { - if (!renderParams) return "" - val params = mutableListOf() - - @Suppress("UNCHECKED_CAST") - val renderer = when (codeMetaInfo.diagnostic.factory) { - is DebugInfoDiagnosticFactory1 -> DiagnosticWithParameters1Renderer( - "{0}", - Renderers.TO_STRING - ) as DiagnosticRenderer - else -> DefaultErrorMessages.getRendererForDiagnostic(codeMetaInfo.diagnostic) - } - if (renderer is AbstractDiagnosticWithParametersRenderer) { - val renderParameters = renderer.renderParameters(codeMetaInfo.diagnostic) - params.addAll(ContainerUtil.map(renderParameters) { it.toString() }) - } - if (renderSeverity) - params.add("severity='${codeMetaInfo.diagnostic.severity}'") - - params.add(getAdditionalParams(codeMetaInfo)) - - return "(\"${params.filter { it.isNotEmpty() }.joinToString("; ")}\")" - } - - fun getTag(codeMetaInfo: DiagnosticCodeMetaInfo): String { - return codeMetaInfo.diagnostic.factory.name!! - } -} - -open class LineMarkerRenderConfiguration(var renderDescription: Boolean = true) : AbstractCodeMetaInfoRenderConfiguration() { - override fun asString(codeMetaInfo: CodeMetaInfo): String { - if (codeMetaInfo !is LineMarkerCodeMetaInfo) return "" - return getTag() + getParamsString(codeMetaInfo) - } - - fun getTag() = "LINE_MARKER" - - private fun getParamsString(lineMarkerCodeMetaInfo: LineMarkerCodeMetaInfo): String { - if (!renderParams) return "" - val params = mutableListOf() - - if (renderDescription) - params.add("descr='${sanitizeLineMarkerTooltip(lineMarkerCodeMetaInfo.lineMarker.lineMarkerTooltip)}'") - - params.add(getAdditionalParams(lineMarkerCodeMetaInfo)) - - val paramsString = params.filter { it.isNotEmpty() }.joinToString("; ") - return if (paramsString.isEmpty()) "" else "(\"$paramsString\")" - } -} - -open class HighlightingRenderConfiguration( - val renderDescription: Boolean = true, - val renderTextAttributesKey: Boolean = true, - val renderSeverity: Boolean = true -) : AbstractCodeMetaInfoRenderConfiguration() { - - override fun asString(codeMetaInfo: CodeMetaInfo): String { - if (codeMetaInfo !is HighlightingCodeMetaInfo) return "" - return getTag() + getParamsString(codeMetaInfo) - } - - fun getTag() = "HIGHLIGHTING" - - private fun getParamsString(highlightingCodeMetaInfo: HighlightingCodeMetaInfo): String { - if (!renderParams) return "" - - val params = mutableListOf() - if (renderSeverity) - params.add("severity='${highlightingCodeMetaInfo.highlightingInfo.severity}'") - if (renderDescription) - params.add("descr='${sanitizeLineBreaks(highlightingCodeMetaInfo.highlightingInfo.description)}'") - if (renderTextAttributesKey) - params.add("textAttributesKey='${highlightingCodeMetaInfo.highlightingInfo.forcedTextAttributesKey}'") - - params.add(getAdditionalParams(highlightingCodeMetaInfo)) - val paramsString = params.filter { it.isNotEmpty() }.joinToString("; ") - - return if (paramsString.isEmpty()) "" else "(\"$paramsString\")" - } -} diff --git a/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/renderConfigurations/HighlightingRenderConfiguration.kt b/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/renderConfigurations/HighlightingRenderConfiguration.kt new file mode 100644 index 00000000000..f3f15bc0e0a --- /dev/null +++ b/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/renderConfigurations/HighlightingRenderConfiguration.kt @@ -0,0 +1,41 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.idea.codeMetaInfo.renderConfigurations + +import org.jetbrains.kotlin.codeMetaInfo.model.CodeMetaInfo +import org.jetbrains.kotlin.codeMetaInfo.renderConfigurations.AbstractCodeMetaInfoRenderConfiguration +import org.jetbrains.kotlin.idea.codeMetaInfo.models.HighlightingCodeMetaInfo + +open class HighlightingRenderConfiguration( + val renderDescription: Boolean = true, + val renderTextAttributesKey: Boolean = true, + val renderSeverity: Boolean = true +) : AbstractCodeMetaInfoRenderConfiguration() { + + override fun asString(codeMetaInfo: CodeMetaInfo): String { + if (codeMetaInfo !is HighlightingCodeMetaInfo) return "" + return getTag() + getParamsString(codeMetaInfo) + } + + fun getTag() = "HIGHLIGHTING" + + private fun getParamsString(highlightingCodeMetaInfo: HighlightingCodeMetaInfo): String { + if (!renderParams) return "" + + val params = mutableListOf() + if (renderSeverity) + params.add("severity='${highlightingCodeMetaInfo.highlightingInfo.severity}'") + if (renderDescription) + params.add("descr='${sanitizeLineBreaks(highlightingCodeMetaInfo.highlightingInfo.description)}'") + if (renderTextAttributesKey) + params.add("textAttributesKey='${highlightingCodeMetaInfo.highlightingInfo.forcedTextAttributesKey}'") + + params.add(getAdditionalParams(highlightingCodeMetaInfo)) + val paramsString = params.filter { it.isNotEmpty() }.joinToString("; ") + + return if (paramsString.isEmpty()) "" else "(\"$paramsString\")" + } +} diff --git a/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/renderConfigurations/LineMarkerRenderConfiguration.kt b/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/renderConfigurations/LineMarkerRenderConfiguration.kt new file mode 100644 index 00000000000..4c5d5fec618 --- /dev/null +++ b/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/renderConfigurations/LineMarkerRenderConfiguration.kt @@ -0,0 +1,32 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.idea.codeMetaInfo.renderConfigurations + +import org.jetbrains.kotlin.codeMetaInfo.model.CodeMetaInfo +import org.jetbrains.kotlin.codeMetaInfo.renderConfigurations.AbstractCodeMetaInfoRenderConfiguration +import org.jetbrains.kotlin.idea.codeMetaInfo.models.LineMarkerCodeMetaInfo + +open class LineMarkerRenderConfiguration(var renderDescription: Boolean = true) : AbstractCodeMetaInfoRenderConfiguration() { + override fun asString(codeMetaInfo: CodeMetaInfo): String { + if (codeMetaInfo !is LineMarkerCodeMetaInfo) return "" + return getTag() + getParamsString(codeMetaInfo) + } + + fun getTag() = "LINE_MARKER" + + private fun getParamsString(lineMarkerCodeMetaInfo: LineMarkerCodeMetaInfo): String { + if (!renderParams) return "" + val params = mutableListOf() + + if (renderDescription) + params.add("descr='${sanitizeLineMarkerTooltip(lineMarkerCodeMetaInfo.lineMarker.lineMarkerTooltip)}'") + + params.add(getAdditionalParams(lineMarkerCodeMetaInfo)) + + val paramsString = params.filter { it.isNotEmpty() }.joinToString("; ") + return if (paramsString.isEmpty()) "" else "(\"$paramsString\")" + } +} From 2bbab3170feb39e4f33be828639b7c93ed4f1cce Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Tue, 3 Nov 2020 14:28:09 +0300 Subject: [PATCH 076/196] [CMI] Replace StringBuffer with StringBuilder in CodeMetaInfoRenderer --- .../codeMetaInfo/CodeMetaInfoRenderer.kt | 45 +++++++++++-------- 1 file changed, 27 insertions(+), 18 deletions(-) diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoRenderer.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoRenderer.kt index 20684f1b177..dd41af597ab 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoRenderer.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoRenderer.kt @@ -9,59 +9,68 @@ import com.intellij.util.containers.Stack import org.jetbrains.kotlin.checkers.utils.CheckerTestUtil import org.jetbrains.kotlin.codeMetaInfo.model.CodeMetaInfo import java.io.File +import java.lang.StringBuilder object CodeMetaInfoRenderer { fun renderTagsToText( codeMetaInfos: List, originalText: String - ): StringBuffer { - val result = StringBuffer() + ): StringBuilder { + return StringBuilder().apply { + renderTagsToText(this, codeMetaInfos, originalText) + } + } + + fun renderTagsToText( + builder: StringBuilder, + codeMetaInfos: List, + originalText: String + ) { if (codeMetaInfos.isEmpty()) { - result.append(originalText) - return result + builder.append(originalText) + return } val sortedMetaInfos = getSortedCodeMetaInfos(codeMetaInfos) val opened = Stack() for ((i, c) in originalText.withIndex()) { - checkOpenedAndCloseStringIfNeeded(opened, i, result) + checkOpenedAndCloseStringIfNeeded(opened, i, builder) val matchedCodeMetaInfos = sortedMetaInfos.filter { it.start == i } if (matchedCodeMetaInfos.isNotEmpty()) { - openStartTag(result) + openStartTag(builder) val iterator = matchedCodeMetaInfos.listIterator() var current: CodeMetaInfo? = iterator.next() while (current != null) { val next: CodeMetaInfo? = if (iterator.hasNext()) iterator.next() else null opened.push(current) - result.append(current.asString()) + builder.append(current.asString()) when { next == null -> - closeStartTag(result) + closeStartTag(builder) next.end == current.end -> - result.append(", ") + builder.append(", ") else -> - closeStartAndOpenNewTag(result) + closeStartAndOpenNewTag(builder) } current = next } } - result.append(c) + builder.append(c) } - checkOpenedAndCloseStringIfNeeded(opened, originalText.length, result) - return result + checkOpenedAndCloseStringIfNeeded(opened, originalText.length, builder) } private fun getSortedCodeMetaInfos(metaInfos: Collection): List { return metaInfos.sortedWith(compareBy { it.start }.then(compareByDescending { it.end })) } - private fun closeString(result: StringBuffer) = result.append("") - private fun openStartTag(result: StringBuffer) = result.append("") - private fun closeStartAndOpenNewTag(result: StringBuffer) = result.append("!>") + private fun openStartTag(result: StringBuilder) = result.append("") + private fun closeStartAndOpenNewTag(result: StringBuilder) = result.append("!>, end: Int, result: StringBuffer) { + private fun checkOpenedAndCloseStringIfNeeded(opened: Stack, end: Int, result: StringBuilder) { var prev: CodeMetaInfo? = null while (!opened.isEmpty() && end == opened.peek().end) { if (prev == null || prev.start != opened.peek().start) From 87a6a6695378dd18bcf86e6b4cc7718660e09a5b Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Thu, 5 Nov 2020 13:41:07 +0300 Subject: [PATCH 077/196] [CMI] Parse description of meta info and save it to ParsedCodeMetaInfo --- .../kotlin/codeMetaInfo/CodeMetaInfoParser.kt | 30 ++++++++++++------- .../codeMetaInfo/model/ParsedCodeMetaInfo.kt | 3 +- 2 files changed, 22 insertions(+), 11 deletions(-) diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoParser.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoParser.kt index 45d44a5d788..d8e26cc5dea 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoParser.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoParser.kt @@ -8,11 +8,16 @@ package org.jetbrains.kotlin.codeMetaInfo import org.jetbrains.kotlin.codeMetaInfo.model.ParsedCodeMetaInfo object CodeMetaInfoParser { - private val openingRegex = "(]+?)!>)".toRegex() - private val closingRegex = "()".toRegex() + private val openingRegex = """(]+?)!>)""".toRegex() + private val closingRegex = """()""".toRegex() - private val descriptionRegex = "\\(\".*?\"\\)".toRegex() - private val platformRegex = "\\{(.+)}".toRegex() + /* + * ([\S&&[^,(){}]]+) -- tag, allowing all non-space characters except bracers and curly bracers + * ([{](.*?)[}])? -- list of platforms + * (\("(.*?)"\))? -- arguments of meta info + * (, )? -- possible separator between different infos + */ + private val tagRegex = """([\S&&[^,(){}]]+)([{](.*?)[}])?(\("(.*?)"\))?(, )?""".toRegex() fun getCodeMetaInfoFromText(renderedText: String): List { var text = renderedText @@ -48,14 +53,19 @@ object CodeMetaInfoParser { while (!openingMatchResults.isEmpty()) { val openingMatchResult = openingMatchResults.removeLast() val closingMatchResult = closingMatchResults.removeLast() - val metaInfoWithoutParams = openingMatchResult.groups[2]!!.value.replace(descriptionRegex, "") - metaInfoWithoutParams.split(",").forEach { - val tag = platformRegex.replace(it, "").trim() - val platforms = - if (platformRegex.containsMatchIn(it)) platformRegex.find(it)!!.destructured.component1().split(";") else listOf() + val allMetaInfos = openingMatchResult.groups[2]!!.value + tagRegex.findAll(allMetaInfos).map { it.groups }.forEach { + val tag = it[1]!!.value + val platforms = it[3]?.value?.split(";") ?: emptyList() + val description = it[5]?.value + result.add( ParsedCodeMetaInfo( - openingMatchResult.range.first, closingMatchResult.range.first, platforms.toMutableList(), tag, + openingMatchResult.range.first, + closingMatchResult.range.first, + platforms.toMutableList(), + tag, + description ) ) } diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/ParsedCodeMetaInfo.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/ParsedCodeMetaInfo.kt index d90342af2bd..f5cc2796ff8 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/ParsedCodeMetaInfo.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/ParsedCodeMetaInfo.kt @@ -11,7 +11,8 @@ class ParsedCodeMetaInfo( override val start: Int, override val end: Int, override val platforms: MutableList, - private val tag: String + private val tag: String, + val description: String? ) : CodeMetaInfo { override val renderConfiguration = object : AbstractCodeMetaInfoRenderConfiguration(false) {} From 9e31b049fce5259a72fb45eac8150c2e2200e0f5 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Wed, 2 Dec 2020 15:49:10 +0300 Subject: [PATCH 078/196] [CMI] Add additional constructor for DiagnosticCodeMetaInfo --- .../kotlin/codeMetaInfo/model/DiagnosticCodeMetaInfo.kt | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/DiagnosticCodeMetaInfo.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/DiagnosticCodeMetaInfo.kt index 2a262659015..4eae522e47d 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/DiagnosticCodeMetaInfo.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/DiagnosticCodeMetaInfo.kt @@ -5,6 +5,7 @@ package org.jetbrains.kotlin.codeMetaInfo.model +import com.intellij.openapi.util.TextRange import org.jetbrains.kotlin.codeMetaInfo.renderConfigurations.DiagnosticCodeMetaInfoRenderConfiguration import org.jetbrains.kotlin.diagnostics.Diagnostic @@ -14,6 +15,12 @@ class DiagnosticCodeMetaInfo( override val renderConfiguration: DiagnosticCodeMetaInfoRenderConfiguration, val diagnostic: Diagnostic ) : CodeMetaInfo { + constructor( + range: TextRange, + renderConfiguration: DiagnosticCodeMetaInfoRenderConfiguration, + diagnostic: Diagnostic + ) : this(range.startOffset, range.endOffset, renderConfiguration, diagnostic) + override val platforms: MutableList = mutableListOf() override fun asString(): String = renderConfiguration.asString(this) From ced9a6fe35503140340523892d8533ef24fd7e2c Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Wed, 2 Dec 2020 15:46:17 +0300 Subject: [PATCH 079/196] [CMI] Replace `getTag` with `tag` property in `CodeMetaInfo` --- .../org/jetbrains/kotlin/codeMetaInfo/model/CodeMetaInfo.kt | 2 +- .../kotlin/codeMetaInfo/model/DiagnosticCodeMetaInfo.kt | 5 +++-- .../kotlin/codeMetaInfo/model/ParsedCodeMetaInfo.kt | 6 ++---- .../AbstractCodeMetaInfoRenderConfiguration.kt | 2 +- .../idea/codeMetaInfo/models/HighlightingCodeMetaInfo.kt | 6 ++++-- .../idea/codeMetaInfo/models/LineMarkerCodeMetaInfo.kt | 6 ++++-- 6 files changed, 15 insertions(+), 12 deletions(-) diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/CodeMetaInfo.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/CodeMetaInfo.kt index a50d791152e..bcb4798ca1f 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/CodeMetaInfo.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/CodeMetaInfo.kt @@ -10,9 +10,9 @@ import org.jetbrains.kotlin.codeMetaInfo.renderConfigurations.AbstractCodeMetaIn interface CodeMetaInfo { val start: Int val end: Int + val tag: String val renderConfiguration: AbstractCodeMetaInfoRenderConfiguration val platforms: MutableList fun asString(): String - fun getTag(): String } diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/DiagnosticCodeMetaInfo.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/DiagnosticCodeMetaInfo.kt index 4eae522e47d..0867f996da0 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/DiagnosticCodeMetaInfo.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/DiagnosticCodeMetaInfo.kt @@ -21,9 +21,10 @@ class DiagnosticCodeMetaInfo( diagnostic: Diagnostic ) : this(range.startOffset, range.endOffset, renderConfiguration, diagnostic) + override val tag: String + get() = renderConfiguration.getTag(this) + override val platforms: MutableList = mutableListOf() override fun asString(): String = renderConfiguration.asString(this) - - override fun getTag(): String = renderConfiguration.getTag(this) } diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/ParsedCodeMetaInfo.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/ParsedCodeMetaInfo.kt index f5cc2796ff8..2e15df0e8eb 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/ParsedCodeMetaInfo.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/ParsedCodeMetaInfo.kt @@ -11,18 +11,16 @@ class ParsedCodeMetaInfo( override val start: Int, override val end: Int, override val platforms: MutableList, - private val tag: String, + override val tag: String, val description: String? ) : CodeMetaInfo { override val renderConfiguration = object : AbstractCodeMetaInfoRenderConfiguration(false) {} override fun asString(): String = renderConfiguration.asString(this) - override fun getTag(): String = tag - override fun equals(other: Any?): Boolean { if (other == null || other !is CodeMetaInfo) return false - return this.tag == other.getTag() && this.start == other.start && this.end == other.end + return this.tag == other.tag && this.start == other.start && this.end == other.end } override fun hashCode(): Int { diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/renderConfigurations/AbstractCodeMetaInfoRenderConfiguration.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/renderConfigurations/AbstractCodeMetaInfoRenderConfiguration.kt index e76f705402f..3c72f7329da 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/renderConfigurations/AbstractCodeMetaInfoRenderConfiguration.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/renderConfigurations/AbstractCodeMetaInfoRenderConfiguration.kt @@ -10,7 +10,7 @@ import org.jetbrains.kotlin.codeMetaInfo.model.CodeMetaInfo abstract class AbstractCodeMetaInfoRenderConfiguration(var renderParams: Boolean = true) { private val clickOrPressRegex = "Click or press (.*)to navigate".toRegex() // We have different hotkeys on different platforms - open fun asString(codeMetaInfo: CodeMetaInfo) = codeMetaInfo.getTag() + getPlatformsString(codeMetaInfo) + open fun asString(codeMetaInfo: CodeMetaInfo): String = codeMetaInfo.tag + getPlatformsString(codeMetaInfo) open fun getAdditionalParams(codeMetaInfo: CodeMetaInfo) = "" diff --git a/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/models/HighlightingCodeMetaInfo.kt b/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/models/HighlightingCodeMetaInfo.kt index 8c6b456b257..d47a5480a59 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/models/HighlightingCodeMetaInfo.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/models/HighlightingCodeMetaInfo.kt @@ -17,9 +17,11 @@ class HighlightingCodeMetaInfo( get() = highlightingInfo.startOffset override val end: Int get() = highlightingInfo.endOffset + + override val tag: String + get() = renderConfiguration.getTag() + override val platforms: MutableList = mutableListOf() override fun asString(): String = renderConfiguration.asString(this) - - override fun getTag(): String = renderConfiguration.getTag() } diff --git a/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/models/LineMarkerCodeMetaInfo.kt b/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/models/LineMarkerCodeMetaInfo.kt index 4ae09ef6735..c397e6f67d5 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/models/LineMarkerCodeMetaInfo.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/models/LineMarkerCodeMetaInfo.kt @@ -17,9 +17,11 @@ class LineMarkerCodeMetaInfo( get() = lineMarker.startOffset override val end: Int get() = lineMarker.endOffset + + override val tag: String + get() = renderConfiguration.getTag() + override val platforms: MutableList = mutableListOf() override fun asString(): String = renderConfiguration.asString(this) - - override fun getTag(): String = renderConfiguration.getTag() } From 3bf60b3accf487449e6a958ff566940790d98301 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Wed, 2 Dec 2020 15:45:06 +0300 Subject: [PATCH 080/196] [CMI] Rename `CodeMetaInfo.platforms` to `attributes` --- .../jetbrains/kotlin/codeMetaInfo/model/CodeMetaInfo.kt | 2 +- .../kotlin/codeMetaInfo/model/DiagnosticCodeMetaInfo.kt | 2 +- .../kotlin/codeMetaInfo/model/ParsedCodeMetaInfo.kt | 2 +- .../AbstractCodeMetaInfoRenderConfiguration.kt | 4 ++-- .../kotlin/idea/codeMetaInfo/AbstractCodeMetaInfoTest.kt | 8 ++++---- .../idea/codeMetaInfo/models/HighlightingCodeMetaInfo.kt | 2 +- .../idea/codeMetaInfo/models/LineMarkerCodeMetaInfo.kt | 2 +- 7 files changed, 11 insertions(+), 11 deletions(-) diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/CodeMetaInfo.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/CodeMetaInfo.kt index bcb4798ca1f..aec752b7a48 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/CodeMetaInfo.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/CodeMetaInfo.kt @@ -12,7 +12,7 @@ interface CodeMetaInfo { val end: Int val tag: String val renderConfiguration: AbstractCodeMetaInfoRenderConfiguration - val platforms: MutableList + val attributes: MutableList fun asString(): String } diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/DiagnosticCodeMetaInfo.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/DiagnosticCodeMetaInfo.kt index 0867f996da0..e2d5afce7a4 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/DiagnosticCodeMetaInfo.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/DiagnosticCodeMetaInfo.kt @@ -24,7 +24,7 @@ class DiagnosticCodeMetaInfo( override val tag: String get() = renderConfiguration.getTag(this) - override val platforms: MutableList = mutableListOf() + override val attributes: MutableList = mutableListOf() override fun asString(): String = renderConfiguration.asString(this) } diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/ParsedCodeMetaInfo.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/ParsedCodeMetaInfo.kt index 2e15df0e8eb..5e2d93bbc74 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/ParsedCodeMetaInfo.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/ParsedCodeMetaInfo.kt @@ -10,7 +10,7 @@ import org.jetbrains.kotlin.codeMetaInfo.renderConfigurations.AbstractCodeMetaIn class ParsedCodeMetaInfo( override val start: Int, override val end: Int, - override val platforms: MutableList, + override val attributes: MutableList, override val tag: String, val description: String? ) : CodeMetaInfo { diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/renderConfigurations/AbstractCodeMetaInfoRenderConfiguration.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/renderConfigurations/AbstractCodeMetaInfoRenderConfiguration.kt index 3c72f7329da..5135ddf25af 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/renderConfigurations/AbstractCodeMetaInfoRenderConfiguration.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/renderConfigurations/AbstractCodeMetaInfoRenderConfiguration.kt @@ -32,7 +32,7 @@ abstract class AbstractCodeMetaInfoRenderConfiguration(var renderParams: Boolean } protected fun getPlatformsString(codeMetaInfo: CodeMetaInfo): String { - if (codeMetaInfo.platforms.isEmpty()) return "" - return "{${codeMetaInfo.platforms.joinToString(";")}}" + if (codeMetaInfo.attributes.isEmpty()) return "" + return "{${codeMetaInfo.attributes.joinToString(";")}}" } } diff --git a/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/AbstractCodeMetaInfoTest.kt b/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/AbstractCodeMetaInfoTest.kt index 17ce19618b9..33032319348 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/AbstractCodeMetaInfoTest.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/AbstractCodeMetaInfoTest.kt @@ -161,13 +161,13 @@ class CodeMetaInfoTestCase( val correspondingParsed = parsedMetaInfo.firstOrNull { it == codeMetaInfo } if (correspondingParsed != null) { parsedMetaInfo.remove(correspondingParsed) - codeMetaInfo.platforms.addAll(correspondingParsed.platforms) - if (correspondingParsed.platforms.isNotEmpty() && OSKind.current.toString() !in correspondingParsed.platforms) - codeMetaInfo.platforms.add(OSKind.current.toString()) + codeMetaInfo.attributes.addAll(correspondingParsed.attributes) + if (correspondingParsed.attributes.isNotEmpty() && OSKind.current.toString() !in correspondingParsed.attributes) + codeMetaInfo.attributes.add(OSKind.current.toString()) } } parsedMetaInfo.forEach { - if (it.platforms.isNotEmpty() && OSKind.current.toString() !in it.platforms) codeMetaInfoForCheck.add( + if (it.attributes.isNotEmpty() && OSKind.current.toString() !in it.attributes) codeMetaInfoForCheck.add( it ) } diff --git a/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/models/HighlightingCodeMetaInfo.kt b/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/models/HighlightingCodeMetaInfo.kt index d47a5480a59..f0c902caa16 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/models/HighlightingCodeMetaInfo.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/models/HighlightingCodeMetaInfo.kt @@ -21,7 +21,7 @@ class HighlightingCodeMetaInfo( override val tag: String get() = renderConfiguration.getTag() - override val platforms: MutableList = mutableListOf() + override val attributes: MutableList = mutableListOf() override fun asString(): String = renderConfiguration.asString(this) } diff --git a/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/models/LineMarkerCodeMetaInfo.kt b/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/models/LineMarkerCodeMetaInfo.kt index c397e6f67d5..8e964a0f2c4 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/models/LineMarkerCodeMetaInfo.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/codeMetaInfo/models/LineMarkerCodeMetaInfo.kt @@ -21,7 +21,7 @@ class LineMarkerCodeMetaInfo( override val tag: String get() = renderConfiguration.getTag() - override val platforms: MutableList = mutableListOf() + override val attributes: MutableList = mutableListOf() override fun asString(): String = renderConfiguration.asString(this) } From d6ff83c7d8d451f6dcb1ea8e452d4984a4aa541b Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Wed, 2 Dec 2020 15:50:01 +0300 Subject: [PATCH 081/196] [CMI] Add ability to copy ParsedCodeMetaInfo --- .../codeMetaInfo/model/ParsedCodeMetaInfo.kt | 9 +++++++-- .../ParsedCodeMetaInfoRenderConfiguration.kt | 16 ++++++++++++++++ 2 files changed, 23 insertions(+), 2 deletions(-) create mode 100644 compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/renderConfigurations/ParsedCodeMetaInfoRenderConfiguration.kt diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/ParsedCodeMetaInfo.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/ParsedCodeMetaInfo.kt index 5e2d93bbc74..425cabcc9c2 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/ParsedCodeMetaInfo.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/ParsedCodeMetaInfo.kt @@ -5,7 +5,7 @@ package org.jetbrains.kotlin.codeMetaInfo.model -import org.jetbrains.kotlin.codeMetaInfo.renderConfigurations.AbstractCodeMetaInfoRenderConfiguration +import org.jetbrains.kotlin.codeMetaInfo.renderConfigurations.ParsedCodeMetaInfoRenderConfiguration class ParsedCodeMetaInfo( override val start: Int, @@ -14,7 +14,7 @@ class ParsedCodeMetaInfo( override val tag: String, val description: String? ) : CodeMetaInfo { - override val renderConfiguration = object : AbstractCodeMetaInfoRenderConfiguration(false) {} + override val renderConfiguration = ParsedCodeMetaInfoRenderConfiguration override fun asString(): String = renderConfiguration.asString(this) @@ -29,4 +29,9 @@ class ParsedCodeMetaInfo( result = 31 * result + tag.hashCode() return result } + + fun copy(): ParsedCodeMetaInfo { + return ParsedCodeMetaInfo(start, end, attributes.toMutableList(), tag, description) + } } + diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/renderConfigurations/ParsedCodeMetaInfoRenderConfiguration.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/renderConfigurations/ParsedCodeMetaInfoRenderConfiguration.kt new file mode 100644 index 00000000000..246ad69f31e --- /dev/null +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/renderConfigurations/ParsedCodeMetaInfoRenderConfiguration.kt @@ -0,0 +1,16 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.codeMetaInfo.renderConfigurations + +import org.jetbrains.kotlin.codeMetaInfo.model.CodeMetaInfo +import org.jetbrains.kotlin.codeMetaInfo.model.ParsedCodeMetaInfo + +object ParsedCodeMetaInfoRenderConfiguration : AbstractCodeMetaInfoRenderConfiguration() { + override fun asString(codeMetaInfo: CodeMetaInfo): String { + require(codeMetaInfo is ParsedCodeMetaInfo) + return super.asString(codeMetaInfo) + (codeMetaInfo.description?.let { "(\"$it\")" } ?: "") + } +} From 09df07349c29a7d5aa1dcdb7c4f1439e666fc502 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Wed, 2 Dec 2020 15:52:47 +0300 Subject: [PATCH 082/196] [CMI] Add ability to replace render configuration of DiagnosticCodeMetaInfo --- .../kotlin/codeMetaInfo/model/DiagnosticCodeMetaInfo.kt | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/DiagnosticCodeMetaInfo.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/DiagnosticCodeMetaInfo.kt index e2d5afce7a4..7afe28cd1cd 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/DiagnosticCodeMetaInfo.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/DiagnosticCodeMetaInfo.kt @@ -12,7 +12,7 @@ import org.jetbrains.kotlin.diagnostics.Diagnostic class DiagnosticCodeMetaInfo( override val start: Int, override val end: Int, - override val renderConfiguration: DiagnosticCodeMetaInfoRenderConfiguration, + renderConfiguration: DiagnosticCodeMetaInfoRenderConfiguration, val diagnostic: Diagnostic ) : CodeMetaInfo { constructor( @@ -21,6 +21,13 @@ class DiagnosticCodeMetaInfo( diagnostic: Diagnostic ) : this(range.startOffset, range.endOffset, renderConfiguration, diagnostic) + override var renderConfiguration: DiagnosticCodeMetaInfoRenderConfiguration = renderConfiguration + private set + + fun replaceRenderConfiguration(renderConfiguration: DiagnosticCodeMetaInfoRenderConfiguration) { + this.renderConfiguration = renderConfiguration + } + override val tag: String get() = renderConfiguration.getTag(this) From 98a2f29f95814ec4067d4ea23241f14244501724 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Thu, 12 Nov 2020 16:19:53 +0300 Subject: [PATCH 083/196] [CMI] Allow using right angle bracket symbol in MetaInfo message --- .../org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoParser.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoParser.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoParser.kt index d8e26cc5dea..07f969bbfdd 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoParser.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoParser.kt @@ -8,7 +8,7 @@ package org.jetbrains.kotlin.codeMetaInfo import org.jetbrains.kotlin.codeMetaInfo.model.ParsedCodeMetaInfo object CodeMetaInfoParser { - private val openingRegex = """(]+?)!>)""".toRegex() + private val openingRegex = """()""".toRegex() private val closingRegex = """()""".toRegex() /* From ceb44ddccd3e64f28e18a3aaf6827e0800453be3 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Tue, 1 Dec 2020 11:24:02 +0300 Subject: [PATCH 084/196] [CMI] Improve CodeMetaInfoRenderer 1. Properly handle meta which start == end 2. Sort metainfos of one range by tag --- .../jetbrains/kotlin/codeMetaInfo/CodeMetaInfoRenderer.kt | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoRenderer.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoRenderer.kt index dd41af597ab..63624ec8ad6 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoRenderer.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoRenderer.kt @@ -56,13 +56,17 @@ object CodeMetaInfoRenderer { current = next } } + // Here we need to handle meta infos which has start == end and close them immediately + checkOpenedAndCloseStringIfNeeded(opened, i, builder) builder.append(c) } checkOpenedAndCloseStringIfNeeded(opened, originalText.length, builder) } + private val metaInfoComparator = (compareBy { it.start } then compareByDescending { it.end }) then compareBy { it.tag } + private fun getSortedCodeMetaInfos(metaInfos: Collection): List { - return metaInfos.sortedWith(compareBy { it.start }.then(compareByDescending { it.end })) + return metaInfos.sortedWith(metaInfoComparator) } private fun closeString(result: StringBuilder) = result.append("") From c558df5b4a175c5f24622bfcda55b9a0b9d0600e Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Tue, 1 Dec 2020 12:59:12 +0300 Subject: [PATCH 085/196] [CMI] Fix rendering metainfos at the end of file --- .../codeMetaInfo/CodeMetaInfoRenderer.kt | 68 ++++++++++++------- 1 file changed, 42 insertions(+), 26 deletions(-) diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoRenderer.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoRenderer.kt index 63624ec8ad6..f93b3851edf 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoRenderer.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoRenderer.kt @@ -30,37 +30,53 @@ object CodeMetaInfoRenderer { builder.append(originalText) return } - val sortedMetaInfos = getSortedCodeMetaInfos(codeMetaInfos) + val sortedMetaInfos = getSortedCodeMetaInfos(codeMetaInfos).groupBy { it.start } val opened = Stack() for ((i, c) in originalText.withIndex()) { - checkOpenedAndCloseStringIfNeeded(opened, i, builder) - val matchedCodeMetaInfos = sortedMetaInfos.filter { it.start == i } - if (matchedCodeMetaInfos.isNotEmpty()) { - openStartTag(builder) - val iterator = matchedCodeMetaInfos.listIterator() - var current: CodeMetaInfo? = iterator.next() - - while (current != null) { - val next: CodeMetaInfo? = if (iterator.hasNext()) iterator.next() else null - opened.push(current) - builder.append(current.asString()) - when { - next == null -> - closeStartTag(builder) - next.end == current.end -> - builder.append(", ") - else -> - closeStartAndOpenNewTag(builder) - } - current = next - } - } - // Here we need to handle meta infos which has start == end and close them immediately - checkOpenedAndCloseStringIfNeeded(opened, i, builder) + processMetaInfosStartedAtOffset(i, sortedMetaInfos, opened, builder) builder.append(c) } - checkOpenedAndCloseStringIfNeeded(opened, originalText.length, builder) + val lastSymbolIsNewLine = builder.last() == '\n' + if (lastSymbolIsNewLine) { + builder.deleteCharAt(builder.length - 1) + } + processMetaInfosStartedAtOffset(originalText.length, sortedMetaInfos, opened, builder) + if (lastSymbolIsNewLine) { + builder.appendLine() + } + } + + private fun processMetaInfosStartedAtOffset( + offset: Int, + sortedMetaInfos: Map>, + opened: Stack, + builder: StringBuilder + ) { + checkOpenedAndCloseStringIfNeeded(opened, offset, builder) + val matchedCodeMetaInfos = sortedMetaInfos[offset] ?: emptyList() + if (matchedCodeMetaInfos.isNotEmpty()) { + openStartTag(builder) + val iterator = matchedCodeMetaInfos.listIterator() + var current: CodeMetaInfo? = iterator.next() + + while (current != null) { + val next: CodeMetaInfo? = if (iterator.hasNext()) iterator.next() else null + opened.push(current) + builder.append(current.asString()) + when { + next == null -> + closeStartTag(builder) + next.end == current.end -> + builder.append(", ") + else -> + closeStartAndOpenNewTag(builder) + } + current = next + } + } + // Here we need to handle meta infos which has start == end and close them immediately + checkOpenedAndCloseStringIfNeeded(opened, offset, builder) } private val metaInfoComparator = (compareBy { it.start } then compareByDescending { it.end }) then compareBy { it.tag } From 7960182674068851d2ab61ad504143db0bb3f15e Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Wed, 2 Dec 2020 16:13:48 +0300 Subject: [PATCH 086/196] [CMI] Fix CodeMetaInfoParser to properly handle nested meta infos There was a problem with cases like that: some text ^ ^ 1 2 (1) is a closing tag for and (2) is for , but before the fix they were matched contrariwise --- .../kotlin/codeMetaInfo/CodeMetaInfoParser.kt | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoParser.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoParser.kt index 07f969bbfdd..343498384ec 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoParser.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoParser.kt @@ -8,7 +8,7 @@ package org.jetbrains.kotlin.codeMetaInfo import org.jetbrains.kotlin.codeMetaInfo.model.ParsedCodeMetaInfo object CodeMetaInfoParser { - private val openingRegex = """()""".toRegex() + private val openingRegex = """()""".toRegex() private val closingRegex = """()""".toRegex() /* @@ -22,7 +22,8 @@ object CodeMetaInfoParser { fun getCodeMetaInfoFromText(renderedText: String): List { var text = renderedText val openingMatchResults = ArrayDeque() - val closingMatchResults = ArrayDeque() + val stackOfOpeningMatchResults = ArrayDeque() + val closingMatchResults = mutableMapOf() val result = mutableListOf() while (true) { @@ -40,10 +41,11 @@ object CodeMetaInfoParser { text = if (openingStartOffset < closingStartOffset) { requireNotNull(opening) openingMatchResults.addLast(opening) + stackOfOpeningMatchResults.addLast(opening) text.removeRange(openingStartOffset, opening.range.last + 1) } else { requireNotNull(closing) - closingMatchResults.addLast(closing) + closingMatchResults[stackOfOpeningMatchResults.removeLast()] = closing text.removeRange(closingStartOffset, closing.range.last + 1) } } @@ -52,7 +54,7 @@ object CodeMetaInfoParser { } while (!openingMatchResults.isEmpty()) { val openingMatchResult = openingMatchResults.removeLast() - val closingMatchResult = closingMatchResults.removeLast() + val closingMatchResult = closingMatchResults.getValue(openingMatchResult) val allMetaInfos = openingMatchResult.groups[2]!!.value tagRegex.findAll(allMetaInfos).map { it.groups }.forEach { val tag = it[1]!!.value From 1c91b74ff0ef9c7fe3bce9f79c9e73e6e9e1a58d Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Thu, 3 Dec 2020 16:52:58 +0300 Subject: [PATCH 087/196] [CMI] Fix clearing code meta infos from original text --- .../org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoParser.kt | 6 ++++-- .../jetbrains/kotlin/codeMetaInfo/CodeMetaInfoRenderer.kt | 2 +- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoParser.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoParser.kt index 343498384ec..9b3f7925d25 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoParser.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoParser.kt @@ -8,8 +8,10 @@ package org.jetbrains.kotlin.codeMetaInfo import org.jetbrains.kotlin.codeMetaInfo.model.ParsedCodeMetaInfo object CodeMetaInfoParser { - private val openingRegex = """()""".toRegex() - private val closingRegex = """()""".toRegex() + val openingRegex = """()""".toRegex() + val closingRegex = """()""".toRegex() + + val openingOrClosingRegex = """(${closingRegex.pattern}|${openingRegex.pattern})""".toRegex() /* * ([\S&&[^,(){}]]+) -- tag, allowing all non-space characters except bracers and curly bracers diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoRenderer.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoRenderer.kt index f93b3851edf..8da47b321c6 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoRenderer.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoRenderer.kt @@ -106,4 +106,4 @@ fun clearFileFromDiagnosticMarkup(file: File) { file.writeText(cleanText) } -fun clearTextFromDiagnosticMarkup(text: String): String = CheckerTestUtil.rangeStartOrEndPattern.matcher(text).replaceAll("") +fun clearTextFromDiagnosticMarkup(text: String): String = text.replace(CodeMetaInfoParser.openingOrClosingRegex, "") From c8f3a4802e41ef20e2f2e5547a7420fbab162c58 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Wed, 2 Dec 2020 16:00:43 +0300 Subject: [PATCH 088/196] [TEST] Introduce test-infrastructure-utils module and extract common test utilities here --- .../tests/CodegenTestsOnAndroidGenerator.kt | 8 +- .../kotlin/android/tests/PathManager.java | 4 +- .../kotlin/daemon/CompilerApiTest.kt | 11 +- .../kotlin/daemon/CompilerDaemonTest.kt | 6 +- .../integration/CompilerApiTest.kt | 10 +- .../integration/CompilerDaemonTest.kt | 6 +- .../experimental/unit/ConnectionsTest.kt | 8 +- .../java/AbstractFirTypeEnhancementTest.kt | 2 +- .../builder/AbstractRawFirBuilderTestCase.kt | 3 +- ...bstractIncrementalJvmCompilerRunnerTest.kt | 4 +- .../build.gradle.kts | 27 +++ .../intellij/testFramework/TestDataFile.java | 0 .../intellij/testFramework/TestDataPath.java | 0 .../kotlin/codeMetaInfo/CodeMetaInfoParser.kt | 0 .../codeMetaInfo/CodeMetaInfoRenderer.kt | 1 - .../kotlin/codeMetaInfo/model/CodeMetaInfo.kt | 0 .../model/DiagnosticCodeMetaInfo.kt | 0 .../codeMetaInfo/model/ParsedCodeMetaInfo.kt | 0 ...AbstractCodeMetaInfoRenderConfiguration.kt | 0 ...agnosticCodeMetaInfoRenderConfiguration.kt | 0 .../ParsedCodeMetaInfoRenderConfiguration.kt | 0 .../forTestCompile/ForTestCompileRuntime.java | 0 .../kotlin/test/util/KtTestUtil.java | 196 ++++++++++++++++ .../AbstractIrCompileKotlinAgainstKlibTest.kt | 4 +- compiler/tests-common/build.gradle.kts | 1 + ...ractDiagnosticsTestWithStdLibUsingJavac.kt | 4 +- ...nAnnotationsNoAnnotationInClasspathTest.kt | 4 +- .../kotlin/checkers/BaseDiagnosticsTest.kt | 18 +- .../kotlin/checkers/CheckerTestUtilTest.kt | 5 +- .../checkers/KotlinMultiFileTestWithJava.kt | 16 +- .../kotlin/checkers/TestCheckerUtil.java | 4 +- .../AbstractDiagnosticsUsingJavacTest.kt | 4 +- .../javac/AbstractJavacDiagnosticsTest.kt | 5 +- .../jetbrains/kotlin/cli/AbstractCliTest.java | 3 +- ...ractCompileKotlinAgainstKotlinJdk15Test.kt | 4 +- ...bstractCompileKotlinAgainstKotlinTest.java | 11 +- .../AbstractCustomJDKBlackBoxCodegenTest.kt | 3 +- ...AbstractGenerateNotNullAssertionsTest.java | 3 +- .../AbstractJdk15BlackBoxCodegenTest.kt | 4 +- .../AbstractJdk9BlackBoxCodegenTest.kt | 6 +- .../codegen/AbstractLightAnalysisModeTest.kt | 2 +- ...AbstractTopLevelMembersInvocationTest.java | 5 +- .../kotlin/codegen/CodegenTestCase.java | 13 +- .../kotlin/codegen/CodegenTestFiles.java | 10 +- .../kotlin/codegen/CodegenTestUtil.java | 5 +- .../debugInformation/AbstractDebugTest.kt | 6 +- ...AbstractFirDiagnosticsWithLightTreeTest.kt | 4 +- .../org/jetbrains/kotlin/fir/FirTestUtils.kt | 6 +- .../KotlinIntegrationTestBase.java | 6 +- .../kotlin/ir/AbstractIrGeneratorTestCase.kt | 2 +- .../AbstractCompileJavaAgainstKotlinTest.kt | 16 +- .../AbstractCompileKotlinAgainstJavaTest.kt | 17 +- .../jvm/compiler/AbstractLoadJava15Test.kt | 6 +- ...stractLoadJava15WithPsiClassReadingTest.kt | 4 +- .../jvm/compiler/AbstractLoadJavaTest.java | 8 +- .../jvm/compiler/LoadDescriptorUtil.java | 7 +- .../resolve/ExtensibleResolveTestCase.java | 3 +- ...stractAnnotationDescriptorResolveTest.java | 5 +- .../calls/AbstractResolvedCallsTest.kt | 3 +- .../AbstractConstraintSystemTest.kt | 9 +- .../jetbrains/kotlin/test/CompilerTestUtil.kt | 3 +- .../jetbrains/kotlin/test/KotlinBaseTest.kt | 3 +- .../kotlin/test/KotlinTestUtils.java | 218 ++---------------- .../jetbrains/kotlin/test/MockLibraryUtil.kt | 7 +- .../checkers/AbstractDiagnosticsTestSpec.kt | 4 +- .../asJava/LightClassAnnotationsTest.java | 3 +- .../kotlin/cli/LauncherScriptTest.kt | 5 +- .../kotlin/cli/WrongBytecodeVersionTest.kt | 5 +- .../cli/jvm/KotlinCliJavaFileManagerTest.kt | 3 +- .../kotlin/codegen/JvmModuleProtoBufTest.kt | 5 +- .../kotlin/codegen/OuterClassGenTest.java | 4 +- .../jetbrains/kotlin/codegen/ScriptGenTest.kt | 3 +- .../integration/CompilerFileLimitTest.kt | 4 +- .../integration/CompilerSmokeTestBase.java | 4 +- .../jvm/compiler/CompileEnvironmentTest.java | 4 +- .../compiler/Java9ModulesIntegrationTest.kt | 9 +- .../LoadJavaPackageAnnotationsTest.kt | 3 +- .../jvm/compiler/MemoryOptimizationsTest.kt | 5 +- .../TypeQualifierAnnotationResolverTest.kt | 5 +- .../AbstractMultiPlatformIntegrationTest.kt | 3 +- .../kotlin/parsing/AbstractParsingTest.java | 4 +- .../jetbrains/kotlin/psi/KtPsiUtilTest.java | 7 +- .../reflection/ReflectionIntegrationTest.kt | 3 +- .../CapturedTypeApproximationTest.kt | 6 +- .../js/JsVersionRequirementTest.kt | 9 +- .../RecursiveDescriptorProcessorTest.java | 2 +- .../AbstractJvmRuntimeDescriptorLoaderTest.kt | 3 +- ...ModelTestAllFilesPresentMethodGenerator.kt | 8 +- .../impl/SimpleTestMethodGenerator.kt | 6 +- ...stModelAllFilesPresentedMethodGenerator.kt | 8 +- .../generators/model/SimpleTestClassModel.kt | 3 +- .../generators/model/SimpleTestMethodModel.kt | 4 +- .../generators/model/SingleClassTestModel.kt | 4 +- .../ProtoBufCompareConsistencyTest.kt | 3 +- .../completion/test/CompletionTestUtil.kt | 4 +- .../test/KotlinCompletionTestCase.java | 5 +- .../test/KotlinCompletionTestCase.java.203 | 4 +- .../AbstractFirMultiModuleLazyResolveTest.kt | 3 +- .../AbstractSessionsInvalidationTest.kt | 5 +- .../api/fir/AbstractResolveCallTest.kt | 3 +- .../MultiplatformProjectImportingTest.kt | 12 +- .../NewMultiplatformProjectImportingTest.kt | 13 +- .../gradle/GradleFacetImportTest.kt | 15 +- .../klib/KlibInfoProviderTest.kt | 2 +- .../kotlin/idea/liveTemplates/paths.kt | 4 +- .../kotlin/idea/maven/MavenTestCase.java | 6 +- .../MavenUpdateConfigurationQuickFixTest.kt | 8 +- .../idea/test/KotlinCodeInsightTestCase.java | 5 +- .../test/KotlinCodeInsightTestCase.java.203 | 4 +- .../KotlinLightCodeInsightFixtureTestCase.kt | 6 +- ...LightPlatformCodeInsightFixtureTestCase.kt | 5 +- ...tPlatformCodeInsightFixtureTestCase.kt.203 | 3 +- .../idea/test/KotlinMultiFileTestCase.kt | 8 +- .../idea/test/KotlinMultiFileTestCase.kt.203 | 6 +- .../kotlin/idea/test/PluginTestCaseBase.java | 6 +- .../idea/test/PluginTestCaseBase.java.201 | 5 +- .../idea/debugger/test/DebuggerTestUtils.kt | 4 +- .../debugger/test/KotlinDescriptorTestCase.kt | 3 +- .../scratch/AbstractScratchRunActionTest.kt | 8 +- .../AbstractScratchRunActionTest.kt.201 | 9 +- .../AbstractScratchRunActionTest.kt.203 | 7 +- ...ractScriptTemplatesFromDependenciesTest.kt | 6 +- .../LightClassesClasspathSortingTest.kt | 6 +- .../AbstractJavaAgainstKotlinCheckerTest.java | 4 +- .../idea/KotlinDaemonAnalyzerTestCase.java | 6 +- .../KotlinDaemonAnalyzerTestCase.java.203 | 4 +- .../idea/actions/AbstractNavigationTest.kt | 4 +- .../idea/caches/KotlinShortNamesCacheTest.kt | 6 +- .../idea/caches/resolve/IdeaModuleInfoTest.kt | 7 +- .../caches/resolve/IdeaModuleInfoTest.kt.203 | 4 +- .../Java9MultiModuleHighlightingTest.kt | 4 +- .../codeInsight/AbstractInspectionTest.kt | 3 +- .../AbstractPostfixTemplateProviderTest.kt | 4 +- .../AbstractConfigureKotlinTest.kt | 6 +- .../AbstractConfigureKotlinTest.kt.201 | 6 +- .../AbstractConfigureKotlinTest.kt.203 | 3 +- .../CodeFragmentCompletionInLibraryTest.kt | 4 +- .../stubBuilder/AbstractClsStubBuilderTest.kt | 3 +- .../AbstractLoadJavaClsStubTest.kt | 8 +- .../ClsStubForWrongAbiVersionTest.kt | 4 +- .../DecompiledTextForWrongAbiVersionTest.kt | 4 +- .../ExternalAnnotationTest.kt | 3 +- .../hierarchy/AbstractHierarchyWithLibTest.kt | 6 +- .../AbstractDiagnosticMessageTest.java | 5 +- ...nTypeAliasByExpansionShortNameIndexTest.kt | 6 +- .../AbstractBytecodeToolWindowTest.kt | 4 +- .../idea/kdoc/AbstractKDocTypingTest.kt | 4 +- .../AbstractKotlinGotoImplementationTest.kt | 6 +- .../AbstractQuickFixMultiModuleTest.kt | 3 +- .../refactoring/AbstractMemberPullPushTest.kt | 5 +- .../introduce/AbstractExtractionTest.kt | 3 +- .../repl/AbstractIdeReplCompletionTest.kt | 8 +- .../repl/AbstractIdeReplCompletionTest.kt.203 | 6 +- .../script/AbstractScriptConfigurationTest.kt | 3 +- .../AbstractScriptConfigurationTest.kt.203 | 3 +- .../kotlin/idea/slicer/AbstractSlicerTest.kt | 6 +- .../idea/stubs/AbstractMultiModuleTest.kt | 8 +- .../idea/stubs/AbstractMultiModuleTest.kt.203 | 6 +- ...ractJavaToKotlinConverterSingleFileTest.kt | 3 +- .../j2k/AbstractJavaToKotlinConverterTest.kt | 8 +- .../AbstractJavaToKotlinConverterTest.kt.203 | 4 +- .../kotlin/jps/build/KotlinJpsBuildTest.kt | 3 +- .../jps/build/KotlinJpsBuildTest.kt.201 | 3 +- .../kotlin/jvm/compiler/ClasspathOrderTest.kt | 4 +- .../kotlin/integration/AntTaskJsTest.java | 4 +- .../js/test/AbstractJsLineNumberTest.kt | 10 +- .../jetbrains/kotlin/js/test/BasicBoxTest.kt | 7 +- .../kotlin/js/test/BasicWasmBoxTest.kt | 10 +- .../AbstractKotlinAndroidGradleTests.kt | 3 +- .../kotlin/gradle/BuildCacheRelocationIT.kt | 8 +- .../gradle/ConfigurationCacheForAndroidIT.kt | 4 +- .../jetbrains/kotlin/gradle/Kapt3AndroidIT.kt | 6 +- .../kotlin/gradle/KotlinGradlePluginIT.kt | 4 +- .../gradle/KotlinSpecificDependenciesIT.kt | 6 +- .../jetbrains/kotlin/gradle/SubpluginsIT.kt | 6 +- .../gradle/model/KotlinAndroidExtensionIT.kt | 7 +- .../kotlin/gradle/model/KotlinProjectIT.kt | 7 +- .../build.gradle.kts | 9 +- .../test/KotlinpCompilerTestDataTest.kt | 4 +- .../kotlin/kotlinp/test/KotlinpTestUtils.kt | 3 +- .../AbstractCommonizationFromSourcesTest.kt | 12 +- ...tNewJavaToKotlinCopyPasteConversionTest.kt | 6 +- .../synthetic/test/AbstractAndroidBoxTest.kt | 3 +- .../kapt3/test/AbstractKotlinKapt3Test.kt | 12 +- .../kotlin/kapt3/test/java9TestUtils.kt | 9 +- .../test/AbstractParcelizeBoxTest.kt | 6 +- .../kotlin/parcelize/test/testUtils.kt | 6 +- .../pacelize/ide/test/parcelizeTestUtil.kt | 6 +- settings.gradle | 2 + 189 files changed, 791 insertions(+), 630 deletions(-) create mode 100644 compiler/test-infrastructure-utils/build.gradle.kts rename compiler/{tests-common => test-infrastructure-utils}/tests/com/intellij/testFramework/TestDataFile.java (100%) rename compiler/{tests-common => test-infrastructure-utils}/tests/com/intellij/testFramework/TestDataPath.java (100%) rename compiler/{tests-common => test-infrastructure-utils}/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoParser.kt (100%) rename compiler/{tests-common => test-infrastructure-utils}/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoRenderer.kt (99%) rename compiler/{tests-common => test-infrastructure-utils}/tests/org/jetbrains/kotlin/codeMetaInfo/model/CodeMetaInfo.kt (100%) rename compiler/{tests-common => test-infrastructure-utils}/tests/org/jetbrains/kotlin/codeMetaInfo/model/DiagnosticCodeMetaInfo.kt (100%) rename compiler/{tests-common => test-infrastructure-utils}/tests/org/jetbrains/kotlin/codeMetaInfo/model/ParsedCodeMetaInfo.kt (100%) rename compiler/{tests-common => test-infrastructure-utils}/tests/org/jetbrains/kotlin/codeMetaInfo/renderConfigurations/AbstractCodeMetaInfoRenderConfiguration.kt (100%) rename compiler/{tests-common => test-infrastructure-utils}/tests/org/jetbrains/kotlin/codeMetaInfo/renderConfigurations/DiagnosticCodeMetaInfoRenderConfiguration.kt (100%) rename compiler/{tests-common => test-infrastructure-utils}/tests/org/jetbrains/kotlin/codeMetaInfo/renderConfigurations/ParsedCodeMetaInfoRenderConfiguration.kt (100%) rename compiler/{tests-common => test-infrastructure-utils}/tests/org/jetbrains/kotlin/codegen/forTestCompile/ForTestCompileRuntime.java (100%) create mode 100644 compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/util/KtTestUtil.java diff --git a/compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/CodegenTestsOnAndroidGenerator.kt b/compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/CodegenTestsOnAndroidGenerator.kt index 055daf8e553..d11d15d3c30 100644 --- a/compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/CodegenTestsOnAndroidGenerator.kt +++ b/compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/CodegenTestsOnAndroidGenerator.kt @@ -5,7 +5,6 @@ package org.jetbrains.kotlin.android.tests -import com.intellij.openapi.Disposable import com.intellij.openapi.util.Disposer import com.intellij.openapi.util.SystemInfo import com.intellij.openapi.util.io.FileUtil @@ -23,6 +22,7 @@ import org.jetbrains.kotlin.config.JvmTarget import org.jetbrains.kotlin.idea.KotlinFileType import org.jetbrains.kotlin.psi.KtFile import org.jetbrains.kotlin.test.* +import org.jetbrains.kotlin.test.util.KtTestUtil import org.junit.Assert import java.io.File import java.io.FileWriter @@ -303,7 +303,9 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager if (kind.withReflection) JVM8REFLECT else JVM8 } else if (kind.withReflection) REFLECT else COMMON val filesHolder = holders.getOrPut(key) { - FilesWriter(compiler, KotlinTestUtils.newConfiguration(kind, jdkKind, KotlinTestUtils.getAnnotationsJar()).apply { + FilesWriter(compiler, KotlinTestUtils.newConfiguration(kind, jdkKind, + KtTestUtil.getAnnotationsJar() + ).apply { println("Creating new configuration by $key") KotlinBaseTest.updateConfigurationByDirectivesInTestFiles(testFiles, this) }) @@ -341,7 +343,7 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager @Throws(IOException::class) internal fun writeAndroidSkdToLocalProperties(pathManager: PathManager) { - val sdkRoot = KotlinTestUtils.getAndroidSdkSystemIndependentPath() + val sdkRoot = KtTestUtil.getAndroidSdkSystemIndependentPath() println("Writing android sdk to local.properties: $sdkRoot") val file = File(pathManager.tmpFolder + "/local.properties") FileWriter(file).use { fw -> fw.write("sdk.dir=$sdkRoot") } diff --git a/compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/PathManager.java b/compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/PathManager.java index 4004b564612..8c135fc9f81 100644 --- a/compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/PathManager.java +++ b/compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/PathManager.java @@ -16,7 +16,7 @@ package org.jetbrains.kotlin.android.tests; -import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import java.io.File; @@ -69,7 +69,7 @@ public class PathManager { } public String getAndroidSdkRoot() { - return KotlinTestUtils.getAndroidSdkSystemIndependentPath(); + return KtTestUtil.getAndroidSdkSystemIndependentPath(); } public String getAndroidModuleRoot() { diff --git a/compiler/daemon/daemon-tests/test/org/jetbrains/kotlin/daemon/CompilerApiTest.kt b/compiler/daemon/daemon-tests/test/org/jetbrains/kotlin/daemon/CompilerApiTest.kt index 3dc53a600bf..820f7e26f06 100644 --- a/compiler/daemon/daemon-tests/test/org/jetbrains/kotlin/daemon/CompilerApiTest.kt +++ b/compiler/daemon/daemon-tests/test/org/jetbrains/kotlin/daemon/CompilerApiTest.kt @@ -18,8 +18,8 @@ package org.jetbrains.kotlin.daemon import com.intellij.openapi.application.ApplicationManager import org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments -import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSourceLocation import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity +import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSourceLocation import org.jetbrains.kotlin.cli.common.messages.MessageCollector import org.jetbrains.kotlin.cli.common.messages.OutputMessageUtil import org.jetbrains.kotlin.cli.jvm.K2JVMCompiler @@ -30,13 +30,16 @@ import org.jetbrains.kotlin.daemon.common.* import org.jetbrains.kotlin.integration.KotlinIntegrationTestBase import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.testFramework.resetApplicationToNull +import org.jetbrains.kotlin.test.util.KtTestUtil import org.junit.Assert import java.io.ByteArrayOutputStream import java.io.File import java.io.PrintStream import java.net.URLClassLoader import java.nio.file.Path -import kotlin.io.path.* +import kotlin.io.path.ExperimentalPathApi +import kotlin.io.path.createTempFile +import kotlin.io.path.deleteIfExists @OptIn(ExperimentalPathApi::class) class CompilerApiTest : KotlinIntegrationTestBase() { @@ -83,8 +86,8 @@ class CompilerApiTest : KotlinIntegrationTestBase() { return code to outputs } - private fun getHelloAppBaseDir(): String = KotlinTestUtils.getTestDataPathBase() + "/integration/smoke/helloApp" - private fun getSimpleScriptBaseDir(): String = KotlinTestUtils.getTestDataPathBase() + "/integration/smoke/simpleScript" + private fun getHelloAppBaseDir(): String = KtTestUtil.getTestDataPathBase() + "/integration/smoke/helloApp" + private fun getSimpleScriptBaseDir(): String = KtTestUtil.getTestDataPathBase() + "/integration/smoke/simpleScript" private fun run(baseDir: String, logName: String, vararg args: String): Int = runJava(baseDir, logName, *args) diff --git a/compiler/daemon/daemon-tests/test/org/jetbrains/kotlin/daemon/CompilerDaemonTest.kt b/compiler/daemon/daemon-tests/test/org/jetbrains/kotlin/daemon/CompilerDaemonTest.kt index 143c22d721b..519f6843453 100644 --- a/compiler/daemon/daemon-tests/test/org/jetbrains/kotlin/daemon/CompilerDaemonTest.kt +++ b/compiler/daemon/daemon-tests/test/org/jetbrains/kotlin/daemon/CompilerDaemonTest.kt @@ -27,7 +27,7 @@ import org.jetbrains.kotlin.daemon.client.* import org.jetbrains.kotlin.daemon.common.* import org.jetbrains.kotlin.integration.KotlinIntegrationTestBase import org.jetbrains.kotlin.progress.CompilationCanceledStatus -import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil import org.jetbrains.kotlin.utils.KotlinPaths import java.io.ByteArrayOutputStream import java.io.File @@ -95,8 +95,8 @@ class CompilerDaemonTest : KotlinIntegrationTestBase() { assertEquals("build results differ", AbstractCliTest.removePerfOutput(res1.out), AbstractCliTest.removePerfOutput(res2.out)) } - private fun getTestBaseDir(): String = KotlinTestUtils.getTestDataPathBase() + "/integration/smoke/" + getTestName(true) - private fun getHelloAppBaseDir(): String = KotlinTestUtils.getTestDataPathBase() + "/integration/smoke/helloApp" + private fun getTestBaseDir(): String = KtTestUtil.getTestDataPathBase() + "/integration/smoke/" + getTestName(true) + private fun getHelloAppBaseDir(): String = KtTestUtil.getTestDataPathBase() + "/integration/smoke/helloApp" private fun run(logName: String, vararg args: String): Int = runJava(getTestBaseDir(), logName, *args) diff --git a/compiler/daemon/daemon-tests/test/org/jetbrains/kotlin/daemon/experimental/integration/CompilerApiTest.kt b/compiler/daemon/daemon-tests/test/org/jetbrains/kotlin/daemon/experimental/integration/CompilerApiTest.kt index b28d713f0c1..ae0ba2d4086 100644 --- a/compiler/daemon/daemon-tests/test/org/jetbrains/kotlin/daemon/experimental/integration/CompilerApiTest.kt +++ b/compiler/daemon/daemon-tests/test/org/jetbrains/kotlin/daemon/experimental/integration/CompilerApiTest.kt @@ -8,8 +8,8 @@ package org.jetbrains.kotlin.daemon.experimental.integration import com.intellij.openapi.application.ApplicationManager import kotlinx.coroutines.runBlocking import org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments -import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSourceLocation import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity +import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSourceLocation import org.jetbrains.kotlin.cli.common.messages.MessageCollector import org.jetbrains.kotlin.cli.common.messages.OutputMessageUtil import org.jetbrains.kotlin.cli.jvm.K2JVMCompiler @@ -24,6 +24,7 @@ import org.jetbrains.kotlin.integration.KotlinIntegrationTestBase import org.jetbrains.kotlin.test.IgnoreAll import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.testFramework.resetApplicationToNull +import org.jetbrains.kotlin.test.util.KtTestUtil import org.junit.Assert import org.junit.runner.RunWith import java.io.File @@ -31,7 +32,8 @@ import java.net.URLClassLoader import java.nio.file.Path import java.util.logging.LogManager import java.util.logging.Logger -import kotlin.io.path.* +import kotlin.io.path.ExperimentalPathApi +import kotlin.io.path.createTempFile private val logFiles = arrayListOf() @@ -150,8 +152,8 @@ class CompilerApiTest : KotlinIntegrationTestBase() { code to outputs } - private fun getHelloAppBaseDir(): String = KotlinTestUtils.getTestDataPathBase() + "/integration/smoke/helloApp" - private fun getSimpleScriptBaseDir(): String = KotlinTestUtils.getTestDataPathBase() + "/integration/smoke/simpleScript" + private fun getHelloAppBaseDir(): String = KtTestUtil.getTestDataPathBase() + "/integration/smoke/helloApp" + private fun getSimpleScriptBaseDir(): String = KtTestUtil.getTestDataPathBase() + "/integration/smoke/simpleScript" private fun run(baseDir: String, logName: String, vararg args: String): Int = runJava(baseDir, logName, *args) diff --git a/compiler/daemon/daemon-tests/test/org/jetbrains/kotlin/daemon/experimental/integration/CompilerDaemonTest.kt b/compiler/daemon/daemon-tests/test/org/jetbrains/kotlin/daemon/experimental/integration/CompilerDaemonTest.kt index 40b3248281b..21541f86b35 100644 --- a/compiler/daemon/daemon-tests/test/org/jetbrains/kotlin/daemon/experimental/integration/CompilerDaemonTest.kt +++ b/compiler/daemon/daemon-tests/test/org/jetbrains/kotlin/daemon/experimental/integration/CompilerDaemonTest.kt @@ -28,7 +28,7 @@ import org.jetbrains.kotlin.daemon.common.experimental.findCallbackServerSocket import org.jetbrains.kotlin.integration.KotlinIntegrationTestBase import org.jetbrains.kotlin.progress.experimental.CompilationCanceledStatus import org.jetbrains.kotlin.test.IgnoreAll -import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil import org.jetbrains.kotlin.utils.KotlinPaths import org.junit.runner.RunWith import java.io.ByteArrayOutputStream @@ -157,8 +157,8 @@ class CompilerDaemonTest : KotlinIntegrationTestBase() { } } - private fun getTestBaseDir(): String = KotlinTestUtils.getTestDataPathBase() + "/integration/smoke/" + getTestName(true) - private fun getHelloAppBaseDir(): String = KotlinTestUtils.getTestDataPathBase() + "/integration/smoke/helloApp" + private fun getTestBaseDir(): String = KtTestUtil.getTestDataPathBase() + "/integration/smoke/" + getTestName(true) + private fun getHelloAppBaseDir(): String = KtTestUtil.getTestDataPathBase() + "/integration/smoke/helloApp" private fun run(logName: String, vararg args: String): Int = runJava(getTestBaseDir(), logName, *args) diff --git a/compiler/daemon/daemon-tests/test/org/jetbrains/kotlin/daemon/experimental/unit/ConnectionsTest.kt b/compiler/daemon/daemon-tests/test/org/jetbrains/kotlin/daemon/experimental/unit/ConnectionsTest.kt index 399f4d19086..b646f75b3d6 100644 --- a/compiler/daemon/daemon-tests/test/org/jetbrains/kotlin/daemon/experimental/unit/ConnectionsTest.kt +++ b/compiler/daemon/daemon-tests/test/org/jetbrains/kotlin/daemon/experimental/unit/ConnectionsTest.kt @@ -25,7 +25,7 @@ import org.jetbrains.kotlin.daemon.experimental.CompileServiceServerSideImpl import org.jetbrains.kotlin.daemon.loggerCompatiblePath import org.jetbrains.kotlin.integration.KotlinIntegrationTestBase import org.jetbrains.kotlin.test.IgnoreAll -import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil import org.junit.runner.RunWith import java.io.ByteArrayOutputStream import java.io.File @@ -36,7 +36,9 @@ import java.util.* import java.util.logging.LogManager import java.util.logging.Logger import kotlin.concurrent.schedule -import kotlin.io.path.* +import kotlin.io.path.ExperimentalPathApi +import kotlin.io.path.createTempFile +import kotlin.io.path.deleteIfExists @OptIn(ExperimentalPathApi::class) @RunWith(IgnoreAll::class) @@ -364,7 +366,7 @@ class ConnectionsTest : KotlinIntegrationTestBase() { CompileService.NO_SESSION, arrayOf( "-include-runtime", - File(KotlinTestUtils.getTestDataPathBase() + "/integration/smoke/helloApp", "hello.kt").absolutePath, + File(KtTestUtil.getTestDataPathBase() + "/integration/smoke/helloApp", "hello.kt").absolutePath, "-d", jar ), diff --git a/compiler/fir/analysis-tests/tests/org/jetbrains/kotlin/fir/java/AbstractFirTypeEnhancementTest.kt b/compiler/fir/analysis-tests/tests/org/jetbrains/kotlin/fir/java/AbstractFirTypeEnhancementTest.kt index 47147ad1248..5b9505f687d 100644 --- a/compiler/fir/analysis-tests/tests/org/jetbrains/kotlin/fir/java/AbstractFirTypeEnhancementTest.kt +++ b/compiler/fir/analysis-tests/tests/org/jetbrains/kotlin/fir/java/AbstractFirTypeEnhancementTest.kt @@ -31,9 +31,9 @@ import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.psi.psiUtil.getChildrenOfType import org.jetbrains.kotlin.test.* -import org.jetbrains.kotlin.test.KotlinTestUtils.getAnnotationsJar import org.jetbrains.kotlin.test.KotlinTestUtils.newConfiguration import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase +import org.jetbrains.kotlin.test.util.KtTestUtil.getAnnotationsJar import java.io.File import java.io.IOException import kotlin.reflect.jvm.javaField diff --git a/compiler/fir/raw-fir/psi2fir/tests/org/jetbrains/kotlin/fir/builder/AbstractRawFirBuilderTestCase.kt b/compiler/fir/raw-fir/psi2fir/tests/org/jetbrains/kotlin/fir/builder/AbstractRawFirBuilderTestCase.kt index 98586fc2da2..fc35efe7221 100644 --- a/compiler/fir/raw-fir/psi2fir/tests/org/jetbrains/kotlin/fir/builder/AbstractRawFirBuilderTestCase.kt +++ b/compiler/fir/raw-fir/psi2fir/tests/org/jetbrains/kotlin/fir/builder/AbstractRawFirBuilderTestCase.kt @@ -36,6 +36,7 @@ import org.jetbrains.kotlin.psi.KtFile import org.jetbrains.kotlin.psi.KtPsiFactory import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.testFramework.KtParsingTestCase +import org.jetbrains.kotlin.test.util.KtTestUtil import java.io.File import kotlin.reflect.full.memberProperties import kotlin.reflect.jvm.isAccessible @@ -45,7 +46,7 @@ abstract class AbstractRawFirBuilderTestCase : KtParsingTestCase( "kt", KotlinParserDefinition() ) { - override fun getTestDataPath() = KotlinTestUtils.getHomeDirectory() + override fun getTestDataPath() = KtTestUtil.getHomeDirectory() private fun createFile(filePath: String, fileType: IElementType): PsiFile { val psiFactory = KtPsiFactory(myProject) diff --git a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/AbstractIncrementalJvmCompilerRunnerTest.kt b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/AbstractIncrementalJvmCompilerRunnerTest.kt index a9a52efb938..327f5d7342f 100644 --- a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/AbstractIncrementalJvmCompilerRunnerTest.kt +++ b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/AbstractIncrementalJvmCompilerRunnerTest.kt @@ -21,7 +21,7 @@ import org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments import org.jetbrains.kotlin.incremental.utils.TestCompilationResult import org.jetbrains.kotlin.incremental.utils.TestICReporter import org.jetbrains.kotlin.incremental.utils.TestMessageCollector -import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil import java.io.ByteArrayOutputStream import java.io.File import javax.tools.ToolProvider @@ -79,6 +79,6 @@ abstract class AbstractIncrementalJvmCompilerRunnerTest : AbstractIncrementalCom private val compileClasspath = listOf( kotlinStdlibJvm, - KotlinTestUtils.getAnnotationsJar() + KtTestUtil.getAnnotationsJar() ).joinToString(File.pathSeparator) { it.canonicalPath } } diff --git a/compiler/test-infrastructure-utils/build.gradle.kts b/compiler/test-infrastructure-utils/build.gradle.kts new file mode 100644 index 00000000000..f1de835837d --- /dev/null +++ b/compiler/test-infrastructure-utils/build.gradle.kts @@ -0,0 +1,27 @@ +plugins { + kotlin("jvm") + id("jps-compatible") +} + +dependencies { + testImplementation(project(":compiler:fir:entrypoint")) + testImplementation(project(":compiler:cli")) + testImplementation(intellijCoreDep()) { includeJars("intellij-core") } + + testCompileOnly(project(":kotlin-reflect-api")) + testRuntimeOnly(project(":kotlin-reflect")) + testRuntimeOnly(project(":core:descriptors.runtime")) + + testImplementation(intellijDep()) { + // This dependency is needed only for FileComparisonFailure + includeJars("idea_rt", rootProject = rootProject) + isTransitive = false + } +} + +sourceSets { + "main" { none() } + "test" { projectDefault() } +} + +testsJar() diff --git a/compiler/tests-common/tests/com/intellij/testFramework/TestDataFile.java b/compiler/test-infrastructure-utils/tests/com/intellij/testFramework/TestDataFile.java similarity index 100% rename from compiler/tests-common/tests/com/intellij/testFramework/TestDataFile.java rename to compiler/test-infrastructure-utils/tests/com/intellij/testFramework/TestDataFile.java diff --git a/compiler/tests-common/tests/com/intellij/testFramework/TestDataPath.java b/compiler/test-infrastructure-utils/tests/com/intellij/testFramework/TestDataPath.java similarity index 100% rename from compiler/tests-common/tests/com/intellij/testFramework/TestDataPath.java rename to compiler/test-infrastructure-utils/tests/com/intellij/testFramework/TestDataPath.java diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoParser.kt b/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoParser.kt similarity index 100% rename from compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoParser.kt rename to compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoParser.kt diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoRenderer.kt b/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoRenderer.kt similarity index 99% rename from compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoRenderer.kt rename to compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoRenderer.kt index 8da47b321c6..01f783596a4 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoRenderer.kt +++ b/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoRenderer.kt @@ -9,7 +9,6 @@ import com.intellij.util.containers.Stack import org.jetbrains.kotlin.checkers.utils.CheckerTestUtil import org.jetbrains.kotlin.codeMetaInfo.model.CodeMetaInfo import java.io.File -import java.lang.StringBuilder object CodeMetaInfoRenderer { fun renderTagsToText( diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/CodeMetaInfo.kt b/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/codeMetaInfo/model/CodeMetaInfo.kt similarity index 100% rename from compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/CodeMetaInfo.kt rename to compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/codeMetaInfo/model/CodeMetaInfo.kt diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/DiagnosticCodeMetaInfo.kt b/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/codeMetaInfo/model/DiagnosticCodeMetaInfo.kt similarity index 100% rename from compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/DiagnosticCodeMetaInfo.kt rename to compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/codeMetaInfo/model/DiagnosticCodeMetaInfo.kt diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/ParsedCodeMetaInfo.kt b/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/codeMetaInfo/model/ParsedCodeMetaInfo.kt similarity index 100% rename from compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/model/ParsedCodeMetaInfo.kt rename to compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/codeMetaInfo/model/ParsedCodeMetaInfo.kt diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/renderConfigurations/AbstractCodeMetaInfoRenderConfiguration.kt b/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/codeMetaInfo/renderConfigurations/AbstractCodeMetaInfoRenderConfiguration.kt similarity index 100% rename from compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/renderConfigurations/AbstractCodeMetaInfoRenderConfiguration.kt rename to compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/codeMetaInfo/renderConfigurations/AbstractCodeMetaInfoRenderConfiguration.kt diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/renderConfigurations/DiagnosticCodeMetaInfoRenderConfiguration.kt b/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/codeMetaInfo/renderConfigurations/DiagnosticCodeMetaInfoRenderConfiguration.kt similarity index 100% rename from compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/renderConfigurations/DiagnosticCodeMetaInfoRenderConfiguration.kt rename to compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/codeMetaInfo/renderConfigurations/DiagnosticCodeMetaInfoRenderConfiguration.kt diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/renderConfigurations/ParsedCodeMetaInfoRenderConfiguration.kt b/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/codeMetaInfo/renderConfigurations/ParsedCodeMetaInfoRenderConfiguration.kt similarity index 100% rename from compiler/tests-common/tests/org/jetbrains/kotlin/codeMetaInfo/renderConfigurations/ParsedCodeMetaInfoRenderConfiguration.kt rename to compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/codeMetaInfo/renderConfigurations/ParsedCodeMetaInfoRenderConfiguration.kt diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/forTestCompile/ForTestCompileRuntime.java b/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/codegen/forTestCompile/ForTestCompileRuntime.java similarity index 100% rename from compiler/tests-common/tests/org/jetbrains/kotlin/codegen/forTestCompile/ForTestCompileRuntime.java rename to compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/codegen/forTestCompile/ForTestCompileRuntime.java diff --git a/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/util/KtTestUtil.java b/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/util/KtTestUtil.java new file mode 100644 index 00000000000..1d9b56b558b --- /dev/null +++ b/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/util/KtTestUtil.java @@ -0,0 +1,196 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.util; + +import com.intellij.openapi.project.Project; +import com.intellij.openapi.util.io.FileUtil; +import com.intellij.openapi.util.text.StringUtilRt; +import com.intellij.openapi.vfs.CharsetToolkit; +import com.intellij.psi.PsiFileFactory; +import com.intellij.psi.impl.PsiFileFactoryImpl; +import com.intellij.testFramework.LightVirtualFile; +import com.intellij.util.PathUtil; +import org.jetbrains.annotations.NonNls; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.kotlin.idea.KotlinLanguage; +import org.jetbrains.kotlin.psi.KtFile; + +import java.io.File; +import java.io.FileNotFoundException; +import java.io.IOException; + +public class KtTestUtil { + private static String homeDir = computeHomeDirectory(); + + @NotNull + public static File tmpDirForTest(@NotNull String testClassName, @NotNull String testName) throws IOException { + return normalizeFile(FileUtil.createTempDirectory(testClassName, testName, false)); + } + + @NotNull + public static File tmpDir(String name) throws IOException { + return normalizeFile(FileUtil.createTempDirectory(name, "", false)); + } + + @NotNull + public static File tmpDirForReusableFolder(String name) throws IOException { + return normalizeFile(FileUtil.createTempDirectory(new File(System.getProperty("java.io.tmpdir")), name, "", true)); + } + + private static File normalizeFile(File file) throws IOException { + // Get canonical file to be sure that it's the same as inside the compiler, + // for example, on Windows, if a canonical path contains any space from FileUtil.createTempDirectory we will get + // a File with short names (8.3) in its path and it will break some normalization passes in tests. + return file.getCanonicalFile(); + } + + @NotNull + public static KtFile createFile(@NotNull @NonNls String name, @NotNull String text, @NotNull Project project) { + String shortName = name.substring(name.lastIndexOf('/') + 1); + shortName = shortName.substring(shortName.lastIndexOf('\\') + 1); + LightVirtualFile virtualFile = new LightVirtualFile(shortName, KotlinLanguage.INSTANCE, StringUtilRt.convertLineSeparators(text)); + + virtualFile.setCharset(CharsetToolkit.UTF8_CHARSET); + PsiFileFactoryImpl factory = (PsiFileFactoryImpl) PsiFileFactory.getInstance(project); + //noinspection ConstantConditions + return (KtFile) factory.trySetupPsiForFile(virtualFile, KotlinLanguage.INSTANCE, true, false); + } + + public static String doLoadFile(String myFullDataPath, String name) throws IOException { + String fullName = myFullDataPath + File.separatorChar + name; + return doLoadFile(new File(fullName)); + } + + public static String doLoadFile(@NotNull File file) throws IOException { + try { + return FileUtil.loadFile(file, CharsetToolkit.UTF8, true); + } + catch (FileNotFoundException fileNotFoundException) { + /* + * Unfortunately, the FileNotFoundException will only show the relative path in it's exception message. + * This clarifies the exception by showing the full path. + */ + String messageWithFullPath = file.getAbsolutePath() + " (No such file or directory)"; + throw new IOException( + "Ensure you have your 'Working Directory' configured correctly as the root " + + "Kotlin project directory in your test configuration\n\t" + + messageWithFullPath, + fileNotFoundException); + } + } + + public static String getFilePath(File file) { + return FileUtil.toSystemIndependentName(file.getPath()); + } + + @NotNull + public static File getJdk9Home() { + String jdk9 = System.getenv("JDK_9"); + if (jdk9 == null) { + jdk9 = System.getenv("JDK_19"); + if (jdk9 == null) { + throw new AssertionError("Environment variable JDK_9 is not set!"); + } + } + return new File(jdk9); + } + + @Nullable + public static File getJdk11Home() { + String jdk11 = System.getenv("JDK_11"); + if (jdk11 == null) { + return null; + } + return new File(jdk11); + } + + @NotNull + public static File getJdk15Home() { + String jdk15 = System.getenv("JDK_15"); + + if (jdk15 == null) { + jdk15 = System.getenv("JDK_15_0"); + } + + if (jdk15 == null) { + throw new AssertionError("Environment variable JDK_15 is not set!"); + } + return new File(jdk15); + } + + @NotNull + public static String getTestDataPathBase() { + return getHomeDirectory() + "/compiler/testData"; + } + + @NotNull + public static String getHomeDirectory() { + return homeDir; + } + + @NotNull + private static String computeHomeDirectory() { + String userDir = System.getProperty("user.dir"); + File dir = new File(userDir == null ? "." : userDir); + return FileUtil.toCanonicalPath(dir.getAbsolutePath()); + } + + public static File findMockJdkRtJar() { + return new File(getHomeDirectory(), "compiler/testData/mockJDK/jre/lib/rt.jar"); + } + + // Differs from common mock JDK only by one additional 'nonExistingMethod' in Collection and constructor from Double in Throwable + // It's needed to test the way we load additional built-ins members that neither in black nor white lists + public static File findMockJdkRtModified() { + return new File(getHomeDirectory(), "compiler/testData/mockJDKModified/rt.jar"); + } + + public static File findAndroidApiJar() { + String androidJarProp = System.getProperty("android.jar"); + File androidJarFile = androidJarProp == null ? null : new File(androidJarProp); + if (androidJarFile == null || !androidJarFile.isFile()) { + throw new RuntimeException( + "Unable to get a valid path from 'android.jar' property (" + + androidJarProp + + "), please point it to the 'android.jar' file location"); + } + return androidJarFile; + } + + @NotNull + public static File findAndroidSdk() { + String androidSdkProp = System.getProperty("android.sdk"); + File androidSdkDir = androidSdkProp == null ? null : new File(androidSdkProp); + if (androidSdkDir == null || !androidSdkDir.isDirectory()) { + throw new RuntimeException( + "Unable to get a valid path from 'android.sdk' property (" + + androidSdkProp + + "), please point it to the android SDK location"); + } + return androidSdkDir; + } + + public static String getAndroidSdkSystemIndependentPath() { + return PathUtil.toSystemIndependentName(findAndroidSdk().getAbsolutePath()); + } + + public static File getAnnotationsJar() { + return new File(getHomeDirectory(), "compiler/testData/mockJDK/jre/lib/annotations.jar"); + } + + public static void mkdirs(@NotNull File file) { + if (file.isDirectory()) { + return; + } + if (!file.mkdirs()) { + if (file.exists()) { + throw new IllegalStateException("Failed to create " + file + ": file exists and not a directory"); + } + throw new IllegalStateException("Failed to create " + file); + } + } +} diff --git a/compiler/tests-against-klib/tests/org/jetbrains/kotlin/codegen/ir/AbstractIrCompileKotlinAgainstKlibTest.kt b/compiler/tests-against-klib/tests/org/jetbrains/kotlin/codegen/ir/AbstractIrCompileKotlinAgainstKlibTest.kt index cafff7cd662..66b468a6e55 100644 --- a/compiler/tests-against-klib/tests/org/jetbrains/kotlin/codegen/ir/AbstractIrCompileKotlinAgainstKlibTest.kt +++ b/compiler/tests-against-klib/tests/org/jetbrains/kotlin/codegen/ir/AbstractIrCompileKotlinAgainstKlibTest.kt @@ -13,8 +13,8 @@ import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment.Companion.cre import org.jetbrains.kotlin.codegen.AbstractBlackBoxCodegenTest import org.jetbrains.kotlin.config.CompilerConfiguration import org.jetbrains.kotlin.config.JVMConfigurationKeys -import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.TargetBackend +import org.jetbrains.kotlin.test.util.KtTestUtil import java.io.File import java.nio.file.Paths import java.util.* @@ -30,7 +30,7 @@ abstract class AbstractCompileKotlinAgainstKlibTest : AbstractBlackBoxCodegenTes klibName = Paths.get(outputDir.toString(), wholeFile.name.toString().removeSuffix(".kt")).toString() val classpath: MutableList = ArrayList() - classpath.add(KotlinTestUtils.getAnnotationsJar()) + classpath.add(KtTestUtil.getAnnotationsJar()) val configuration = createConfiguration( configurationKind, getTestJdkKind(files), backend, classpath, listOf(outputDir), files ) diff --git a/compiler/tests-common/build.gradle.kts b/compiler/tests-common/build.gradle.kts index 8ce16983e30..236b42857a4 100644 --- a/compiler/tests-common/build.gradle.kts +++ b/compiler/tests-common/build.gradle.kts @@ -48,6 +48,7 @@ dependencies { testCompile(project(":kotlin-test:kotlin-test-jvm")) testCompile(projectTests(":compiler:tests-common-jvm6")) testCompile(project(":kotlin-scripting-compiler-impl")) + testCompile(projectTests(":compiler:test-infrastructure-utils")) testCompile(commonDep("junit:junit")) testCompile(androidDxJar()) { isTransitive = false } testCompile(commonDep("com.android.tools:r8")) diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/cfg/javac/AbstractDiagnosticsTestWithStdLibUsingJavac.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/cfg/javac/AbstractDiagnosticsTestWithStdLibUsingJavac.kt index c67c91ed953..a0b65dd114d 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/cfg/javac/AbstractDiagnosticsTestWithStdLibUsingJavac.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/cfg/javac/AbstractDiagnosticsTestWithStdLibUsingJavac.kt @@ -20,7 +20,7 @@ import org.jetbrains.kotlin.checkers.AbstractDiagnosticsTestWithStdLib import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment import org.jetbrains.kotlin.config.JVMConfigurationKeys import org.jetbrains.kotlin.test.InTextDirectivesUtils -import org.jetbrains.kotlin.test.KotlinTestUtils.getHomeDirectory +import org.jetbrains.kotlin.test.util.KtTestUtil.getHomeDirectory import java.io.File abstract class AbstractDiagnosticsTestWithStdLibUsingJavac : AbstractDiagnosticsTestWithStdLib() { @@ -45,4 +45,4 @@ abstract class AbstractDiagnosticsTestWithStdLibUsingJavac : AbstractDiagnostics environment.configuration.put(JVMConfigurationKeys.USE_JAVAC, true) } -} \ No newline at end of file +} diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractForeignAnnotationsNoAnnotationInClasspathTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractForeignAnnotationsNoAnnotationInClasspathTest.kt index eb43b0551f5..a08c193f54e 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractForeignAnnotationsNoAnnotationInClasspathTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractForeignAnnotationsNoAnnotationInClasspathTest.kt @@ -18,14 +18,14 @@ package org.jetbrains.kotlin.checkers import org.jetbrains.kotlin.codegen.CodegenTestUtil import org.jetbrains.kotlin.test.InTextDirectivesUtils -import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil import java.io.File abstract class AbstractForeignAnnotationsNoAnnotationInClasspathTest : AbstractForeignAnnotationsTest() { // This should be executed after setUp runs, since setUp changes the root folder // for temporary files. private val compiledJavaPath by lazy { - KotlinTestUtils.tmpDir("java-compiled-files") + KtTestUtil.tmpDir("java-compiled-files") } override fun getExtraClasspath(): List { diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/BaseDiagnosticsTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/BaseDiagnosticsTest.kt index c6935bb88c3..5cd4b9a80c9 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/BaseDiagnosticsTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/BaseDiagnosticsTest.kt @@ -52,7 +52,7 @@ import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValueFactoryImpl import org.jetbrains.kotlin.test.Directives import org.jetbrains.kotlin.test.InTextDirectivesUtils.isDirectiveDefined import org.jetbrains.kotlin.test.KotlinBaseTest -import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil import org.jetbrains.kotlin.utils.addIfNotNull import org.junit.Assert import java.io.File @@ -118,12 +118,24 @@ abstract class BaseDiagnosticsTest : KotlinMultiFileTestWithJava { val result: MutableList = ArrayList() - result.add(KotlinTestUtils.getAnnotationsJar()) + result.add(KtTestUtil.getAnnotationsJar()) result.addAll(getExtraClasspath()) val fileText = file.readText(Charsets.UTF_8) if (InTextDirectivesUtils.isDirectiveDefined(fileText, "ANDROID_ANNOTATIONS")) { @@ -104,7 +108,7 @@ abstract class KotlinMultiFileTestWithJava ktFiles = - files.stream().map(file -> KotlinTestUtils.createFile(file.name, file.content, environment.getProject())) + files.stream().map(file -> KtTestUtil.createFile(file.name, file.content, environment.getProject())) .collect(Collectors.toList()); ModuleVisibilityManager.SERVICE.getInstance(environment.getProject()).addModule( diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractCustomJDKBlackBoxCodegenTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractCustomJDKBlackBoxCodegenTest.kt index 68bbe470618..348a67caff4 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractCustomJDKBlackBoxCodegenTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractCustomJDKBlackBoxCodegenTest.kt @@ -10,6 +10,7 @@ import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime import org.jetbrains.kotlin.test.ConfigurationKind import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.TestJdkKind +import org.jetbrains.kotlin.test.util.KtTestUtil import java.io.File import java.util.concurrent.TimeUnit @@ -18,7 +19,7 @@ abstract class AbstractCustomJDKBlackBoxCodegenTest : AbstractBlackBoxCodegenTes override fun doTest(filePath: String) { val file = File(filePath) val expectedText = - KotlinTestUtils.doLoadFile(file) + + KtTestUtil.doLoadFile(file) + "\n" + """ fun main() { diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractGenerateNotNullAssertionsTest.java b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractGenerateNotNullAssertionsTest.java index 3e9a6f3251b..e7a18772303 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractGenerateNotNullAssertionsTest.java +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractGenerateNotNullAssertionsTest.java @@ -19,6 +19,7 @@ import org.jetbrains.kotlin.psi.KtFile; import org.jetbrains.kotlin.test.ConfigurationKind; import org.jetbrains.kotlin.test.KotlinTestUtils; import org.jetbrains.kotlin.test.TestJdkKind; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.org.objectweb.asm.ClassReader; import org.jetbrains.org.objectweb.asm.ClassVisitor; import org.jetbrains.org.objectweb.asm.MethodVisitor; @@ -49,7 +50,7 @@ abstract public class AbstractGenerateNotNullAssertionsTest extends CodegenTestC } private void loadSource(@NotNull String fileName) { - loadFileByFullPath(KotlinTestUtils.getTestDataPathBase() + "/codegen/" + getPrefix() + "/" + fileName); + loadFileByFullPath(KtTestUtil.getTestDataPathBase() + "/codegen/" + getPrefix() + "/" + fileName); } protected void doTestNoAssertionsForKotlinFromBinary(String binaryDependencyFilename, String testFilename) { diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractJdk15BlackBoxCodegenTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractJdk15BlackBoxCodegenTest.kt index ade7bd2b4b8..de0a07b0643 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractJdk15BlackBoxCodegenTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractJdk15BlackBoxCodegenTest.kt @@ -5,13 +5,13 @@ package org.jetbrains.kotlin.codegen -import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.TestJdkKind +import org.jetbrains.kotlin.test.util.KtTestUtil import java.io.File abstract class AbstractJdk15BlackBoxCodegenTest : AbstractCustomJDKBlackBoxCodegenTest() { override fun getTestJdkKind(): TestJdkKind = TestJdkKind.FULL_JDK_15 - override fun getJdkHome(): File = KotlinTestUtils.getJdk15Home() + override fun getJdkHome(): File = KtTestUtil.getJdk15Home() override fun getPrefix(): String = "java15/box" override fun getAdditionalJvmArgs(): List = listOf("--enable-preview") diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractJdk9BlackBoxCodegenTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractJdk9BlackBoxCodegenTest.kt index 74ed94364cd..7d61b2af0a5 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractJdk9BlackBoxCodegenTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractJdk9BlackBoxCodegenTest.kt @@ -5,12 +5,12 @@ package org.jetbrains.kotlin.codegen -import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.TestJdkKind +import org.jetbrains.kotlin.test.util.KtTestUtil import java.io.File abstract class AbstractJdk9BlackBoxCodegenTest : AbstractCustomJDKBlackBoxCodegenTest() { override fun getTestJdkKind(): TestJdkKind = TestJdkKind.FULL_JDK_9 - override fun getJdkHome(): File = KotlinTestUtils.getJdk9Home() + override fun getJdkHome(): File = KtTestUtil.getJdk9Home() override fun getPrefix(): String = "java9/box" -} \ No newline at end of file +} diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractLightAnalysisModeTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractLightAnalysisModeTest.kt index b8b847fe465..349e603f1d3 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractLightAnalysisModeTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractLightAnalysisModeTest.kt @@ -15,7 +15,7 @@ import org.jetbrains.kotlin.load.java.JvmAbi import org.jetbrains.kotlin.resolve.jvm.AsmTypes import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisHandlerExtension import org.jetbrains.kotlin.resolve.jvm.extensions.PartialAnalysisHandlerExtension -import org.jetbrains.kotlin.test.KotlinTestUtils.getAnnotationsJar +import org.jetbrains.kotlin.test.util.KtTestUtil.getAnnotationsJar import org.jetbrains.org.objectweb.asm.Opcodes.* import java.io.File diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractTopLevelMembersInvocationTest.java b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractTopLevelMembersInvocationTest.java index 17a1e4d30b1..e62336dfb78 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractTopLevelMembersInvocationTest.java +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractTopLevelMembersInvocationTest.java @@ -24,6 +24,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles; import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment; import org.jetbrains.kotlin.test.*; +import org.jetbrains.kotlin.test.util.KtTestUtil; import java.io.File; import java.util.Collections; @@ -51,13 +52,13 @@ public abstract class AbstractTopLevelMembersInvocationTest extends AbstractByte getTestRootDisposable(), KotlinTestUtils.newConfiguration( ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, - CollectionsKt.plus(classPath, KotlinTestUtils.getAnnotationsJar()), Collections.emptyList() + CollectionsKt.plus(classPath, KtTestUtil.getAnnotationsJar()), Collections.emptyList() ), EnvironmentConfigFiles.JVM_CONFIG_FILES); loadFiles(ArrayUtil.toStringArray(sourceFiles)); - List expected = readExpectedOccurrences(KotlinTestUtils.getTestDataPathBase() + "/codegen/" + sourceFiles.get(0)); + List expected = readExpectedOccurrences(KtTestUtil.getTestDataPathBase() + "/codegen/" + sourceFiles.get(0)); String actual = generateToText(); Companion.checkGeneratedTextAgainstExpectedOccurrences(actual, expected, TargetBackend.ANY, true); } diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/CodegenTestCase.java b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/CodegenTestCase.java index 1d2aa0b83d6..ae2cb841d22 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/CodegenTestCase.java +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/CodegenTestCase.java @@ -38,6 +38,7 @@ import org.jetbrains.kotlin.scripting.definitions.ScriptDependenciesProvider; import org.jetbrains.kotlin.scripting.resolve.ScriptCompilationConfigurationWrapper; import org.jetbrains.kotlin.test.*; import org.jetbrains.kotlin.test.clientserver.TestProxy; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.utils.ExceptionUtilsKt; import org.jetbrains.org.objectweb.asm.ClassReader; import org.jetbrains.org.objectweb.asm.tree.ClassNode; @@ -63,8 +64,8 @@ import java.util.stream.Collectors; import static org.jetbrains.kotlin.cli.common.output.OutputUtilsKt.writeAllTo; import static org.jetbrains.kotlin.codegen.CodegenTestUtil.*; import static org.jetbrains.kotlin.codegen.TestUtilsKt.extractUrls; -import static org.jetbrains.kotlin.test.KotlinTestUtils.getAnnotationsJar; import static org.jetbrains.kotlin.test.clientserver.TestProcessServerKt.*; +import static org.jetbrains.kotlin.test.util.KtTestUtil.getAnnotationsJar; public abstract class CodegenTestCase extends KotlinBaseTest { private static final String DEFAULT_TEST_FILE_NAME = "a_test"; @@ -134,7 +135,7 @@ public abstract class CodegenTestCase extends KotlinBaseTest(0), null); - ktFiles.add(KotlinTestUtils.createFile(file.name, content, project)); + ktFiles.add(KtTestUtil.createFile(file.name, content, project)); } } @@ -608,7 +609,7 @@ public abstract class CodegenTestCase extends KotlinBaseTest testFiles = createTestFilesFromFile(file, expectedText); doMultiFileTest(file, testFiles); @@ -659,7 +660,7 @@ public abstract class CodegenTestCase extends KotlinBaseTest files = new ArrayList<>(names.length); for (String name : names) { try { - String content = KotlinTestUtils.doLoadFile(testDataPath + "/codegen/", name); - KtFile file = KotlinTestUtils.createFile(name, content, project); + String content = KtTestUtil.doLoadFile(testDataPath + "/codegen/", name); + KtFile file = KtTestUtil.createFile(name, content, project); files.add(file); } catch (IOException e) { @@ -103,7 +103,7 @@ public class CodegenTestFiles { public static CodegenTestFiles create(@NotNull String fileName, @NotNull String contentWithDiagnosticMarkup, @NotNull Project project) { // `rangesToDiagnosticNames` parameter is not-null only for diagnostic tests, it's using for lazy diagnostics String content = CheckerTestUtil.INSTANCE.parseDiagnosedRanges(contentWithDiagnosticMarkup, new ArrayList<>(), null); - KtFile file = KotlinTestUtils.createFile(fileName, content, project); + KtFile file = KtTestUtil.createFile(fileName, content, project); List ranges = AnalyzingUtils.getSyntaxErrorRanges(file); assert ranges.isEmpty() : "Syntax errors found in " + file + ": " + ranges; diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/CodegenTestUtil.java b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/CodegenTestUtil.java index b526bd0d784..6b563937420 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/CodegenTestUtil.java +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/CodegenTestUtil.java @@ -25,6 +25,7 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment; import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.utils.ExceptionUtilsKt; import org.jetbrains.kotlin.utils.StringsKt; @@ -85,7 +86,7 @@ public class CodegenTestUtil { @NotNull List additionalOptions ) { try { - File directory = KotlinTestUtils.tmpDir("java-classes"); + File directory = KtTestUtil.tmpDir("java-classes"); compileJava(fileNames, additionalClasspath, additionalOptions, directory); return directory; } @@ -118,7 +119,7 @@ public class CodegenTestUtil { List classpath = new ArrayList<>(); classpath.add(ForTestCompileRuntime.runtimeJarForTests().getPath()); classpath.add(ForTestCompileRuntime.reflectJarForTests().getPath()); - classpath.add(KotlinTestUtils.getAnnotationsJar().getPath()); + classpath.add(KtTestUtil.getAnnotationsJar().getPath()); classpath.addAll(additionalClasspath); List options = new ArrayList<>(Arrays.asList( diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/debugInformation/AbstractDebugTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/debugInformation/AbstractDebugTest.kt index 555355b3ad4..360fc31124b 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/debugInformation/AbstractDebugTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/debugInformation/AbstractDebugTest.kt @@ -25,10 +25,10 @@ import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.clientserver.TestProcessServer import org.jetbrains.kotlin.test.clientserver.TestProxy import org.jetbrains.kotlin.test.clientserver.getGeneratedClass +import org.jetbrains.kotlin.test.util.KtTestUtil import org.junit.After import org.junit.Before import java.io.File -import java.lang.IllegalStateException import java.net.URLClassLoader import kotlin.properties.Delegates @@ -158,7 +158,7 @@ abstract class AbstractDebugTest : CodegenTestCase() { GenerationUtils.compileFiles(myFiles.psiFiles, myEnvironment, classBuilderFactory) classFileFactory = generationState.factory - val tempDirForTest = KotlinTestUtils.tmpDir("debuggerTest") + val tempDirForTest = KtTestUtil.tmpDir("debuggerTest") val classesDir = File(tempDirForTest, "classes") try { classFileFactory.writeAllTo(classesDir) @@ -298,4 +298,4 @@ abstract class AbstractDebugTest : CodegenTestCase() { abstract fun storeStep(loggedItems: ArrayList, event: Event) abstract fun checkResult(wholeFile: File, loggedItems: List) -} \ No newline at end of file +} diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/fir/AbstractFirDiagnosticsWithLightTreeTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/fir/AbstractFirDiagnosticsWithLightTreeTest.kt index 05169864ad2..ca2cbf49a4c 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/fir/AbstractFirDiagnosticsWithLightTreeTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/fir/AbstractFirDiagnosticsWithLightTreeTest.kt @@ -12,14 +12,14 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirLightDiagnostic import org.jetbrains.kotlin.fir.declarations.FirFile import org.jetbrains.kotlin.psi.KtFile import org.jetbrains.kotlin.test.InTextDirectivesUtils -import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil import java.io.File import kotlin.math.abs abstract class AbstractFirDiagnosticsWithLightTreeTest : AbstractFirDiagnosticsTest() { override fun doTest(filePath: String) { val file = createTestFileFromPath(filePath) - val expectedText = KotlinTestUtils.doLoadFile(file) + val expectedText = KtTestUtil.doLoadFile(file) if (InTextDirectivesUtils.isDirectiveDefined(expectedText, "// IGNORE_LIGHT_TREE")) return super.doTest(filePath) diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/fir/FirTestUtils.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/fir/FirTestUtils.kt index f47f5c000c7..d323f75eb95 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/fir/FirTestUtils.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/fir/FirTestUtils.kt @@ -10,7 +10,7 @@ import junit.framework.TestCase import org.jetbrains.kotlin.checkers.BaseDiagnosticsTest.Companion.DIAGNOSTIC_IN_TESTDATA_PATTERN import org.jetbrains.kotlin.checkers.BaseDiagnosticsTest.Companion.SPEC_LINKED_TESTDATA_PATTERN import org.jetbrains.kotlin.checkers.BaseDiagnosticsTest.Companion.SPEC_NOT_LINED_TESTDATA_PATTERN -import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil import org.jetbrains.kotlin.test.util.trimTrailingWhitespacesAndAddNewlineAtEOF import java.io.File @@ -53,11 +53,11 @@ fun compareAndMergeFirFileAndOldFrontendFile( } private fun loadTestData(file: File, vararg patternsToBeRemoved: Regex): String { - var text = KotlinTestUtils.doLoadFile(file) + var text = KtTestUtil.doLoadFile(file) patternsToBeRemoved.forEach { text = text.replace(it, "") } return StringUtil.convertLineSeparators(text.trim()).trimTrailingWhitespacesAndAddNewlineAtEOF() } fun loadTestDataWithDiagnostics(file: File) = loadTestData(file, SPEC_LINKED_TESTDATA_PATTERN, SPEC_NOT_LINED_TESTDATA_PATTERN) -fun loadTestDataWithoutDiagnostics(file: File) = loadTestData(file, DIAGNOSTIC_IN_TESTDATA_PATTERN, SPEC_LINKED_TESTDATA_PATTERN) \ No newline at end of file +fun loadTestDataWithoutDiagnostics(file: File) = loadTestData(file, DIAGNOSTIC_IN_TESTDATA_PATTERN, SPEC_LINKED_TESTDATA_PATTERN) diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/integration/KotlinIntegrationTestBase.java b/compiler/tests-common/tests/org/jetbrains/kotlin/integration/KotlinIntegrationTestBase.java index ad81712d034..937f3296b05 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/integration/KotlinIntegrationTestBase.java +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/integration/KotlinIntegrationTestBase.java @@ -22,7 +22,6 @@ 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; @@ -35,6 +34,7 @@ import org.jetbrains.kotlin.config.KotlinCompilerVersion; import org.jetbrains.kotlin.test.KotlinTestUtils; import org.jetbrains.kotlin.test.TestCaseWithTmpdir; import org.jetbrains.kotlin.test.WithMutedInDatabaseRunTest; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.utils.KotlinPaths; import org.jetbrains.kotlin.utils.PathUtil; @@ -88,7 +88,7 @@ public abstract class KotlinIntegrationTestBase extends TestCaseWithTmpdir { content = normalizePath(content, testDataDir, "[TestData]"); content = normalizePath(content, tmpdir, "[Temp]"); content = normalizePath(content, getCompilerLib(), "[CompilerLib]"); - content = normalizePath(content, new File(KotlinTestUtils.getHomeDirectory()), "[KotlinProjectHome]"); + content = normalizePath(content, new File(KtTestUtil.getHomeDirectory()), "[KotlinProjectHome]"); content = content.replaceAll(Pattern.quote(KotlinCompilerVersion.VERSION), "[KotlinVersion]"); content = content.replaceAll("\\(JRE .+\\)", "(JRE [JREVersion])"); content = StringUtil.convertLineSeparators(content); @@ -177,4 +177,4 @@ public abstract class KotlinIntegrationTestBase extends TestCaseWithTmpdir { @Override public void processTerminated(ProcessEvent event) {} } -} \ No newline at end of file +} diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/ir/AbstractIrGeneratorTestCase.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/ir/AbstractIrGeneratorTestCase.kt index 8c13fecda66..fa8e35a6c8d 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/ir/AbstractIrGeneratorTestCase.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/ir/AbstractIrGeneratorTestCase.kt @@ -45,7 +45,7 @@ import org.jetbrains.kotlin.resolve.BindingContext import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil import org.jetbrains.kotlin.test.ConfigurationKind import org.jetbrains.kotlin.test.InTextDirectivesUtils -import org.jetbrains.kotlin.test.KotlinTestUtils.getAnnotationsJar +import org.jetbrains.kotlin.test.util.KtTestUtil.getAnnotationsJar import java.io.File import java.util.* diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileJavaAgainstKotlinTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileJavaAgainstKotlinTest.kt index 915e0118b9f..5d05ccfbacb 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileJavaAgainstKotlinTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileJavaAgainstKotlinTest.kt @@ -27,21 +27,24 @@ import org.jetbrains.kotlin.config.CompilerConfiguration import org.jetbrains.kotlin.config.JVMConfigurationKeys import org.jetbrains.kotlin.javac.JavacWrapper import org.jetbrains.kotlin.name.FqName -import org.jetbrains.kotlin.renderer.* +import org.jetbrains.kotlin.renderer.AnnotationArgumentsRenderingPolicy +import org.jetbrains.kotlin.renderer.DescriptorRenderer +import org.jetbrains.kotlin.renderer.DescriptorRendererModifier +import org.jetbrains.kotlin.renderer.ParameterNameRenderingPolicy import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil import org.jetbrains.kotlin.test.ConfigurationKind import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.KotlinTestUtils.createEnvironmentWithMockJdkAndIdeaAnnotations +import org.jetbrains.kotlin.test.KotlinTestUtils.newConfiguration import org.jetbrains.kotlin.test.TestCaseWithTmpdir import org.jetbrains.kotlin.test.TestJdkKind +import org.jetbrains.kotlin.test.util.KtTestUtil +import org.jetbrains.kotlin.test.util.RecursiveDescriptorComparator.validateAndCompareDescriptorWithFile import org.junit.Assert - import java.io.File import java.io.IOException import java.lang.annotation.Retention -import org.jetbrains.kotlin.test.KotlinTestUtils.* -import org.jetbrains.kotlin.test.util.RecursiveDescriptorComparator.validateAndCompareDescriptorWithFile - abstract class AbstractCompileJavaAgainstKotlinTest : TestCaseWithTmpdir() { @Throws(IOException::class) @@ -80,7 +83,8 @@ abstract class AbstractCompileJavaAgainstKotlinTest : TestCaseWithTmpdir() { if (!compiledSuccessfully) return - val configuration = newConfiguration(ConfigurationKind.ALL, TestJdkKind.FULL_JDK, getAnnotationsJar(), out) + val configuration = newConfiguration(ConfigurationKind.ALL, TestJdkKind.FULL_JDK, + KtTestUtil.getAnnotationsJar(), out) configuration.put(JVMConfigurationKeys.USE_PSI_CLASS_FILES_READING, true) val environment = KotlinCoreEnvironment.createForTests(testRootDisposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES) setupLanguageVersionSettingsForCompilerTests(ktFile.readText(), environment) diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileKotlinAgainstJavaTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileKotlinAgainstJavaTest.kt index bdaaf0c659a..14339751282 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileKotlinAgainstJavaTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileKotlinAgainstJavaTest.kt @@ -33,9 +33,11 @@ import org.jetbrains.kotlin.renderer.DescriptorRendererModifier import org.jetbrains.kotlin.renderer.ParameterNameRenderingPolicy import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil import org.jetbrains.kotlin.test.ConfigurationKind -import org.jetbrains.kotlin.test.KotlinTestUtils.* +import org.jetbrains.kotlin.test.KotlinTestUtils.createEnvironmentWithMockJdkAndIdeaAnnotations +import org.jetbrains.kotlin.test.KotlinTestUtils.newConfiguration import org.jetbrains.kotlin.test.TestCaseWithTmpdir import org.jetbrains.kotlin.test.TestJdkKind +import org.jetbrains.kotlin.test.util.KtTestUtil import org.jetbrains.kotlin.test.util.RecursiveDescriptorComparator.validateAndCompareDescriptorWithFile import org.junit.Assert import java.io.File @@ -67,13 +69,14 @@ abstract class AbstractCompileKotlinAgainstJavaTest : TestCaseWithTmpdir() { val environment = KotlinCoreEnvironment.createForTests( testRootDisposable, - newConfiguration(ConfigurationKind.ALL, TestJdkKind.MOCK_JDK, getAnnotationsJar(), out), + newConfiguration(ConfigurationKind.ALL, TestJdkKind.MOCK_JDK, + KtTestUtil.getAnnotationsJar(), out), EnvironmentConfigFiles.JVM_CONFIG_FILES ) environment.configuration.put(JVMConfigurationKeys.USE_JAVAC, true) environment.configuration.put(JVMConfigurationKeys.OUTPUT_DIRECTORY, out) - environment.registerJavac(emptyList(), bootClasspath = listOf(findMockJdkRtJar())) + environment.registerJavac(emptyList(), bootClasspath = listOf(KtTestUtil.findMockJdkRtJar())) val analysisResult = JvmResolveUtil.analyze(environment) val packageView = analysisResult.moduleDescriptor.getPackage(LoadDescriptorUtil.TEST_PACKAGE_FQNAME) @@ -95,13 +98,17 @@ abstract class AbstractCompileKotlinAgainstJavaTest : TestCaseWithTmpdir() { environment.configuration.put(JVMConfigurationKeys.USE_JAVAC, true) environment.configuration.put(JVMConfigurationKeys.COMPILE_JAVA, true) val ktFiles = kotlinFiles.map { kotlinFile: File -> - createFile(kotlinFile.name, FileUtil.loadFile(kotlinFile, true), environment.project) + KtTestUtil.createFile( + kotlinFile.name, + FileUtil.loadFile(kotlinFile, true), + environment.project + ) } environment.registerJavac( javaFiles = javaFiles, kotlinFiles = ktFiles, arguments = if (aptMode) arrayOf() else arrayOf("-proc:none"), - bootClasspath = listOf(findMockJdkRtJar()) + bootClasspath = listOf(KtTestUtil.findMockJdkRtJar()) ) ModuleVisibilityManager.SERVICE.getInstance(environment.project).addModule( ModuleBuilder("module for test", tmpdir.absolutePath, "test") diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJava15Test.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJava15Test.kt index f55f166d6a4..100ea799eb3 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJava15Test.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJava15Test.kt @@ -5,14 +5,14 @@ package org.jetbrains.kotlin.jvm.compiler -import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.TestJdkKind +import org.jetbrains.kotlin.test.util.KtTestUtil import java.io.File abstract class AbstractLoadJava15Test : AbstractLoadJavaTest() { override fun getJdkKind(): TestJdkKind = TestJdkKind.FULL_JDK_15 - override fun getJdkHomeForJavac(): File = KotlinTestUtils.getJdk15Home() + override fun getJdkHomeForJavac(): File = KtTestUtil.getJdk15Home() override fun getAdditionalJavacArgs(): List = ADDITIONAL_JAVAC_ARGS_FOR_15 } -val ADDITIONAL_JAVAC_ARGS_FOR_15 = listOf("--release", "15", "--enable-preview") \ No newline at end of file +val ADDITIONAL_JAVAC_ARGS_FOR_15 = listOf("--release", "15", "--enable-preview") diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJava15WithPsiClassReadingTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJava15WithPsiClassReadingTest.kt index 65f174495d0..5b5028ab17c 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJava15WithPsiClassReadingTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJava15WithPsiClassReadingTest.kt @@ -5,12 +5,12 @@ package org.jetbrains.kotlin.jvm.compiler -import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.TestJdkKind +import org.jetbrains.kotlin.test.util.KtTestUtil import java.io.File abstract class AbstractLoadJava15WithPsiClassReadingTest : AbstractLoadJavaWithPsiClassReadingTest() { override fun getJdkKind(): TestJdkKind = TestJdkKind.FULL_JDK_15 - override fun getJdkHomeForJavac(): File = KotlinTestUtils.getJdk15Home() + override fun getJdkHomeForJavac(): File = KtTestUtil.getJdk15Home() override fun getAdditionalJavacArgs(): List = ADDITIONAL_JAVAC_ARGS_FOR_15 } diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java b/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java index 059b070975f..2855bf494d9 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java @@ -31,6 +31,7 @@ import org.jetbrains.kotlin.resolve.DescriptorUtils; import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedClassDescriptor; import org.jetbrains.kotlin.test.*; import org.jetbrains.kotlin.test.util.DescriptorValidator; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.junit.Assert; import java.io.File; @@ -39,7 +40,8 @@ import java.util.*; import java.util.regex.Pattern; import static org.jetbrains.kotlin.jvm.compiler.LoadDescriptorUtil.*; -import static org.jetbrains.kotlin.test.KotlinTestUtils.*; +import static org.jetbrains.kotlin.test.KotlinTestUtils.compileKotlinWithJava; +import static org.jetbrains.kotlin.test.KotlinTestUtils.newConfiguration; import static org.jetbrains.kotlin.test.util.DescriptorValidator.ValidationVisitor.errorTypesAllowed; import static org.jetbrains.kotlin.test.util.DescriptorValidator.ValidationVisitor.errorTypesForbidden; import static org.jetbrains.kotlin.test.util.RecursiveDescriptorComparator.*; @@ -89,7 +91,7 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { @NotNull private List getClasspath(File... files) { List classpath = new ArrayList<>(getExtraClasspath()); - classpath.add(getAnnotationsJar()); + classpath.add(KtTestUtil.getAnnotationsJar()); classpath.addAll(Arrays.asList(files)); return classpath; } @@ -240,7 +242,7 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { ); registerJavacIfNeeded(environment); configureEnvironment(environment); - KtFile ktFile = KotlinTestUtils.createFile(kotlinSrc.getPath(), FileUtil.loadFile(kotlinSrc, true), environment.getProject()); + KtFile ktFile = KtTestUtil.createFile(kotlinSrc.getPath(), FileUtil.loadFile(kotlinSrc, true), environment.getProject()); ModuleDescriptor module = GenerationUtils.compileFiles(Collections.singletonList(ktFile), environment).getModule(); PackageViewDescriptor packageView = module.getPackage(TEST_PACKAGE_FQNAME); diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/LoadDescriptorUtil.java b/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/LoadDescriptorUtil.java index 149e68e72ca..0aae9989fa1 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/LoadDescriptorUtil.java +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/LoadDescriptorUtil.java @@ -47,6 +47,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.util.KtTestUtil; import org.jetbrains.kotlin.utils.ExceptionUtilsKt; import java.io.File; @@ -111,7 +112,7 @@ public class LoadDescriptorUtil { ) { List javaBinaryRoots = new ArrayList<>(); // TODO: use the same additional binary roots as those were used for compilation - javaBinaryRoots.add(KotlinTestUtils.getAnnotationsJar()); + javaBinaryRoots.add(KtTestUtil.getAnnotationsJar()); javaBinaryRoots.add(ForTestCompileRuntime.jvmAnnotationsForTests()); javaBinaryRoots.addAll(additionalClasspath); @@ -156,7 +157,7 @@ public class LoadDescriptorUtil { List classpath = new ArrayList<>(); classpath.add(ForTestCompileRuntime.runtimeJarForTests()); - classpath.add(KotlinTestUtils.getAnnotationsJar()); + classpath.add(KtTestUtil.getAnnotationsJar()); for (File test : javaFiles) { String content = FilesKt.readText(test, Charsets.UTF_8); @@ -189,7 +190,7 @@ public class LoadDescriptorUtil { private static List createKtFiles(@NotNull List kotlinFiles, @NotNull KotlinCoreEnvironment environment) { return CollectionsKt.map(kotlinFiles, kotlinFile -> { try { - return KotlinTestUtils.createFile(kotlinFile.getName(), FileUtil.loadFile(kotlinFile, true), environment.getProject()); + return KtTestUtil.createFile(kotlinFile.getName(), FileUtil.loadFile(kotlinFile, true), environment.getProject()); } catch (IOException e) { throw ExceptionUtilsKt.rethrow(e); diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/resolve/ExtensibleResolveTestCase.java b/compiler/tests-common/tests/org/jetbrains/kotlin/resolve/ExtensibleResolveTestCase.java index 0ca2cf943ee..0d9b4bb7b47 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/resolve/ExtensibleResolveTestCase.java +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/resolve/ExtensibleResolveTestCase.java @@ -13,6 +13,7 @@ import org.jetbrains.kotlin.config.CompilerConfiguration; import org.jetbrains.kotlin.config.JVMConfigurationKeys; import org.jetbrains.kotlin.psi.KtFile; import org.jetbrains.kotlin.test.*; +import org.jetbrains.kotlin.test.util.KtTestUtil; import java.io.File; import java.util.List; @@ -43,7 +44,7 @@ public abstract class ExtensibleResolveTestCase extends KotlinTestWithEnvironmen protected void doTest(@NonNls String filePath) throws Exception { File file = new File(filePath); - String text = KotlinTestUtils.doLoadFile(file); + String text = KtTestUtil.doLoadFile(file); List files = TestFiles.createTestFiles("file.kt", text, new TestFiles.TestFileFactoryNoModules() { @NotNull @Override diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/resolve/annotation/AbstractAnnotationDescriptorResolveTest.java b/compiler/tests-common/tests/org/jetbrains/kotlin/resolve/annotation/AbstractAnnotationDescriptorResolveTest.java index 6c63f80fe26..1fda6a24be0 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/resolve/annotation/AbstractAnnotationDescriptorResolveTest.java +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/resolve/annotation/AbstractAnnotationDescriptorResolveTest.java @@ -43,6 +43,7 @@ import org.jetbrains.kotlin.resolve.lazy.descriptors.PackageDescriptorUtilKt; import org.jetbrains.kotlin.resolve.scopes.MemberScope; import org.jetbrains.kotlin.test.KotlinTestUtils; import org.jetbrains.kotlin.test.KotlinTestWithEnvironment; +import org.jetbrains.kotlin.test.util.KtTestUtil; import java.io.File; import java.io.IOException; @@ -340,7 +341,7 @@ public abstract class AbstractAnnotationDescriptorResolveTest extends KotlinTest @NotNull protected KtFile getFile(@NotNull String content) { - KtFile ktFile = KotlinTestUtils.createFile("dummy.kt", content, getProject()); + KtFile ktFile = KtTestUtil.createFile("dummy.kt", content, getProject()); analysisResult = KotlinTestUtils.analyzeFile(ktFile, getEnvironment()); return ktFile; @@ -361,7 +362,7 @@ public abstract class AbstractAnnotationDescriptorResolveTest extends KotlinTest protected static String getContent(@NotNull String annotationText) throws IOException { File file = new File(PATH); - return KotlinTestUtils.doLoadFile(file).replaceAll("ANNOTATION", annotationText); + return KtTestUtil.doLoadFile(file).replaceAll("ANNOTATION", annotationText); } public static String renderAnnotations(Annotations annotations) { diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/resolve/calls/AbstractResolvedCallsTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/resolve/calls/AbstractResolvedCallsTest.kt index d7e70600959..a62ebc80ef6 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/resolve/calls/AbstractResolvedCallsTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/resolve/calls/AbstractResolvedCallsTest.kt @@ -43,13 +43,14 @@ import org.jetbrains.kotlin.resolve.scopes.receivers.Receiver import org.jetbrains.kotlin.test.ConfigurationKind import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.KotlinTestWithEnvironment +import org.jetbrains.kotlin.test.util.KtTestUtil import java.io.File abstract class AbstractResolvedCallsTest : KotlinTestWithEnvironment() { override fun createEnvironment(): KotlinCoreEnvironment = createEnvironmentWithMockJdk(ConfigurationKind.ALL) fun doTest(filePath: String) { - val originalText = KotlinTestUtils.doLoadFile(File(filePath))!! + val originalText = KtTestUtil.doLoadFile(File(filePath))!! val (text, carets) = extractCarets(originalText) setupLanguageVersionSettingsForCompilerTests(originalText, environment) diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/resolve/constraintSystem/AbstractConstraintSystemTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/resolve/constraintSystem/AbstractConstraintSystemTest.kt index 74caf625775..5ef4406b9d0 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/resolve/constraintSystem/AbstractConstraintSystemTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/resolve/constraintSystem/AbstractConstraintSystemTest.kt @@ -28,6 +28,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.util.KtTestUtil import org.jetbrains.kotlin.tests.di.createContainerForTests import org.jetbrains.kotlin.types.ErrorUtils import org.jetbrains.kotlin.types.KotlinType @@ -61,12 +62,16 @@ abstract class AbstractConstraintSystemTest : KotlinTestWithEnvironment() { } private val testDataPath: String - get() = KotlinTestUtils.getTestDataPathBase() + "/constraintSystem/" + get() = KtTestUtil.getTestDataPathBase() + "/constraintSystem/" private fun analyzeDeclarations(): ConstraintSystemTestData { val fileName = "declarations.kt" - val psiFile = KotlinTestUtils.createFile(fileName, KotlinTestUtils.doLoadFile(testDataPath, fileName), project) + val psiFile = KtTestUtil.createFile( + fileName, + KtTestUtil.doLoadFile(testDataPath, fileName), + project + ) val bindingContext = JvmResolveUtil.analyzeAndCheckForErrors(psiFile, environment).bindingContext return ConstraintSystemTestData(bindingContext, project, typeResolver) } diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/test/CompilerTestUtil.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/test/CompilerTestUtil.kt index 38206c3b802..9f368d1db1d 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/test/CompilerTestUtil.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/test/CompilerTestUtil.kt @@ -19,6 +19,7 @@ package org.jetbrains.kotlin.test import org.jetbrains.kotlin.cli.common.CLITool import org.jetbrains.kotlin.cli.common.ExitCode import org.jetbrains.kotlin.cli.jvm.K2JVMCompiler +import org.jetbrains.kotlin.test.util.KtTestUtil import java.io.ByteArrayOutputStream import java.io.File import java.io.PrintStream @@ -53,7 +54,7 @@ object CompilerTestUtil { extraOptions: List = emptyList(), extraClasspath: List = emptyList() ): File { - val destination = File(KotlinTestUtils.tmpDir("testLibrary"), "$libraryName.jar") + val destination = File(KtTestUtil.tmpDir("testLibrary"), "$libraryName.jar") val args = mutableListOf().apply { add(src.path) add("-d") diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/test/KotlinBaseTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/test/KotlinBaseTest.kt index f41d9d4ce5a..d7b27140cef 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/test/KotlinBaseTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/test/KotlinBaseTest.kt @@ -18,6 +18,7 @@ import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime import org.jetbrains.kotlin.config.* import org.jetbrains.kotlin.config.JvmTarget.Companion.fromString import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase +import org.jetbrains.kotlin.test.util.KtTestUtil import java.io.File import java.lang.reflect.Field import java.util.* @@ -32,7 +33,7 @@ abstract class KotlinBaseTest : KtUsefulTestCase() @Throws(java.lang.Exception::class) protected open fun doTest(filePath: String) { val file = File(filePath) - val expectedText = KotlinTestUtils.doLoadFile(file) + val expectedText = KtTestUtil.doLoadFile(file) doMultiFileTest(file, createTestFilesFromFile(file, expectedText)) } diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/test/KotlinTestUtils.java b/compiler/tests-common/tests/org/jetbrains/kotlin/test/KotlinTestUtils.java index a45ce8992f6..a5390e30c57 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/test/KotlinTestUtils.java +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/test/KotlinTestUtils.java @@ -12,19 +12,13 @@ import com.intellij.openapi.editor.Document; import com.intellij.openapi.editor.Editor; import com.intellij.openapi.project.Project; import com.intellij.openapi.util.Comparing; -import com.intellij.openapi.util.ShutDownTracker; import com.intellij.openapi.util.SystemInfo; import com.intellij.openapi.util.io.FileUtil; import com.intellij.openapi.util.text.StringUtil; -import com.intellij.openapi.util.text.StringUtilRt; import com.intellij.openapi.vfs.CharsetToolkit; import com.intellij.psi.PsiElement; -import com.intellij.psi.PsiFileFactory; -import com.intellij.psi.impl.PsiFileFactoryImpl; import com.intellij.rt.execution.junit.FileComparisonFailure; -import com.intellij.testFramework.LightVirtualFile; import com.intellij.testFramework.TestDataFile; -import com.intellij.util.PathUtil; import com.intellij.util.containers.ContainerUtil; import junit.framework.TestCase; import kotlin.Unit; @@ -32,7 +26,6 @@ import kotlin.collections.CollectionsKt; import kotlin.collections.SetsKt; import kotlin.jvm.functions.Function0; import kotlin.jvm.functions.Function1; -import org.jetbrains.annotations.NonNls; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.analyzer.AnalysisResult; @@ -43,8 +36,8 @@ import org.jetbrains.kotlin.checkers.CompilerTestLanguageVersionSettingsKt; import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys; import org.jetbrains.kotlin.cli.common.config.ContentRootsKt; import org.jetbrains.kotlin.cli.common.config.KotlinSourceRoot; -import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSourceLocation; import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity; +import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSourceLocation; import org.jetbrains.kotlin.cli.common.messages.MessageCollector; import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles; import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment; @@ -52,7 +45,6 @@ import org.jetbrains.kotlin.cli.jvm.config.JvmContentRootsKt; import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime; import org.jetbrains.kotlin.config.*; import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl; -import org.jetbrains.kotlin.idea.KotlinLanguage; import org.jetbrains.kotlin.jvm.compiler.LoadDescriptorUtil; import org.jetbrains.kotlin.lexer.KtTokens; import org.jetbrains.kotlin.name.Name; @@ -61,12 +53,12 @@ import org.jetbrains.kotlin.psi.KtPsiFactoryKt; import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil; import org.jetbrains.kotlin.storage.LockBasedStorageManager; import org.jetbrains.kotlin.test.util.JetTestUtilsKt; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.utils.ExceptionUtilsKt; import org.junit.Assert; import javax.tools.*; import java.io.File; -import java.io.FileNotFoundException; import java.io.IOException; import java.io.StringWriter; import java.lang.annotation.Annotation; @@ -96,8 +88,6 @@ public class KotlinTestUtils { private static final boolean AUTOMATICALLY_UNMUTE_PASSED_TESTS = false; private static final boolean AUTOMATICALLY_MUTE_FAILED_TESTS = false; - private static final List filesToDelete = new ArrayList<>(); - private static final Pattern DIRECTIVE_PATTERN = Pattern.compile("^//\\s*[!]?([A-Z_]+)(:[ \\t]*(.*))?$", Pattern.MULTILINE); private KotlinTestUtils() { @@ -125,7 +115,7 @@ public class KotlinTestUtils { @NotNull TestJdkKind jdkKind ) { return KotlinCoreEnvironment.createForTests( - disposable, newConfiguration(configurationKind, jdkKind, getAnnotationsJar()), EnvironmentConfigFiles.JVM_CONFIG_FILES + disposable, newConfiguration(configurationKind, jdkKind, KtTestUtil.getAnnotationsJar()), EnvironmentConfigFiles.JVM_CONFIG_FILES ); } @@ -134,156 +124,9 @@ public class KotlinTestUtils { return createEnvironmentWithJdkAndNullabilityAnnotationsFromIdea(disposable, ConfigurationKind.ALL, TestJdkKind.FULL_JDK); } - @NotNull - public static String getTestDataPathBase() { - return getHomeDirectory() + "/compiler/testData"; - } - - private static String homeDir = computeHomeDirectory(); - - @NotNull - public static String getHomeDirectory() { - return homeDir; - } - - @NotNull - private static String computeHomeDirectory() { - String userDir = System.getProperty("user.dir"); - File dir = new File(userDir == null ? "." : userDir); - return FileUtil.toCanonicalPath(dir.getAbsolutePath()); - } - - public static File findMockJdkRtJar() { - return new File(getHomeDirectory(), "compiler/testData/mockJDK/jre/lib/rt.jar"); - } - - // Differs from common mock JDK only by one additional 'nonExistingMethod' in Collection and constructor from Double in Throwable - // It's needed to test the way we load additional built-ins members that neither in black nor white lists - public static File findMockJdkRtModified() { - return new File(getHomeDirectory(), "compiler/testData/mockJDKModified/rt.jar"); - } - - public static File findAndroidApiJar() { - String androidJarProp = System.getProperty("android.jar"); - File androidJarFile = androidJarProp == null ? null : new File(androidJarProp); - if (androidJarFile == null || !androidJarFile.isFile()) { - throw new RuntimeException( - "Unable to get a valid path from 'android.jar' property (" + - androidJarProp + - "), please point it to the 'android.jar' file location"); - } - return androidJarFile; - } - - @NotNull - public static File findAndroidSdk() { - String androidSdkProp = System.getProperty("android.sdk"); - File androidSdkDir = androidSdkProp == null ? null : new File(androidSdkProp); - if (androidSdkDir == null || !androidSdkDir.isDirectory()) { - throw new RuntimeException( - "Unable to get a valid path from 'android.sdk' property (" + - androidSdkProp + - "), please point it to the android SDK location"); - } - return androidSdkDir; - } - - public static String getAndroidSdkSystemIndependentPath() { - return PathUtil.toSystemIndependentName(findAndroidSdk().getAbsolutePath()); - } - - public static File getAnnotationsJar() { - return new File(getHomeDirectory(), "compiler/testData/mockJDK/jre/lib/annotations.jar"); - } - - public static void mkdirs(@NotNull File file) { - if (file.isDirectory()) { - return; - } - if (!file.mkdirs()) { - if (file.exists()) { - throw new IllegalStateException("Failed to create " + file + ": file exists and not a directory"); - } - throw new IllegalStateException("Failed to create " + file); - } - } - - @NotNull - public static File tmpDirForTest(@NotNull String testClassName, @NotNull String testName) throws IOException { - return normalizeFile(FileUtil.createTempDirectory(testClassName, testName, false)); - } - @NotNull public static File tmpDirForTest(TestCase test) throws IOException { - return tmpDirForTest(test.getClass().getSimpleName(), test.getName()); - } - - @NotNull - public static File tmpDir(String name) throws IOException { - return normalizeFile(FileUtil.createTempDirectory(name, "", false)); - } - - @NotNull - public static File tmpDirForReusableFolder(String name) throws IOException { - return normalizeFile(FileUtil.createTempDirectory(new File(System.getProperty("java.io.tmpdir")), name, "", true)); - } - - private static File normalizeFile(File file) throws IOException { - // Get canonical file to be sure that it's the same as inside the compiler, - // for example, on Windows, if a canonical path contains any space from FileUtil.createTempDirectory we will get - // a File with short names (8.3) in its path and it will break some normalization passes in tests. - return file.getCanonicalFile(); - } - - private static void deleteOnShutdown(File file) { - if (filesToDelete.isEmpty()) { - ShutDownTracker.getInstance().registerShutdownTask(() -> { - for (File victim : filesToDelete) { - FileUtil.delete(victim); - } - }); - } - - filesToDelete.add(file); - } - - @NotNull - public static KtFile createFile(@NotNull @NonNls String name, @NotNull String text, @NotNull Project project) { - String shortName = name.substring(name.lastIndexOf('/') + 1); - shortName = shortName.substring(shortName.lastIndexOf('\\') + 1); - LightVirtualFile virtualFile = new LightVirtualFile(shortName, KotlinLanguage.INSTANCE, StringUtilRt.convertLineSeparators(text)); - - virtualFile.setCharset(CharsetToolkit.UTF8_CHARSET); - PsiFileFactoryImpl factory = (PsiFileFactoryImpl) PsiFileFactory.getInstance(project); - //noinspection ConstantConditions - return (KtFile) factory.trySetupPsiForFile(virtualFile, KotlinLanguage.INSTANCE, true, false); - } - - public static String doLoadFile(String myFullDataPath, String name) throws IOException { - String fullName = myFullDataPath + File.separatorChar + name; - return doLoadFile(new File(fullName)); - } - - public static String doLoadFile(@NotNull File file) throws IOException { - try { - return FileUtil.loadFile(file, CharsetToolkit.UTF8, true); - } - catch (FileNotFoundException fileNotFoundException) { - /* - * Unfortunately, the FileNotFoundException will only show the relative path in it's exception message. - * This clarifies the exception by showing the full path. - */ - String messageWithFullPath = file.getAbsolutePath() + " (No such file or directory)"; - throw new IOException( - "Ensure you have your 'Working Directory' configured correctly as the root " + - "Kotlin project directory in your test configuration\n\t" + - messageWithFullPath, - fileNotFoundException); - } - } - - public static String getFilePath(File file) { - return FileUtil.toSystemIndependentName(file.getPath()); + return KtTestUtil.tmpDirForTest(test.getClass().getSimpleName(), test.getName()); } @NotNull @@ -346,15 +189,15 @@ public class KotlinTestUtils { CompilerConfiguration configuration = newConfiguration(); JvmContentRootsKt.addJavaSourceRoots(configuration, javaSource); if (jdkKind == TestJdkKind.MOCK_JDK) { - JvmContentRootsKt.addJvmClasspathRoot(configuration, findMockJdkRtJar()); + JvmContentRootsKt.addJvmClasspathRoot(configuration, KtTestUtil.findMockJdkRtJar()); configuration.put(JVMConfigurationKeys.NO_JDK, true); } else if (jdkKind == TestJdkKind.MODIFIED_MOCK_JDK) { - JvmContentRootsKt.addJvmClasspathRoot(configuration, findMockJdkRtModified()); + JvmContentRootsKt.addJvmClasspathRoot(configuration, KtTestUtil.findMockJdkRtModified()); configuration.put(JVMConfigurationKeys.NO_JDK, true); } else if (jdkKind == TestJdkKind.ANDROID_API) { - JvmContentRootsKt.addJvmClasspathRoot(configuration, findAndroidApiJar()); + JvmContentRootsKt.addJvmClasspathRoot(configuration, KtTestUtil.findAndroidApiJar()); configuration.put(JVMConfigurationKeys.NO_JDK, true); } else if (jdkKind == TestJdkKind.FULL_JDK_6) { @@ -363,10 +206,10 @@ public class KotlinTestUtils { configuration.put(JVMConfigurationKeys.JDK_HOME, new File(jdk6)); } else if (jdkKind == TestJdkKind.FULL_JDK_9) { - configuration.put(JVMConfigurationKeys.JDK_HOME, getJdk9Home()); + configuration.put(JVMConfigurationKeys.JDK_HOME, KtTestUtil.getJdk9Home()); } else if (jdkKind == TestJdkKind.FULL_JDK_15) { - configuration.put(JVMConfigurationKeys.JDK_HOME, getJdk15Home()); + configuration.put(JVMConfigurationKeys.JDK_HOME, KtTestUtil.getJdk15Home()); } else if (SystemInfo.IS_AT_LEAST_JAVA9) { configuration.put(JVMConfigurationKeys.JDK_HOME, new File(System.getProperty("java.home"))); @@ -390,41 +233,6 @@ public class KotlinTestUtils { return configuration; } - @NotNull - public static File getJdk9Home() { - String jdk9 = System.getenv("JDK_9"); - if (jdk9 == null) { - jdk9 = System.getenv("JDK_19"); - if (jdk9 == null) { - throw new AssertionError("Environment variable JDK_9 is not set!"); - } - } - return new File(jdk9); - } - - @Nullable - public static File getJdk11Home() { - String jdk11 = System.getenv("JDK_11"); - if (jdk11 == null) { - return null; - } - return new File(jdk11); - } - - @NotNull - public static File getJdk15Home() { - String jdk15 = System.getenv("JDK_15"); - - if (jdk15 == null) { - jdk15 = System.getenv("JDK_15_0"); - } - - if (jdk15 == null) { - throw new AssertionError("Environment variable JDK_15 is not set!"); - } - return new File(jdk15); - } - public static void resolveAllKotlinFiles(KotlinCoreEnvironment environment) throws IOException { List roots = ContentRootsKt.getKotlinSourceRoots(environment.getConfiguration()); if (roots.isEmpty()) return; @@ -685,7 +493,7 @@ public class KotlinTestUtils { } public static boolean compileJavaFilesExternallyWithJava9(@NotNull Collection files, @NotNull List options) { - return compileJavaFilesExternally(files, options, getJdk9Home()); + return compileJavaFilesExternally(files, options, KtTestUtil.getJdk9Home()); } public static boolean compileJavaFilesExternally(@NotNull Collection files, @NotNull List options, @NotNull File jdkHome) { @@ -825,7 +633,7 @@ public class KotlinTestUtils { } catch (Throwable e) { if (!isIgnored && AUTOMATICALLY_MUTE_FAILED_TESTS) { - String text = doLoadFile(testDataFile); + String text = KtTestUtil.doLoadFile(testDataFile); String directive = ignoreDirective + targetBackend.name() + "\n"; String newText; @@ -864,7 +672,7 @@ public class KotlinTestUtils { if (isIgnored) { if (AUTOMATICALLY_UNMUTE_PASSED_TESTS) { - String text = doLoadFile(testDataFile); + String text = KtTestUtil.doLoadFile(testDataFile); String directive = ignoreDirective + targetBackend.name(); String newText = Pattern.compile("^" + directive + "\n", Pattern.MULTILINE).matcher(text).replaceAll(""); if (!newText.equals(text)) { @@ -1069,7 +877,7 @@ public class KotlinTestUtils { private static void assertTestClassPresentByMetadata(@NotNull Class outerClass, @NotNull File testDataDir) { for (Class nestedClass : outerClass.getDeclaredClasses()) { TestMetadata testMetadata = nestedClass.getAnnotation(TestMetadata.class); - if (testMetadata != null && testMetadata.value().equals(getFilePath(testDataDir))) { + if (testMetadata != null && testMetadata.value().equals(KtTestUtil.getFilePath(testDataDir))) { return; } } diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/test/MockLibraryUtil.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/test/MockLibraryUtil.kt index d5c57b4bfa5..b08bdb94603 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/test/MockLibraryUtil.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/test/MockLibraryUtil.kt @@ -25,6 +25,7 @@ import org.jetbrains.kotlin.cli.jvm.K2JVMCompiler import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime import org.jetbrains.kotlin.preloading.ClassPreloadingUtils import org.jetbrains.kotlin.preloading.Preloader +import org.jetbrains.kotlin.test.util.KtTestUtil import org.jetbrains.kotlin.utils.PathUtil import org.junit.Assert import org.junit.Assert.assertEquals @@ -52,7 +53,7 @@ object MockLibraryUtil { useJava9: Boolean = false ): File { return compileLibraryToJar( - sourcesPath, KotlinTestUtils.tmpDirForReusableFolder("testLibrary-" + jarName), jarName, addSources, allowKotlinSources, extraOptions, extraClasspath + sourcesPath, KtTestUtil.tmpDirForReusableFolder("testLibrary-" + jarName), jarName, addSources, allowKotlinSources, extraOptions, extraClasspath , useJava9)} @JvmStatic @@ -96,7 +97,7 @@ object MockLibraryUtil { if (javaFiles.isNotEmpty()) { val classpath = mutableListOf() classpath += ForTestCompileRuntime.runtimeJarForTests().path - classpath += KotlinTestUtils.getAnnotationsJar().path + classpath += KtTestUtil.getAnnotationsJar().path classpath += extraClasspath // Probably no kotlin files were present, so dir might not have been created after kotlin compiler @@ -127,7 +128,7 @@ object MockLibraryUtil { @JvmStatic fun compileJsLibraryToJar(sourcesPath: String, jarName: String, addSources: Boolean, extraOptions: List = emptyList()): File { - val contentDir = KotlinTestUtils.tmpDirForReusableFolder("testLibrary-" + jarName) + val contentDir = KtTestUtil.tmpDirForReusableFolder("testLibrary-" + jarName) val outDir = File(contentDir, "out") val outputFile = File(outDir, jarName + ".js") diff --git a/compiler/tests-spec/tests/org/jetbrains/kotlin/spec/checkers/AbstractDiagnosticsTestSpec.kt b/compiler/tests-spec/tests/org/jetbrains/kotlin/spec/checkers/AbstractDiagnosticsTestSpec.kt index 76309160719..45babdd43ee 100644 --- a/compiler/tests-spec/tests/org/jetbrains/kotlin/spec/checkers/AbstractDiagnosticsTestSpec.kt +++ b/compiler/tests-spec/tests/org/jetbrains/kotlin/spec/checkers/AbstractDiagnosticsTestSpec.kt @@ -18,7 +18,7 @@ import org.jetbrains.kotlin.spec.utils.parsers.CommonParser import org.jetbrains.kotlin.spec.utils.validators.DiagnosticTestTypeValidator import org.jetbrains.kotlin.spec.utils.validators.SpecTestValidationException import org.jetbrains.kotlin.test.ConfigurationKind -import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil import org.junit.Assert import java.io.File import java.util.regex.Matcher @@ -41,7 +41,7 @@ abstract class AbstractDiagnosticsTestSpec : org.jetbrains.kotlin.checkers.Abstr val helperContent = FileUtil.loadFile(File("$HELPERS_PATH/$filename"), true) - KotlinTestUtils.createFile(filename, helperContent, project) + KtTestUtil.createFile(filename, helperContent, project) } } } diff --git a/compiler/tests/org/jetbrains/kotlin/asJava/LightClassAnnotationsTest.java b/compiler/tests/org/jetbrains/kotlin/asJava/LightClassAnnotationsTest.java index 4a635f2ce13..4043a7eec5e 100644 --- a/compiler/tests/org/jetbrains/kotlin/asJava/LightClassAnnotationsTest.java +++ b/compiler/tests/org/jetbrains/kotlin/asJava/LightClassAnnotationsTest.java @@ -25,6 +25,7 @@ import org.jetbrains.kotlin.asJava.classes.KtLightClass; import org.jetbrains.kotlin.cli.jvm.config.JvmContentRootsKt; import org.jetbrains.kotlin.config.CompilerConfiguration; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import java.io.File; import java.util.Collections; @@ -40,7 +41,7 @@ public class LightClassAnnotationsTest extends KotlinAsJavaTestBase { @Override protected void extraConfiguration(@NotNull CompilerConfiguration configuration) { - JvmContentRootsKt.addJvmClasspathRoot(configuration, KotlinTestUtils.getAnnotationsJar()); + JvmContentRootsKt.addJvmClasspathRoot(configuration, KtTestUtil.getAnnotationsJar()); } public void testExtraAnnotations() throws Exception { diff --git a/compiler/tests/org/jetbrains/kotlin/cli/LauncherScriptTest.kt b/compiler/tests/org/jetbrains/kotlin/cli/LauncherScriptTest.kt index 1ecc167fa79..7d1706ef646 100644 --- a/compiler/tests/org/jetbrains/kotlin/cli/LauncherScriptTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/cli/LauncherScriptTest.kt @@ -20,9 +20,10 @@ import com.intellij.openapi.util.SystemInfo import com.intellij.openapi.util.text.StringUtil import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.TestCaseWithTmpdir +import org.jetbrains.kotlin.test.util.KtTestUtil import org.jetbrains.kotlin.utils.PathUtil import org.jetbrains.kotlin.utils.addToStdlib.cast -import java.io.* +import java.io.File import java.util.concurrent.TimeUnit class LauncherScriptTest : TestCaseWithTmpdir() { @@ -75,7 +76,7 @@ class LauncherScriptTest : TestCaseWithTmpdir() { else args.cast() private val testDataDirectory: String - get() = KotlinTestUtils.getTestDataPathBase() + "/launcher" + get() = KtTestUtil.getTestDataPathBase() + "/launcher" fun testKotlincSimple() { runProcess( diff --git a/compiler/tests/org/jetbrains/kotlin/cli/WrongBytecodeVersionTest.kt b/compiler/tests/org/jetbrains/kotlin/cli/WrongBytecodeVersionTest.kt index 57d307c7715..f353617c62f 100644 --- a/compiler/tests/org/jetbrains/kotlin/cli/WrongBytecodeVersionTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/cli/WrongBytecodeVersionTest.kt @@ -24,6 +24,7 @@ import org.jetbrains.kotlin.load.java.JvmAnnotationNames import org.jetbrains.kotlin.metadata.jvm.deserialization.JvmBytecodeBinaryVersion import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase +import org.jetbrains.kotlin.test.util.KtTestUtil import org.jetbrains.org.objectweb.asm.* import java.io.File @@ -31,11 +32,11 @@ class WrongBytecodeVersionTest : KtUsefulTestCase() { private val incompatibleVersion = JvmBytecodeBinaryVersion(42, 0, 0).toArray() private fun doTest(relativeDirectory: String, version: IntArray = incompatibleVersion) { - val directory = KotlinTestUtils.getTestDataPathBase() + relativeDirectory + val directory = KtTestUtil.getTestDataPathBase() + relativeDirectory val librarySource = File(directory, "A.kt") val usageSource = File(directory, "B.kt") - val tmpdir = KotlinTestUtils.tmpDir(this::class.java.simpleName) + val tmpdir = KtTestUtil.tmpDir(this::class.java.simpleName) val environment = KotlinTestUtils.createEnvironmentWithMockJdkAndIdeaAnnotations(testRootDisposable) LoadDescriptorUtil.compileKotlinToDirAndGetModule(listOf(librarySource), tmpdir, environment) diff --git a/compiler/tests/org/jetbrains/kotlin/cli/jvm/KotlinCliJavaFileManagerTest.kt b/compiler/tests/org/jetbrains/kotlin/cli/jvm/KotlinCliJavaFileManagerTest.kt index e0e25beab9d..7d6b0deff2e 100644 --- a/compiler/tests/org/jetbrains/kotlin/cli/jvm/KotlinCliJavaFileManagerTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/cli/jvm/KotlinCliJavaFileManagerTest.kt @@ -36,6 +36,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.util.KtTestUtil import java.io.File class KotlinCliJavaFileManagerTest : KotlinTestWithEnvironment() { @@ -182,7 +183,7 @@ class KotlinCliJavaFileManagerTest : KotlinTestWithEnvironment() { } override fun createEnvironment(): KotlinCoreEnvironment { - javaFilesDir = KotlinTestUtils.tmpDir("java-file-manager-test") + javaFilesDir = KtTestUtil.tmpDir("java-file-manager-test") val configuration = KotlinTestUtils.newConfiguration( ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, emptyList(), listOf(javaFilesDir) diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/JvmModuleProtoBufTest.kt b/compiler/tests/org/jetbrains/kotlin/codegen/JvmModuleProtoBufTest.kt index edeb43ee2da..b886bb410d8 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/JvmModuleProtoBufTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/codegen/JvmModuleProtoBufTest.kt @@ -26,6 +26,7 @@ import org.jetbrains.kotlin.resolve.CompilerDeserializationConfiguration import org.jetbrains.kotlin.test.CompilerTestUtil import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase +import org.jetbrains.kotlin.test.util.KtTestUtil import java.io.File class JvmModuleProtoBufTest : KtUsefulTestCase() { @@ -35,8 +36,8 @@ class JvmModuleProtoBufTest : KtUsefulTestCase() { loadWith: LanguageVersion = LanguageVersion.LATEST_STABLE, extraOptions: List = emptyList() ) { - val directory = KotlinTestUtils.getTestDataPathBase() + relativeDirectory - val tmpdir = KotlinTestUtils.tmpDir(this::class.simpleName) + val directory = KtTestUtil.getTestDataPathBase() + relativeDirectory + val tmpdir = KtTestUtil.tmpDir(this::class.simpleName) val moduleName = "main" CompilerTestUtil.executeCompilerAssertSuccessful( diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/OuterClassGenTest.java b/compiler/tests/org/jetbrains/kotlin/codegen/OuterClassGenTest.java index c919987f708..bffde6c6c83 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/OuterClassGenTest.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/OuterClassGenTest.java @@ -25,7 +25,7 @@ import org.jetbrains.kotlin.backend.common.output.OutputFile; import org.jetbrains.kotlin.backend.common.output.OutputFileCollection; import org.jetbrains.kotlin.name.SpecialNames; import org.jetbrains.kotlin.test.ConfigurationKind; -import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.utils.StringsKt; import org.jetbrains.org.objectweb.asm.ClassReader; import org.jetbrains.org.objectweb.asm.ClassVisitor; @@ -156,7 +156,7 @@ public class OuterClassGenTest extends CodegenTestCase { private void doTest(@NotNull String classFqName, @NotNull String javaClassName, @NotNull String testDataFile) { File javaOut = CodegenTestUtil.compileJava( - Collections.singletonList(KotlinTestUtils.getTestDataPathBase() + "/codegen/" + getPrefix() + "/" + testDataFile + ".java"), + Collections.singletonList(KtTestUtil.getTestDataPathBase() + "/codegen/" + getPrefix() + "/" + testDataFile + ".java"), Collections.emptyList(), Collections.emptyList() ); diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/ScriptGenTest.kt b/compiler/tests/org/jetbrains/kotlin/codegen/ScriptGenTest.kt index ae2b3bb36b8..75dad52e20a 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/ScriptGenTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/codegen/ScriptGenTest.kt @@ -31,6 +31,7 @@ import org.jetbrains.kotlin.scripting.resolve.KotlinScriptDefinitionFromAnnotate import org.jetbrains.kotlin.test.ConfigurationKind import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.TestJdkKind +import org.jetbrains.kotlin.test.util.KtTestUtil import org.jetbrains.org.objectweb.asm.Opcodes import java.io.File import kotlin.script.experimental.jvm.defaultJvmScriptingHostConfiguration @@ -132,7 +133,7 @@ class ScriptGenTest : CodegenTestCase() { add(ScriptingConfigurationKeys.SCRIPT_DEFINITIONS, NO_PARAM_SCRIPT_DEFINITION) put(JVMConfigurationKeys.RETAIN_OUTPUT_IN_MEMORY, true) - addKotlinSourceRoots(sourcePaths.map { "${KotlinTestUtils.getTestDataPathBase()}/codegen/$it" }) + addKotlinSourceRoots(sourcePaths.map { "${KtTestUtil.getTestDataPathBase()}/codegen/$it" }) addJvmClasspathRoots(additionalDependencies) } loadScriptingPlugin(configuration) diff --git a/compiler/tests/org/jetbrains/kotlin/integration/CompilerFileLimitTest.kt b/compiler/tests/org/jetbrains/kotlin/integration/CompilerFileLimitTest.kt index c826714a839..f14e2fb3568 100644 --- a/compiler/tests/org/jetbrains/kotlin/integration/CompilerFileLimitTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/integration/CompilerFileLimitTest.kt @@ -17,7 +17,7 @@ package org.jetbrains.kotlin.integration import com.intellij.openapi.util.io.FileUtil -import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil import org.junit.Assert import java.io.File @@ -112,5 +112,5 @@ class CompilerFileLimitTest : CompilerSmokeTestBase() { } - private fun tempDir(markerName: String) = KotlinTestUtils.tmpDir("${CompilerFileLimitTest::class.simpleName}$markerName") + private fun tempDir(markerName: String) = KtTestUtil.tmpDir("${CompilerFileLimitTest::class.simpleName}$markerName") } diff --git a/compiler/tests/org/jetbrains/kotlin/integration/CompilerSmokeTestBase.java b/compiler/tests/org/jetbrains/kotlin/integration/CompilerSmokeTestBase.java index 1d0ce394385..986ba11a99f 100644 --- a/compiler/tests/org/jetbrains/kotlin/integration/CompilerSmokeTestBase.java +++ b/compiler/tests/org/jetbrains/kotlin/integration/CompilerSmokeTestBase.java @@ -18,7 +18,7 @@ package org.jetbrains.kotlin.integration; import com.intellij.util.ArrayUtil; import org.jetbrains.annotations.NotNull; -import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.utils.StringsKt; import java.io.File; @@ -30,7 +30,7 @@ import java.util.Collections; public abstract class CompilerSmokeTestBase extends KotlinIntegrationTestBase { @NotNull protected String getTestDataDir() { - return KotlinTestUtils.getTestDataPathBase() + "/integration/smoke/" + getTestName(true); + return KtTestUtil.getTestDataPathBase() + "/integration/smoke/" + getTestName(true); } protected int run(String logName, String... args) throws Exception { diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/CompileEnvironmentTest.java b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/CompileEnvironmentTest.java index 8a75ae16396..91036cd9264 100644 --- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/CompileEnvironmentTest.java +++ b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/CompileEnvironmentTest.java @@ -21,7 +21,7 @@ import junit.framework.TestCase; import org.jetbrains.kotlin.cli.common.ExitCode; import org.jetbrains.kotlin.cli.jvm.K2JVMCompiler; import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime; -import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.junit.Assert; import java.io.File; @@ -39,7 +39,7 @@ public class CompileEnvironmentTest extends TestCase { File stdlib = ForTestCompileRuntime.runtimeJarForTests(); ExitCode exitCode = new K2JVMCompiler().exec( System.out, - KotlinTestUtils.getTestDataPathBase() + "/compiler/smoke/Smoke.kt", + KtTestUtil.getTestDataPathBase() + "/compiler/smoke/Smoke.kt", "-d", out.getAbsolutePath(), "-no-stdlib", "-classpath", stdlib.getAbsolutePath() diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/Java9ModulesIntegrationTest.kt b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/Java9ModulesIntegrationTest.kt index b9f63fd9298..f39a36da96b 100644 --- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/Java9ModulesIntegrationTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/Java9ModulesIntegrationTest.kt @@ -9,6 +9,7 @@ import com.intellij.openapi.util.io.FileUtil import org.jetbrains.kotlin.cli.AbstractCliTest import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil import java.io.File import java.util.concurrent.TimeUnit import java.util.jar.Manifest @@ -27,7 +28,7 @@ class Java9ModulesIntegrationTest : AbstractKotlinCompilerIntegrationTest() { val paths = (modulePath + ForTestCompileRuntime.runtimeJarForTests()).joinToString(separator = File.pathSeparator) { it.path } val kotlinOptions = mutableListOf( - "-jdk-home", KotlinTestUtils.getJdk9Home().path, + "-jdk-home", KtTestUtil.getJdk9Home().path, "-jvm-target", "1.8", "-Xmodule-path=$paths" ) @@ -63,7 +64,7 @@ class Java9ModulesIntegrationTest : AbstractKotlinCompilerIntegrationTest() { private fun runModule(className: String, modulePath: List): ModuleRunResult { val command = listOf( - File(KotlinTestUtils.getJdk9Home(), "bin/java").path, + File(KtTestUtil.getJdk9Home(), "bin/java").path, "-p", (modulePath + ForTestCompileRuntime.runtimeJarForTests()).joinToString(File.pathSeparator, transform = File::getPath), "-m", className ) @@ -170,7 +171,7 @@ class Java9ModulesIntegrationTest : AbstractKotlinCompilerIntegrationTest() { val kotlinOptions = mutableListOf( "$testDataDirectory/someOtherDirectoryWithTheActualModuleInfo/module-info.java", - "-jdk-home", KotlinTestUtils.getJdk9Home().path, + "-jdk-home", KtTestUtil.getJdk9Home().path, "-Xmodule-path=${a.path}" ) compileLibrary( @@ -192,7 +193,7 @@ class Java9ModulesIntegrationTest : AbstractKotlinCompilerIntegrationTest() { // Use the name other from 'library' to prevent it from being loaded as an automatic module if module-info.class is not found val libraryJar = createMultiReleaseJar( - KotlinTestUtils.getJdk9Home(), File(tmpdir, "multi-release-library.jar"), libraryOut, libraryOut9 + KtTestUtil.getJdk9Home(), File(tmpdir, "multi-release-library.jar"), libraryOut, libraryOut9 ) module("main", listOf(libraryJar)) diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadJavaPackageAnnotationsTest.kt b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadJavaPackageAnnotationsTest.kt index 53b8b55cd82..ebe3e34f39e 100644 --- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadJavaPackageAnnotationsTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadJavaPackageAnnotationsTest.kt @@ -31,6 +31,7 @@ import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.MockLibraryUtil import org.jetbrains.kotlin.test.TestJdkKind import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase +import org.jetbrains.kotlin.test.util.KtTestUtil import org.jetbrains.kotlin.utils.JavaTypeEnhancementState import java.io.File @@ -41,7 +42,7 @@ class LoadJavaPackageAnnotationsTest : KtUsefulTestCase() { private fun doTest(useJavac: Boolean, configurator: (CompilerConfiguration) -> Unit) { val configuration = KotlinTestUtils.newConfiguration( - ConfigurationKind.ALL, TestJdkKind.FULL_JDK, KotlinTestUtils.getAnnotationsJar() + ConfigurationKind.ALL, TestJdkKind.FULL_JDK, KtTestUtil.getAnnotationsJar() ).apply { if (useJavac) { put(JVMConfigurationKeys.USE_JAVAC, true) diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/MemoryOptimizationsTest.kt b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/MemoryOptimizationsTest.kt index 6bc6bc314e8..73ae8a8ad93 100644 --- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/MemoryOptimizationsTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/MemoryOptimizationsTest.kt @@ -28,6 +28,7 @@ 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.jetbrains.kotlin.test.util.KtTestUtil import org.jetbrains.kotlin.types.FlexibleType import org.jetbrains.kotlin.types.TypeConstructorSubstitution import org.jetbrains.kotlin.types.lowerIfFlexible @@ -75,8 +76,8 @@ class MemoryOptimizationsTest : KtUsefulTestCase() { ) val moduleDescriptor = JvmResolveUtil.analyze( - KotlinTestUtils.createFile("main.kt", text, environment.project), - environment + KtTestUtil.createFile("main.kt", text, environment.project), + environment ).moduleDescriptor val aClass = diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/TypeQualifierAnnotationResolverTest.kt b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/TypeQualifierAnnotationResolverTest.kt index 4f7c10a5eef..7425678e775 100644 --- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/TypeQualifierAnnotationResolverTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/TypeQualifierAnnotationResolverTest.kt @@ -38,6 +38,7 @@ import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.MockLibraryUtil import org.jetbrains.kotlin.test.TestJdkKind import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase +import org.jetbrains.kotlin.test.util.KtTestUtil import org.jetbrains.kotlin.utils.JavaTypeEnhancementState import java.io.File @@ -88,8 +89,8 @@ class TypeQualifierAnnotationResolverTest : KtUsefulTestCase() { val configuration = KotlinTestUtils.newConfiguration( ConfigurationKind.ALL, TestJdkKind.FULL_JDK, listOf( - KotlinTestUtils.getAnnotationsJar(), - MockLibraryUtil.compileJavaFilesLibraryToJar( + KtTestUtil.getAnnotationsJar(), + MockLibraryUtil.compileJavaFilesLibraryToJar( FOREIGN_ANNOTATIONS_SOURCES_PATH, "foreign-annotations" ) diff --git a/compiler/tests/org/jetbrains/kotlin/multiplatform/AbstractMultiPlatformIntegrationTest.kt b/compiler/tests/org/jetbrains/kotlin/multiplatform/AbstractMultiPlatformIntegrationTest.kt index 5f364118145..460783b9d7d 100644 --- a/compiler/tests/org/jetbrains/kotlin/multiplatform/AbstractMultiPlatformIntegrationTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/multiplatform/AbstractMultiPlatformIntegrationTest.kt @@ -24,6 +24,7 @@ import org.jetbrains.kotlin.cli.metadata.K2MetadataCompiler import org.jetbrains.kotlin.test.InTextDirectivesUtils import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase +import org.jetbrains.kotlin.test.util.KtTestUtil import org.jetbrains.kotlin.test.util.trimTrailingWhitespacesAndAddNewlineAtEOF import java.io.File import java.nio.file.Files @@ -40,7 +41,7 @@ abstract class AbstractMultiPlatformIntegrationTest : KtUsefulTestCase() { val common2Src = File(root, "common2.kt").takeIf(File::exists) val jvm2Src = File(root, "jvm2.kt").takeIf(File::exists) - val tmpdir = KotlinTestUtils.tmpDir(getTestName(true)) + val tmpdir = KtTestUtil.tmpDir(getTestName(true)) val optionalStdlibCommon = if (InTextDirectivesUtils.isDirectiveDefined(commonSrc.readText(), "WITH_RUNTIME")) diff --git a/compiler/tests/org/jetbrains/kotlin/parsing/AbstractParsingTest.java b/compiler/tests/org/jetbrains/kotlin/parsing/AbstractParsingTest.java index 7a3548a21eb..0ae37e545d7 100644 --- a/compiler/tests/org/jetbrains/kotlin/parsing/AbstractParsingTest.java +++ b/compiler/tests/org/jetbrains/kotlin/parsing/AbstractParsingTest.java @@ -31,8 +31,8 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.kotlin.KtNodeTypes; import org.jetbrains.kotlin.TestsCompilerError; import org.jetbrains.kotlin.psi.*; -import org.jetbrains.kotlin.test.KotlinTestUtils; import org.jetbrains.kotlin.test.testFramework.KtParsingTestCase; +import org.jetbrains.kotlin.test.util.KtTestUtil; import java.lang.annotation.Annotation; import java.lang.reflect.Method; @@ -42,7 +42,7 @@ public abstract class AbstractParsingTest extends KtParsingTestCase { @Override protected String getTestDataPath() { - return KotlinTestUtils.getHomeDirectory(); + return KtTestUtil.getHomeDirectory(); } public AbstractParsingTest() { diff --git a/compiler/tests/org/jetbrains/kotlin/psi/KtPsiUtilTest.java b/compiler/tests/org/jetbrains/kotlin/psi/KtPsiUtilTest.java index da339cdb9db..facb9be4042 100644 --- a/compiler/tests/org/jetbrains/kotlin/psi/KtPsiUtilTest.java +++ b/compiler/tests/org/jetbrains/kotlin/psi/KtPsiUtilTest.java @@ -28,6 +28,7 @@ import org.jetbrains.kotlin.psi.psiUtil.KtPsiUtilKt; import org.jetbrains.kotlin.resolve.ImportPath; import org.jetbrains.kotlin.test.KotlinTestUtils; import org.jetbrains.kotlin.test.KotlinTestWithEnvironment; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.junit.Assert; import java.io.File; @@ -40,8 +41,8 @@ public class KtPsiUtilTest extends KotlinTestWithEnvironment { @NotNull private KtFile loadPsiFile(@NotNull String name) { try { - String text = KotlinTestUtils.doLoadFile(KotlinTestUtils.getTestDataPathBase(), name); - return KotlinTestUtils.createFile(name + ".kt", text, getProject()); + String text = KtTestUtil.doLoadFile(KtTestUtil.getTestDataPathBase(), name); + return KtTestUtil.createFile(name + ".kt", text, getProject()); } catch (IOException e) { throw new RuntimeException(e); @@ -84,7 +85,7 @@ public class KtPsiUtilTest extends KotlinTestWithEnvironment { } public void testIsLocalClass() throws IOException { - String text = FileUtil.loadFile(new File(KotlinTestUtils.getTestDataPathBase() + "/psiUtil/isLocalClass.kt"), true); + String text = FileUtil.loadFile(new File(KtTestUtil.getTestDataPathBase() + "/psiUtil/isLocalClass.kt"), true); KtClass aClass = KtPsiFactoryKt.KtPsiFactory(getProject()).createClass(text); @SuppressWarnings("unchecked") diff --git a/compiler/tests/org/jetbrains/kotlin/reflection/ReflectionIntegrationTest.kt b/compiler/tests/org/jetbrains/kotlin/reflection/ReflectionIntegrationTest.kt index 9d863be6c7e..5a6fade3c05 100644 --- a/compiler/tests/org/jetbrains/kotlin/reflection/ReflectionIntegrationTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/reflection/ReflectionIntegrationTest.kt @@ -9,6 +9,7 @@ import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime import org.jetbrains.kotlin.test.CompilerTestUtil import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase +import org.jetbrains.kotlin.test.util.KtTestUtil import java.io.File import java.util.concurrent.TimeUnit @@ -20,7 +21,7 @@ class ReflectionIntegrationTest : KtUsefulTestCase() { fun testClassLoaderForBuiltIns() { val tmpdir = KotlinTestUtils.tmpDirForTest(this) - val root = KotlinTestUtils.getTestDataPathBase() + "/reflection/classLoaderForBuiltIns" + val root = KtTestUtil.getTestDataPathBase() + "/reflection/classLoaderForBuiltIns" KotlinTestUtils.compileJavaFiles( listOf(File("$root/Main.java")), listOf("-d", tmpdir.absolutePath) diff --git a/compiler/tests/org/jetbrains/kotlin/resolve/typeApproximation/CapturedTypeApproximationTest.kt b/compiler/tests/org/jetbrains/kotlin/resolve/typeApproximation/CapturedTypeApproximationTest.kt index deff8df2965..61c3e62f00a 100644 --- a/compiler/tests/org/jetbrains/kotlin/resolve/typeApproximation/CapturedTypeApproximationTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/resolve/typeApproximation/CapturedTypeApproximationTest.kt @@ -27,6 +27,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.util.KtTestUtil import org.jetbrains.kotlin.types.TypeProjection import org.jetbrains.kotlin.types.TypeProjectionImpl import org.jetbrains.kotlin.types.TypeSubstitutor @@ -38,7 +39,7 @@ import java.util.* class CapturedTypeApproximationTest : KotlinTestWithEnvironment() { private val testDataPath: String - get() = KotlinTestUtils.getTestDataPathBase() + "/capturedTypeApproximation/" + get() = KtTestUtil.getTestDataPathBase() + "/capturedTypeApproximation/" override fun createEnvironment(): KotlinCoreEnvironment = createEnvironmentWithMockJdk(ConfigurationKind.JDK_ONLY) @@ -46,7 +47,8 @@ class CapturedTypeApproximationTest : KotlinTestWithEnvironment() { assert(substitutions.size in 1..2) { "Captured type approximation test requires substitutions for (T) or (T, R)" } val oneTypeVariable = substitutions.size == 1 - val declarationsText = KotlinTestUtils.doLoadFile(File(testDataPath + "/declarations.kt")) + val declarationsText = + KtTestUtil.doLoadFile(File(testDataPath + "/declarations.kt")) fun analyzeTestFile(testType: String) = run { val test = declarationsText.replace("#TestType#", testType) diff --git a/compiler/tests/org/jetbrains/kotlin/serialization/js/JsVersionRequirementTest.kt b/compiler/tests/org/jetbrains/kotlin/serialization/js/JsVersionRequirementTest.kt index 28255e020b4..e6b58f2401c 100644 --- a/compiler/tests/org/jetbrains/kotlin/serialization/js/JsVersionRequirementTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/serialization/js/JsVersionRequirementTest.kt @@ -27,6 +27,7 @@ import org.jetbrains.kotlin.serialization.AbstractVersionRequirementTest import org.jetbrains.kotlin.test.ConfigurationKind import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.TestJdkKind +import org.jetbrains.kotlin.test.util.KtTestUtil import java.io.File class JsVersionRequirementTest : AbstractVersionRequirementTest() { @@ -37,7 +38,13 @@ class JsVersionRequirementTest : AbstractVersionRequirementTest() { analysisFlags: Map, Any?> ) { val environment = createEnvironment(languageVersion) - val ktFiles = files.map { file -> KotlinTestUtils.createFile(file.name, file.readText(), environment.project) } + val ktFiles = files.map { file -> + KtTestUtil.createFile( + file.name, + file.readText(), + environment.project + ) + } val trace = BindingTraceContext() val analysisResult = TopDownAnalyzerFacadeForJS.analyzeFilesWithGivenTrace( ktFiles, trace, createModule(environment), environment.configuration diff --git a/compiler/tests/org/jetbrains/kotlin/test/util/RecursiveDescriptorProcessorTest.java b/compiler/tests/org/jetbrains/kotlin/test/util/RecursiveDescriptorProcessorTest.java index c5f4f508cb0..8a1e71357b0 100644 --- a/compiler/tests/org/jetbrains/kotlin/test/util/RecursiveDescriptorProcessorTest.java +++ b/compiler/tests/org/jetbrains/kotlin/test/util/RecursiveDescriptorProcessorTest.java @@ -43,7 +43,7 @@ public class RecursiveDescriptorProcessorTest extends KotlinTestWithEnvironment File ktFile = new File("compiler/testData/recursiveProcessor/declarations.kt"); File txtFile = new File("compiler/testData/recursiveProcessor/declarations.txt"); String text = FileUtil.loadFile(ktFile, true); - KtFile jetFile = KotlinTestUtils.createFile("declarations.kt", text, getEnvironment().getProject()); + KtFile jetFile = KtTestUtil.createFile("declarations.kt", text, getEnvironment().getProject()); AnalysisResult result = KotlinTestUtils.analyzeFile(jetFile, getEnvironment()); PackageViewDescriptor testPackage = result.getModuleDescriptor().getPackage(FqName.topLevel(Name.identifier("test"))); diff --git a/core/descriptors.runtime/tests/org/jetbrains/kotlin/jvm/runtime/AbstractJvmRuntimeDescriptorLoaderTest.kt b/core/descriptors.runtime/tests/org/jetbrains/kotlin/jvm/runtime/AbstractJvmRuntimeDescriptorLoaderTest.kt index 2464d77580e..71844faf698 100644 --- a/core/descriptors.runtime/tests/org/jetbrains/kotlin/jvm/runtime/AbstractJvmRuntimeDescriptorLoaderTest.kt +++ b/core/descriptors.runtime/tests/org/jetbrains/kotlin/jvm/runtime/AbstractJvmRuntimeDescriptorLoaderTest.kt @@ -33,6 +33,7 @@ import org.jetbrains.kotlin.resolve.scopes.MemberScopeImpl import org.jetbrains.kotlin.test.* import org.jetbrains.kotlin.test.TestFiles.TestFileFactoryNoModules import org.jetbrains.kotlin.test.util.DescriptorValidator.ValidationVisitor.errorTypesForbidden +import org.jetbrains.kotlin.test.util.KtTestUtil import org.jetbrains.kotlin.test.util.RecursiveDescriptorComparator import org.jetbrains.kotlin.test.util.RecursiveDescriptorComparator.Configuration import org.jetbrains.kotlin.utils.Printer @@ -133,7 +134,7 @@ abstract class AbstractJvmRuntimeDescriptorLoaderTest : TestCaseWithTmpdir() { for (root in environment.configuration.getList(CLIConfigurationKeys.CONTENT_ROOTS)) { LOG.info("root: $root") } - val ktFile = KotlinTestUtils.createFile(file.path, text, environment.project) + val ktFile = KtTestUtil.createFile(file.path, text, environment.project) GenerationUtils.compileFileTo(ktFile, environment, tmpdir) } } diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/impl/SimpleTestClassModelTestAllFilesPresentMethodGenerator.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/impl/SimpleTestClassModelTestAllFilesPresentMethodGenerator.kt index f5aad1e0d61..8881cbf99de 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/impl/SimpleTestClassModelTestAllFilesPresentMethodGenerator.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/impl/SimpleTestClassModelTestAllFilesPresentMethodGenerator.kt @@ -6,11 +6,11 @@ package org.jetbrains.kotlin.generators.impl import com.intellij.openapi.util.text.StringUtil -import org.jetbrains.kotlin.generators.model.MethodModel import org.jetbrains.kotlin.generators.MethodGenerator +import org.jetbrains.kotlin.generators.model.MethodModel import org.jetbrains.kotlin.generators.model.SimpleTestClassModel -import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.TargetBackend +import org.jetbrains.kotlin.test.util.KtTestUtil import org.jetbrains.kotlin.utils.Printer import org.jetbrains.kotlin.utils.addToStdlib.runIf @@ -36,7 +36,7 @@ object SimpleTestClassModelTestAllFilesPresentMethodGenerator : MethodGenerator< val assertTestsPresentStr = if (classModel.targetBackend === TargetBackend.ANY) { String.format( "KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File(\"%s\"), Pattern.compile(\"%s\"), %s, %s%s);", - KotlinTestUtils.getFilePath(classModel.rootFile), + KtTestUtil.getFilePath(classModel.rootFile), StringUtil.escapeStringCharacters(classModel.filenamePattern.pattern()), excludedArgument, classModel.recursive, @@ -45,7 +45,7 @@ object SimpleTestClassModelTestAllFilesPresentMethodGenerator : MethodGenerator< } else { String.format( "KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File(\"%s\"), Pattern.compile(\"%s\"), %s, %s.%s, %s%s);", - KotlinTestUtils.getFilePath(classModel.rootFile), + KtTestUtil.getFilePath(classModel.rootFile), StringUtil.escapeStringCharacters(classModel.filenamePattern.pattern()), excludedArgument, TargetBackend::class.java.simpleName, classModel.targetBackend.toString(), classModel.recursive, exclude ) diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/impl/SimpleTestMethodGenerator.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/impl/SimpleTestMethodGenerator.kt index bd0cb8b5983..99fe9c60836 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/impl/SimpleTestMethodGenerator.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/impl/SimpleTestMethodGenerator.kt @@ -5,11 +5,11 @@ package org.jetbrains.kotlin.generators.impl -import org.jetbrains.kotlin.generators.model.MethodModel import org.jetbrains.kotlin.generators.MethodGenerator +import org.jetbrains.kotlin.generators.model.MethodModel import org.jetbrains.kotlin.generators.model.RunTestMethodModel import org.jetbrains.kotlin.generators.model.SimpleTestMethodModel -import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil import org.jetbrains.kotlin.utils.Printer object SimpleTestMethodGenerator : MethodGenerator() { @@ -22,7 +22,7 @@ object SimpleTestMethodGenerator : MethodGenerator() { override fun generateBody(method: SimpleTestMethodModel, p: Printer) { with(method) { - val filePath = KotlinTestUtils.getFilePath(file) + if (file.isDirectory) "/" else "" + val filePath = KtTestUtil.getFilePath(file) + if (file.isDirectory) "/" else "" p.println(RunTestMethodModel.METHOD_NAME, "(\"", filePath, "\");") } } diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/impl/SingleClassTestModelAllFilesPresentedMethodGenerator.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/impl/SingleClassTestModelAllFilesPresentedMethodGenerator.kt index 21fcadf6fbb..e4a7efe7d4b 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/impl/SingleClassTestModelAllFilesPresentedMethodGenerator.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/impl/SingleClassTestModelAllFilesPresentedMethodGenerator.kt @@ -6,11 +6,11 @@ package org.jetbrains.kotlin.generators.impl import com.intellij.openapi.util.text.StringUtil -import org.jetbrains.kotlin.generators.model.MethodModel import org.jetbrains.kotlin.generators.MethodGenerator +import org.jetbrains.kotlin.generators.model.MethodModel import org.jetbrains.kotlin.generators.model.SingleClassTestModel -import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.TargetBackend +import org.jetbrains.kotlin.test.util.KtTestUtil import org.jetbrains.kotlin.utils.Printer object SingleClassTestModelAllFilesPresentedMethodGenerator : MethodGenerator() { @@ -37,13 +37,13 @@ object SingleClassTestModelAllFilesPresentedMethodGenerator : MethodGenerator runWriteAction { file.delete(this) } @@ -376,4 +377,4 @@ abstract class AbstractScratchRunActionTest : FileEditorManagerTestCase() { } } -} \ No newline at end of file +} diff --git a/idea/scripting-support/test/org/jetbrains/kotlin/idea/scratch/AbstractScratchRunActionTest.kt.203 b/idea/scripting-support/test/org/jetbrains/kotlin/idea/scratch/AbstractScratchRunActionTest.kt.203 index c0030ff88f5..0ca946ac6a6 100644 --- a/idea/scripting-support/test/org/jetbrains/kotlin/idea/scratch/AbstractScratchRunActionTest.kt.203 +++ b/idea/scripting-support/test/org/jetbrains/kotlin/idea/scratch/AbstractScratchRunActionTest.kt.203 @@ -38,6 +38,7 @@ import org.jetbrains.kotlin.parsing.KotlinParserDefinition.Companion.STD_SCRIPT_ import org.jetbrains.kotlin.test.InTextDirectivesUtils import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.MockLibraryUtil +import org.jetbrains.kotlin.test.util.KtTestUtil import org.jetbrains.kotlin.utils.PathUtil import org.junit.Assert import java.io.File @@ -294,7 +295,7 @@ abstract class AbstractScratchRunActionTest : FileEditorManagerTestCase() { return File(testDataPath, "idea/scripting-support/testData/scratch/custom/test_scratch.kts").readText() } - override fun getTestDataPath() = KotlinTestUtils.getHomeDirectory() + override fun getTestDataPath() = KtTestUtil.getHomeDirectory() override fun getProjectDescriptor(): com.intellij.testFramework.LightProjectDescriptor { @@ -311,7 +312,7 @@ abstract class AbstractScratchRunActionTest : FileEditorManagerTestCase() { override fun setUp() { super.setUp() - VfsRootAccess.allowRootAccess(getTestRootDisposable(), KotlinTestUtils.getHomeDirectory()) + VfsRootAccess.allowRootAccess(getTestRootDisposable(), KtTestUtil.getHomeDirectory()) PluginTestCaseBase.addJdk(myFixture.projectDisposable) { PluginTestCaseBase.fullJdk() } } @@ -373,4 +374,4 @@ abstract class AbstractScratchRunActionTest : FileEditorManagerTestCase() { } } -} \ No newline at end of file +} diff --git a/idea/scripting-support/test/org/jetbrains/kotlin/idea/script/AbstractScriptTemplatesFromDependenciesTest.kt b/idea/scripting-support/test/org/jetbrains/kotlin/idea/script/AbstractScriptTemplatesFromDependenciesTest.kt index 819e38c4209..3578e27102f 100644 --- a/idea/scripting-support/test/org/jetbrains/kotlin/idea/script/AbstractScriptTemplatesFromDependenciesTest.kt +++ b/idea/scripting-support/test/org/jetbrains/kotlin/idea/script/AbstractScriptTemplatesFromDependenciesTest.kt @@ -24,8 +24,8 @@ import org.jetbrains.kotlin.idea.core.script.ScriptDefinitionContributor import org.jetbrains.kotlin.idea.util.application.runWriteAction import org.jetbrains.kotlin.test.InTextDirectivesUtils import org.jetbrains.kotlin.test.JUnit3RunnerWithInnersForJPS -import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.MockLibraryUtil +import org.jetbrains.kotlin.test.util.KtTestUtil import org.jetbrains.kotlin.test.util.addDependency import org.jetbrains.kotlin.test.util.jarRoot import org.jetbrains.kotlin.test.util.projectLibrary @@ -137,7 +137,7 @@ abstract class AbstractScriptTemplatesFromDependenciesTest : HeavyPlatformTestCa } private fun packJar(dir: File): File { - val contentDir = KotlinTestUtils.tmpDirForReusableFolder("folderForLibrary-${getTestName(true)}") + val contentDir = KtTestUtil.tmpDirForReusableFolder("folderForLibrary-${getTestName(true)}") return MockLibraryUtil.createJarFile(contentDir, dir, "templates") } -} \ No newline at end of file +} diff --git a/idea/tests/org/jetbrains/kotlin/asJava/LightClassesClasspathSortingTest.kt b/idea/tests/org/jetbrains/kotlin/asJava/LightClassesClasspathSortingTest.kt index 8441be022bc..5351dfe921e 100644 --- a/idea/tests/org/jetbrains/kotlin/asJava/LightClassesClasspathSortingTest.kt +++ b/idea/tests/org/jetbrains/kotlin/asJava/LightClassesClasspathSortingTest.kt @@ -14,7 +14,7 @@ import org.jetbrains.kotlin.idea.caches.lightClasses.KtLightClassForDecompiledDe import org.jetbrains.kotlin.idea.test.KotlinLightCodeInsightFixtureTestCase import org.jetbrains.kotlin.idea.test.SdkAndMockLibraryProjectDescriptor import org.jetbrains.kotlin.test.JUnit3WithIdeaConfigurationRunner -import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil import org.junit.runner.RunWith import java.io.File import kotlin.test.assertNotNull @@ -58,6 +58,6 @@ class LightClassesClasspathSortingTest : KotlinLightCodeInsightFixtureTestCase() } override fun getTestDataPath(): String { - return KotlinTestUtils.getHomeDirectory() + "/idea/testData/decompiler/lightClassesOrder/" + return KtTestUtil.getHomeDirectory() + "/idea/testData/decompiler/lightClassesOrder/" } -} \ No newline at end of file +} diff --git a/idea/tests/org/jetbrains/kotlin/checkers/AbstractJavaAgainstKotlinCheckerTest.java b/idea/tests/org/jetbrains/kotlin/checkers/AbstractJavaAgainstKotlinCheckerTest.java index c29cb5722e4..79e2f5c2518 100644 --- a/idea/tests/org/jetbrains/kotlin/checkers/AbstractJavaAgainstKotlinCheckerTest.java +++ b/idea/tests/org/jetbrains/kotlin/checkers/AbstractJavaAgainstKotlinCheckerTest.java @@ -24,7 +24,7 @@ import org.jetbrains.kotlin.idea.KotlinDaemonAnalyzerTestCase; import org.jetbrains.kotlin.idea.test.ConfigLibraryUtil; import org.jetbrains.kotlin.idea.test.PluginTestCaseBase; import org.jetbrains.kotlin.test.InTextDirectivesUtils; -import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.utils.ExceptionUtilsKt; import java.io.File; @@ -131,6 +131,6 @@ public abstract class AbstractJavaAgainstKotlinCheckerTest extends KotlinDaemonA @Override protected String getTestDataPath() { - return KotlinTestUtils.getHomeDirectory() + "/"; + return KtTestUtil.getHomeDirectory() + "/"; } } diff --git a/idea/tests/org/jetbrains/kotlin/idea/KotlinDaemonAnalyzerTestCase.java b/idea/tests/org/jetbrains/kotlin/idea/KotlinDaemonAnalyzerTestCase.java index e2b0879a114..b1aacfbfb90 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/KotlinDaemonAnalyzerTestCase.java +++ b/idea/tests/org/jetbrains/kotlin/idea/KotlinDaemonAnalyzerTestCase.java @@ -7,18 +7,18 @@ package org.jetbrains.kotlin.idea; import com.intellij.codeInsight.daemon.DaemonAnalyzerTestCase; import com.intellij.openapi.vfs.newvfs.impl.VfsRootAccess; -import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; abstract public class KotlinDaemonAnalyzerTestCase extends DaemonAnalyzerTestCase { @Override protected void setUp() throws Exception { - VfsRootAccess.allowRootAccess(KotlinTestUtils.getHomeDirectory()); + VfsRootAccess.allowRootAccess(KtTestUtil.getHomeDirectory()); super.setUp(); } @Override protected void tearDown() throws Exception { super.tearDown(); - VfsRootAccess.disallowRootAccess(KotlinTestUtils.getHomeDirectory()); + VfsRootAccess.disallowRootAccess(KtTestUtil.getHomeDirectory()); } } diff --git a/idea/tests/org/jetbrains/kotlin/idea/KotlinDaemonAnalyzerTestCase.java.203 b/idea/tests/org/jetbrains/kotlin/idea/KotlinDaemonAnalyzerTestCase.java.203 index 029612bac65..0eff566e641 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/KotlinDaemonAnalyzerTestCase.java.203 +++ b/idea/tests/org/jetbrains/kotlin/idea/KotlinDaemonAnalyzerTestCase.java.203 @@ -7,12 +7,12 @@ package org.jetbrains.kotlin.idea; import com.intellij.codeInsight.daemon.DaemonAnalyzerTestCase; import com.intellij.openapi.vfs.newvfs.impl.VfsRootAccess; -import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; abstract public class KotlinDaemonAnalyzerTestCase extends DaemonAnalyzerTestCase { @Override protected void setUp() throws Exception { - VfsRootAccess.allowRootAccess(getTestRootDisposable(), KotlinTestUtils.getHomeDirectory()); + VfsRootAccess.allowRootAccess(getTestRootDisposable(), KtTestUtil.getHomeDirectory()); super.setUp(); } } diff --git a/idea/tests/org/jetbrains/kotlin/idea/actions/AbstractNavigationTest.kt b/idea/tests/org/jetbrains/kotlin/idea/actions/AbstractNavigationTest.kt index 628d8bef1d2..009f6e82862 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/actions/AbstractNavigationTest.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/actions/AbstractNavigationTest.kt @@ -14,7 +14,7 @@ import org.jetbrains.kotlin.idea.navigation.NavigationTestUtils import org.jetbrains.kotlin.idea.test.ConfigLibraryUtil import org.jetbrains.kotlin.idea.test.KotlinLightCodeInsightFixtureTestCase import org.jetbrains.kotlin.idea.test.KotlinWithJdkAndRuntimeLightProjectDescriptor -import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil import java.io.File abstract class AbstractNavigationTest : KotlinLightCodeInsightFixtureTestCase() { @@ -33,7 +33,7 @@ abstract class AbstractNavigationTest : KotlinLightCodeInsightFixtureTestCase() try { ConfigLibraryUtil.configureLibrariesByDirective(module, PlatformTestUtil.getCommunityPath(), fileText) - myFixture.testDataPath = "${KotlinTestUtils.getHomeDirectory()}/${mainFile.parent}" + myFixture.testDataPath = "${KtTestUtil.getHomeDirectory()}/${mainFile.parent}" val mainFileName = mainFile.name val mainFileBaseName = mainFileName.substring(0, mainFileName.indexOf('.')) diff --git a/idea/tests/org/jetbrains/kotlin/idea/caches/KotlinShortNamesCacheTest.kt b/idea/tests/org/jetbrains/kotlin/idea/caches/KotlinShortNamesCacheTest.kt index 6553aa4ecce..ee96354dd53 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/caches/KotlinShortNamesCacheTest.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/caches/KotlinShortNamesCacheTest.kt @@ -23,7 +23,7 @@ import org.jetbrains.kotlin.load.java.JvmAbi import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.psi.KtProperty import org.jetbrains.kotlin.test.JUnit3WithIdeaConfigurationRunner -import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil import org.junit.runner.RunWith import kotlin.reflect.KMutableProperty0 @@ -262,6 +262,6 @@ class KotlinShortNamesCacheTest : KotlinLightCodeInsightFixtureTestCase() { } override fun getTestDataPath(): String { - return KotlinTestUtils.getHomeDirectory() + "/idea/testData/cache/" + return KtTestUtil.getHomeDirectory() + "/idea/testData/cache/" } -} \ No newline at end of file +} diff --git a/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/IdeaModuleInfoTest.kt b/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/IdeaModuleInfoTest.kt index 8eef5ef4b81..0bf97db23ff 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/IdeaModuleInfoTest.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/IdeaModuleInfoTest.kt @@ -26,13 +26,12 @@ import org.jetbrains.kotlin.idea.caches.project.ModuleTestSourceInfo import org.jetbrains.kotlin.idea.framework.CommonLibraryKind import org.jetbrains.kotlin.idea.framework.JSLibraryKind import org.jetbrains.kotlin.idea.framework.platform -import org.jetbrains.kotlin.idea.test.PluginTestCaseBase import org.jetbrains.kotlin.idea.test.PluginTestCaseBase.* import org.jetbrains.kotlin.idea.util.application.runWriteAction import org.jetbrains.kotlin.idea.util.getProjectJdkTableSafe import org.jetbrains.kotlin.platform.TargetPlatform import org.jetbrains.kotlin.test.JUnit3WithIdeaConfigurationRunner -import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil import org.jetbrains.kotlin.test.util.addDependency import org.jetbrains.kotlin.test.util.jarRoot import org.jetbrains.kotlin.test.util.projectLibrary @@ -484,11 +483,11 @@ class IdeaModuleInfoTest : ModuleTestCase() { override fun setUp() { super.setUp() - VfsRootAccess.allowRootAccess(KotlinTestUtils.getHomeDirectory()) + VfsRootAccess.allowRootAccess(KtTestUtil.getHomeDirectory()) } override fun tearDown() { - VfsRootAccess.disallowRootAccess(KotlinTestUtils.getHomeDirectory()) + VfsRootAccess.disallowRootAccess(KtTestUtil.getHomeDirectory()) super.tearDown() } diff --git a/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/IdeaModuleInfoTest.kt.203 b/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/IdeaModuleInfoTest.kt.203 index 0425a029acc..bc23654473a 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/IdeaModuleInfoTest.kt.203 +++ b/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/IdeaModuleInfoTest.kt.203 @@ -31,7 +31,7 @@ import org.jetbrains.kotlin.idea.util.application.runWriteAction import org.jetbrains.kotlin.idea.util.getProjectJdkTableSafe import org.jetbrains.kotlin.platform.TargetPlatform import org.jetbrains.kotlin.test.JUnit3WithIdeaConfigurationRunner -import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil import org.jetbrains.kotlin.test.util.addDependency import org.jetbrains.kotlin.test.util.jarRoot import org.jetbrains.kotlin.test.util.projectLibrary @@ -483,6 +483,6 @@ class IdeaModuleInfoTest : ModuleTestCase() { override fun setUp() { super.setUp() - VfsRootAccess.allowRootAccess(testRootDisposable, KotlinTestUtils.getHomeDirectory()) + VfsRootAccess.allowRootAccess(testRootDisposable, KtTestUtil.getHomeDirectory()) } } diff --git a/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/Java9MultiModuleHighlightingTest.kt b/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/Java9MultiModuleHighlightingTest.kt index 79926663e02..953e051cded 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/Java9MultiModuleHighlightingTest.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/Java9MultiModuleHighlightingTest.kt @@ -8,9 +8,9 @@ package org.jetbrains.kotlin.idea.caches.resolve import com.intellij.openapi.module.Module import org.jetbrains.kotlin.idea.test.PluginTestCaseBase import org.jetbrains.kotlin.test.JUnit3WithIdeaConfigurationRunner -import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.MockLibraryUtil import org.jetbrains.kotlin.test.TestJdkKind.FULL_JDK_9 +import org.jetbrains.kotlin.test.util.KtTestUtil import org.junit.runner.RunWith @RunWith(JUnit3WithIdeaConfigurationRunner::class) @@ -28,7 +28,7 @@ class Java9MultiModuleHighlightingTest : AbstractMultiModuleHighlightingTest() { // -Xallow-kotlin-package to avoid "require kotlin.stdlib" in module-info.java val library = MockLibraryUtil.compileJvmLibraryToJar( testDataPath + "${getTestName(true)}/library", "library", - extraOptions = listOf("-jdk-home", KotlinTestUtils.getJdk9Home().path, "-Xallow-kotlin-package"), + extraOptions = listOf("-jdk-home", KtTestUtil.getJdk9Home().path, "-Xallow-kotlin-package"), useJava9 = true ) diff --git a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/AbstractInspectionTest.kt b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/AbstractInspectionTest.kt index 302b854d8bd..d3768c15995 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/AbstractInspectionTest.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/AbstractInspectionTest.kt @@ -24,6 +24,7 @@ import org.jetbrains.kotlin.idea.util.application.runWriteAction import org.jetbrains.kotlin.idea.versions.bundledRuntimeVersion import org.jetbrains.kotlin.test.InTextDirectivesUtils import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil import org.jetbrains.plugins.groovy.GroovyFileType import java.io.File @@ -74,7 +75,7 @@ abstract class AbstractInspectionTest : KotlinLightCodeInsightFixtureTestCase() } with(myFixture) { - testDataPath = "${KotlinTestUtils.getHomeDirectory()}/$srcDir" + testDataPath = "${KtTestUtil.getHomeDirectory()}/$srcDir" val afterFiles = srcDir.listFiles { it -> it.name == "inspectionData" }?.single()?.listFiles { it -> it.extension == "after" } diff --git a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/postfix/AbstractPostfixTemplateProviderTest.kt b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/postfix/AbstractPostfixTemplateProviderTest.kt index 949752da78d..635b752c9f8 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/postfix/AbstractPostfixTemplateProviderTest.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/postfix/AbstractPostfixTemplateProviderTest.kt @@ -9,14 +9,14 @@ import com.intellij.codeInsight.template.impl.TemplateManagerImpl import org.jetbrains.kotlin.idea.test.KotlinLightCodeInsightFixtureTestCase import org.jetbrains.kotlin.idea.test.KotlinWithJdkAndRuntimeLightProjectDescriptor import org.jetbrains.kotlin.test.InTextDirectivesUtils -import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil import java.io.File abstract class AbstractPostfixTemplateProviderTest : KotlinLightCodeInsightFixtureTestCase() { override fun getProjectDescriptor() = KotlinWithJdkAndRuntimeLightProjectDescriptor.INSTANCE - override fun getTestDataPath() = KotlinTestUtils.getHomeDirectory() + override fun getTestDataPath() = KtTestUtil.getHomeDirectory() override fun setUp() { diff --git a/idea/tests/org/jetbrains/kotlin/idea/configuration/AbstractConfigureKotlinTest.kt b/idea/tests/org/jetbrains/kotlin/idea/configuration/AbstractConfigureKotlinTest.kt index 7b4f64b7cd9..3ff0daa73cb 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/configuration/AbstractConfigureKotlinTest.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/configuration/AbstractConfigureKotlinTest.kt @@ -22,9 +22,9 @@ import junit.framework.TestCase import org.jetbrains.kotlin.idea.configuration.KotlinWithLibraryConfigurator.FileState import org.jetbrains.kotlin.idea.framework.KotlinSdkType import org.jetbrains.kotlin.idea.test.PluginTestCaseBase.* -import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.WithMutedInDatabaseRunTest import org.jetbrains.kotlin.test.runTest +import org.jetbrains.kotlin.test.util.KtTestUtil import org.jetbrains.kotlin.utils.PathUtil import java.io.File import java.nio.file.Path @@ -34,12 +34,12 @@ abstract class AbstractConfigureKotlinTest : PlatformTestCase() { override fun setUp() { super.setUp() - VfsRootAccess.allowRootAccess(KotlinTestUtils.getHomeDirectory()) + VfsRootAccess.allowRootAccess(KtTestUtil.getHomeDirectory()) } @Throws(Exception::class) override fun tearDown() { - VfsRootAccess.disallowRootAccess(KotlinTestUtils.getHomeDirectory()) + VfsRootAccess.disallowRootAccess(KtTestUtil.getHomeDirectory()) PathMacros.getInstance().removeMacro(TEMP_DIR_MACRO_KEY) super.tearDown() diff --git a/idea/tests/org/jetbrains/kotlin/idea/configuration/AbstractConfigureKotlinTest.kt.201 b/idea/tests/org/jetbrains/kotlin/idea/configuration/AbstractConfigureKotlinTest.kt.201 index 41cd2d4a754..ea5d0592859 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/configuration/AbstractConfigureKotlinTest.kt.201 +++ b/idea/tests/org/jetbrains/kotlin/idea/configuration/AbstractConfigureKotlinTest.kt.201 @@ -22,9 +22,9 @@ import junit.framework.TestCase import org.jetbrains.kotlin.idea.configuration.KotlinWithLibraryConfigurator.FileState import org.jetbrains.kotlin.idea.framework.KotlinSdkType import org.jetbrains.kotlin.idea.test.PluginTestCaseBase.* -import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.WithMutedInDatabaseRunTest import org.jetbrains.kotlin.test.runTest +import org.jetbrains.kotlin.test.util.KtTestUtil import org.jetbrains.kotlin.utils.PathUtil import java.io.File import java.nio.file.Path @@ -34,12 +34,12 @@ abstract class AbstractConfigureKotlinTest : PlatformTestCase() { override fun setUp() { super.setUp() - VfsRootAccess.allowRootAccess(KotlinTestUtils.getHomeDirectory()) + VfsRootAccess.allowRootAccess(KtTestUtil.getHomeDirectory()) } @Throws(Exception::class) override fun tearDown() { - VfsRootAccess.disallowRootAccess(KotlinTestUtils.getHomeDirectory()) + VfsRootAccess.disallowRootAccess(KtTestUtil.getHomeDirectory()) PathMacros.getInstance().removeMacro(TEMP_DIR_MACRO_KEY) super.tearDown() diff --git a/idea/tests/org/jetbrains/kotlin/idea/configuration/AbstractConfigureKotlinTest.kt.203 b/idea/tests/org/jetbrains/kotlin/idea/configuration/AbstractConfigureKotlinTest.kt.203 index 1a020148c6f..48327df9b66 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/configuration/AbstractConfigureKotlinTest.kt.203 +++ b/idea/tests/org/jetbrains/kotlin/idea/configuration/AbstractConfigureKotlinTest.kt.203 @@ -26,6 +26,7 @@ import org.jetbrains.kotlin.idea.test.PluginTestCaseBase.* import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.WithMutedInDatabaseRunTest import org.jetbrains.kotlin.test.runTest +import org.jetbrains.kotlin.test.util.KtTestUtil import org.jetbrains.kotlin.utils.PathUtil import java.io.File import java.nio.file.Path @@ -36,7 +37,7 @@ abstract class AbstractConfigureKotlinTest : PlatformTestCase() { override fun setUp() { super.setUp() - VfsRootAccess.allowRootAccess(testRootDisposable, KotlinTestUtils.getHomeDirectory()) + VfsRootAccess.allowRootAccess(testRootDisposable, KtTestUtil.getHomeDirectory()) } @Throws(Exception::class) diff --git a/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/CodeFragmentCompletionInLibraryTest.kt b/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/CodeFragmentCompletionInLibraryTest.kt index 2af06628a7b..a5d4b7f64c5 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/CodeFragmentCompletionInLibraryTest.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/CodeFragmentCompletionInLibraryTest.kt @@ -21,12 +21,12 @@ import org.jetbrains.kotlin.psi.KtFile import org.jetbrains.kotlin.psi.KtFunction import org.jetbrains.kotlin.psi.KtPsiFactory import org.jetbrains.kotlin.test.JUnit3WithIdeaConfigurationRunner -import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil import org.junit.runner.RunWith import java.io.File private val LIBRARY_SRC_PATH = - KotlinTestUtils.getHomeDirectory() + "/idea/idea-completion/testData/codeFragmentInLibrarySource/customLibrary/" + KtTestUtil.getHomeDirectory() + "/idea/idea-completion/testData/codeFragmentInLibrarySource/customLibrary/" @RunWith(JUnit3WithIdeaConfigurationRunner::class) class CodeFragmentCompletionInLibraryTest : AbstractJvmBasicCompletionTest() { diff --git a/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/AbstractClsStubBuilderTest.kt b/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/AbstractClsStubBuilderTest.kt index 1d98e481ee1..7b3768690d0 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/AbstractClsStubBuilderTest.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/AbstractClsStubBuilderTest.kt @@ -19,6 +19,7 @@ import org.jetbrains.kotlin.psi.stubs.elements.KtFileStubBuilder import org.jetbrains.kotlin.test.InTextDirectivesUtils import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.MockLibraryUtil +import org.jetbrains.kotlin.test.util.KtTestUtil import org.jetbrains.kotlin.utils.addIfNotNull import org.junit.Assert import java.io.File @@ -66,7 +67,7 @@ abstract class AbstractClsStubBuilderTest : LightCodeInsightFixtureTestCase() { } private fun getClassFileToDecompile(sourcePath: String, isUseStringTable: Boolean, classFileName: String?): VirtualFile { - val outDir = KotlinTestUtils.tmpDir("libForStubTest-" + sourcePath) + val outDir = KtTestUtil.tmpDir("libForStubTest-" + sourcePath) val extraOptions = ArrayList() extraOptions.add("-Xallow-kotlin-package") diff --git a/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/AbstractLoadJavaClsStubTest.kt b/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/AbstractLoadJavaClsStubTest.kt index 564ba58ec03..caf70e0ec68 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/AbstractLoadJavaClsStubTest.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/AbstractLoadJavaClsStubTest.kt @@ -20,10 +20,10 @@ import org.jetbrains.kotlin.idea.decompiler.classFile.KtClsFile import org.jetbrains.kotlin.jvm.compiler.LoadDescriptorUtil import org.jetbrains.kotlin.psi.stubs.elements.KtFileStubBuilder import org.jetbrains.kotlin.test.ConfigurationKind -import org.jetbrains.kotlin.test.KotlinTestUtils.getAnnotationsJar import org.jetbrains.kotlin.test.KotlinTestUtils.newConfiguration import org.jetbrains.kotlin.test.TestCaseWithTmpdir import org.jetbrains.kotlin.test.TestJdkKind +import org.jetbrains.kotlin.test.util.KtTestUtil.getAnnotationsJar import org.junit.Assert import java.io.File @@ -37,7 +37,9 @@ abstract class AbstractLoadJavaClsStubTest : TestCaseWithTmpdir() { private fun doTestCompiledKotlin(ktFileName: String, configurationKind: ConfigurationKind, useTypeTableInSerializer: Boolean) { val ktFile = File(ktFileName) - val configuration = newConfiguration(configurationKind, TestJdkKind.MOCK_JDK, getAnnotationsJar()) + val configuration = newConfiguration(configurationKind, TestJdkKind.MOCK_JDK, + getAnnotationsJar() + ) if (useTypeTableInSerializer) { configuration.put(JVMConfigurationKeys.USE_TYPE_TABLE, true) } @@ -88,4 +90,4 @@ abstract class AbstractLoadJavaClsStubTest : TestCaseWithTmpdir() { } } } -} \ No newline at end of file +} diff --git a/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClsStubForWrongAbiVersionTest.kt b/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClsStubForWrongAbiVersionTest.kt index 978ac733ebd..15dea4e4db9 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClsStubForWrongAbiVersionTest.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClsStubForWrongAbiVersionTest.kt @@ -9,7 +9,7 @@ import com.intellij.testFramework.LightProjectDescriptor import org.jetbrains.kotlin.idea.decompiler.textBuilder.findTestLibraryRoot import org.jetbrains.kotlin.idea.test.KotlinJdkAndLibraryProjectDescriptor import org.jetbrains.kotlin.test.JUnit3WithIdeaConfigurationRunner -import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil import org.junit.runner.RunWith import java.io.File @@ -27,6 +27,6 @@ class ClsStubBuilderForWrongAbiVersionTest : AbstractClsStubBuilderTest() { } override fun getProjectDescriptor(): LightProjectDescriptor { - return KotlinJdkAndLibraryProjectDescriptor(File(KotlinTestUtils.getTestDataPathBase() + "/cli/jvm/wrongAbiVersionLib/bin")) + return KotlinJdkAndLibraryProjectDescriptor(File(KtTestUtil.getTestDataPathBase() + "/cli/jvm/wrongAbiVersionLib/bin")) } } diff --git a/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/DecompiledTextForWrongAbiVersionTest.kt b/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/DecompiledTextForWrongAbiVersionTest.kt index f6d03c000d7..383996c28f0 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/DecompiledTextForWrongAbiVersionTest.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/DecompiledTextForWrongAbiVersionTest.kt @@ -14,7 +14,7 @@ import org.jetbrains.kotlin.idea.decompiler.common.INCOMPATIBLE_ABI_VERSION_GENE import org.jetbrains.kotlin.idea.decompiler.stubBuilder.findClassFileByName import org.jetbrains.kotlin.idea.test.KotlinJdkAndLibraryProjectDescriptor import org.jetbrains.kotlin.test.JUnit3WithIdeaConfigurationRunner -import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil import org.junit.Assert import org.junit.runner.RunWith import java.io.File @@ -23,7 +23,7 @@ import java.io.File class DecompiledTextForWrongAbiVersionTest : AbstractInternalCompiledClassesTest() { override fun getProjectDescriptor(): LightProjectDescriptor { - return KotlinJdkAndLibraryProjectDescriptor(File(KotlinTestUtils.getTestDataPathBase() + "/cli/jvm/wrongAbiVersionLib/bin")) + return KotlinJdkAndLibraryProjectDescriptor(File(KtTestUtil.getTestDataPathBase() + "/cli/jvm/wrongAbiVersionLib/bin")) } fun testSyntheticClassIsInvisibleWrongAbiVersion() = doTestNoPsiFilesAreBuiltForSyntheticClasses() diff --git a/idea/tests/org/jetbrains/kotlin/idea/externalAnnotations/ExternalAnnotationTest.kt b/idea/tests/org/jetbrains/kotlin/idea/externalAnnotations/ExternalAnnotationTest.kt index d47bf27bba9..e2535f6dfda 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/externalAnnotations/ExternalAnnotationTest.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/externalAnnotations/ExternalAnnotationTest.kt @@ -18,13 +18,14 @@ import org.jetbrains.kotlin.idea.util.application.runWriteAction import org.jetbrains.kotlin.test.JUnit3WithIdeaConfigurationRunner import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.TargetBackend +import org.jetbrains.kotlin.test.util.KtTestUtil import org.junit.runner.RunWith import java.io.File @RunWith(JUnit3WithIdeaConfigurationRunner::class) class ExternalAnnotationTest : KotlinLightCodeInsightFixtureTestCase() { - override fun getTestDataPath() = KotlinTestUtils.getHomeDirectory() + override fun getTestDataPath() = KtTestUtil.getHomeDirectory() fun testNotNullMethod() { KotlinTestUtils.runTest(::doTest, TargetBackend.ANY, "idea/testData/externalAnnotations/notNullMethod.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/hierarchy/AbstractHierarchyWithLibTest.kt b/idea/tests/org/jetbrains/kotlin/idea/hierarchy/AbstractHierarchyWithLibTest.kt index 92f8edf204b..b7469364446 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/hierarchy/AbstractHierarchyWithLibTest.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/hierarchy/AbstractHierarchyWithLibTest.kt @@ -14,7 +14,7 @@ import com.intellij.psi.search.GlobalSearchScope import com.intellij.testFramework.LightProjectDescriptor import org.jetbrains.kotlin.idea.test.ProjectDescriptorWithStdlibSources import org.jetbrains.kotlin.test.InTextDirectivesUtils -import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil import java.io.File abstract class AbstractHierarchyWithLibTest : AbstractHierarchyTest() { @@ -24,7 +24,7 @@ abstract class AbstractHierarchyWithLibTest : AbstractHierarchyTest() { val filesToConfigure = filesToConfigure val file = filesToConfigure.first() val directive = InTextDirectivesUtils.findLinesWithPrefixesRemoved( - File("${KotlinTestUtils.getHomeDirectory()}/$folderName/$file").readText(), + File("${KtTestUtil.getHomeDirectory()}/$folderName/$file").readText(), "// BASE_CLASS: " ).singleOrNull() ?: error("File should contain BASE_CLASS directive") @@ -48,4 +48,4 @@ abstract class AbstractHierarchyWithLibTest : AbstractHierarchyTest() { } override fun getProjectDescriptor(): LightProjectDescriptor = ProjectDescriptorWithStdlibSources.INSTANCE -} \ No newline at end of file +} diff --git a/idea/tests/org/jetbrains/kotlin/idea/highlighter/AbstractDiagnosticMessageTest.java b/idea/tests/org/jetbrains/kotlin/idea/highlighter/AbstractDiagnosticMessageTest.java index 130960e956e..8beb9597e29 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/highlighter/AbstractDiagnosticMessageTest.java +++ b/idea/tests/org/jetbrains/kotlin/idea/highlighter/AbstractDiagnosticMessageTest.java @@ -24,6 +24,7 @@ import org.jetbrains.kotlin.resolve.BindingContext; import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm; import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil; import org.jetbrains.kotlin.test.*; +import org.jetbrains.kotlin.test.util.KtTestUtil; import java.io.File; import java.lang.reflect.Field; @@ -76,7 +77,7 @@ public abstract class AbstractDiagnosticMessageTest extends KotlinTestWithEnviro File file = new File(filePath); String fileName = file.getName(); - String fileData = KotlinTestUtils.doLoadFile(file); + String fileData = KtTestUtil.doLoadFile(file); Directives directives = KotlinTestUtils.parseDirectives(fileData); int diagnosticNumber = getDiagnosticNumber(directives); final Set> diagnosticFactories = getDiagnosticFactories(directives); @@ -86,7 +87,7 @@ public abstract class AbstractDiagnosticMessageTest extends KotlinTestWithEnviro LanguageVersion version = explicitLanguageVersion == null ? null : LanguageVersion.fromVersionString(explicitLanguageVersion); Map specificFeatures = parseLanguageFeatures(fileData); - KtFile psiFile = KotlinTestUtils.createFile(fileName, KotlinTestUtils.doLoadFile(getTestDataPath(), fileName), getProject()); + KtFile psiFile = KtTestUtil.createFile(fileName, KtTestUtil.doLoadFile(getTestDataPath(), fileName), getProject()); AnalysisResult analysisResult = analyze(psiFile, version, specificFeatures); BindingContext bindingContext = analysisResult.getBindingContext(); diff --git a/idea/tests/org/jetbrains/kotlin/idea/index/AbstractKotlinTypeAliasByExpansionShortNameIndexTest.kt b/idea/tests/org/jetbrains/kotlin/idea/index/AbstractKotlinTypeAliasByExpansionShortNameIndexTest.kt index 084aecd9834..f67fb94a6d1 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/index/AbstractKotlinTypeAliasByExpansionShortNameIndexTest.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/index/AbstractKotlinTypeAliasByExpansionShortNameIndexTest.kt @@ -9,7 +9,7 @@ import com.intellij.psi.search.GlobalSearchScope import org.jetbrains.kotlin.idea.stubindex.KotlinTypeAliasByExpansionShortNameIndex import org.jetbrains.kotlin.idea.test.KotlinLightCodeInsightFixtureTestCase import org.jetbrains.kotlin.test.InTextDirectivesUtils -import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil import org.junit.Assert import kotlin.reflect.KMutableProperty0 @@ -17,7 +17,7 @@ abstract class AbstractKotlinTypeAliasByExpansionShortNameIndexTest : KotlinLigh override fun getTestDataPath(): String { - return KotlinTestUtils.getHomeDirectory() + "/" + return KtTestUtil.getHomeDirectory() + "/" } private lateinit var scope: GlobalSearchScope @@ -63,4 +63,4 @@ abstract class AbstractKotlinTypeAliasByExpansionShortNameIndexTest : KotlinLigh } } -} \ No newline at end of file +} diff --git a/idea/tests/org/jetbrains/kotlin/idea/internal/AbstractBytecodeToolWindowTest.kt b/idea/tests/org/jetbrains/kotlin/idea/internal/AbstractBytecodeToolWindowTest.kt index b3d8d879577..68954543ccb 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/internal/AbstractBytecodeToolWindowTest.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/internal/AbstractBytecodeToolWindowTest.kt @@ -14,11 +14,11 @@ import org.jetbrains.kotlin.idea.test.KotlinLightCodeInsightFixtureTestCase import org.jetbrains.kotlin.idea.test.KotlinWithJdkAndRuntimeLightProjectDescriptor import org.jetbrains.kotlin.psi.KtFile import org.jetbrains.kotlin.test.InTextDirectivesUtils -import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil import java.io.File abstract class AbstractBytecodeToolWindowTest : KotlinLightCodeInsightFixtureTestCase() { - override fun getTestDataPath() = KotlinTestUtils.getHomeDirectory() + override fun getTestDataPath() = KtTestUtil.getHomeDirectory() override fun getProjectDescriptor() = KotlinWithJdkAndRuntimeLightProjectDescriptor.INSTANCE fun doTest(testPath: String) { diff --git a/idea/tests/org/jetbrains/kotlin/idea/kdoc/AbstractKDocTypingTest.kt b/idea/tests/org/jetbrains/kotlin/idea/kdoc/AbstractKDocTypingTest.kt index 8684871c9aa..9e217b23915 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/kdoc/AbstractKDocTypingTest.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/kdoc/AbstractKDocTypingTest.kt @@ -8,10 +8,10 @@ package org.jetbrains.kotlin.idea.kdoc import org.jetbrains.kotlin.idea.test.KotlinLightCodeInsightFixtureTestCase import org.jetbrains.kotlin.idea.test.KotlinLightProjectDescriptor import org.jetbrains.kotlin.test.InTextDirectivesUtils -import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil abstract class AbstractKDocTypingTest : KotlinLightCodeInsightFixtureTestCase() { - override fun getTestDataPath(): String = KotlinTestUtils.getHomeDirectory() + override fun getTestDataPath(): String = KtTestUtil.getHomeDirectory() override fun getProjectDescriptor() = KotlinLightProjectDescriptor.INSTANCE protected fun doTest(fileName: String) { diff --git a/idea/tests/org/jetbrains/kotlin/idea/navigation/AbstractKotlinGotoImplementationTest.kt b/idea/tests/org/jetbrains/kotlin/idea/navigation/AbstractKotlinGotoImplementationTest.kt index ec95a8f297e..d4369635b1b 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/navigation/AbstractKotlinGotoImplementationTest.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/navigation/AbstractKotlinGotoImplementationTest.kt @@ -9,7 +9,7 @@ import com.intellij.openapi.projectRoots.Sdk import com.intellij.testFramework.LightCodeInsightTestCase import org.jetbrains.kotlin.idea.test.PluginTestCaseBase import org.jetbrains.kotlin.idea.test.invalidateLibraryCache -import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil import java.io.File @Suppress("DEPRECATION") @@ -20,7 +20,7 @@ abstract class AbstractKotlinGotoImplementationTest : LightCodeInsightTestCase() invalidateLibraryCache(project) } - override fun getTestDataPath(): String = KotlinTestUtils.getHomeDirectory() + File.separator + override fun getTestDataPath(): String = KtTestUtil.getHomeDirectory() + File.separator override fun getProjectJDK(): Sdk = PluginTestCaseBase.mockJdk() @@ -29,4 +29,4 @@ abstract class AbstractKotlinGotoImplementationTest : LightCodeInsightTestCase() val gotoData = NavigationTestUtils.invokeGotoImplementations(editor, file) NavigationTestUtils.assertGotoDataMatching(editor, gotoData) } -} \ No newline at end of file +} diff --git a/idea/tests/org/jetbrains/kotlin/idea/quickfix/AbstractQuickFixMultiModuleTest.kt b/idea/tests/org/jetbrains/kotlin/idea/quickfix/AbstractQuickFixMultiModuleTest.kt index a17c57cc847..64abb375043 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/quickfix/AbstractQuickFixMultiModuleTest.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/quickfix/AbstractQuickFixMultiModuleTest.kt @@ -22,6 +22,7 @@ import org.jetbrains.kotlin.idea.util.application.executeCommand import org.jetbrains.kotlin.psi.KtFile import org.jetbrains.kotlin.test.InTextDirectivesUtils import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil import org.junit.Assert import java.io.File @@ -107,7 +108,7 @@ abstract class AbstractQuickFixMultiModuleTest : AbstractMultiModuleTest(), Quic } private fun compareToExpected(directory: String) { - val projectDirectory = File("${KotlinTestUtils.getHomeDirectory()}/$directory") + val projectDirectory = File("${KtTestUtil.getHomeDirectory()}/$directory") val afterFiles = projectDirectory.walkTopDown().filter { it.path.endsWith(".after") }.toList() for (editedFile in project.allKotlinFiles()) { diff --git a/idea/tests/org/jetbrains/kotlin/idea/refactoring/AbstractMemberPullPushTest.kt b/idea/tests/org/jetbrains/kotlin/idea/refactoring/AbstractMemberPullPushTest.kt index 69cf503f057..20950c76ebd 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/refactoring/AbstractMemberPullPushTest.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/refactoring/AbstractMemberPullPushTest.kt @@ -19,6 +19,7 @@ import org.jetbrains.kotlin.idea.refactoring.memberInfo.KtPsiClassWrapper import org.jetbrains.kotlin.idea.test.KotlinLightCodeInsightFixtureTestCase import org.jetbrains.kotlin.psi.NotNullableUserDataProperty import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil import org.jetbrains.kotlin.test.util.findElementsByCommentPrefix import java.io.File @@ -30,7 +31,7 @@ abstract class AbstractMemberPullPushTest : KotlinLightCodeInsightFixtureTestCas val afterFile = File("$path.after") val conflictFile = File("$path.messages") - fixture.testDataPath = "${KotlinTestUtils.getHomeDirectory()}/${mainFile.parent}" + fixture.testDataPath = "${KtTestUtil.getHomeDirectory()}/${mainFile.parent}" val mainFileName = mainFile.name val mainFileBaseName = FileUtil.getNameWithoutExtension(mainFileName) @@ -87,4 +88,4 @@ internal fun > chooseMembers(members: List): List { it.isToAbstract = info.toAbstract } return members.filter { it.isChecked } -} \ No newline at end of file +} diff --git a/idea/tests/org/jetbrains/kotlin/idea/refactoring/introduce/AbstractExtractionTest.kt b/idea/tests/org/jetbrains/kotlin/idea/refactoring/introduce/AbstractExtractionTest.kt index 9e57011e789..8d3e291827b 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/refactoring/introduce/AbstractExtractionTest.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/refactoring/introduce/AbstractExtractionTest.kt @@ -57,6 +57,7 @@ import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType import org.jetbrains.kotlin.renderer.DescriptorRenderer import org.jetbrains.kotlin.test.InTextDirectivesUtils import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil import org.jetbrains.kotlin.test.util.findElementByCommentPrefix import java.io.File import java.util.* @@ -325,7 +326,7 @@ abstract class AbstractExtractionTest : KotlinLightCodeInsightFixtureTestCase() ScriptConfigurationManager.updateScriptDependenciesSynchronously(ktFile) } - fixture.testDataPath = "${KotlinTestUtils.getHomeDirectory()}/${mainFile.parent}" + fixture.testDataPath = "${KtTestUtil.getHomeDirectory()}/${mainFile.parent}" val mainFileName = mainFile.name diff --git a/idea/tests/org/jetbrains/kotlin/idea/repl/AbstractIdeReplCompletionTest.kt b/idea/tests/org/jetbrains/kotlin/idea/repl/AbstractIdeReplCompletionTest.kt index e409d3dbcbe..9f647284ec9 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/repl/AbstractIdeReplCompletionTest.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/repl/AbstractIdeReplCompletionTest.kt @@ -19,7 +19,7 @@ import org.jetbrains.kotlin.idea.test.KotlinWithJdkAndRuntimeLightProjectDescrip import org.jetbrains.kotlin.idea.test.PluginTestCaseBase import org.jetbrains.kotlin.idea.util.application.runWriteAction import org.jetbrains.kotlin.platform.jvm.JvmPlatforms -import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil import java.io.File abstract class AbstractIdeReplCompletionTest : KotlinFixtureCompletionBaseTestCase() { @@ -29,11 +29,11 @@ abstract class AbstractIdeReplCompletionTest : KotlinFixtureCompletionBaseTestCa super.setUp() consoleRunner = KotlinConsoleKeeper.getInstance(project).run(module)!! ScriptConfigurationManager.updateScriptDependenciesSynchronously(consoleRunner!!.consoleFile) - VfsRootAccess.allowRootAccess(KotlinTestUtils.getHomeDirectory()) + VfsRootAccess.allowRootAccess(KtTestUtil.getHomeDirectory()) } override fun tearDown() { - VfsRootAccess.disallowRootAccess(KotlinTestUtils.getHomeDirectory()) + VfsRootAccess.disallowRootAccess(KtTestUtil.getHomeDirectory()) consoleRunner?.dispose() consoleRunner = null super.tearDown() @@ -69,4 +69,4 @@ abstract class AbstractIdeReplCompletionTest : KotlinFixtureCompletionBaseTestCa private object FullJdkProjectDescriptor : KotlinWithJdkAndRuntimeLightProjectDescriptor() { override fun getSdk() = PluginTestCaseBase.fullJdk() -} \ No newline at end of file +} diff --git a/idea/tests/org/jetbrains/kotlin/idea/repl/AbstractIdeReplCompletionTest.kt.203 b/idea/tests/org/jetbrains/kotlin/idea/repl/AbstractIdeReplCompletionTest.kt.203 index 3c42d35a47b..c3fc6c4bc9d 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/repl/AbstractIdeReplCompletionTest.kt.203 +++ b/idea/tests/org/jetbrains/kotlin/idea/repl/AbstractIdeReplCompletionTest.kt.203 @@ -19,7 +19,7 @@ import org.jetbrains.kotlin.idea.test.KotlinWithJdkAndRuntimeLightProjectDescrip import org.jetbrains.kotlin.idea.test.PluginTestCaseBase import org.jetbrains.kotlin.idea.util.application.runWriteAction import org.jetbrains.kotlin.platform.jvm.JvmPlatforms -import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil import java.io.File abstract class AbstractIdeReplCompletionTest : KotlinFixtureCompletionBaseTestCase() { @@ -29,7 +29,7 @@ abstract class AbstractIdeReplCompletionTest : KotlinFixtureCompletionBaseTestCa super.setUp() consoleRunner = KotlinConsoleKeeper.getInstance(project).run(module)!! ScriptConfigurationManager.updateScriptDependenciesSynchronously(consoleRunner!!.consoleFile) - VfsRootAccess.allowRootAccess(testRootDisposable, KotlinTestUtils.getHomeDirectory()) + VfsRootAccess.allowRootAccess(testRootDisposable, KtTestUtil.getHomeDirectory()) } override fun tearDown() { @@ -68,4 +68,4 @@ abstract class AbstractIdeReplCompletionTest : KotlinFixtureCompletionBaseTestCa private object FullJdkProjectDescriptor : KotlinWithJdkAndRuntimeLightProjectDescriptor() { override fun getSdk() = PluginTestCaseBase.fullJdk() -} \ No newline at end of file +} diff --git a/idea/tests/org/jetbrains/kotlin/idea/script/AbstractScriptConfigurationTest.kt b/idea/tests/org/jetbrains/kotlin/idea/script/AbstractScriptConfigurationTest.kt index 38268c8b98e..6ca4de3e15e 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/script/AbstractScriptConfigurationTest.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/script/AbstractScriptConfigurationTest.kt @@ -37,6 +37,7 @@ import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.MockLibraryUtil import org.jetbrains.kotlin.test.TestJdkKind import org.jetbrains.kotlin.test.TestMetadata +import org.jetbrains.kotlin.test.util.KtTestUtil import org.jetbrains.kotlin.test.util.addDependency import org.jetbrains.kotlin.test.util.projectLibrary import org.jetbrains.kotlin.utils.PathUtil @@ -345,7 +346,7 @@ abstract class AbstractScriptConfigurationTest : KotlinCompletionTestCase() { private fun compileLibToDir(srcDir: File, vararg classpath: String): File { //TODO: tmpDir would be enough, but there is tricky fail under AS otherwise - val outDir = KotlinTestUtils.tmpDirForReusableFolder("${getTestName(false)}${srcDir.name}Out") + val outDir = KtTestUtil.tmpDirForReusableFolder("${getTestName(false)}${srcDir.name}Out") val javaSourceFiles = FileUtil.findFilesByMask(Pattern.compile(".+\\.java$"), srcDir) if (javaSourceFiles.isNotEmpty()) { diff --git a/idea/tests/org/jetbrains/kotlin/idea/script/AbstractScriptConfigurationTest.kt.203 b/idea/tests/org/jetbrains/kotlin/idea/script/AbstractScriptConfigurationTest.kt.203 index 910649bcf3a..41627db1fdc 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/script/AbstractScriptConfigurationTest.kt.203 +++ b/idea/tests/org/jetbrains/kotlin/idea/script/AbstractScriptConfigurationTest.kt.203 @@ -37,6 +37,7 @@ import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.MockLibraryUtil import org.jetbrains.kotlin.test.TestJdkKind import org.jetbrains.kotlin.test.TestMetadata +import org.jetbrains.kotlin.test.util.KtTestUtil import org.jetbrains.kotlin.test.util.addDependency import org.jetbrains.kotlin.test.util.projectLibrary import org.jetbrains.kotlin.utils.PathUtil @@ -345,7 +346,7 @@ abstract class AbstractScriptConfigurationTest : KotlinCompletionTestCase() { private fun compileLibToDir(srcDir: File, vararg classpath: String): File { //TODO: tmpDir would be enough, but there is tricky fail under AS otherwise - val outDir = KotlinTestUtils.tmpDirForReusableFolder("${getTestName(false)}${srcDir.name}Out") + val outDir = KtTestUtil.tmpDirForReusableFolder("${getTestName(false)}${srcDir.name}Out") val javaSourceFiles = FileUtil.findFilesByMask(Pattern.compile(".+\\.java$"), srcDir) if (javaSourceFiles.isNotEmpty()) { diff --git a/idea/tests/org/jetbrains/kotlin/idea/slicer/AbstractSlicerTest.kt b/idea/tests/org/jetbrains/kotlin/idea/slicer/AbstractSlicerTest.kt index 5cb218c8ddb..1d786f0423e 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/slicer/AbstractSlicerTest.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/slicer/AbstractSlicerTest.kt @@ -10,7 +10,7 @@ import com.intellij.slicer.SliceRootNode import com.intellij.util.PathUtil import org.jetbrains.kotlin.idea.test.KotlinLightCodeInsightFixtureTestCase import org.jetbrains.kotlin.psi.KtFile -import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil import java.io.File abstract class AbstractSlicerTest : KotlinLightCodeInsightFixtureTestCase() { @@ -25,7 +25,7 @@ abstract class AbstractSlicerTest : KotlinLightCodeInsightFixtureTestCase() { name.startsWith("$namePrefix.") && PathUtil.getFileExtension(name).let { it == "kt" || it == "java" } }!! - myFixture.testDataPath = "${KotlinTestUtils.getHomeDirectory()}/${rootDir.path}" + myFixture.testDataPath = "${KtTestUtil.getHomeDirectory()}/${rootDir.path}" val extraPsiFiles = extraFiles.map { myFixture.configureByFile(it.name) } val file = myFixture.configureByFile(mainFile.name) as KtFile @@ -40,4 +40,4 @@ abstract class AbstractSlicerTest : KotlinLightCodeInsightFixtureTestCase() { doTest(path, sliceProvider, rootNode) } } -} \ No newline at end of file +} diff --git a/idea/tests/org/jetbrains/kotlin/idea/stubs/AbstractMultiModuleTest.kt b/idea/tests/org/jetbrains/kotlin/idea/stubs/AbstractMultiModuleTest.kt index 56023fd85d5..f74071338f3 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/stubs/AbstractMultiModuleTest.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/stubs/AbstractMultiModuleTest.kt @@ -32,10 +32,10 @@ import org.jetbrains.kotlin.idea.facet.getOrCreateFacet import org.jetbrains.kotlin.idea.facet.initializeIfNeeded import org.jetbrains.kotlin.idea.test.* import org.jetbrains.kotlin.platform.TargetPlatform -import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.TestJdkKind import org.jetbrains.kotlin.test.WithMutedInDatabaseRunTest import org.jetbrains.kotlin.test.runTest +import org.jetbrains.kotlin.test.util.KtTestUtil import org.junit.Assert import java.io.File @@ -47,7 +47,7 @@ abstract class AbstractMultiModuleTest : DaemonAnalyzerTestCase() { override fun setUp() { super.setUp() enableKotlinOfficialCodeStyle(project) - VfsRootAccess.allowRootAccess(KotlinTestUtils.getHomeDirectory()) + VfsRootAccess.allowRootAccess(KtTestUtil.getHomeDirectory()) } fun module(name: String, jdk: TestJdkKind = TestJdkKind.MOCK_JDK, hasTestRoot: Boolean = false): Module { @@ -67,7 +67,7 @@ abstract class AbstractMultiModuleTest : DaemonAnalyzerTestCase() { } override fun tearDown() = runAll( - ThrowableRunnable { VfsRootAccess.disallowRootAccess(KotlinTestUtils.getHomeDirectory()) }, + ThrowableRunnable { VfsRootAccess.disallowRootAccess(KtTestUtil.getHomeDirectory()) }, ThrowableRunnable { disableKotlinOfficialCodeStyle(project) }, ThrowableRunnable { super.tearDown() }, ) @@ -201,4 +201,4 @@ private fun Module.createFacetWithAdditionalSetup( } modelsProvider.commit() } -} \ No newline at end of file +} diff --git a/idea/tests/org/jetbrains/kotlin/idea/stubs/AbstractMultiModuleTest.kt.203 b/idea/tests/org/jetbrains/kotlin/idea/stubs/AbstractMultiModuleTest.kt.203 index 174f3a97417..d6a1fd8f938 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/stubs/AbstractMultiModuleTest.kt.203 +++ b/idea/tests/org/jetbrains/kotlin/idea/stubs/AbstractMultiModuleTest.kt.203 @@ -32,10 +32,10 @@ import org.jetbrains.kotlin.idea.facet.getOrCreateFacet import org.jetbrains.kotlin.idea.facet.initializeIfNeeded import org.jetbrains.kotlin.idea.test.* import org.jetbrains.kotlin.platform.TargetPlatform -import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.TestJdkKind import org.jetbrains.kotlin.test.WithMutedInDatabaseRunTest import org.jetbrains.kotlin.test.runTest +import org.jetbrains.kotlin.test.util.KtTestUtil import org.junit.Assert import java.io.File @@ -47,7 +47,7 @@ abstract class AbstractMultiModuleTest : DaemonAnalyzerTestCase() { override fun setUp() { super.setUp() enableKotlinOfficialCodeStyle(project) - VfsRootAccess.allowRootAccess(testRootDisposable, KotlinTestUtils.getHomeDirectory()) + VfsRootAccess.allowRootAccess(testRootDisposable, KtTestUtil.getHomeDirectory()) } fun module(name: String, jdk: TestJdkKind = TestJdkKind.MOCK_JDK, hasTestRoot: Boolean = false): Module { @@ -200,4 +200,4 @@ private fun Module.createFacetWithAdditionalSetup( } modelsProvider.commit() } -} \ No newline at end of file +} diff --git a/j2k/tests/org/jetbrains/kotlin/j2k/AbstractJavaToKotlinConverterSingleFileTest.kt b/j2k/tests/org/jetbrains/kotlin/j2k/AbstractJavaToKotlinConverterSingleFileTest.kt index 2f0384c0c2f..c1f0315ba5c 100644 --- a/j2k/tests/org/jetbrains/kotlin/j2k/AbstractJavaToKotlinConverterSingleFileTest.kt +++ b/j2k/tests/org/jetbrains/kotlin/j2k/AbstractJavaToKotlinConverterSingleFileTest.kt @@ -19,6 +19,7 @@ import org.jetbrains.kotlin.idea.test.dumpTextWithErrors import org.jetbrains.kotlin.psi.KtFile import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil import java.io.File import java.util.regex.Pattern @@ -93,7 +94,7 @@ abstract class AbstractJavaToKotlinConverterSingleFileTest : AbstractJavaToKotli val funBody = text.lines().joinToString(separator = "\n", transform = { " $it" }) val textToFormat = if (inFunContext) "fun convertedTemp() {\n$funBody\n}" else text - val convertedFile = KotlinTestUtils.createFile("converted", textToFormat, project) + val convertedFile = KtTestUtil.createFile("converted", textToFormat, project) WriteCommandAction.runWriteCommandAction(project) { CodeStyleManager.getInstance(project)!!.reformat(convertedFile) } diff --git a/j2k/tests/org/jetbrains/kotlin/j2k/AbstractJavaToKotlinConverterTest.kt b/j2k/tests/org/jetbrains/kotlin/j2k/AbstractJavaToKotlinConverterTest.kt index 6834019ece6..d87a1f23983 100644 --- a/j2k/tests/org/jetbrains/kotlin/j2k/AbstractJavaToKotlinConverterTest.kt +++ b/j2k/tests/org/jetbrains/kotlin/j2k/AbstractJavaToKotlinConverterTest.kt @@ -22,11 +22,11 @@ import com.intellij.openapi.vfs.VirtualFile import com.intellij.openapi.vfs.newvfs.impl.VfsRootAccess import com.intellij.pom.java.LanguageLevel import com.intellij.testFramework.LightPlatformTestCase +import org.jetbrains.kotlin.idea.caches.PerModulePackageCacheService.Companion.DEBUG_LOG_ENABLE_PerModulePackageCache import org.jetbrains.kotlin.idea.test.KotlinLightCodeInsightFixtureTestCase import org.jetbrains.kotlin.idea.test.invalidateLibraryCache import org.jetbrains.kotlin.idea.util.application.runWriteAction -import org.jetbrains.kotlin.test.KotlinTestUtils -import org.jetbrains.kotlin.idea.caches.PerModulePackageCacheService.Companion.DEBUG_LOG_ENABLE_PerModulePackageCache +import org.jetbrains.kotlin.test.util.KtTestUtil import java.io.File abstract class AbstractJavaToKotlinConverterTest : KotlinLightCodeInsightFixtureTestCase() { @@ -40,7 +40,7 @@ abstract class AbstractJavaToKotlinConverterTest : KotlinLightCodeInsightFixture LanguageLevelProjectExtension.getInstance(project).languageLevel = LanguageLevel.JDK_1_8 } - VfsRootAccess.allowRootAccess(KotlinTestUtils.getHomeDirectory()) + VfsRootAccess.allowRootAccess(KtTestUtil.getHomeDirectory()) invalidateLibraryCache(project) @@ -49,7 +49,7 @@ abstract class AbstractJavaToKotlinConverterTest : KotlinLightCodeInsightFixture } override fun tearDown() { - VfsRootAccess.disallowRootAccess(KotlinTestUtils.getHomeDirectory()) + VfsRootAccess.disallowRootAccess(KtTestUtil.getHomeDirectory()) project.DEBUG_LOG_ENABLE_PerModulePackageCache = false super.tearDown() diff --git a/j2k/tests/org/jetbrains/kotlin/j2k/AbstractJavaToKotlinConverterTest.kt.203 b/j2k/tests/org/jetbrains/kotlin/j2k/AbstractJavaToKotlinConverterTest.kt.203 index aa87f659f90..14657633ef1 100644 --- a/j2k/tests/org/jetbrains/kotlin/j2k/AbstractJavaToKotlinConverterTest.kt.203 +++ b/j2k/tests/org/jetbrains/kotlin/j2k/AbstractJavaToKotlinConverterTest.kt.203 @@ -26,7 +26,7 @@ import org.jetbrains.kotlin.idea.caches.PerModulePackageCacheService.Companion.D import org.jetbrains.kotlin.idea.test.KotlinLightCodeInsightFixtureTestCase import org.jetbrains.kotlin.idea.test.invalidateLibraryCache import org.jetbrains.kotlin.idea.util.application.runWriteAction -import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil import java.io.File abstract class AbstractJavaToKotlinConverterTest : KotlinLightCodeInsightFixtureTestCase() { @@ -40,7 +40,7 @@ abstract class AbstractJavaToKotlinConverterTest : KotlinLightCodeInsightFixture LanguageLevelProjectExtension.getInstance(project).languageLevel = LanguageLevel.JDK_1_8 } - VfsRootAccess.allowRootAccess(getTestRootDisposable(), KotlinTestUtils.getHomeDirectory()) + VfsRootAccess.allowRootAccess(getTestRootDisposable(), KtTestUtil.getHomeDirectory()) invalidateLibraryCache(project) diff --git a/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/KotlinJpsBuildTest.kt b/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/KotlinJpsBuildTest.kt index 3e158535610..780a2148ae0 100644 --- a/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/KotlinJpsBuildTest.kt +++ b/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/KotlinJpsBuildTest.kt @@ -69,6 +69,7 @@ import org.jetbrains.kotlin.load.kotlin.PackagePartClassUtils import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.MockLibraryUtil +import org.jetbrains.kotlin.test.util.KtTestUtil import org.jetbrains.kotlin.utils.PathUtil import org.jetbrains.kotlin.utils.Printer import org.jetbrains.org.objectweb.asm.ClassReader @@ -962,7 +963,7 @@ open class KotlinJpsBuildTest : KotlinJpsBuildTestBase() { } fun testJre9() { - val jdk9Path = KotlinTestUtils.getJdk9Home().absolutePath + val jdk9Path = KtTestUtil.getJdk9Home().absolutePath val jdk = myModel.global.addSdk(JDK_NAME, jdk9Path, "9", JpsJavaSdkType.INSTANCE) jdk.addRoot(StandardFileSystems.JRT_PROTOCOL_PREFIX + jdk9Path + URLUtil.JAR_SEPARATOR + "java.base", JpsOrderRootType.COMPILED) diff --git a/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/KotlinJpsBuildTest.kt.201 b/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/KotlinJpsBuildTest.kt.201 index e78ecb115c4..10af39dca01 100644 --- a/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/KotlinJpsBuildTest.kt.201 +++ b/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/KotlinJpsBuildTest.kt.201 @@ -69,6 +69,7 @@ import org.jetbrains.kotlin.load.kotlin.PackagePartClassUtils import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.MockLibraryUtil +import org.jetbrains.kotlin.test.util.KtTestUtil import org.jetbrains.kotlin.utils.PathUtil import org.jetbrains.kotlin.utils.Printer import org.jetbrains.org.objectweb.asm.ClassReader @@ -962,7 +963,7 @@ open class KotlinJpsBuildTest : KotlinJpsBuildTestBase() { } fun testJre9() { - val jdk9Path = KotlinTestUtils.getJdk9Home().absolutePath + val jdk9Path = KtTestUtil.getJdk9Home().absolutePath val jdk = myModel.global.addSdk(JDK_NAME, jdk9Path, "9", JpsJavaSdkType.INSTANCE) jdk.addRoot(StandardFileSystems.JRT_PROTOCOL_PREFIX + jdk9Path + URLUtil.JAR_SEPARATOR + "java.base", JpsOrderRootType.COMPILED) diff --git a/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jvm/compiler/ClasspathOrderTest.kt b/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jvm/compiler/ClasspathOrderTest.kt index 62ad269e3c1..244a538fdde 100644 --- a/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jvm/compiler/ClasspathOrderTest.kt +++ b/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jvm/compiler/ClasspathOrderTest.kt @@ -19,9 +19,9 @@ package org.jetbrains.kotlin.jvm.compiler import org.jetbrains.jps.builders.java.JavaModuleBuildTargetType import org.jetbrains.kotlin.build.JvmSourceRoot import org.jetbrains.kotlin.modules.KotlinModuleXmlBuilder -import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.MockLibraryUtil import org.jetbrains.kotlin.test.TestCaseWithTmpdir +import org.jetbrains.kotlin.test.util.KtTestUtil import org.jetbrains.kotlin.utils.PathUtil import java.io.File @@ -32,7 +32,7 @@ import java.io.File */ class ClasspathOrderTest : TestCaseWithTmpdir() { companion object { - private val sourceDir = File(KotlinTestUtils.getTestDataPathBase() + "/classpathOrder").absoluteFile + private val sourceDir = File(KtTestUtil.getTestDataPathBase() + "/classpathOrder").absoluteFile } fun testClasspathOrderForCLI() { diff --git a/js/js.tests/test/org/jetbrains/kotlin/integration/AntTaskJsTest.java b/js/js.tests/test/org/jetbrains/kotlin/integration/AntTaskJsTest.java index 12dffa74f97..616ac6e287d 100644 --- a/js/js.tests/test/org/jetbrains/kotlin/integration/AntTaskJsTest.java +++ b/js/js.tests/test/org/jetbrains/kotlin/integration/AntTaskJsTest.java @@ -11,7 +11,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.js.test.NashornJsTestChecker; import org.jetbrains.kotlin.js.test.V8JsTestChecker; -import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import java.io.File; import java.io.IOException; @@ -25,7 +25,7 @@ public class AntTaskJsTest extends AbstractAntTaskTest { @NotNull private String getTestDataDir() { - return KotlinTestUtils.getTestDataPathBase() + "/integration/ant/js/" + getTestName(true); + return KtTestUtil.getTestDataPathBase() + "/integration/ant/js/" + getTestName(true); } @NotNull diff --git a/js/js.tests/test/org/jetbrains/kotlin/js/test/AbstractJsLineNumberTest.kt b/js/js.tests/test/org/jetbrains/kotlin/js/test/AbstractJsLineNumberTest.kt index ba506fbf626..8c787e88f85 100644 --- a/js/js.tests/test/org/jetbrains/kotlin/js/test/AbstractJsLineNumberTest.kt +++ b/js/js.tests/test/org/jetbrains/kotlin/js/test/AbstractJsLineNumberTest.kt @@ -30,7 +30,11 @@ import org.jetbrains.kotlin.js.test.utils.LineOutputToStringVisitor import org.jetbrains.kotlin.js.util.TextOutputImpl import org.jetbrains.kotlin.psi.KtFile import org.jetbrains.kotlin.serialization.js.ModuleKind -import org.jetbrains.kotlin.test.* +import org.jetbrains.kotlin.test.Directives +import org.jetbrains.kotlin.test.KotlinBaseTest +import org.jetbrains.kotlin.test.KotlinTestWithEnvironment +import org.jetbrains.kotlin.test.TestFiles +import org.jetbrains.kotlin.test.util.KtTestUtil import org.jetbrains.kotlin.utils.DFS import java.io.ByteArrayOutputStream import java.io.Closeable @@ -134,14 +138,14 @@ abstract class AbstractJsLineNumberTest : KotlinTestWithEnvironment() { } private inner class TestFileFactoryImpl : TestFiles.TestFileFactory, Closeable { - private val tmpDir = KotlinTestUtils.tmpDir("js-tests") + private val tmpDir = KtTestUtil.tmpDir("js-tests") private val defaultModule = TestModule(BasicBoxTest.TEST_MODULE, emptyList(), emptyList()) override fun createFile(module: TestModule?, fileName: String, text: String, directives: Directives): TestFile? { val currentModule = module ?: defaultModule val temporaryFile = File(tmpDir, "${currentModule.name}/$fileName") - KotlinTestUtils.mkdirs(temporaryFile.parentFile) + KtTestUtil.mkdirs(temporaryFile.parentFile) temporaryFile.writeText(text, Charsets.UTF_8) return TestFile(temporaryFile.absolutePath, text, currentModule, directives) diff --git a/js/js.tests/test/org/jetbrains/kotlin/js/test/BasicBoxTest.kt b/js/js.tests/test/org/jetbrains/kotlin/js/test/BasicBoxTest.kt index 91d9ee82cbf..8360f5f456e 100644 --- a/js/js.tests/test/org/jetbrains/kotlin/js/test/BasicBoxTest.kt +++ b/js/js.tests/test/org/jetbrains/kotlin/js/test/BasicBoxTest.kt @@ -52,6 +52,7 @@ import org.jetbrains.kotlin.serialization.js.JsSerializerProtocol import org.jetbrains.kotlin.serialization.js.KotlinJavascriptSerializationUtil import org.jetbrains.kotlin.serialization.js.ModuleKind import org.jetbrains.kotlin.test.* +import org.jetbrains.kotlin.test.util.KtTestUtil import org.jetbrains.kotlin.utils.DFS import org.jetbrains.kotlin.utils.JsMetadataVersion import org.jetbrains.kotlin.utils.KotlinJavascriptMetadata @@ -108,7 +109,7 @@ abstract class BasicBoxTest( val outputDir = getOutputDir(file) val dceOutputDir = getOutputDir(file, testGroupOutputDirForMinification) val pirOutputDir = getOutputDir(file, testGroupOutputDirForPir) - var fileContent = KotlinTestUtils.doLoadFile(file) + var fileContent = KtTestUtil.doLoadFile(file) if (coroutinesPackage.isNotEmpty()) { fileContent = fileContent.replace("COROUTINES_PACKAGE", coroutinesPackage) } @@ -936,7 +937,7 @@ abstract class BasicBoxTest( private inner class TestFileFactoryImpl(val coroutinesPackage: String) : TestFiles.TestFileFactory, Closeable { var testPackage: String? = null - val tmpDir = KotlinTestUtils.tmpDir("js-tests") + val tmpDir = KtTestUtil.tmpDir("js-tests") val defaultModule = TestModule(TEST_MODULE, emptyList(), emptyList()) var languageVersionSettings: LanguageVersionSettings? = null @@ -962,7 +963,7 @@ abstract class BasicBoxTest( } val temporaryFile = File(tmpDir, "${currentModule.name}/$fileName") - KotlinTestUtils.mkdirs(temporaryFile.parentFile) + KtTestUtil.mkdirs(temporaryFile.parentFile) temporaryFile.writeText(text, Charsets.UTF_8) // TODO Deduplicate logic copied from CodegenTestCase.updateConfigurationByDirectivesInTestFiles diff --git a/js/js.tests/test/org/jetbrains/kotlin/js/test/BasicWasmBoxTest.kt b/js/js.tests/test/org/jetbrains/kotlin/js/test/BasicWasmBoxTest.kt index bc67960b279..3ee83a7dbbb 100644 --- a/js/js.tests/test/org/jetbrains/kotlin/js/test/BasicWasmBoxTest.kt +++ b/js/js.tests/test/org/jetbrains/kotlin/js/test/BasicWasmBoxTest.kt @@ -27,9 +27,9 @@ import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.psi.KtNamedFunction import org.jetbrains.kotlin.psi.KtPsiFactory import org.jetbrains.kotlin.test.Directives -import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.KotlinTestWithEnvironment -import org.jetbrains.kotlin.test.* +import org.jetbrains.kotlin.test.TestFiles +import org.jetbrains.kotlin.test.util.KtTestUtil import java.io.Closeable import java.io.File import java.lang.Boolean.getBoolean @@ -54,7 +54,7 @@ abstract class BasicWasmBoxTest( val file = File(filePath) val outputDir = getOutputDir(file) - val fileContent = KotlinTestUtils.doLoadFile(file) + val fileContent = KtTestUtil.doLoadFile(file) TestFileFactoryImpl().use { testFactory -> val inputFiles: MutableList = TestFiles.createTestFiles(file.name, fileContent, testFactory, true) @@ -180,14 +180,14 @@ abstract class BasicWasmBoxTest( val languageVersionSettings = parseLanguageVersionSettings(directives) val temporaryFile = File(tmpDir, "WASM_TEST/$fileName") - KotlinTestUtils.mkdirs(temporaryFile.parentFile) + KtTestUtil.mkdirs(temporaryFile.parentFile) temporaryFile.writeText(text, Charsets.UTF_8) return TestFile(temporaryFile.absolutePath, languageVersionSettings) } var testPackage: String? = null - val tmpDir = KotlinTestUtils.tmpDir("wasm-tests") + val tmpDir = KtTestUtil.tmpDir("wasm-tests") override fun close() { FileUtil.delete(tmpDir) diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/AbstractKotlinAndroidGradleTests.kt b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/AbstractKotlinAndroidGradleTests.kt index 5f32b0f5f83..56b5f2dd6ce 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/AbstractKotlinAndroidGradleTests.kt +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/AbstractKotlinAndroidGradleTests.kt @@ -3,6 +3,7 @@ package org.jetbrains.kotlin.gradle import org.gradle.api.logging.LogLevel import org.jetbrains.kotlin.gradle.util.* import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil import org.junit.Assume import org.junit.Test import java.io.File @@ -548,7 +549,7 @@ abstract class AbstractKotlinAndroidGradleTests : BaseGradleIT() { override fun defaultBuildOptions() = super.defaultBuildOptions().copy( - androidHome = KotlinTestUtils.findAndroidSdk(), + androidHome = KtTestUtil.findAndroidSdk(), androidGradlePluginVersion = androidGradlePluginVersion ) diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/BuildCacheRelocationIT.kt b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/BuildCacheRelocationIT.kt index 4a5f06b3ea6..ffe9d8974ba 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/BuildCacheRelocationIT.kt +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/BuildCacheRelocationIT.kt @@ -17,13 +17,13 @@ package org.jetbrains.kotlin.gradle import org.jetbrains.kotlin.gradle.util.AGPVersion +import org.jetbrains.kotlin.gradle.util.createTempDir import org.jetbrains.kotlin.gradle.util.modify -import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil import org.junit.Test import org.junit.runner.RunWith import org.junit.runners.Parameterized import java.io.File -import org.jetbrains.kotlin.gradle.util.createTempDir import kotlin.test.assertEquals private val DEFAULT_GRADLE_VERSION = GradleVersionRequired.AtLeast("5.6.4") @@ -37,7 +37,7 @@ class BuildCacheRelocationIT : BaseGradleIT() { override fun defaultBuildOptions(): BuildOptions = super.defaultBuildOptions().copy( withBuildCache = true, - androidHome = KotlinTestUtils.findAndroidSdk() + androidHome = KtTestUtil.findAndroidSdk() ) @Parameterized.Parameter @@ -205,4 +205,4 @@ class BuildCacheRelocationIT : BaseGradleIT() { .map { it.relativeTo(dir) to it.readBytes().contentHashCode() } .toList() } -} \ No newline at end of file +} diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/ConfigurationCacheForAndroidIT.kt b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/ConfigurationCacheForAndroidIT.kt index 59344b3df39..e9b489e9077 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/ConfigurationCacheForAndroidIT.kt +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/ConfigurationCacheForAndroidIT.kt @@ -7,7 +7,7 @@ package org.jetbrains.kotlin.gradle import org.gradle.api.logging.configuration.WarningMode import org.jetbrains.kotlin.gradle.util.AGPVersion -import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil import org.junit.Test class ConfigurationCacheForAndroidIT : AbstractConfigurationCacheIT() { @@ -16,7 +16,7 @@ class ConfigurationCacheForAndroidIT : AbstractConfigurationCacheIT() { override fun defaultBuildOptions() = super.defaultBuildOptions().copy( - androidHome = KotlinTestUtils.findAndroidSdk(), + androidHome = KtTestUtil.findAndroidSdk(), androidGradlePluginVersion = androidGradlePluginVersion, configurationCache = true, configurationCacheProblems = ConfigurationCacheProblems.FAIL diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/Kapt3AndroidIT.kt b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/Kapt3AndroidIT.kt index b02ff0a0061..eb64ae5deea 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/Kapt3AndroidIT.kt +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/Kapt3AndroidIT.kt @@ -1,7 +1,7 @@ package org.jetbrains.kotlin.gradle import org.jetbrains.kotlin.gradle.util.* -import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil import org.junit.Assert import org.junit.Test import java.io.File @@ -95,7 +95,7 @@ abstract class Kapt3AndroidIT : Kapt3BaseIT() { override fun defaultBuildOptions() = super.defaultBuildOptions().copy( - androidHome = KotlinTestUtils.findAndroidSdk(), + androidHome = KtTestUtil.findAndroidSdk(), androidGradlePluginVersion = androidGradlePluginVersion ) @@ -263,4 +263,4 @@ abstract class Kapt3AndroidIT : Kapt3BaseIT() { """.trimIndent() } } -} \ No newline at end of file +} diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/KotlinGradlePluginIT.kt b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/KotlinGradlePluginIT.kt index dcaec936d7d..b33ef668bd3 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/KotlinGradlePluginIT.kt +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/KotlinGradlePluginIT.kt @@ -23,7 +23,7 @@ import org.jetbrains.kotlin.gradle.plugin.MULTIPLE_KOTLIN_PLUGINS_SPECIFIC_PROJE import org.jetbrains.kotlin.gradle.scripting.internal.ScriptingGradleSubplugin import org.jetbrains.kotlin.gradle.tasks.USING_JVM_INCREMENTAL_COMPILATION_MESSAGE import org.jetbrains.kotlin.gradle.util.* -import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil import org.junit.Test import java.io.File import java.nio.file.FileSystemException @@ -1053,7 +1053,7 @@ class KotlinGradleIT : BaseGradleIT() { ":lib1:compileDebugUnitTestKotlin", options = defaultBuildOptions().copy( androidGradlePluginVersion = AGPVersion.v3_2_0, - androidHome = KotlinTestUtils.findAndroidSdk(), + androidHome = KtTestUtil.findAndroidSdk(), ), ) { assertSuccessful() diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/KotlinSpecificDependenciesIT.kt b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/KotlinSpecificDependenciesIT.kt index f6b50ef7ce8..b2cfa6a6936 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/KotlinSpecificDependenciesIT.kt +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/KotlinSpecificDependenciesIT.kt @@ -8,7 +8,7 @@ package org.jetbrains.kotlin.gradle import org.jetbrains.kotlin.gradle.internals.KOTLIN_TEST_MULTIPLATFORM_MODULE_NAME import org.jetbrains.kotlin.gradle.util.AGPVersion import org.jetbrains.kotlin.gradle.util.modify -import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil import kotlin.test.Test import kotlin.test.assertFalse import kotlin.test.assertTrue @@ -19,7 +19,7 @@ class KotlinSpecificDependenciesIT : BaseGradleIT() { get() = GradleVersionRequired.FOR_MPP_SUPPORT override fun defaultBuildOptions(): BuildOptions = - super.defaultBuildOptions().copy(androidGradlePluginVersion = AGPVersion.v3_6_0, androidHome = KotlinTestUtils.findAndroidSdk()) + super.defaultBuildOptions().copy(androidGradlePluginVersion = AGPVersion.v3_6_0, androidHome = KtTestUtil.findAndroidSdk()) private fun Project.prepare() { // call this when reusing a project after a test, too, in order to remove any added dependencies setupWorkingDir() @@ -326,4 +326,4 @@ private fun BaseGradleIT.Project.checkPrintedItems( checkAnyItemsContains.forEach { pattern -> assertTrue { items.any { pattern in it } } } checkNoItemContains.forEach { pattern -> assertFalse { items.any { pattern in it } } } } -} \ No newline at end of file +} diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/SubpluginsIT.kt b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/SubpluginsIT.kt index ae78f872008..8f549f79cc6 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/SubpluginsIT.kt +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/SubpluginsIT.kt @@ -9,7 +9,7 @@ import org.gradle.api.logging.configuration.WarningMode import org.jetbrains.kotlin.gradle.util.AGPVersion import org.jetbrains.kotlin.gradle.util.checkBytecodeContains import org.jetbrains.kotlin.gradle.util.modify -import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil import org.junit.Test import java.io.File import kotlin.test.assertTrue @@ -222,7 +222,7 @@ class SubpluginsIT : BaseGradleIT() { ":app:compileDebugKotlin", options = defaultBuildOptions().copy( androidGradlePluginVersion = AGPVersion.v3_4_1, - androidHome = KotlinTestUtils.findAndroidSdk() + androidHome = KtTestUtil.findAndroidSdk() ) ) { assertSuccessful() @@ -263,4 +263,4 @@ class SubpluginsIT : BaseGradleIT() { } } } -} \ No newline at end of file +} diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/model/KotlinAndroidExtensionIT.kt b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/model/KotlinAndroidExtensionIT.kt index a3cdee047c5..b2506bb7f85 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/model/KotlinAndroidExtensionIT.kt +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/model/KotlinAndroidExtensionIT.kt @@ -6,9 +6,8 @@ package org.jetbrains.kotlin.gradle.model import org.jetbrains.kotlin.gradle.BaseGradleIT -import org.jetbrains.kotlin.gradle.GradleVersionRequired import org.jetbrains.kotlin.gradle.util.AGPVersion -import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil import org.junit.Test import kotlin.test.assertEquals import kotlin.test.assertFalse @@ -19,7 +18,7 @@ class KotlinAndroidExtensionIT : BaseGradleIT() { override fun defaultBuildOptions(): BuildOptions { return super.defaultBuildOptions().copy( androidGradlePluginVersion = AGPVersion.v3_1_0, - androidHome = KotlinTestUtils.findAndroidSdk() + androidHome = KtTestUtil.findAndroidSdk() ) } @@ -52,4 +51,4 @@ class KotlinAndroidExtensionIT : BaseGradleIT() { assertNull(model) } -} \ No newline at end of file +} diff --git a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/model/KotlinProjectIT.kt b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/model/KotlinProjectIT.kt index 43b598f00b4..ccdca174a42 100644 --- a/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/model/KotlinProjectIT.kt +++ b/libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/model/KotlinProjectIT.kt @@ -6,9 +6,8 @@ package org.jetbrains.kotlin.gradle.model import org.jetbrains.kotlin.gradle.BaseGradleIT -import org.jetbrains.kotlin.gradle.GradleVersionRequired import org.jetbrains.kotlin.gradle.util.AGPVersion -import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil import org.junit.Test import kotlin.test.assertEquals import kotlin.test.assertFalse @@ -19,7 +18,7 @@ class KotlinProjectIT : BaseGradleIT() { override fun defaultBuildOptions(): BuildOptions { return super.defaultBuildOptions().copy( androidGradlePluginVersion = AGPVersion.v3_1_0, - androidHome = KotlinTestUtils.findAndroidSdk() + androidHome = KtTestUtil.findAndroidSdk() ) } @@ -294,4 +293,4 @@ class KotlinProjectIT : BaseGradleIT() { assertEquals(expectedFriendSourceSets.toList(), friendSourceSets.toList()) } } -} \ No newline at end of file +} diff --git a/libraries/tools/kotlin-gradle-plugin-test-utils-embeddable/build.gradle.kts b/libraries/tools/kotlin-gradle-plugin-test-utils-embeddable/build.gradle.kts index a9c098b3a0a..b5bed7e668b 100644 --- a/libraries/tools/kotlin-gradle-plugin-test-utils-embeddable/build.gradle.kts +++ b/libraries/tools/kotlin-gradle-plugin-test-utils-embeddable/build.gradle.kts @@ -13,9 +13,12 @@ plugins { `java` } val packedJars by configurations.creating -val projectsToInclude = listOf(":compiler:tests-common", - ":compiler:incremental-compilation-impl", - ":kotlin-build-common") +val projectsToInclude = listOf( + ":compiler:test-infrastructure-utils", + ":compiler:tests-common", + ":compiler:incremental-compilation-impl", + ":kotlin-build-common" +) dependencies { for (projectName in projectsToInclude) { diff --git a/libraries/tools/kotlinp/test/org/jetbrains/kotlin/kotlinp/test/KotlinpCompilerTestDataTest.kt b/libraries/tools/kotlinp/test/org/jetbrains/kotlin/kotlinp/test/KotlinpCompilerTestDataTest.kt index 48793cda63c..9e4e4b0f1ef 100644 --- a/libraries/tools/kotlinp/test/org/jetbrains/kotlin/kotlinp/test/KotlinpCompilerTestDataTest.kt +++ b/libraries/tools/kotlinp/test/org/jetbrains/kotlin/kotlinp/test/KotlinpCompilerTestDataTest.kt @@ -7,7 +7,7 @@ package org.jetbrains.kotlin.kotlinp.test import com.intellij.openapi.Disposable import com.intellij.openapi.util.Disposer -import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil import org.junit.Test import org.junit.runner.RunWith import org.junit.runners.Parameterized @@ -21,7 +21,7 @@ class KotlinpCompilerTestDataTest(private val file: File) { @Test fun doTest() { - val tmpdir = KotlinTestUtils.tmpDirForTest(this::class.java.simpleName, file.nameWithoutExtension) + val tmpdir = KtTestUtil.tmpDirForTest(this::class.java.simpleName, file.nameWithoutExtension) val disposable = TestDisposable() try { diff --git a/libraries/tools/kotlinp/test/org/jetbrains/kotlin/kotlinp/test/KotlinpTestUtils.kt b/libraries/tools/kotlinp/test/org/jetbrains/kotlin/kotlinp/test/KotlinpTestUtils.kt index 1ed8c5975af..1c78787b7a4 100644 --- a/libraries/tools/kotlinp/test/org/jetbrains/kotlin/kotlinp/test/KotlinpTestUtils.kt +++ b/libraries/tools/kotlinp/test/org/jetbrains/kotlin/kotlinp/test/KotlinpTestUtils.kt @@ -20,6 +20,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.util.KtTestUtil import java.io.File import kotlin.test.fail @@ -76,7 +77,7 @@ private fun compile(file: File, disposable: Disposable, tmpdir: File, forEachOut AbstractLoadJavaTest.updateConfigurationWithDirectives(content, configuration) val environment = KotlinCoreEnvironment.createForTests(disposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES) setupLanguageVersionSettingsForCompilerTests(content, environment) - val ktFile = KotlinTestUtils.createFile(file.name, content, environment.project) + val ktFile = KtTestUtil.createFile(file.name, content, environment.project) GenerationUtils.compileFileTo(ktFile, environment, tmpdir) for (outputFile in tmpdir.walkTopDown().sortedBy { it.nameWithoutExtension }) { diff --git a/native/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/AbstractCommonizationFromSourcesTest.kt b/native/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/AbstractCommonizationFromSourcesTest.kt index eff9561f99a..098f985a000 100644 --- a/native/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/AbstractCommonizationFromSourcesTest.kt +++ b/native/commonizer/tests/org/jetbrains/kotlin/descriptors/commonizer/AbstractCommonizationFromSourcesTest.kt @@ -17,14 +17,15 @@ import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment import org.jetbrains.kotlin.config.CommonConfigurationKeys import org.jetbrains.kotlin.config.CompilerConfiguration import org.jetbrains.kotlin.config.languageVersionSettings -import org.jetbrains.kotlin.descriptors.* +import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor +import org.jetbrains.kotlin.descriptors.ModuleDescriptor +import org.jetbrains.kotlin.descriptors.PackageFragmentProvider import org.jetbrains.kotlin.descriptors.commonizer.SourceModuleRoot.Companion.SHARED_TARGET_NAME import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.ClassCollector import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.FunctionCollector import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.collectMembers import org.jetbrains.kotlin.descriptors.commonizer.mergedtree.collectNonEmptyPackageMemberScopes import org.jetbrains.kotlin.descriptors.commonizer.utils.* -import org.jetbrains.kotlin.descriptors.commonizer.utils.MockBuiltInsProvider import org.jetbrains.kotlin.descriptors.impl.DeclarationDescriptorVisitorEmptyBodies import org.jetbrains.kotlin.descriptors.impl.FunctionDescriptorImpl import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl @@ -34,8 +35,9 @@ import org.jetbrains.kotlin.platform.CommonPlatforms import org.jetbrains.kotlin.psi.KtFile import org.jetbrains.kotlin.psi.KtPsiFactory import org.jetbrains.kotlin.resolve.scopes.MemberScope -import org.jetbrains.kotlin.test.KotlinTestUtils.* +import org.jetbrains.kotlin.test.KotlinTestUtils.newConfiguration import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase +import org.jetbrains.kotlin.test.util.KtTestUtil import java.io.File import kotlin.contracts.ExperimentalContracts import kotlin.test.fail @@ -55,7 +57,7 @@ abstract class AbstractCommonizationFromSourcesTest : KtUsefulTestCase() { ) val testDir = testDirectoryName - return File(getHomeDirectory()) + return File(KtTestUtil.getHomeDirectory()) .resolve("native/commonizer/testData") .resolve(testCaseDir) .resolve(testDir) @@ -312,7 +314,7 @@ private class AnalyzedModules( val psiFiles: List = moduleRoot.location.walkTopDown() .filter { it.isFile } - .map { psiFactory.createFile(it.name, doLoadFile(it)) } + .map { psiFactory.createFile(it.name, KtTestUtil.doLoadFile(it)) } .toList() val module = CommonResolverForModuleFactory.analyzeFiles( diff --git a/nj2k/tests/org/jetbrains/kotlin/nj2k/AbstractNewJavaToKotlinCopyPasteConversionTest.kt b/nj2k/tests/org/jetbrains/kotlin/nj2k/AbstractNewJavaToKotlinCopyPasteConversionTest.kt index bce74a76ab9..be4efb47d82 100644 --- a/nj2k/tests/org/jetbrains/kotlin/nj2k/AbstractNewJavaToKotlinCopyPasteConversionTest.kt +++ b/nj2k/tests/org/jetbrains/kotlin/nj2k/AbstractNewJavaToKotlinCopyPasteConversionTest.kt @@ -6,10 +6,10 @@ package org.jetbrains.kotlin.nj2k import org.jetbrains.kotlin.idea.conversion.copy.AbstractJavaToKotlinCopyPasteConversionTest -import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil abstract class AbstractNewJavaToKotlinCopyPasteConversionTest : AbstractJavaToKotlinCopyPasteConversionTest() { - override val BASE_PATH = KotlinTestUtils.getHomeDirectory() + "/nj2k/testData/copyPaste" + override val BASE_PATH = KtTestUtil.getHomeDirectory() + "/nj2k/testData/copyPaste" override fun isNewJ2K(): Boolean = true -} \ No newline at end of file +} diff --git a/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/synthetic/test/AbstractAndroidBoxTest.kt b/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/synthetic/test/AbstractAndroidBoxTest.kt index 27abd0ae3de..05dda7c0ddc 100755 --- a/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/synthetic/test/AbstractAndroidBoxTest.kt +++ b/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/synthetic/test/AbstractAndroidBoxTest.kt @@ -15,6 +15,7 @@ import org.jetbrains.kotlin.config.JVMConfigurationKeys import org.jetbrains.kotlin.test.ConfigurationKind import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.TestJdkKind +import org.jetbrains.kotlin.test.util.KtTestUtil import java.io.File import java.net.URL import java.util.regex.Pattern @@ -94,7 +95,7 @@ abstract class AbstractAndroidBoxTest : AbstractBlackBoxCodegenTest() { myFiles = CodegenTestFiles.create( myEnvironment!!.project, ArrayUtil.toStringArray(files), - KotlinTestUtils.getHomeDirectory() + "/plugins/android-extensions/android-extensions-compiler/testData" + KtTestUtil.getHomeDirectory() + "/plugins/android-extensions/android-extensions-compiler/testData" ) blackBox(true) } diff --git a/plugins/kapt3/kapt3-compiler/test/org/jetbrains/kotlin/kapt3/test/AbstractKotlinKapt3Test.kt b/plugins/kapt3/kapt3-compiler/test/org/jetbrains/kotlin/kapt3/test/AbstractKotlinKapt3Test.kt index 908d63451b5..ee2a0d826bf 100644 --- a/plugins/kapt3/kapt3-compiler/test/org/jetbrains/kotlin/kapt3/test/AbstractKotlinKapt3Test.kt +++ b/plugins/kapt3/kapt3-compiler/test/org/jetbrains/kotlin/kapt3/test/AbstractKotlinKapt3Test.kt @@ -33,7 +33,10 @@ import org.jetbrains.kotlin.cli.common.messages.MessageRenderer import org.jetbrains.kotlin.cli.common.messages.PrintingMessageCollector import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment import org.jetbrains.kotlin.cli.jvm.config.JvmClasspathRoot -import org.jetbrains.kotlin.codegen.* +import org.jetbrains.kotlin.codegen.ClassBuilderMode +import org.jetbrains.kotlin.codegen.CodegenTestFiles +import org.jetbrains.kotlin.codegen.GenerationUtils +import org.jetbrains.kotlin.codegen.OriginCollectingClassBuilderFactory import org.jetbrains.kotlin.extensions.StorageComponentContainerContributor import org.jetbrains.kotlin.kapt.base.test.JavaKaptContextTest import org.jetbrains.kotlin.kapt3.Kapt3ComponentRegistrar.KaptComponentContributor @@ -52,6 +55,7 @@ import org.jetbrains.kotlin.resolve.jvm.extensions.PartialAnalysisHandlerExtensi import org.jetbrains.kotlin.test.ConfigurationKind import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.TestJdkKind +import org.jetbrains.kotlin.test.util.KtTestUtil import org.jetbrains.kotlin.test.util.trimTrailingWhitespacesAndAddNewlineAtEOF import org.jetbrains.kotlin.utils.PathUtil import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstance @@ -85,7 +89,7 @@ abstract class AbstractKotlinKapt3Test : KotlinKapt3TestBase() { val project = myEnvironment.project val psiManager = PsiManager.getInstance(project) - val tmpDir = KotlinTestUtils.tmpDir("kaptTest") + val tmpDir = KtTestUtil.tmpDir("kaptTest") val ktFiles = ArrayList(files.size) for (file in files.sorted()) { @@ -119,7 +123,7 @@ abstract class AbstractKotlinKapt3Test : KotlinKapt3TestBase() { projectBaseDir = project.basePath?.let { File(it) } compileClasspath.addAll(PathUtil.getJdkClassesRootsFromCurrentJre() + PathUtil.kotlinPathsForIdeaPlugin.stdlibPath) - sourcesOutputDir = KotlinTestUtils.tmpDir("kaptRunner") + sourcesOutputDir = KtTestUtil.tmpDir("kaptRunner") classesOutputDir = sourcesOutputDir stubsOutputDir = sourcesOutputDir incrementalDataOutputDir = sourcesOutputDir @@ -353,4 +357,4 @@ private fun addAnnotationProcessingRuntimeLibrary(environment: KotlinCoreEnviron val runtimeLibrary = File(PathUtil.kotlinPathsForCompiler.libPath, "kotlin-annotation-processing-runtime.jar") updateClasspath(listOf(JvmClasspathRoot(runtimeLibrary))) } -} \ No newline at end of file +} diff --git a/plugins/kapt3/kapt3-compiler/test/org/jetbrains/kotlin/kapt3/test/java9TestUtils.kt b/plugins/kapt3/kapt3-compiler/test/org/jetbrains/kotlin/kapt3/test/java9TestUtils.kt index 8f1e45e1913..32ea35b60e6 100644 --- a/plugins/kapt3/kapt3-compiler/test/org/jetbrains/kotlin/kapt3/test/java9TestUtils.kt +++ b/plugins/kapt3/kapt3-compiler/test/org/jetbrains/kotlin/kapt3/test/java9TestUtils.kt @@ -18,9 +18,8 @@ package org.jetbrains.kotlin.kapt3.test import com.intellij.openapi.application.PathManager import com.intellij.openapi.util.SystemInfoRt -import org.jetbrains.kotlin.kapt3.base.util.isJava11OrLater import org.jetbrains.kotlin.kapt3.base.util.isJava9OrLater -import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil import java.io.File import java.net.URL import java.net.URLClassLoader @@ -31,12 +30,12 @@ interface CustomJdkTestLauncher { // Already under Java 9 if (isJava9OrLater()) return - doTestCustomJdk(mainClass, arg, KotlinTestUtils.getJdk9Home()) + doTestCustomJdk(mainClass, arg, KtTestUtil.getJdk9Home()) } fun doTestWithJdk11(mainClass: Class<*>, arg: String) { if (isJava9OrLater()) return - KotlinTestUtils.getJdk11Home()?.let { doTestCustomJdk(mainClass, arg, it) } + KtTestUtil.getJdk11Home()?.let { doTestCustomJdk(mainClass, arg, it) } } private fun doTestCustomJdk(mainClass: Class<*>, arg: String, javaHome: File) { @@ -79,4 +78,4 @@ interface CustomJdkTestLauncher { else -> emptyList() } -} \ No newline at end of file +} diff --git a/plugins/parcelize/parcelize-compiler/tests/org/jetbrains/kotlin/parcelize/test/AbstractParcelizeBoxTest.kt b/plugins/parcelize/parcelize-compiler/tests/org/jetbrains/kotlin/parcelize/test/AbstractParcelizeBoxTest.kt index 7df13884b2b..e974386b3ea 100644 --- a/plugins/parcelize/parcelize-compiler/tests/org/jetbrains/kotlin/parcelize/test/AbstractParcelizeBoxTest.kt +++ b/plugins/parcelize/parcelize-compiler/tests/org/jetbrains/kotlin/parcelize/test/AbstractParcelizeBoxTest.kt @@ -10,8 +10,8 @@ import org.jetbrains.kotlin.cli.jvm.config.JvmClasspathRoot import org.jetbrains.kotlin.codegen.CodegenTestCase import org.jetbrains.kotlin.codegen.getClassFiles import org.jetbrains.kotlin.parcelize.ParcelizeComponentRegistrar -import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.TargetBackend +import org.jetbrains.kotlin.test.util.KtTestUtil import org.jetbrains.kotlin.utils.PathUtil import org.jetbrains.org.objectweb.asm.ClassWriter import org.jetbrains.org.objectweb.asm.ClassWriter.COMPUTE_FRAMES @@ -178,10 +178,10 @@ abstract class AbstractParcelizeBoxTest : CodegenTestCase() { override fun setupEnvironment(environment: KotlinCoreEnvironment) { ParcelizeComponentRegistrar.registerParcelizeComponents(environment.project) addParcelizeRuntimeLibrary(environment) - environment.updateClasspath(listOf(JvmClasspathRoot(KotlinTestUtils.findAndroidApiJar()))) + environment.updateClasspath(listOf(JvmClasspathRoot(KtTestUtil.findAndroidApiJar()))) } override fun updateJavaClasspath(javaClasspath: MutableList) { - javaClasspath += KotlinTestUtils.findAndroidApiJar().absolutePath + javaClasspath += KtTestUtil.findAndroidApiJar().absolutePath } } diff --git a/plugins/parcelize/parcelize-compiler/tests/org/jetbrains/kotlin/parcelize/test/testUtils.kt b/plugins/parcelize/parcelize-compiler/tests/org/jetbrains/kotlin/parcelize/test/testUtils.kt index 7ddf6213d8e..f1270eec9f0 100644 --- a/plugins/parcelize/parcelize-compiler/tests/org/jetbrains/kotlin/parcelize/test/testUtils.kt +++ b/plugins/parcelize/parcelize-compiler/tests/org/jetbrains/kotlin/parcelize/test/testUtils.kt @@ -7,7 +7,7 @@ package org.jetbrains.kotlin.parcelize.test import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment import org.jetbrains.kotlin.cli.jvm.config.JvmClasspathRoot -import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil import org.jetbrains.kotlin.utils.PathUtil import java.io.File @@ -18,5 +18,5 @@ fun addParcelizeRuntimeLibrary(environment: KotlinCoreEnvironment) { } fun addAndroidJarLibrary(environment: KotlinCoreEnvironment) { - environment.updateClasspath(listOf(JvmClasspathRoot(KotlinTestUtils.findAndroidApiJar()))) -} \ No newline at end of file + environment.updateClasspath(listOf(JvmClasspathRoot(KtTestUtil.findAndroidApiJar()))) +} diff --git a/plugins/parcelize/parcelize-ide/tests/org/jetbrains/kotlin/pacelize/ide/test/parcelizeTestUtil.kt b/plugins/parcelize/parcelize-ide/tests/org/jetbrains/kotlin/pacelize/ide/test/parcelizeTestUtil.kt index f42ed6a7f68..af3d4f183c9 100644 --- a/plugins/parcelize/parcelize-ide/tests/org/jetbrains/kotlin/pacelize/ide/test/parcelizeTestUtil.kt +++ b/plugins/parcelize/parcelize-ide/tests/org/jetbrains/kotlin/pacelize/ide/test/parcelizeTestUtil.kt @@ -7,10 +7,10 @@ package org.jetbrains.kotlin.pacelize.ide.test import com.intellij.openapi.module.Module import org.jetbrains.kotlin.idea.test.ConfigLibraryUtil -import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil fun addParcelizeLibraries(module: Module) { - val androidJar = KotlinTestUtils.findAndroidApiJar() + val androidJar = KtTestUtil.findAndroidApiJar() ConfigLibraryUtil.addLibrary(module, "androidJar", androidJar.parentFile.absolutePath, arrayOf(androidJar.name)) ConfigLibraryUtil.addLibrary(module, "parcelizeRuntime", "dist/kotlinc/lib", arrayOf("parcelize-runtime.jar")) ConfigLibraryUtil.addLibrary(module, "androidExtensionsRuntime", "dist/kotlinc/lib", arrayOf("android-extensions-runtime.jar")) @@ -20,4 +20,4 @@ fun removeParcelizeLibraries(module: Module) { ConfigLibraryUtil.removeLibrary(module, "androidJar") ConfigLibraryUtil.removeLibrary(module, "parcelizeRuntime") ConfigLibraryUtil.removeLibrary(module, "androidExtensionsRuntime") -} \ No newline at end of file +} diff --git a/settings.gradle b/settings.gradle index bc420b33a01..ba13c605ba9 100644 --- a/settings.gradle +++ b/settings.gradle @@ -326,6 +326,8 @@ include ":compiler:fir:cones", ":compiler:fir:entrypoint", ":compiler:fir:analysis-tests" +include ":compiler:test-infrastructure-utils" + include ":idea:idea-frontend-fir:idea-fir-low-level-api" include ":idea:idea-fir-performance-tests" From 35437e6da9a129460a6c780fb965bba19d199df4 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Wed, 2 Dec 2020 16:32:38 +0300 Subject: [PATCH 089/196] [FE] Allow explicitly specify dependent modules fin TopDownAnalyzerFacade --- .../compiler/TopDownAnalyzerFacadeForJVM.kt | 19 +++++++++++++++---- 1 file changed, 15 insertions(+), 4 deletions(-) diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/TopDownAnalyzerFacadeForJVM.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/TopDownAnalyzerFacadeForJVM.kt index 9c5eed0c1d6..6f9bd00fe8c 100644 --- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/TopDownAnalyzerFacadeForJVM.kt +++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/TopDownAnalyzerFacadeForJVM.kt @@ -90,11 +90,12 @@ object TopDownAnalyzerFacadeForJVM { packagePartProvider: (GlobalSearchScope) -> PackagePartProvider, declarationProviderFactory: (StorageManager, Collection) -> DeclarationProviderFactory = ::FileBasedDeclarationProviderFactory, sourceModuleSearchScope: GlobalSearchScope = newModuleSearchScope(project, files), - klibList: List = emptyList() + klibList: List = emptyList(), + explicitModuleDependencyList: List = emptyList() ): AnalysisResult { val container = createContainer( project, files, trace, configuration, packagePartProvider, declarationProviderFactory, CompilerEnvironment, - sourceModuleSearchScope, klibList + sourceModuleSearchScope, klibList, explicitModuleDependencyList = explicitModuleDependencyList ) val module = container.get() @@ -127,6 +128,7 @@ object TopDownAnalyzerFacadeForJVM { return AnalysisResult.success(trace.bindingContext, module) } + @OptIn(ExperimentalStdlibApi::class) fun createContainer( project: Project, files: Collection, @@ -137,7 +139,8 @@ object TopDownAnalyzerFacadeForJVM { targetEnvironment: TargetEnvironment = CompilerEnvironment, sourceModuleSearchScope: GlobalSearchScope = newModuleSearchScope(project, files), klibList: List = emptyList(), - implicitsResolutionFilter: ImplicitsExtensionsResolutionFilter? = null + implicitsResolutionFilter: ImplicitsExtensionsResolutionFilter? = null, + explicitModuleDependencyList: List = emptyList() ): ComponentProvider { val jvmTarget = configuration.get(JVMConfigurationKeys.JVM_TARGET, JvmTarget.DEFAULT) val languageVersionSettings = configuration.languageVersionSettings @@ -252,8 +255,16 @@ object TopDownAnalyzerFacadeForJVM { val klibModules = getKlibModules(klibList, dependencyModule) // TODO: remove dependencyModule from friends + val dependencies = buildList { + add(module) + dependencyModule?.let { add(it) } + add(fallbackBuiltIns) + addAll(klibModules) + @Suppress("UNCHECKED_CAST") + addAll(explicitModuleDependencyList) + } module.setDependencies( - listOfNotNull(module, dependencyModule, fallbackBuiltIns) + klibModules, + dependencies, if (dependencyModule != null) setOf(dependencyModule) else emptySet() ) module.initialize( From dd402b16d9205e65066c504d5bdb362b04263bf6 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Wed, 2 Dec 2020 16:30:53 +0300 Subject: [PATCH 090/196] [TEST] Add core of new tests infrastructure It contains different abstractions which represents parts of compiler pipeline and artifacts produced by them, service structure, handlers for analysis of artifacts --- .../jetbrains/kotlin/test/util/StringUtils.kt | 9 + compiler/test-infrastructure/build.gradle.kts | 27 +++ .../kotlin/test/ExceptionFromTestError.kt | 11 ++ .../kotlin/test/TestConfiguration.kt | 47 +++++ .../org/jetbrains/kotlin/test/TestRunner.kt | 171 ++++++++++++++++++ .../LanguageVersionSettingsBuilder.kt | 112 ++++++++++++ .../directives/ConfigurationDirectives.kt | 14 ++ .../directives/LanguageSettingsDirectives.kt | 70 +++++++ .../directives/ModuleStructureDirectives.kt | 54 ++++++ .../kotlin/test/directives/model/Directive.kt | 140 ++++++++++++++ .../directives/model/DirectivesContainer.kt | 89 +++++++++ .../kotlin/test/model/AfterAnalysisChecker.kt | 18 ++ .../kotlin/test/model/AnalysisHandler.kt | 44 +++++ .../jetbrains/kotlin/test/model/Facades.kt | 46 +++++ .../jetbrains/kotlin/test/model/Modules.kt | 64 +++++++ .../kotlin/test/model/ResultingArtifact.kt | 42 +++++ .../kotlin/test/model/TestArtifactKind.kt | 38 ++++ .../test/services/AdditionalSourceProvider.kt | 32 ++++ .../kotlin/test/services/Assertions.kt | 31 ++++ .../DefaultRegisteredDirectivesProvider.kt | 19 ++ .../kotlin/test/services/DefaultsProvider.kt | 36 ++++ .../test/services/DependencyProvider.kt | 49 +++++ .../test/services/EnvironmentConfigurator.kt | 29 +++ .../services/GlobalMetadataInfoHandler.kt | 82 +++++++++ .../test/services/MetaTestConfigurator.kt | 17 ++ .../test/services/ModuleStructureExtractor.kt | 18 ++ .../test/services/SourceFileProvider.kt | 86 +++++++++ .../test/services/TestModuleStructure.kt | 21 +++ .../kotlin/test/services/TestServices.kt | 51 ++++++ .../impl/RegisteredDirectivesParser.kt | 97 ++++++++++ .../services/impl/TargetPlatformParser.kt | 51 ++++++ settings.gradle | 3 +- 32 files changed, 1617 insertions(+), 1 deletion(-) create mode 100644 compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/util/StringUtils.kt create mode 100644 compiler/test-infrastructure/build.gradle.kts create mode 100644 compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/ExceptionFromTestError.kt create mode 100644 compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/TestConfiguration.kt create mode 100644 compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/TestRunner.kt create mode 100644 compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/builders/LanguageVersionSettingsBuilder.kt create mode 100644 compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/directives/ConfigurationDirectives.kt create mode 100644 compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/directives/LanguageSettingsDirectives.kt create mode 100644 compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/directives/ModuleStructureDirectives.kt create mode 100644 compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/directives/model/Directive.kt create mode 100644 compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/directives/model/DirectivesContainer.kt create mode 100644 compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/model/AfterAnalysisChecker.kt create mode 100644 compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/model/AnalysisHandler.kt create mode 100644 compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/model/Facades.kt create mode 100644 compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/model/Modules.kt create mode 100644 compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/model/ResultingArtifact.kt create mode 100644 compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/model/TestArtifactKind.kt create mode 100644 compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/AdditionalSourceProvider.kt create mode 100644 compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/Assertions.kt create mode 100644 compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/DefaultRegisteredDirectivesProvider.kt create mode 100644 compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/DefaultsProvider.kt create mode 100644 compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/DependencyProvider.kt create mode 100644 compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/EnvironmentConfigurator.kt create mode 100644 compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/GlobalMetadataInfoHandler.kt create mode 100644 compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/MetaTestConfigurator.kt create mode 100644 compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/ModuleStructureExtractor.kt create mode 100644 compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/SourceFileProvider.kt create mode 100644 compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/TestModuleStructure.kt create mode 100644 compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/TestServices.kt create mode 100644 compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/impl/RegisteredDirectivesParser.kt create mode 100644 compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/impl/TargetPlatformParser.kt diff --git a/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/util/StringUtils.kt b/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/util/StringUtils.kt new file mode 100644 index 00000000000..db23ad397ab --- /dev/null +++ b/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/util/StringUtils.kt @@ -0,0 +1,9 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.util + +fun Iterable<*>.joinToArrayString(): String = joinToString(separator = ", ", prefix = "[", postfix = "]") +fun Array<*>.joinToArrayString(): String = joinToString(separator = ", ", prefix = "[", postfix = "]") diff --git a/compiler/test-infrastructure/build.gradle.kts b/compiler/test-infrastructure/build.gradle.kts new file mode 100644 index 00000000000..1c4450700da --- /dev/null +++ b/compiler/test-infrastructure/build.gradle.kts @@ -0,0 +1,27 @@ +plugins { + kotlin("jvm") + id("jps-compatible") +} + +dependencies { + testApi(project(":compiler:fir:entrypoint")) + testApi(project(":compiler:cli")) + testApi(intellijCoreDep()) { includeJars("intellij-core") } + + testCompileOnly(project(":kotlin-reflect-api")) + testRuntimeOnly(project(":kotlin-reflect")) + testRuntimeOnly(project(":core:descriptors.runtime")) + + testImplementation(projectTests(":compiler:test-infrastructure-utils")) + + testRuntimeOnly(intellijDep()) { + includeJars("jna", rootProject = rootProject) + } +} + +sourceSets { + "main" { none() } + "test" { projectDefault() } +} + +testsJar() diff --git a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/ExceptionFromTestError.kt b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/ExceptionFromTestError.kt new file mode 100644 index 00000000000..91b2f7330b5 --- /dev/null +++ b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/ExceptionFromTestError.kt @@ -0,0 +1,11 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test + +class ExceptionFromTestError(cause: Throwable) : AssertionError(cause) { + override val message: String + get() = "Exception was thrown" +} diff --git a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/TestConfiguration.kt b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/TestConfiguration.kt new file mode 100644 index 00000000000..39c7578e2ad --- /dev/null +++ b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/TestConfiguration.kt @@ -0,0 +1,47 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test + +import com.intellij.openapi.Disposable +import org.jetbrains.kotlin.test.directives.ConfigurationDirectives +import org.jetbrains.kotlin.test.directives.LanguageSettingsDirectives +import org.jetbrains.kotlin.test.directives.model.DirectivesContainer +import org.jetbrains.kotlin.test.directives.model.RegisteredDirectives +import org.jetbrains.kotlin.test.model.* +import org.jetbrains.kotlin.test.services.MetaTestConfigurator +import org.jetbrains.kotlin.test.services.ModuleStructureExtractor +import org.jetbrains.kotlin.test.services.SourceFilePreprocessor +import org.jetbrains.kotlin.test.services.TestServices + +typealias Constructor = (TestServices) -> T + +abstract class TestConfiguration { + abstract val rootDisposable: Disposable + + abstract val testServices: TestServices + + abstract val directives: DirectivesContainer + + abstract val defaultRegisteredDirectives: RegisteredDirectives + + abstract val moduleStructureExtractor: ModuleStructureExtractor + + abstract val metaTestConfigurators: List + + abstract val afterAnalysisCheckers: List + + abstract val metaInfoHandlerEnabled: Boolean + + abstract fun , O : ResultingArtifact> getFacade( + inputKind: TestArtifactKind, + outputKind: TestArtifactKind + ): AbstractTestFacade + + abstract fun > getHandlers(artifactKind: TestArtifactKind): List> + + abstract fun getAllHandlers(): List> +} + diff --git a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/TestRunner.kt b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/TestRunner.kt new file mode 100644 index 00000000000..fe9b7ccb97f --- /dev/null +++ b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/TestRunner.kt @@ -0,0 +1,171 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test + +import com.intellij.openapi.util.Disposer +import com.intellij.testFramework.TestDataFile +import org.jetbrains.kotlin.test.model.* +import org.jetbrains.kotlin.test.services.* + +class TestRunner(private val testConfiguration: TestConfiguration) { + private val failedAssertions = mutableListOf() + + fun runTest(@TestDataFile testDataFileName: String) { + try { + runTestImpl(testDataFileName) + } finally { + Disposer.dispose(testConfiguration.rootDisposable) + } + } + + private fun runTestImpl(@TestDataFile testDataFileName: String) { + val services = testConfiguration.testServices + + @Suppress("NAME_SHADOWING") + val testDataFileName = testConfiguration.metaTestConfigurators.fold(testDataFileName) { fileName, configurator -> + configurator.transformTestDataPath(fileName) + } + + val moduleStructure = testConfiguration.moduleStructureExtractor.splitTestDataByModules( + testDataFileName, + testConfiguration.directives, + ).also { + services.register(TestModuleStructure::class, it) + } + + testConfiguration.metaTestConfigurators.forEach { + if (it.shouldSkipTest()) return + } + + val globalMetadataInfoHandler = testConfiguration.testServices.globalMetadataInfoHandler + globalMetadataInfoHandler.parseExistingMetadataInfosFromAllSources() + + val modules = moduleStructure.modules + val dependencyProvider = DependencyProviderImpl(services, modules) + services.registerDependencyProvider(dependencyProvider) + var failedException: Throwable? = null + try { + for (module in modules) { + processModule(module, dependencyProvider, moduleStructure) + } + } catch (e: Throwable) { + failedException = e + } + for (handler in testConfiguration.getAllHandlers()) { + withAssertionCatching { handler.processAfterAllModules(failedAssertions.isNotEmpty()) } + } + if (testConfiguration.metaInfoHandlerEnabled) { + withAssertionCatching { + globalMetadataInfoHandler.compareAllMetaDataInfos() + } + } + if (failedException != null) { + failedAssertions.add(0, ExceptionFromTestError(failedException)) + } + + testConfiguration.afterAnalysisCheckers.forEach { + withAssertionCatching { + it.check(failedAssertions) + } + } + + val filteredFailedAssertions = testConfiguration.afterAnalysisCheckers + .fold>(failedAssertions) { assertions, checker -> + checker.suppressIfNeeded(assertions) + } + + services.assertions.assertAll(filteredFailedAssertions) + } + + private fun processModule( + module: TestModule, + dependencyProvider: DependencyProviderImpl, + moduleStructure: TestModuleStructure + ) { + val sourcesArtifact = ResultingArtifact.Source() + + val frontendKind = module.frontendKind + if (!frontendKind.shouldRunAnalysis) return + + val frontendArtifacts: ResultingArtifact.FrontendOutput<*> = testConfiguration.getFacade(SourcesKind, frontendKind) + .transform(module, sourcesArtifact).also { dependencyProvider.registerArtifact(module, it) } + val frontendHandlers: List> = testConfiguration.getHandlers(frontendKind) + for (frontendHandler in frontendHandlers) { + withAssertionCatching { + frontendHandler.hackyProcess(module, frontendArtifacts) + } + } + + val backendKind = module.backendKind + if (!backendKind.shouldRunAnalysis) return + + val backendInputInfo = testConfiguration.getFacade(frontendKind, backendKind) + .hackyTransform(module, frontendArtifacts).also { dependencyProvider.registerArtifact(module, it) } + + val backendHandlers: List> = testConfiguration.getHandlers(backendKind) + for (backendHandler in backendHandlers) { + withAssertionCatching { backendHandler.hackyProcess(module, backendInputInfo) } + } + + for (artifactKind in moduleStructure.getTargetArtifactKinds(module)) { + if (!artifactKind.shouldRunAnalysis) continue + val binaryArtifact = testConfiguration.getFacade(backendKind, artifactKind) + .hackyTransform(module, backendInputInfo).also { + dependencyProvider.registerArtifact(module, it) + } + + val binaryHandlers: List> = testConfiguration.getHandlers(artifactKind) + for (binaryHandler in binaryHandlers) { + withAssertionCatching { binaryHandler.hackyProcess(module, binaryArtifact) } + } + } + } + + private inline fun withAssertionCatching(block: () -> Unit) { + try { + block() + } catch (e: AssertionError) { + failedAssertions += e + } + } +} + +// ---------------------------------------------------------------------------------------------------------------- +/* + * Those `hackyProcess` methods are needed to hack kotlin type system. In common test case + * we have artifact of type ResultingArtifact<*> and handler of type AnalysisHandler<*> and actually + * at runtime types under `*` are same (that achieved by grouping handlers and facades by + * frontend/backend/artifact kind). But there is no way to tell that to compiler, so I unsafely cast types with `*` + * to types with Empty artifacts to make it compile. Since unsafe cast has no effort at runtime, it's safe to use it + */ + +private fun AnalysisHandler<*>.hackyProcess(module: TestModule, artifact: ResultingArtifact<*>) { + @Suppress("UNCHECKED_CAST") + (this as AnalysisHandler) + .processModule(module, artifact as ResultingArtifact) +} + +private fun > AnalysisHandler.processModule(module: TestModule, artifact: ResultingArtifact) { + @Suppress("UNCHECKED_CAST") + processModule(module, artifact as A) +} + +private fun AbstractTestFacade<*, *>.hackyTransform( + module: TestModule, + artifact: ResultingArtifact<*> +): ResultingArtifact<*> { + @Suppress("UNCHECKED_CAST") + return (this as AbstractTestFacade) + .transform(module, artifact as ResultingArtifact) +} + +private fun , O : ResultingArtifact> AbstractTestFacade.transform( + module: TestModule, + inputArtifact: ResultingArtifact +): O { + @Suppress("UNCHECKED_CAST") + return transform(module, inputArtifact as I) +} diff --git a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/builders/LanguageVersionSettingsBuilder.kt b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/builders/LanguageVersionSettingsBuilder.kt new file mode 100644 index 00000000000..de1f6bda417 --- /dev/null +++ b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/builders/LanguageVersionSettingsBuilder.kt @@ -0,0 +1,112 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.builders + +import org.jetbrains.kotlin.config.* +import org.jetbrains.kotlin.test.directives.LanguageSettingsDirectives +import org.jetbrains.kotlin.test.directives.model.RegisteredDirectives +import org.jetbrains.kotlin.test.directives.model.singleOrZeroValue +import org.jetbrains.kotlin.test.services.DefaultsDsl +import org.jetbrains.kotlin.utils.addToStdlib.runIf +import java.util.regex.Pattern + +@DefaultsDsl +class LanguageVersionSettingsBuilder { + companion object { + private val languageFeaturePattern = Pattern.compile("""(\+|-|warn:)(\w+)\s*""") + + fun fromExistingSettings(builder: LanguageVersionSettingsBuilder): LanguageVersionSettingsBuilder { + return LanguageVersionSettingsBuilder().apply { + languageVersion = builder.languageVersion + apiVersion = builder.apiVersion + specificFeatures += builder.specificFeatures + analysisFlags += builder.analysisFlags + } + } + } + + var languageVersion: LanguageVersion = LanguageVersion.LATEST_STABLE + var apiVersion: ApiVersion = ApiVersion.LATEST_STABLE + + private val specificFeatures: MutableMap = mutableMapOf() + private val analysisFlags: MutableMap, Any?> = mutableMapOf() + + fun enable(feature: LanguageFeature) { + specificFeatures[feature] = LanguageFeature.State.ENABLED + } + + fun enableWithWarning(feature: LanguageFeature) { + specificFeatures[feature] = LanguageFeature.State.ENABLED_WITH_WARNING + } + + fun disable(feature: LanguageFeature) { + specificFeatures[feature] = LanguageFeature.State.DISABLED + } + + fun withFlag(flag: AnalysisFlag, value: T) { + analysisFlags[flag] = value + } + + fun configureUsingDirectives(directives: RegisteredDirectives) { + val apiVersion = directives.singleOrZeroValue(LanguageSettingsDirectives.API_VERSION) + if (apiVersion != null) { + this.apiVersion = apiVersion + val languageVersion = maxOf(LanguageVersion.LATEST_STABLE, LanguageVersion.fromVersionString(apiVersion.versionString)!!) + this.languageVersion = languageVersion + } + + val analysisFlags = listOfNotNull( + analysisFlag(AnalysisFlags.experimental, directives[LanguageSettingsDirectives.EXPERIMENTAL].takeIf { it.isNotEmpty() }), + analysisFlag(AnalysisFlags.useExperimental, directives[LanguageSettingsDirectives.USE_EXPERIMENTAL].takeIf { it.isNotEmpty() }), + analysisFlag(AnalysisFlags.ignoreDataFlowInAssert, trueOrNull(LanguageSettingsDirectives.IGNORE_DATA_FLOW_IN_ASSERT in directives)), + analysisFlag(AnalysisFlags.constraintSystemForOverloadResolution, directives.singleOrZeroValue(LanguageSettingsDirectives.CONSTRAINT_SYSTEM_FOR_OVERLOAD_RESOLUTION)), + analysisFlag(AnalysisFlags.allowResultReturnType, trueOrNull(LanguageSettingsDirectives.ALLOW_RESULT_RETURN_TYPE in directives)), + + analysisFlag(JvmAnalysisFlags.jvmDefaultMode, directives.singleOrZeroValue(LanguageSettingsDirectives.JVM_DEFAULT_MODE)), + analysisFlag(JvmAnalysisFlags.inheritMultifileParts, trueOrNull(LanguageSettingsDirectives.INHERIT_MULTIFILE_PARTS in directives)), + analysisFlag(JvmAnalysisFlags.sanitizeParentheses, trueOrNull(LanguageSettingsDirectives.SANITIZE_PARENTHESES in directives)), + + analysisFlag(AnalysisFlags.explicitApiVersion, trueOrNull(apiVersion != null)), + ) + + analysisFlags.forEach { withFlag(it.first, it.second) } + + directives[LanguageSettingsDirectives.LANGUAGE].forEach { parseLanguageFeature(it) } + } + + private fun parseLanguageFeature(featureString: String) { + val matcher = languageFeaturePattern.matcher(featureString) + if (!matcher.find()) { + error( + """Wrong syntax in the '// !${LanguageSettingsDirectives.LANGUAGE.name}: ...' directive: + found: '$featureString' + Must be '((+|-|warn:)LanguageFeatureName)+' + where '+' means 'enable', '-' means 'disable', 'warn:' means 'enable with warning' + and language feature names are names of enum entries in LanguageFeature enum class""" + ) + } + val mode = when (val mode = matcher.group(1)) { + "+" -> LanguageFeature.State.ENABLED + "-" -> LanguageFeature.State.DISABLED + "warn:" -> LanguageFeature.State.ENABLED_WITH_WARNING + else -> error("Unknown mode for language feature: $mode") + } + val name = matcher.group(2) + val feature = LanguageFeature.fromString(name) ?: error("Language feature with name \"$name\" not found") + specificFeatures[feature] = mode + } + + @Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE") + private fun analysisFlag(flag: AnalysisFlag, value: @kotlin.internal.NoInfer T?): Pair, T>? = + value?.let(flag::to) + + private fun trueOrNull(condition: Boolean): Boolean? = runIf(condition) { true } + + fun build(): LanguageVersionSettings { + return LanguageVersionSettingsImpl(languageVersion, apiVersion, analysisFlags, specificFeatures) + } +} + diff --git a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/directives/ConfigurationDirectives.kt b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/directives/ConfigurationDirectives.kt new file mode 100644 index 00000000000..376376a3446 --- /dev/null +++ b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/directives/ConfigurationDirectives.kt @@ -0,0 +1,14 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.directives + +import org.jetbrains.kotlin.test.directives.model.SimpleDirectivesContainer + +object ConfigurationDirectives : SimpleDirectivesContainer() { + val KOTLIN_CONFIGURATION_FLAGS by stringDirective( + "List of kotlin configuration flags" + ) +} diff --git a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/directives/LanguageSettingsDirectives.kt b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/directives/LanguageSettingsDirectives.kt new file mode 100644 index 00000000000..a0977487e29 --- /dev/null +++ b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/directives/LanguageSettingsDirectives.kt @@ -0,0 +1,70 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.directives + +import org.jetbrains.kotlin.config.ApiVersion +import org.jetbrains.kotlin.config.ConstraintSystemForOverloadResolutionMode +import org.jetbrains.kotlin.config.JvmDefaultMode +import org.jetbrains.kotlin.test.directives.model.SimpleDirectivesContainer + +object LanguageSettingsDirectives : SimpleDirectivesContainer() { + val LANGUAGE by stringDirective( + description = """ + List of enabled and disabled language features. + Usage: // !LANGUAGE: +SomeFeature -OtherFeature warn:FeatureWithEarning + """.trimIndent() + ) + + @Suppress("RemoveExplicitTypeArguments") + val API_VERSION by valueDirective( + description = "Version of Kotlin API", + parser = this::parseApiVersion + ) + // --------------------- Analysis Flags --------------------- + + val USE_EXPERIMENTAL by stringDirective( + description = "List of opted in annotations (AnalysisFlags.useExperimental)" + ) + + val EXPERIMENTAL by stringDirective( + description = "Require opt in for specified annotations (AnalysisFlags.experimental)" + ) + + val IGNORE_DATA_FLOW_IN_ASSERT by directive( + description = "Enables corresponding analysis flag (AnalysisFlags.ignoreDataFlowInAssert)" + ) + + val CONSTRAINT_SYSTEM_FOR_OVERLOAD_RESOLUTION by enumDirective( + description = "Configures corresponding analysis flag (AnalysisFlags.constraintSystemForOverloadResolution)", + ) + + val ALLOW_RESULT_RETURN_TYPE by directive( + description = "Allow using Result in return type position" + ) + + // --------------------- Jvm Analysis Flags --------------------- + + @Suppress("RemoveExplicitTypeArguments") + val JVM_DEFAULT_MODE by enumDirective( + description = "Configures corresponding analysis flag (JvmAnalysisFlags.jvmDefaultMode)", + additionalParser = JvmDefaultMode.Companion::fromStringOrNull + ) + + val INHERIT_MULTIFILE_PARTS by directive( + description = "Enables corresponding analysis flag (JvmAnalysisFlags.inheritMultifileParts)" + ) + + val SANITIZE_PARENTHESES by directive( + description = "Enables corresponding analysis flag (JvmAnalysisFlags.sanitizeParentheses)" + ) + + // --------------------- Utils --------------------- + + fun parseApiVersion(versionString: String): ApiVersion = when (versionString) { + "LATEST" -> ApiVersion.LATEST + else -> ApiVersion.parse(versionString) ?: error("Unknown API version: $versionString") + } +} diff --git a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/directives/ModuleStructureDirectives.kt b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/directives/ModuleStructureDirectives.kt new file mode 100644 index 00000000000..db1c132c7dd --- /dev/null +++ b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/directives/ModuleStructureDirectives.kt @@ -0,0 +1,54 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.directives + +import org.jetbrains.kotlin.test.directives.model.SimpleDirectivesContainer + +object ModuleStructureDirectives : SimpleDirectivesContainer() { + val MODULE by stringDirective( + """ + Usage: // MODULE: {name}[(dependencies)] + Describes one module. If no targets are specified then + """.trimIndent() + ) + + val DEPENDENCY by stringDirective( + """ + Usage: // DEPENDENCY: {name} [SOURCE|KLIB|BINARY] + Declares simple dependency on other module + """.trimIndent() + ) + + val DEPENDS_ON by stringDirective( + """ + Usage: // DEPENDS_ON: {name} [SOURCE|KLIB|BINARY] + Declares dependency on other module witch may contains `expect` + declarations which has corresponding `expect` declarations + in current module + """.trimIndent() + ) + + val FILE by stringDirective( + """ + Usage: // FILE: name.{kt|java} + Declares file with specified name in current module + """.trimIndent() + ) + + val TARGET_FRONTEND by stringDirective( + """ + Usage: // TARGET_FRONTEND: {Frontend} + Declares frontend for analyzing current module + """.trimIndent() + ) + + val TARGET_BACKEND_KIND by stringDirective( + """ + Usage: // TARGET_BACKEND: {Backend} + Declares backend for analyzing current module + """.trimIndent() + ) +} diff --git a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/directives/model/Directive.kt b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/directives/model/Directive.kt new file mode 100644 index 00000000000..024bcd7bb0a --- /dev/null +++ b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/directives/model/Directive.kt @@ -0,0 +1,140 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.directives.model + +import org.jetbrains.kotlin.test.util.joinToArrayString + +// --------------------------- Directive declaration --------------------------- + +sealed class Directive(val name: String, val description: String) { + override fun toString(): String { + return name + } +} + +class SimpleDirective( + name: String, + description: String +) : Directive(name, description) + +class StringDirective( + name: String, + description: String +) : Directive(name, description) + +class ValueDirective( + name: String, + description: String, + val parser: (String) -> T? +) : Directive(name, description) + +// --------------------------- Registered directive --------------------------- + +abstract class RegisteredDirectives { + companion object { + val Empty = RegisteredDirectivesImpl(emptyList(), emptyMap(), emptyMap()) + } + + abstract operator fun contains(directive: Directive): Boolean + abstract operator fun get(directive: StringDirective): List + abstract operator fun get(directive: ValueDirective): List + + abstract fun isEmpty(): Boolean +} + +class RegisteredDirectivesImpl( + private val simpleDirectives: List, + private val stringDirectives: Map>, + private val valueDirectives: Map, List> +) : RegisteredDirectives() { + override operator fun contains(directive: Directive): Boolean { + return when (directive) { + is SimpleDirective -> directive in simpleDirectives + is StringDirective -> directive in stringDirectives + is ValueDirective<*> -> directive in valueDirectives + } + } + + override operator fun get(directive: StringDirective): List { + return stringDirectives[directive] ?: emptyList() + } + + override fun get(directive: ValueDirective): List { + @Suppress("UNCHECKED_CAST") + return valueDirectives[directive] as List? ?: emptyList() + } + + override fun isEmpty(): Boolean { + return simpleDirectives.isEmpty() && stringDirectives.isEmpty() && valueDirectives.isEmpty() + } + + override fun toString(): String { + return buildString { + simpleDirectives.forEach { appendLine(" $it") } + stringDirectives.forEach { (d, v) -> appendLine(" $d: ${v.joinToArrayString()}") } + valueDirectives.forEach { (d, v) -> appendLine(" $d: ${v.joinToArrayString()}")} + } + } +} + +class ComposedRegisteredDirectives( + private val containers: List +) : RegisteredDirectives() { + companion object { + operator fun invoke(vararg containers: RegisteredDirectives): RegisteredDirectives { + val notEmptyContainers = containers.filterNot { it.isEmpty() } + return when (notEmptyContainers.size) { + 0 -> Empty + 1 -> notEmptyContainers.single() + else -> ComposedRegisteredDirectives(notEmptyContainers) + } + } + } + + override fun contains(directive: Directive): Boolean { + return containers.any { directive in it } + } + + override fun get(directive: StringDirective): List { + return containers.flatMap { it[directive] } + } + + override fun get(directive: ValueDirective): List { + return containers.flatMap { it[directive] } + } + + override fun isEmpty(): Boolean { + return containers.all { it.isEmpty() } + } +} + +// --------------------------- Utils --------------------------- + +fun RegisteredDirectives.singleValue(directive: StringDirective): String { + return singleOrZeroValue(directive) ?: error("No values passed to $directive") +} + +fun RegisteredDirectives.singleOrZeroValue(directive: StringDirective): String? { + val values = this[directive] + return when (values.size) { + 0 -> null + 1 -> values.single() + else -> error("Too many values passed to $directive") + } +} + +fun RegisteredDirectives.singleValue(directive: ValueDirective): T { + return singleOrZeroValue(directive) ?: error("No values passed to $directive") +} + +fun RegisteredDirectives.singleOrZeroValue(directive: ValueDirective): T? { + val values = this[directive] + return when (values.size) { + 0 -> null + 1 -> values.single() + else -> error("Too many values passed to $directive") + } +} diff --git a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/directives/model/DirectivesContainer.kt b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/directives/model/DirectivesContainer.kt new file mode 100644 index 00000000000..00d6288a5f8 --- /dev/null +++ b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/directives/model/DirectivesContainer.kt @@ -0,0 +1,89 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.directives.model + +import kotlin.properties.ReadOnlyProperty +import kotlin.reflect.KProperty + +sealed class DirectivesContainer { + object Empty : SimpleDirectivesContainer() + + abstract operator fun get(name: String): Directive? + abstract operator fun contains(directive: Directive): Boolean +} + +abstract class SimpleDirectivesContainer : DirectivesContainer() { + private val registeredDirectives: MutableMap = mutableMapOf() + + override operator fun get(name: String): Directive? = registeredDirectives[name] + + protected fun directive(description: String): DirectiveDelegateProvider { + return DirectiveDelegateProvider { SimpleDirective(it, description) } + } + + protected fun stringDirective(description: String): DirectiveDelegateProvider { + return DirectiveDelegateProvider { StringDirective(it, description) } + } + + protected inline fun > enumDirective( + description: String, + noinline additionalParser: ((String) -> T?)? = null + ): DirectiveDelegateProvider> { + val possibleValues = enumValues() + val parser: (String) -> T? = { value -> possibleValues.firstOrNull { it.name == value } ?: additionalParser?.invoke(value) } + return DirectiveDelegateProvider { ValueDirective(it, description, parser) } + } + + protected fun valueDirective( + description: String, + parser: (String) -> T? + ): DirectiveDelegateProvider> { + return DirectiveDelegateProvider { ValueDirective(it, description, parser) } + } + + protected fun registerDirective(directive: Directive) { + registeredDirectives[directive.name] = directive + } + + override fun contains(directive: Directive): Boolean { + return directive in registeredDirectives.values + } + + override fun toString(): String { + return buildString { + appendLine("Directive container:") + for (directive in registeredDirectives.values) { + append(" ") + appendLine(directive) + } + } + } + + protected inner class DirectiveDelegateProvider(val directiveConstructor: (String) -> T) { + operator fun provideDelegate( + thisRef: SimpleDirectivesContainer, + property: KProperty<*> + ): ReadOnlyProperty { + val directive = directiveConstructor(property.name).also { thisRef.registerDirective(it) } + return ReadOnlyProperty { _, _ -> directive } + } + } +} + +class ComposedDirectivesContainer(private val containers: Collection) : DirectivesContainer() { + constructor(vararg containers: DirectivesContainer) : this(containers.toList()) + + override fun get(name: String): Directive? { + for (container in containers) { + container[name]?.let { return it } + } + return null + } + + override fun contains(directive: Directive): Boolean { + return containers.any { directive in it } + } +} diff --git a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/model/AfterAnalysisChecker.kt b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/model/AfterAnalysisChecker.kt new file mode 100644 index 00000000000..52ec8c4e69d --- /dev/null +++ b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/model/AfterAnalysisChecker.kt @@ -0,0 +1,18 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.model + +import org.jetbrains.kotlin.test.directives.model.DirectivesContainer +import org.jetbrains.kotlin.test.services.TestServices + +abstract class AfterAnalysisChecker(protected val testServices: TestServices) { + open val directives: List + get() = emptyList() + + open fun check(failedAssertions: List) {} + + open fun suppressIfNeeded(failedAssertions: List): List = failedAssertions +} diff --git a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/model/AnalysisHandler.kt b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/model/AnalysisHandler.kt new file mode 100644 index 00000000000..ae0564a165e --- /dev/null +++ b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/model/AnalysisHandler.kt @@ -0,0 +1,44 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.model + +import org.jetbrains.kotlin.test.directives.model.DirectivesContainer +import org.jetbrains.kotlin.test.services.Assertions +import org.jetbrains.kotlin.test.services.ServiceRegistrationData +import org.jetbrains.kotlin.test.services.TestServices +import org.jetbrains.kotlin.test.services.assertions + +abstract class AnalysisHandler>(val testServices: TestServices) { + protected val assertions: Assertions + get() = testServices.assertions + + open val directivesContainers: List + get() = emptyList() + + open val additionalServices: List + get() = emptyList() + + abstract val artifactKind: TestArtifactKind + + abstract fun processModule(module: TestModule, info: A) + + abstract fun processAfterAllModules(someAssertionWasFailed: Boolean) +} + +abstract class FrontendOutputHandler>( + testServices: TestServices, + override val artifactKind: FrontendKind +) : AnalysisHandler(testServices) + +abstract class BackendInputHandler>( + testServices: TestServices, + override val artifactKind: BackendKind +) : AnalysisHandler(testServices) + +abstract class BinaryArtifactHandler>( + testServices: TestServices, + override val artifactKind: BinaryKind +) : AnalysisHandler(testServices) diff --git a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/model/Facades.kt b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/model/Facades.kt new file mode 100644 index 00000000000..aafed38186b --- /dev/null +++ b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/model/Facades.kt @@ -0,0 +1,46 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.model + +import org.jetbrains.kotlin.test.services.ServiceRegistrationData +import org.jetbrains.kotlin.test.services.TestServices + +abstract class AbstractTestFacade, O : ResultingArtifact> { + abstract val inputKind: TestArtifactKind + abstract val outputKind: TestArtifactKind + + abstract fun transform(module: TestModule, inputArtifact: I): O + + open val additionalServices: List + get() = emptyList() +} + +abstract class FrontendFacade>( + val testServices: TestServices, + final override val outputKind: FrontendKind +) : AbstractTestFacade() { + final override val inputKind: TestArtifactKind + get() = SourcesKind + + abstract fun analyze(module: TestModule): R + + final override fun transform(module: TestModule, inputArtifact: ResultingArtifact.Source): R { + // TODO: pass sources + return analyze(module) + } +} + +abstract class Frontend2BackendConverter, I : ResultingArtifact.BackendInput>( + val testServices: TestServices, + final override val inputKind: FrontendKind, + final override val outputKind: BackendKind +) : AbstractTestFacade() + +abstract class BackendFacade, A : ResultingArtifact.Binary>( + val testServices: TestServices, + final override val inputKind: BackendKind, + final override val outputKind: BinaryKind +) : AbstractTestFacade() diff --git a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/model/Modules.kt b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/model/Modules.kt new file mode 100644 index 00000000000..e645417efda --- /dev/null +++ b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/model/Modules.kt @@ -0,0 +1,64 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.model + +import org.jetbrains.kotlin.config.LanguageVersionSettings +import org.jetbrains.kotlin.platform.TargetPlatform +import org.jetbrains.kotlin.test.directives.model.RegisteredDirectives +import java.io.File + +data class TestModule( + val name: String, + val targetPlatform: TargetPlatform, + val frontendKind: FrontendKind<*>, + val backendKind: BackendKind<*>, + val files: List, + val dependencies: List, + val directives: RegisteredDirectives, + val languageVersionSettings: LanguageVersionSettings +) { + override fun toString(): String { + return buildString { + appendLine("Module: $name") + appendLine("targetPlatform = $targetPlatform") + appendLine("Dependencies:") + dependencies.forEach { appendLine(" $it") } + appendLine("Directives:\n $directives") + files.forEach { appendLine(it) } + } + } +} + +class TestFile( + val relativePath: String, + val originalContent: String, + val originalFile: File, + val startLineNumberInOriginalFile: Int, // line count starts with 0 + /* + * isAdditional means that this file provided as addition to sources of testdata + * and there is no need to apply any handlers or preprocessors over it + */ + val isAdditional: Boolean +) { + val name: String = relativePath.split("/").last() +} + +enum class DependencyRelation { + Dependency, + DependsOn +} + +enum class DependencyKind { + Source, + KLib, + Binary +} + +data class DependencyDescription( + val moduleName: String, + val kind: DependencyKind, + val relation: DependencyRelation +) diff --git a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/model/ResultingArtifact.kt b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/model/ResultingArtifact.kt new file mode 100644 index 00000000000..adc5419954f --- /dev/null +++ b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/model/ResultingArtifact.kt @@ -0,0 +1,42 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.model + +abstract class ResultingArtifact> { + abstract val kind: TestArtifactKind + + class Source : ResultingArtifact() { + override val kind: TestArtifactKind + get() = SourcesKind + } + + abstract class FrontendOutput> : ResultingArtifact() { + abstract override val kind: FrontendKind + + object Empty : FrontendOutput() { + override val kind: FrontendKind + get() = FrontendKind.NoFrontend + } + } + + abstract class BackendInput> : ResultingArtifact() { + abstract override val kind: BackendKind + + object Empty : BackendInput() { + override val kind: BackendKind + get() = BackendKind.NoBackend + } + } + + abstract class Binary> : ResultingArtifact() { + abstract override val kind: BinaryKind + + object Empty : Binary() { + override val kind: BinaryKind + get() = BinaryKind.NoArtifact + } + } +} diff --git a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/model/TestArtifactKind.kt b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/model/TestArtifactKind.kt new file mode 100644 index 00000000000..532d1238fc9 --- /dev/null +++ b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/model/TestArtifactKind.kt @@ -0,0 +1,38 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.model + +abstract class TestArtifactKind>(private val representation: String) { + open val shouldRunAnalysis: Boolean + get() = true + + override fun toString(): String { + return representation + } +} + +object SourcesKind : TestArtifactKind("Sources") + +abstract class FrontendKind>(representation: String) : TestArtifactKind(representation) { + object NoFrontend : FrontendKind("NoFrontend") { + override val shouldRunAnalysis: Boolean + get() = false + } +} + +abstract class BackendKind>(representation: String) : TestArtifactKind(representation) { + object NoBackend : BackendKind("NoBackend") { + override val shouldRunAnalysis: Boolean + get() = false + } +} + +abstract class BinaryKind>(representation: String) : TestArtifactKind(representation) { + object NoArtifact : BinaryKind("NoArtifact") { + override val shouldRunAnalysis: Boolean + get() = false + } +} diff --git a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/AdditionalSourceProvider.kt b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/AdditionalSourceProvider.kt new file mode 100644 index 00000000000..10a4548248f --- /dev/null +++ b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/AdditionalSourceProvider.kt @@ -0,0 +1,32 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.services + +import org.jetbrains.kotlin.test.directives.model.DirectivesContainer +import org.jetbrains.kotlin.test.directives.model.RegisteredDirectives +import org.jetbrains.kotlin.test.directives.model.SimpleDirective +import org.jetbrains.kotlin.test.model.TestFile +import org.jetbrains.kotlin.test.model.TestModule +import java.io.File + +abstract class AdditionalSourceProvider(val testServices: TestServices) { + open val directives: List + get() = emptyList() + + /** + * Note that you can not use [testServices.moduleStructure] here because it's not initialized yet + */ + abstract fun produceAdditionalFiles(globalDirectives: RegisteredDirectives, module: TestModule): List + + protected fun containsDirective(globalDirectives: RegisteredDirectives, module: TestModule, directive: SimpleDirective): Boolean { + return globalDirectives.contains(directive) || module.directives.contains(directive) + } + + protected fun File.toTestFile(): TestFile { + return TestFile(this.name, this.readText(), this, startLineNumberInOriginalFile = 0, isAdditional = true) + } +} + diff --git a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/Assertions.kt b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/Assertions.kt new file mode 100644 index 00000000000..c2e8fbab2a3 --- /dev/null +++ b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/Assertions.kt @@ -0,0 +1,31 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.services + +import java.io.File + +abstract class Assertions : TestService { + fun assertEqualsToFile(expectedFile: File, actual: String, sanitizer: (String) -> String = { it }) { + assertEqualsToFile(expectedFile, actual, sanitizer) { "Actual data differs from file content" } + } + + abstract fun assertEqualsToFile( + expectedFile: File, + actual: String, + sanitizer: (String) -> String = { it }, + message: (() -> String) + ) + + abstract fun assertEquals(expected: Any?, actual: Any?, message: (() -> String)? = null) + abstract fun assertNotEquals(expected: Any?, actual: Any?, message: (() -> String)? = null) + abstract fun assertTrue(value: Boolean, message: (() -> String)? = null) + abstract fun assertFalse(value: Boolean, message: (() -> String)? = null) + abstract fun assertAll(exceptions: List) + + abstract fun fail(message: () -> String): Nothing +} + +val TestServices.assertions: Assertions by TestServices.testServiceAccessor() diff --git a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/DefaultRegisteredDirectivesProvider.kt b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/DefaultRegisteredDirectivesProvider.kt new file mode 100644 index 00000000000..ffb37d66c25 --- /dev/null +++ b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/DefaultRegisteredDirectivesProvider.kt @@ -0,0 +1,19 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.services + +import org.jetbrains.kotlin.test.directives.model.RegisteredDirectives + +class DefaultRegisteredDirectivesProvider(defaultGlobalDirectives: RegisteredDirectives) : TestService { + val defaultDirectives: RegisteredDirectives by lazy { + defaultGlobalDirectives + } +} + +private val TestServices.defaultRegisteredDirectivesProvider: DefaultRegisteredDirectivesProvider by TestServices.testServiceAccessor() + +val TestServices.defaultDirectives: RegisteredDirectives + get() = defaultRegisteredDirectivesProvider.defaultDirectives diff --git a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/DefaultsProvider.kt b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/DefaultsProvider.kt new file mode 100644 index 00000000000..78c23446c93 --- /dev/null +++ b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/DefaultsProvider.kt @@ -0,0 +1,36 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.services + +import org.jetbrains.kotlin.config.LanguageVersionSettings +import org.jetbrains.kotlin.platform.TargetPlatform +import org.jetbrains.kotlin.test.builders.LanguageVersionSettingsBuilder +import org.jetbrains.kotlin.test.model.BackendKind +import org.jetbrains.kotlin.test.model.DependencyKind +import org.jetbrains.kotlin.test.model.FrontendKind + +/* + * TODO: + * - default target artifact + * - default libraries + */ +class DefaultsProvider( + val defaultBackend: BackendKind<*>, + val defaultFrontend: FrontendKind<*>, + val defaultLanguageSettings: LanguageVersionSettings, + private val defaultLanguageSettingsBuilder: LanguageVersionSettingsBuilder, + val defaultPlatform: TargetPlatform, + val defaultDependencyKind: DependencyKind +) : TestService { + fun newLanguageSettingsBuilder(): LanguageVersionSettingsBuilder { + return LanguageVersionSettingsBuilder.fromExistingSettings(defaultLanguageSettingsBuilder) + } +} + +val TestServices.defaultsProvider: DefaultsProvider by TestServices.testServiceAccessor() + +@DslMarker +annotation class DefaultsDsl diff --git a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/DependencyProvider.kt b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/DependencyProvider.kt new file mode 100644 index 00000000000..7bb7fbe234e --- /dev/null +++ b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/DependencyProvider.kt @@ -0,0 +1,49 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.services + +import org.jetbrains.kotlin.test.model.* + +abstract class DependencyProvider : TestService { + abstract fun getTestModule(name: String): TestModule + + abstract fun > getArtifact(module: TestModule, kind: TestArtifactKind): A +} + +val TestServices.dependencyProvider: DependencyProvider by TestServices.testServiceAccessor() + +class DependencyProviderImpl( + private val testServices: TestServices, + testModules: List +) : DependencyProvider() { + private val assertions: Assertions + get() = testServices.assertions + + private val testModulesByName = testModules.map { it.name to it }.toMap() + + private val artifactsByModule: MutableMap, ResultingArtifact<*>>> = mutableMapOf() + + override fun getTestModule(name: String): TestModule { + return testModulesByName[name] ?: assertions.fail { "Module $name is not defined" } + } + + override fun > getArtifact(module: TestModule, kind: TestArtifactKind): A { + val artifact = artifactsByModule.getMap(module)[kind] + ?: error("Artifact with kind $kind is not registered for module ${module.name}") + @Suppress("UNCHECKED_CAST") + return artifact as A + } + + fun > registerArtifact(module: TestModule, artifact: ResultingArtifact) { + val kind = artifact.kind + val previousValue = artifactsByModule.getMap(module).put(kind, artifact) + if (previousValue != null) error("Artifact with kind $kind already registered for module ${module.name}") + } + + private fun MutableMap>.getMap(key: K): MutableMap { + return getOrPut(key) { mutableMapOf() } + } +} diff --git a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/EnvironmentConfigurator.kt b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/EnvironmentConfigurator.kt new file mode 100644 index 00000000000..ec4c8b7c5e0 --- /dev/null +++ b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/EnvironmentConfigurator.kt @@ -0,0 +1,29 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.services + +import com.intellij.mock.MockProject +import org.jetbrains.kotlin.config.CompilerConfiguration +import org.jetbrains.kotlin.test.directives.model.ComposedRegisteredDirectives +import org.jetbrains.kotlin.test.directives.model.DirectivesContainer +import org.jetbrains.kotlin.test.directives.model.RegisteredDirectives +import org.jetbrains.kotlin.test.model.TestModule + +abstract class EnvironmentConfigurator(protected val testServices: TestServices) { + open val directivesContainers: List + get() = emptyList() + + open val additionalServices: List + get() = emptyList() + + protected val moduleStructure: TestModuleStructure + get() = testServices.moduleStructure + + protected val TestModule.allRegisteredDirectives: RegisteredDirectives + get() = ComposedRegisteredDirectives(directives, testServices.defaultDirectives) + + open fun configureCompilerConfiguration(configuration: CompilerConfiguration, module: TestModule, project: MockProject) {} +} diff --git a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/GlobalMetadataInfoHandler.kt b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/GlobalMetadataInfoHandler.kt new file mode 100644 index 00000000000..b6a3517a678 --- /dev/null +++ b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/GlobalMetadataInfoHandler.kt @@ -0,0 +1,82 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.services + +import org.jetbrains.kotlin.codeMetaInfo.CodeMetaInfoParser +import org.jetbrains.kotlin.codeMetaInfo.CodeMetaInfoRenderer +import org.jetbrains.kotlin.codeMetaInfo.model.CodeMetaInfo +import org.jetbrains.kotlin.codeMetaInfo.model.ParsedCodeMetaInfo +import org.jetbrains.kotlin.test.model.TestFile +import org.jetbrains.kotlin.test.model.TestModule + +class GlobalMetadataInfoHandler( + private val testServices: TestServices, + private val processors: List +) : TestService { + private lateinit var existingInfosPerFile: Map> + + private val infosPerFile: MutableMap> = + mutableMapOf>().withDefault { mutableListOf() } + + private val existingInfosPerFilePerInfoCache = mutableMapOf, List>() + + @OptIn(ExperimentalStdlibApi::class) + fun parseExistingMetadataInfosFromAllSources() { + existingInfosPerFile = buildMap { + for (file in testServices.moduleStructure.modules.flatMap { it.files }) { + put(file, CodeMetaInfoParser.getCodeMetaInfoFromText(file.originalContent)) + } + } + } + + fun getExistingMetaInfosForFile(file: TestFile): List { + return existingInfosPerFile.getValue(file) + } + + fun getReportedMetaInfosForFile(file: TestFile): List { + return infosPerFile.getValue(file) + } + + fun getExistingMetaInfosForActualMetadata(file: TestFile, metaInfo: CodeMetaInfo): List { + return existingInfosPerFilePerInfoCache.getOrPut(file to metaInfo) { + getExistingMetaInfosForFile(file).filter { it == metaInfo } + } + } + + fun addMetadataInfosForFile(file: TestFile, codeMetaInfos: List) { + val infos = infosPerFile.getOrPut(file) { mutableListOf() } + infos += codeMetaInfos + } + + fun compareAllMetaDataInfos() { + // TODO: adapt to multiple testdata files + val moduleStructure = testServices.moduleStructure + val builder = StringBuilder() + for (module in moduleStructure.modules) { + for (file in module.files) { + if (file.isAdditional) continue + processors.forEach { it.processMetaInfos(module, file) } + val codeMetaInfos = infosPerFile.getValue(file) + CodeMetaInfoRenderer.renderTagsToText( + builder, + codeMetaInfos, + testServices.sourceFileProvider.getContentOfSourceFile(file) + ) + } + } + val actualText = builder.toString() + testServices.assertions.assertEqualsToFile(moduleStructure.originalTestDataFiles.single(), actualText) + } +} + +val TestServices.globalMetadataInfoHandler: GlobalMetadataInfoHandler by TestServices.testServiceAccessor() + +abstract class AdditionalMetaInfoProcessor(protected val testServices: TestServices) { + protected val globalMetadataInfoHandler: GlobalMetadataInfoHandler + get() = testServices.globalMetadataInfoHandler + + abstract fun processMetaInfos(module: TestModule, file: TestFile) +} diff --git a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/MetaTestConfigurator.kt b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/MetaTestConfigurator.kt new file mode 100644 index 00000000000..75a155dce84 --- /dev/null +++ b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/MetaTestConfigurator.kt @@ -0,0 +1,17 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.services + +import org.jetbrains.kotlin.test.directives.model.DirectivesContainer + +abstract class MetaTestConfigurator(protected val testServices: TestServices) { + open val directives: List + get() = emptyList() + + open fun transformTestDataPath(testDataFileName: String): String = testDataFileName + + open fun shouldSkipTest(): Boolean = false +} diff --git a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/ModuleStructureExtractor.kt b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/ModuleStructureExtractor.kt new file mode 100644 index 00000000000..c0161f13257 --- /dev/null +++ b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/ModuleStructureExtractor.kt @@ -0,0 +1,18 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.services + +import org.jetbrains.kotlin.test.directives.model.DirectivesContainer + +abstract class ModuleStructureExtractor( + protected val testServices: TestServices, + protected val additionalSourceProviders: List +) { + abstract fun splitTestDataByModules( + testDataFileName: String, + directivesContainer: DirectivesContainer, + ): TestModuleStructure +} diff --git a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/SourceFileProvider.kt b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/SourceFileProvider.kt new file mode 100644 index 00000000000..a22b1e5c91d --- /dev/null +++ b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/SourceFileProvider.kt @@ -0,0 +1,86 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.services + +import com.intellij.openapi.project.Project +import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.test.model.TestFile +import org.jetbrains.kotlin.test.util.KtTestUtil +import java.io.File + +abstract class SourceFilePreprocessor(val testServices: TestServices) { + abstract fun process(file: TestFile, content: String): String +} + +abstract class SourceFileProvider : TestService { + abstract val kotlinSourceDirectory: File + abstract val javaSourceDirectory: File + + abstract fun getContentOfSourceFile(testFile: TestFile): String + abstract fun getRealFileForSourceFile(testFile: TestFile): File +} + +val TestServices.sourceFileProvider: SourceFileProvider by TestServices.testServiceAccessor() + +class SourceFileProviderImpl(val preprocessors: List) : SourceFileProvider() { + override val kotlinSourceDirectory: File = KtTestUtil.tmpDir("kotlin-files") + override val javaSourceDirectory: File = KtTestUtil.tmpDir("java-files") + + private val contentOfFiles = mutableMapOf() + private val realFileMap = mutableMapOf() + + override fun getContentOfSourceFile(testFile: TestFile): String { + return contentOfFiles.getOrPut(testFile) { + generateFinalContent(testFile) + } + } + + override fun getRealFileForSourceFile(testFile: TestFile): File { + return realFileMap.getOrPut(testFile) { + val directory = when { + testFile.isKtFile -> kotlinSourceDirectory + testFile.isJavaFile -> javaSourceDirectory + else -> error("Unknown file type: ${testFile.name}") + } + directory.resolve(testFile.relativePath).also { + it.parentFile.mkdirs() + it.writeText(getContentOfSourceFile(testFile)) + } + } + } + + private fun generateFinalContent(testFile: TestFile): String { + return preprocessors.fold(testFile.originalContent) { content, preprocessor -> + preprocessor.process(testFile, content) + } + } +} + +fun SourceFileProvider.getKtFileForSourceFile(testFile: TestFile, project: Project): KtFile { +// TODO +// return TestCheckerUtil.createCheckAndReturnPsiFile( + return KtTestUtil.createFile( + testFile.name, + getContentOfSourceFile(testFile), + project + ) +} + +fun SourceFileProvider.getKtFilesForSourceFiles(testFiles: Collection, project: Project): Map { + return testFiles.mapNotNull { + if (!it.isKtFile) return@mapNotNull null + it to getKtFileForSourceFile(it, project) + }.toMap() +} + +val TestFile.isKtFile: Boolean + get() = name.endsWith(".kt") || name.endsWith(".kts") + +val TestFile.isKtsFile: Boolean + get() = name.endsWith(".kts") + +val TestFile.isJavaFile: Boolean + get() = name.endsWith(".java") diff --git a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/TestModuleStructure.kt b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/TestModuleStructure.kt new file mode 100644 index 00000000000..b272ca20cf1 --- /dev/null +++ b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/TestModuleStructure.kt @@ -0,0 +1,21 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.services + +import org.jetbrains.kotlin.test.directives.model.RegisteredDirectives +import org.jetbrains.kotlin.test.model.BinaryKind +import org.jetbrains.kotlin.test.model.TestModule +import java.io.File + +abstract class TestModuleStructure : TestService { + abstract val modules: List + abstract val allDirectives: RegisteredDirectives + abstract val originalTestDataFiles: List + + abstract fun getTargetArtifactKinds(module: TestModule): List> +} + +val TestServices.moduleStructure: TestModuleStructure by TestServices.testServiceAccessor() diff --git a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/TestServices.kt b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/TestServices.kt new file mode 100644 index 00000000000..1febc71e29e --- /dev/null +++ b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/TestServices.kt @@ -0,0 +1,51 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.services + +import org.jetbrains.kotlin.fir.utils.ArrayMapAccessor +import org.jetbrains.kotlin.fir.utils.ComponentArrayOwner +import org.jetbrains.kotlin.fir.utils.TypeRegistry +import kotlin.reflect.KClass + +interface TestService + +data class ServiceRegistrationData( + val kClass: KClass, + val serviceConstructor: (TestServices) -> TestService +) + +inline fun service( + noinline serviceConstructor: (TestServices) -> T +): ServiceRegistrationData { + return ServiceRegistrationData(T::class, serviceConstructor) +} + +class TestServices : ComponentArrayOwner(){ + override val typeRegistry: TypeRegistry + get() = Companion + + companion object : TypeRegistry() { + inline fun testServiceAccessor(): ArrayMapAccessor { + return generateAccessor(T::class) + } + } + + fun register(data: ServiceRegistrationData) { + registerComponent(data.kClass, data.serviceConstructor(this)) + } + + fun register(kClass: KClass, service: TestService) { + registerComponent(kClass, service) + } + + fun register(data: List) { + data.forEach { register(it) } + } +} + +fun TestServices.registerDependencyProvider(dependencyProvider: DependencyProvider) { + register(DependencyProvider::class, dependencyProvider) +} diff --git a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/impl/RegisteredDirectivesParser.kt b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/impl/RegisteredDirectivesParser.kt new file mode 100644 index 00000000000..42faa246966 --- /dev/null +++ b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/impl/RegisteredDirectivesParser.kt @@ -0,0 +1,97 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.services.impl + +import org.jetbrains.kotlin.test.directives.model.* +import org.jetbrains.kotlin.test.services.Assertions + +class RegisteredDirectivesParser(private val container: DirectivesContainer, private val assertions: Assertions) { + companion object { + private val DIRECTIVE_PATTERN = Regex("""^//\s*[!]?([A-Z0-9_]+)(:[ \t]*(.*))? *$""") + private val SPACES_PATTERN = Regex("""[,]?[ \t]+""") + private const val NAME_GROUP = 1 + private const val VALUES_GROUP = 3 + + fun parseDirective(line: String): RawDirective? { + val result = DIRECTIVE_PATTERN.matchEntire(line)?.groupValues ?: return null + val name = result.getOrNull(NAME_GROUP) ?: return null + val values = result.getOrNull(VALUES_GROUP)?.split(SPACES_PATTERN)?.filter { it.isNotBlank() }?.takeIf { it.isNotEmpty() } + return RawDirective(name, values) + } + } + + data class RawDirective(val name: String, val values: List?) + data class ParsedDirective(val directive: Directive, val values: List<*>) + + private val simpleDirectives = mutableListOf() + private val stringValueDirectives = mutableMapOf>() + private val valueDirectives = mutableMapOf, MutableList>() + + /** + * returns true means that line contain directive + */ + fun parse(line: String): Boolean { + val rawDirective = parseDirective(line) ?: return false + val parsedDirective = convertToRegisteredDirective(rawDirective) ?: return false + addParsedDirective(parsedDirective) + return true + } + + fun addParsedDirective(parsedDirective: ParsedDirective) { + val (directive, values) = parsedDirective + when (directive) { + is SimpleDirective -> simpleDirectives += directive + is StringDirective -> { + val list = stringValueDirectives.getOrPut(directive, ::mutableListOf) + @Suppress("UNCHECKED_CAST") + list += values as List + } + is ValueDirective<*> -> { + val list = valueDirectives.getOrPut(directive, ::mutableListOf) + @Suppress("UNCHECKED_CAST") + list.addAll(values as List) + } + } + } + + fun convertToRegisteredDirective(rawDirective: RawDirective): ParsedDirective? { + val (name, rawValues) = rawDirective + val directive = container[name] ?: return null + + val values: List<*> = when (directive) { + is SimpleDirective -> { + if (rawValues != null) { + assertions.fail { + "Directive $directive should have no arguments, but ${rawValues.joinToString(", ")} are passed" + } + } + emptyList() + } + + is StringDirective -> { + rawValues ?: emptyList() + } + + is ValueDirective<*> -> { + if (rawValues == null) { + assertions.fail { + "Directive $directive must have at least one value" + } + } + rawValues.map { directive.extractValue(it) ?: assertions.fail { "$it is not valid value for $directive" } } + } + } + return ParsedDirective(directive, values) + } + + private fun ValueDirective.extractValue(name: String): T? { + return parser.invoke(name) + } + + fun build(): RegisteredDirectives { + return RegisteredDirectivesImpl(simpleDirectives, stringValueDirectives, valueDirectives) + } +} diff --git a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/impl/TargetPlatformParser.kt b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/impl/TargetPlatformParser.kt new file mode 100644 index 00000000000..a0c32f7bdb3 --- /dev/null +++ b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/impl/TargetPlatformParser.kt @@ -0,0 +1,51 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.services.impl + +import org.jetbrains.kotlin.config.JvmTarget +import org.jetbrains.kotlin.platform.TargetPlatform +import org.jetbrains.kotlin.platform.js.JsPlatform +import org.jetbrains.kotlin.platform.js.JsPlatforms +import org.jetbrains.kotlin.platform.jvm.JdkPlatform +import org.jetbrains.kotlin.platform.konan.NativePlatform +import org.jetbrains.kotlin.test.util.joinToArrayString +import org.jetbrains.kotlin.utils.addToStdlib.runIf + +object TargetPlatformParser { + private const val JVM = "JVM" + private const val JDK = "JDK" + private const val JS = "JS" + + fun parseTargetPlatform(declaredPlatforms: List): TargetPlatform? { + if (declaredPlatforms.isEmpty()) return null + val simplePlatforms = declaredPlatforms.mapTo(mutableSetOf()) { platformString -> + tryParseJdkPlatform(platformString)?.let { return@mapTo it } + tryParseJsPlatform(platformString)?.let { return@mapTo it } + tryParseNativePlatform(platformString)?.let { return@mapTo it } + error("Unknown platform: $platformString") + } + return TargetPlatform(simplePlatforms) + } + + private fun tryParseJdkPlatform(platformString: String): JdkPlatform? { + val target = when { + platformString == JVM -> JvmTarget.DEFAULT + !platformString.startsWith(JDK) -> return null + else -> JvmTarget.values().find { it.name == platformString } + ?: error("JvmTarget \"$platformString\" not found.\nAvailable targets: ${JvmTarget.values().joinToArrayString()}") + } + return JdkPlatform(target) + } + + private fun tryParseJsPlatform(platformString: String): JsPlatform? { + return runIf(platformString == JS) { JsPlatforms.DefaultSimpleJsPlatform } + } + + private fun tryParseNativePlatform(platformString: String): NativePlatform? { + // TODO: support native platforms + return null + } +} diff --git a/settings.gradle b/settings.gradle index ba13c605ba9..09e7e05ae78 100644 --- a/settings.gradle +++ b/settings.gradle @@ -326,7 +326,8 @@ include ":compiler:fir:cones", ":compiler:fir:entrypoint", ":compiler:fir:analysis-tests" -include ":compiler:test-infrastructure-utils" +include ":compiler:test-infrastructure", + ":compiler:test-infrastructure-utils" include ":idea:idea-frontend-fir:idea-fir-low-level-api" include ":idea:idea-fir-performance-tests" From cb5183ab4d18eb692e6f0a80a9fd1aecf2e90188 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Wed, 2 Dec 2020 17:22:12 +0300 Subject: [PATCH 091/196] [TEST] Add implementation of new infrastructure services for compiler tests All of new classes lays in lays in :compiler:tests-common-new module which includes classes for FE 1.0 and FIR diagnostics tests and JVM black boxtests --- .../cli/jvm/compiler/KotlinCoreEnvironment.kt | 14 + .../compiler/KotlinCoreEnvironment.kt.as42 | 14 + .../kotlin/platform/jvm/JvmPlatform.kt | 2 +- .../kotlin/fir/analysis/FirAnalyzerFacade.kt | 2 +- .../kotlin/fir/session/FirJvmModuleInfo.kt | 5 +- .../kotlin/checkers/utils/CheckerTestUtil.kt | 2 +- .../DiagnosticFactoryWithPsiElement.java | 4 + .../kotlin/backend/jvm/JvmIrCodegenFactory.kt | 2 +- .../jetbrains/kotlin/script/scriptTestUtil.kt | 0 .../jetbrains/kotlin/test/util/Condition.kt | 142 ++++++++ .../jetbrains/kotlin/test/util/StringUtils.kt | 12 + compiler/tests-common-new/build.gradle.kts | 66 ++++ .../test/backend/BlackBoxCodegenSuppressor.kt | 68 ++++ .../backend/classic/ClassicBackendFacade.kt | 14 + .../backend/classic/ClassicBackendInput.kt | 26 ++ .../classic/ClassicJvmBackendFacade.kt | 41 +++ .../handlers/BinaryArtifactHandlers.kt | 23 ++ .../test/backend/handlers/JvmBoxRunner.kt | 109 ++++++ .../kotlin/test/backend/ir/IrBackendFacade.kt | 14 + .../kotlin/test/backend/ir/IrBackendInput.kt | 32 ++ .../test/backend/ir/JvmIrBackendFacade.kt | 36 ++ .../test/builders/DefaultsProviderBuilder.kt | 51 +++ .../builders/RegisteredDirectivesBuilder.kt | 45 +++ .../test/builders/TestConfigurationBuilder.kt | 150 ++++++++ .../builders/TestConfigurationDslMarker.kt | 9 + .../kotlin/test/builders/TestPathMatcher.kt | 7 + .../kotlin/test/builders/TestRunnerBuilder.kt | 12 + .../directives/AdditionalFilesDirectives.kt | 40 +++ .../test/directives/CodegenTestDirectives.kt | 15 + .../test/directives/DiagnosticsDirectives.kt | 49 +++ .../directives/FirDiagnosticsDirectives.kt | 27 ++ .../JsEnvironmentConfigurationDirectives.kt | 13 + .../JvmEnvironmentConfigurationDirectives.kt | 36 ++ ...ClassicFrontend2ClassicBackendConverter.kt | 32 ++ .../classic/ClassicFrontend2IrConverter.kt | 158 +++++++++ .../frontend/classic/ClassicFrontendFacade.kt | 263 ++++++++++++++ .../classic/ClassicFrontendOutputArtifact.kt | 26 ++ .../classic/ModuleDescriptorProvider.kt | 32 ++ .../handlers/ClassicDiagnosticsHandler.kt | 253 ++++++++++++++ .../ClassicFrontendAnalysisHandler.kt | 17 + .../classic/handlers/ClassicMetaInfoUtils.kt | 13 + .../handlers/DeclarationsDumpHandler.kt | 136 ++++++++ ...DiagnosticTestWithJavacSkipConfigurator.kt | 21 ++ .../handlers/FirTestDataConsistencyHandler.kt | 46 +++ .../frontend/fir/Fir2IrResultsConverter.kt | 96 ++++++ .../frontend/fir/FirFailingTestSuppressor.kt | 26 ++ .../test/frontend/fir/FirFrontendFacade.kt | 99 ++++++ .../frontend/fir/FirModuleInfoProvider.kt | 44 +++ .../test/frontend/fir/FirOutputArtifact.kt | 24 ++ .../fir/handlers/FirAnalysisHandler.kt | 19 + .../fir/handlers/FirCfgConsistencyHandler.kt | 19 + .../fir/handlers/FirCfgDumpHandler.kt | 36 ++ .../fir/handlers/FirDiagnosticCodeMetaInfo.kt | 90 +++++ .../fir/handlers/FirDiagnosticsHandler.kt | 232 +++++++++++++ .../frontend/fir/handlers/FirDumpHandler.kt | 41 +++ .../fir/handlers/FirIdenticalChecker.kt | 53 +++ .../kotlin/test/impl/TestConfigurationImpl.kt | 151 ++++++++ .../kotlin/test/model/ResultingArtifacts.kt | 30 ++ .../kotlin/test/model/TestArtifactKinds.kt | 54 +++ .../MetaInfosCleanupPreprocessor.kt | 17 + ...dditionalDiagnosticsSourceFilesProvider.kt | 32 ++ .../services/CompilerConfigurationProvider.kt | 100 ++++++ .../CoroutineHelpersSourceFilesProvider.kt | 42 +++ .../test/services/DiagnosticsService.kt | 49 +++ .../kotlin/test/services/JUnit5Assertions.kt | 62 ++++ .../JsEnvironmentConfigurator.kt | 36 ++ .../JvmEnvironmentConfigurator.kt | 162 +++++++++ .../ScriptingEnvironmentConfigurator.kt | 22 ++ .../fir/FirOldFrontendMetaConfigurator.kt | 28 ++ .../impl/ModuleStructureExtractorImpl.kt | 326 ++++++++++++++++++ .../services/impl/TestModuleStructureImpl.kt | 62 ++++ .../test/services/jvm/CompiledJarManager.kt | 37 ++ .../jetbrains/kotlin/test/utils/FileUtils.kt | 28 ++ .../test/utils/MultiModuleInfoDumper.kt | 37 ++ .../kotlin/test/utils/TestDisposable.kt | 18 + .../kotlin/fir/AbstractFirDiagnosticTest.kt | 2 +- .../kotlin/test/KotlinTestUtils.java | 6 +- .../kotlin/test/util/jetTestUtils.kt | 8 - .../kotlin/platform/js/JsPlatform.kt | 2 +- settings.gradle | 3 +- 80 files changed, 4153 insertions(+), 19 deletions(-) rename compiler/{tests-common => test-infrastructure-utils}/tests/org/jetbrains/kotlin/script/scriptTestUtil.kt (100%) create mode 100644 compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/util/Condition.kt create mode 100644 compiler/tests-common-new/build.gradle.kts create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/BlackBoxCodegenSuppressor.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/classic/ClassicBackendFacade.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/classic/ClassicBackendInput.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/classic/ClassicJvmBackendFacade.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/BinaryArtifactHandlers.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/JvmBoxRunner.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/ir/IrBackendFacade.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/ir/IrBackendInput.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/ir/JvmIrBackendFacade.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/builders/DefaultsProviderBuilder.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/builders/RegisteredDirectivesBuilder.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/builders/TestConfigurationBuilder.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/builders/TestConfigurationDslMarker.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/builders/TestPathMatcher.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/builders/TestRunnerBuilder.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/directives/AdditionalFilesDirectives.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/directives/CodegenTestDirectives.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/directives/DiagnosticsDirectives.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/directives/FirDiagnosticsDirectives.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/directives/JsEnvironmentConfigurationDirectives.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/directives/JvmEnvironmentConfigurationDirectives.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/ClassicFrontend2ClassicBackendConverter.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/ClassicFrontend2IrConverter.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/ClassicFrontendFacade.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/ClassicFrontendOutputArtifact.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/ModuleDescriptorProvider.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/handlers/ClassicDiagnosticsHandler.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/handlers/ClassicFrontendAnalysisHandler.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/handlers/ClassicMetaInfoUtils.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/handlers/DeclarationsDumpHandler.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/handlers/DiagnosticTestWithJavacSkipConfigurator.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/handlers/FirTestDataConsistencyHandler.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/Fir2IrResultsConverter.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/FirFailingTestSuppressor.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/FirFrontendFacade.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/FirModuleInfoProvider.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/FirOutputArtifact.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirAnalysisHandler.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirCfgConsistencyHandler.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirCfgDumpHandler.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirDiagnosticCodeMetaInfo.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirDiagnosticsHandler.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirDumpHandler.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirIdenticalChecker.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/impl/TestConfigurationImpl.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/model/ResultingArtifacts.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/model/TestArtifactKinds.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/preprocessors/MetaInfosCleanupPreprocessor.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/AdditionalDiagnosticsSourceFilesProvider.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/CompilerConfigurationProvider.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/CoroutineHelpersSourceFilesProvider.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/DiagnosticsService.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/JUnit5Assertions.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/configuration/JsEnvironmentConfigurator.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/configuration/JvmEnvironmentConfigurator.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/configuration/ScriptingEnvironmentConfigurator.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/fir/FirOldFrontendMetaConfigurator.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/impl/ModuleStructureExtractorImpl.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/impl/TestModuleStructureImpl.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/jvm/CompiledJarManager.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/utils/FileUtils.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/utils/MultiModuleInfoDumper.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/utils/TestDisposable.kt diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreEnvironment.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreEnvironment.kt index b898e84423d..47c6ee66a30 100644 --- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreEnvironment.kt +++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreEnvironment.kt @@ -458,6 +458,20 @@ class KotlinCoreEnvironment private constructor( return KotlinCoreEnvironment(projectEnv, configuration, extensionConfigs) } + @TestOnly + @JvmStatic + fun createForTests( + projectEnvironment: ProjectEnvironment, initialConfiguration: CompilerConfiguration, extensionConfigs: EnvironmentConfigFiles + ): KotlinCoreEnvironment { + return KotlinCoreEnvironment(projectEnvironment, initialConfiguration, extensionConfigs) + } + + @TestOnly + fun createProjectEnvironmentForTests(parentDisposable: Disposable, configuration: CompilerConfiguration): ProjectEnvironment { + val appEnv = createApplicationEnvironment(parentDisposable, configuration, unitTestMode = true) + return ProjectEnvironment(parentDisposable, appEnv) + } + // used in the daemon for jar cache cleanup val applicationEnvironment: KotlinCoreApplicationEnvironment? get() = ourApplicationEnvironment diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreEnvironment.kt.as42 b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreEnvironment.kt.as42 index b41f8d46e03..dc420f7f739 100644 --- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreEnvironment.kt.as42 +++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreEnvironment.kt.as42 @@ -456,6 +456,20 @@ class KotlinCoreEnvironment private constructor( return KotlinCoreEnvironment(projectEnv, configuration, extensionConfigs) } + @TestOnly + @JvmStatic + fun createForTests( + projectEnvironment: ProjectEnvironment, initialConfiguration: CompilerConfiguration, extensionConfigs: EnvironmentConfigFiles + ): KotlinCoreEnvironment { + return KotlinCoreEnvironment(projectEnvironment, initialConfiguration, extensionConfigs) + } + + @TestOnly + fun createProjectEnvironmentForTests(parentDisposable: Disposable, configuration: CompilerConfiguration): ProjectEnvironment { + val appEnv = createApplicationEnvironment(parentDisposable, configuration, unitTestMode = true) + return ProjectEnvironment(parentDisposable, appEnv) + } + // used in the daemon for jar cache cleanup val applicationEnvironment: KotlinCoreApplicationEnvironment? get() = ourApplicationEnvironment diff --git a/compiler/config.jvm/src/org/jetbrains/kotlin/platform/jvm/JvmPlatform.kt b/compiler/config.jvm/src/org/jetbrains/kotlin/platform/jvm/JvmPlatform.kt index 68ff43b357b..09c029a3faa 100644 --- a/compiler/config.jvm/src/org/jetbrains/kotlin/platform/jvm/JvmPlatform.kt +++ b/compiler/config.jvm/src/org/jetbrains/kotlin/platform/jvm/JvmPlatform.kt @@ -18,7 +18,7 @@ abstract class JvmPlatform : SimplePlatform("JVM") { @Suppress("DEPRECATION_ERROR") object JvmPlatforms { - private val UNSPECIFIED_SIMPLE_JVM_PLATFORM = JdkPlatform(JvmTarget.JVM_1_6) + private val UNSPECIFIED_SIMPLE_JVM_PLATFORM = JdkPlatform(JvmTarget.DEFAULT) private val jvmTargetToJdkPlatform: Map = JvmTarget.values().map { it to JdkPlatform(it).toTargetPlatform() }.toMap() diff --git a/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/analysis/FirAnalyzerFacade.kt b/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/analysis/FirAnalyzerFacade.kt index 0eb4608bb47..b6146c99b48 100644 --- a/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/analysis/FirAnalyzerFacade.kt +++ b/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/analysis/FirAnalyzerFacade.kt @@ -26,7 +26,7 @@ import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl import org.jetbrains.kotlin.psi.KtFile import org.jetbrains.kotlin.psi2ir.generators.GeneratorExtensions -class FirAnalyzerFacade(val session: FirSession, val languageVersionSettings: LanguageVersionSettings, val ktFiles: List) { +class FirAnalyzerFacade(val session: FirSession, val languageVersionSettings: LanguageVersionSettings, val ktFiles: Collection) { private var firFiles: List? = null private var scopeSession: ScopeSession? = null private var collectedDiagnostics: Map>>? = null diff --git a/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/FirJvmModuleInfo.kt b/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/FirJvmModuleInfo.kt index 82a56fde399..e342b7f50e3 100644 --- a/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/FirJvmModuleInfo.kt +++ b/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/FirJvmModuleInfo.kt @@ -16,7 +16,10 @@ class FirJvmModuleInfo(override val name: Name, val dependencies: List") - fun createForLibraries(): FirJvmModuleInfo = FirJvmModuleInfo(LIBRARIES_MODULE_NAME, emptyList()) + fun createForLibraries(mainModuleName: String? = null): FirJvmModuleInfo { + val name = mainModuleName?.let { Name.special("") } ?: LIBRARIES_MODULE_NAME + return FirJvmModuleInfo(name, emptyList()) + } } constructor(moduleName: String, dependencies: List) : this(Name.identifier(moduleName), dependencies) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/checkers/utils/CheckerTestUtil.kt b/compiler/frontend/src/org/jetbrains/kotlin/checkers/utils/CheckerTestUtil.kt index 8c50415868d..00f3ea98021 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/checkers/utils/CheckerTestUtil.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/checkers/utils/CheckerTestUtil.kt @@ -149,7 +149,7 @@ object CheckerTestUtil { return diagnostics } - private fun getDebugInfoDiagnostics( + fun getDebugInfoDiagnostics( root: PsiElement, bindingContext: BindingContext, markDynamicCalls: Boolean, diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/DiagnosticFactoryWithPsiElement.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/DiagnosticFactoryWithPsiElement.java index 16a8223e4e5..62f2a6ba77d 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/DiagnosticFactoryWithPsiElement.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/DiagnosticFactoryWithPsiElement.java @@ -36,4 +36,8 @@ public abstract class DiagnosticFactoryWithPsiElement diagnostic) { return positioningStrategy.isValid(diagnostic.getPsiElement()); } + + public PositioningStrategy getPositioningStrategy() { + return positioningStrategy; + } } diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmIrCodegenFactory.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmIrCodegenFactory.kt index 096f6a87a7d..28fa2b6499d 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmIrCodegenFactory.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/JvmIrCodegenFactory.kt @@ -124,7 +124,7 @@ class JvmIrCodegenFactory(private val phaseConfig: PhaseConfig) : CodegenFactory ) } - internal fun doGenerateFilesInternal( + fun doGenerateFilesInternal( state: GenerationState, irModuleFragment: IrModuleFragment, symbolTable: SymbolTable, diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/script/scriptTestUtil.kt b/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/script/scriptTestUtil.kt similarity index 100% rename from compiler/tests-common/tests/org/jetbrains/kotlin/script/scriptTestUtil.kt rename to compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/script/scriptTestUtil.kt diff --git a/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/util/Condition.kt b/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/util/Condition.kt new file mode 100644 index 00000000000..1e65a5b8b6f --- /dev/null +++ b/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/util/Condition.kt @@ -0,0 +1,142 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.util + +import java.util.* + +fun interface Condition { + operator fun invoke(value: T): Boolean +} + +object Conditions { + private val TRUE = Condition { true } + private val FALSE = Condition { false } + + fun alwaysTrue(): Condition { + return TRUE + } + + fun alwaysFalse(): Condition { + return FALSE + } + + fun notNull(): Condition { + return Condition { it != null } + } + + fun constant(value: Boolean): Condition { + return if (value) alwaysTrue() else alwaysFalse() + } + + fun instanceOf(clazz: Class<*>): Condition { + return Condition { t -> clazz.isInstance(t) } + } + + fun notInstanceOf(clazz: Class<*>): Condition { + return Condition { t -> !clazz.isInstance(t) } + } + + fun assignableTo(clazz: Class<*>): Condition> { + return Condition { t -> clazz.isAssignableFrom(t) } + } + + fun instanceOf(vararg clazz: Class<*>): Condition { + return Condition { t -> + for (aClass in clazz) { + if (aClass.isInstance(t)) return@Condition true + } + false + } + } + + fun `is`(option: T): Condition { + return equalTo(option) + } + + fun equalTo(option: Any?): Condition { + return Condition { t -> t == option } + } + + fun notEqualTo(option: Any?): Condition { + return Condition { t -> t != option } + } + + fun oneOf(vararg options: T): Condition { + return oneOf(options.toList()) + } + + fun oneOf(options: Collection): Condition { + return Condition { t -> options.contains(t) } + } + + fun not(c: Condition): Condition { + if (c === alwaysTrue()) return alwaysFalse() + if (c === alwaysFalse()) return alwaysTrue() + return if (c is Not<*>) { + (c as Not).c as Condition + } else Not(c) + } + + fun and(c1: Condition, c2: Condition): Condition { + if (c1 === alwaysTrue() || c2 === alwaysFalse()) return c2 + return if (c2 === alwaysTrue() || c1 === alwaysFalse()) c1 else And(c1, c2) + } + + fun or(c1: Condition, c2: Condition): Condition { + if (c1 === alwaysFalse() || c2 === alwaysTrue()) return c2 + return if (c2 === alwaysFalse() || c1 === alwaysTrue()) c1 else Or(c1, c2) + } + + fun compose(func: (A) -> B, condition: Condition): Condition { + return Condition { condition.invoke(func(it)) } + } + + fun cached(c: Condition): Condition { + return SoftRefCache(c) + } + + private class Not(val c: Condition) : Condition { + override fun invoke(value: T): Boolean { + return !c.invoke(value) + } + } + + private class And(val c1: Condition, val c2: Condition) : Condition { + override fun invoke(value: T): Boolean { + return c1.invoke(value) && c2.invoke(value) + } + } + + private class Or(val c1: Condition, val c2: Condition) : Condition { + override fun invoke(value: T): Boolean { + return c1.invoke(value) || c2.invoke(value) + } + } + + private class SoftRefCache(private val myCondition: Condition) : Condition { + private val myCache: WeakHashMap = WeakHashMap(); + + override fun invoke(value: T): Boolean { + return myCache.computeIfAbsent(value) { myCondition(value) } + } + } +} + +infix fun Condition.and(other: Condition): Condition { + return Conditions.and(this, other) +} + +infix fun Condition.or(other: Condition): Condition { + return Conditions.or(this, other) +} + +operator fun Condition.not(): Condition { + return Conditions.not(this) +} + +fun Condition.cached(): Condition { + return Conditions.cached(this) +} diff --git a/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/util/StringUtils.kt b/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/util/StringUtils.kt index db23ad397ab..9c56bab4713 100644 --- a/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/util/StringUtils.kt +++ b/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/util/StringUtils.kt @@ -7,3 +7,15 @@ package org.jetbrains.kotlin.test.util fun Iterable<*>.joinToArrayString(): String = joinToString(separator = ", ", prefix = "[", postfix = "]") fun Array<*>.joinToArrayString(): String = joinToString(separator = ", ", prefix = "[", postfix = "]") + +private const val DEFAULT_LINE_SEPARATOR = "\n" + +fun String.trimTrailingWhitespacesAndAddNewlineAtEOF(): String = + this.trimTrailingWhitespaces().let { result -> if (result.endsWith("\n")) result else result + "\n" } + +fun String.trimTrailingWhitespaces(): String = + this.split('\n').joinToString(separator = "\n") { it.trimEnd() } + +fun String.convertLineSeparators(separator: String = DEFAULT_LINE_SEPARATOR): String { + return replace(Regex.fromLiteral("\r\n|\r|\n"), separator) +} diff --git a/compiler/tests-common-new/build.gradle.kts b/compiler/tests-common-new/build.gradle.kts new file mode 100644 index 00000000000..b037e357a9c --- /dev/null +++ b/compiler/tests-common-new/build.gradle.kts @@ -0,0 +1,66 @@ +import org.jetbrains.kotlin.ideaExt.idea + +plugins { + kotlin("jvm") + id("jps-compatible") +} + +dependencies { + testApi(project(":compiler:fir:entrypoint")) + testApi(project(":compiler:cli")) + testImplementation(project(":compiler:ir.tree.impl")) + testImplementation(intellijCoreDep()) { includeJars("intellij-core") } + + testCompileOnly(project(":kotlin-reflect-api")) + testRuntimeOnly(project(":kotlin-reflect")) + testRuntimeOnly(project(":core:descriptors.runtime")) + + testImplementation(projectTests(":generators:test-generator")) + + testImplementation(platform("org.junit:junit-bom:5.7.0")) + testImplementation("org.junit.jupiter:junit-jupiter") + testImplementation("org.junit.platform:junit-platform-commons:1.7.0") + testApi(projectTests(":compiler:test-infrastructure")) + testImplementation(projectTests(":compiler:test-infrastructure-utils")) + + testImplementation(intellijDep()) { + // This dependency is needed only for FileComparisonFailure + includeJars("idea_rt", rootProject = rootProject) + isTransitive = false + } + + // This is needed only for using FileComparisonFailure, which relies on JUnit 3 classes + testRuntimeOnly(commonDep("junit:junit")) + testRuntimeOnly(intellijDep()) { + includeJars("jna", rootProject = rootProject) + } + testRuntimeOnly(toolsJar()) +} + +val generationRoot = projectDir.resolve("tests-gen") + +sourceSets { + "main" { none() } + "test" { + projectDefault() + this.java.srcDir(generationRoot.name) + } +} + +if (kotlinBuildProperties.isInJpsBuildIdeaSync) { + apply(plugin = "idea") + idea { + this.module.generatedSourceDirs.add(generationRoot) + } +} + +projectTest(parallel = true) { + dependsOn(":dist") + workingDir = rootDir + jvmArgs!!.removeIf { it.contains("-Xmx") } + maxHeapSize = "3g" + + useJUnitPlatform() +} + +testsJar() diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/BlackBoxCodegenSuppressor.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/BlackBoxCodegenSuppressor.kt new file mode 100644 index 00000000000..47f9befff9a --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/BlackBoxCodegenSuppressor.kt @@ -0,0 +1,68 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.backend + +import org.jetbrains.kotlin.platform.js.isJs +import org.jetbrains.kotlin.platform.jvm.isJvm +import org.jetbrains.kotlin.test.TargetBackend +import org.jetbrains.kotlin.test.directives.CodegenTestDirectives +import org.jetbrains.kotlin.test.directives.model.DirectivesContainer +import org.jetbrains.kotlin.test.model.AfterAnalysisChecker +import org.jetbrains.kotlin.test.model.BackendKinds +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.TestServices +import org.jetbrains.kotlin.test.services.moduleStructure +import org.jetbrains.kotlin.test.util.joinToArrayString + +class BlackBoxCodegenSuppressor(testServices: TestServices) : AfterAnalysisChecker(testServices) { + override val directives: List + get() = listOf(CodegenTestDirectives) + + override fun suppressIfNeeded(failedAssertions: List): List { + val moduleStructure = testServices.moduleStructure + val ignoredBackends = moduleStructure.modules.flatMap { it.directives[CodegenTestDirectives.IGNORE_BACKEND] } + if (ignoredBackends.isEmpty()) return failedAssertions + val targetBackends = moduleStructure.modules.flatMap { it.targetBackends } + val matchedBackend = ignoredBackends.intersect(targetBackends) + if (ignoredBackends.contains(TargetBackend.ANY)) { + return processAssertions(failedAssertions) + } + if (matchedBackend.isNotEmpty()) { + return processAssertions(failedAssertions, "for ${matchedBackend.joinToArrayString()}") + } + return failedAssertions + + } + + private fun processAssertions(failedAssertions: List, additionalMessage: String = ""): List { + return if (failedAssertions.isNotEmpty()) emptyList() + else { + val message = buildString { + append("Looks like this test can be unmuted. Remove IGNORE_BACKEND directive") + if (additionalMessage.isNotEmpty()) { + append(" ") + append(additionalMessage) + } + } + listOf(AssertionError(message)) + } + } + + private val TestModule.targetBackends: List + get() = when (backendKind) { + BackendKinds.ClassicBackend -> when { + targetPlatform.isJvm() -> listOf(TargetBackend.JVM, TargetBackend.JVM_OLD) + targetPlatform.isJs() -> listOf(TargetBackend.JS) + else -> emptyList() + } + BackendKinds.IrBackend -> when { + targetPlatform.isJvm() -> listOf(TargetBackend.JVM_IR) + targetPlatform.isJs() -> listOf(TargetBackend.JS_IR) + else -> emptyList() + } + else -> emptyList() + } +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/classic/ClassicBackendFacade.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/classic/ClassicBackendFacade.kt new file mode 100644 index 00000000000..4358bb39649 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/classic/ClassicBackendFacade.kt @@ -0,0 +1,14 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.backend.classic + +import org.jetbrains.kotlin.test.model.* +import org.jetbrains.kotlin.test.services.TestServices + +abstract class ClassicBackendFacade>( + testServices: TestServices, + binaryKind: BinaryKind +) : BackendFacade(testServices, BackendKinds.ClassicBackend, binaryKind) diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/classic/ClassicBackendInput.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/classic/ClassicBackendInput.kt new file mode 100644 index 00000000000..29358945820 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/classic/ClassicBackendInput.kt @@ -0,0 +1,26 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.backend.classic + +import com.intellij.openapi.project.Project +import org.jetbrains.kotlin.config.LanguageVersionSettings +import org.jetbrains.kotlin.descriptors.ModuleDescriptor +import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.resolve.BindingContext +import org.jetbrains.kotlin.test.model.BackendKinds +import org.jetbrains.kotlin.test.model.ResultingArtifact + +// Old backend (JVM and JS) +data class ClassicBackendInput( + val psiFiles: Collection, + val bindingContext: BindingContext, + val moduleDescriptor: ModuleDescriptor, + val project: Project, + val languageVersionSettings: LanguageVersionSettings +) : ResultingArtifact.BackendInput() { + override val kind: BackendKinds.ClassicBackend + get() = BackendKinds.ClassicBackend +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/classic/ClassicJvmBackendFacade.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/classic/ClassicJvmBackendFacade.kt new file mode 100644 index 00000000000..c368339c1e8 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/classic/ClassicJvmBackendFacade.kt @@ -0,0 +1,41 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.backend.classic + +import org.jetbrains.kotlin.codegen.ClassBuilderFactories +import org.jetbrains.kotlin.codegen.DefaultCodegenFactory +import org.jetbrains.kotlin.codegen.KotlinCodegenFacade +import org.jetbrains.kotlin.codegen.state.GenerationState +import org.jetbrains.kotlin.test.model.ArtifactKinds +import org.jetbrains.kotlin.test.model.BinaryArtifacts +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.TestServices +import org.jetbrains.kotlin.test.services.compilerConfigurationProvider + +class ClassicJvmBackendFacade( + testServices: TestServices +) : ClassicBackendFacade(testServices, ArtifactKinds.Jvm) { + override fun transform( + module: TestModule, + inputArtifact: ClassicBackendInput + ): BinaryArtifacts.Jvm { + val compilerConfiguration = testServices.compilerConfigurationProvider.getCompilerConfiguration(module) + val (psiFiles, bindingContext, moduleDescriptor, project, languageVersionSettings) = inputArtifact + // TODO: add configuring classBuilderFactory + val generationState = GenerationState.Builder( + project, + ClassBuilderFactories.TEST, + moduleDescriptor, + bindingContext, + psiFiles.toList(), + compilerConfiguration + ).codegenFactory(DefaultCodegenFactory).build() + + KotlinCodegenFacade.compileCorrectFiles(generationState) + + return BinaryArtifacts.Jvm(generationState.factory) + } +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/BinaryArtifactHandlers.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/BinaryArtifactHandlers.kt new file mode 100644 index 00000000000..930fd0967c7 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/BinaryArtifactHandlers.kt @@ -0,0 +1,23 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.backend.handlers + +import org.jetbrains.kotlin.test.model.ArtifactKinds +import org.jetbrains.kotlin.test.model.BinaryArtifactHandler +import org.jetbrains.kotlin.test.model.BinaryArtifacts +import org.jetbrains.kotlin.test.services.TestServices + +abstract class JvmBinaryArtifactHandler( + testServices: TestServices +) : BinaryArtifactHandler(testServices, ArtifactKinds.Jvm) + +abstract class JsBinaryArtifactHandler( + testServices: TestServices +) : BinaryArtifactHandler(testServices, ArtifactKinds.Js) + +abstract class NativeBinaryArtifactHandler( + testServices: TestServices +) : BinaryArtifactHandler(testServices, ArtifactKinds.Native) diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/JvmBoxRunner.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/JvmBoxRunner.kt new file mode 100644 index 00000000000..ababfab1b2a --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/JvmBoxRunner.kt @@ -0,0 +1,109 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.backend.handlers + +import junit.framework.TestCase +import org.jetbrains.kotlin.backend.common.CodegenUtil.getMemberDeclarationsToGenerate +import org.jetbrains.kotlin.cli.jvm.config.jvmClasspathRoots +import org.jetbrains.kotlin.codegen.ClassFileFactory +import org.jetbrains.kotlin.codegen.GeneratedClassLoader +import org.jetbrains.kotlin.fileClasses.JvmFileClassUtil.getFileClassInfoNoResolve +import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.test.model.BinaryArtifacts +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.TestServices +import org.jetbrains.kotlin.test.services.compilerConfigurationProvider +import org.jetbrains.kotlin.utils.addToStdlib.runIf +import java.lang.reflect.Method +import java.net.URLClassLoader + +class JvmBoxRunner( + testServices: TestServices +) : JvmBinaryArtifactHandler(testServices) { + companion object { + private val BOX_IN_SEPARATE_PROCESS_PORT = System.getProperty("kotlin.test.box.in.separate.process.port") + } + + private var boxMethodFound = false + + override fun processAfterAllModules(someAssertionWasFailed: Boolean) { + if (!boxMethodFound) { + assertions.fail { "Can't find box methods" } + } + } + + override fun processModule(module: TestModule, info: BinaryArtifacts.Jvm) { + val ktFiles = info.classFileFactory.inputFiles + val classLoader = createClassLoader(module, info.classFileFactory) + for (ktFile in ktFiles) { + val className = ktFile.getFacadeFqName() ?: continue + val clazz = classLoader.getGeneratedClass(className) + val method = clazz.getBoxMethodOrNull() ?: continue + boxMethodFound = true + callBoxMethodAndCheckResult(classLoader, clazz, method, unexpectedBehaviour = false) + return + } + } + + private fun callBoxMethodAndCheckResult( + classLoader: URLClassLoader, + clazz: Class<*>?, + method: Method, + unexpectedBehaviour: Boolean + ) { + val result = if (BOX_IN_SEPARATE_PROCESS_PORT != null) { + TODO() +// result = invokeBoxInSeparateProcess(classLoader, aClass) + } else { + val savedClassLoader = Thread.currentThread().contextClassLoader + if (savedClassLoader !== classLoader) { + // otherwise the test infrastructure used in the test may conflict with the one from the context classloader + Thread.currentThread().contextClassLoader = classLoader + } + try { + method.invoke(null) as String + } finally { + if (savedClassLoader !== classLoader) { + Thread.currentThread().contextClassLoader = savedClassLoader + } + } + } + if (unexpectedBehaviour) { + TestCase.assertNotSame("OK", result) + } else { + assertions.assertEquals("OK", result) + } + } + + private fun createClassLoader(module: TestModule, classFileFactory: ClassFileFactory): GeneratedClassLoader { + val configuration = testServices.compilerConfigurationProvider.getCompilerConfiguration(module) + val urls = configuration.jvmClasspathRoots.map { it.toURI().toURL() } + val classLoader = URLClassLoader(urls.toTypedArray()) + return GeneratedClassLoader(classFileFactory, classLoader) + } + + private fun KtFile.getFacadeFqName(): String? { + return runIf(getMemberDeclarationsToGenerate(this).isNotEmpty()) { + getFileClassInfoNoResolve(this).facadeClassFqName.asString() + } + } + + private fun ClassLoader.getGeneratedClass(className: String): Class<*> { + try { + return loadClass(className) + } catch (e: ClassNotFoundException) { + assertions.fail { "No class file was generated for: $className" } + } + } + + private fun Class<*>.getBoxMethodOrNull(): Method? { + return try { + getMethod("box") + } catch (e: NoSuchMethodException) { + return null + } + } +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/ir/IrBackendFacade.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/ir/IrBackendFacade.kt new file mode 100644 index 00000000000..3a7e7ba4e38 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/ir/IrBackendFacade.kt @@ -0,0 +1,14 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.backend.ir + +import org.jetbrains.kotlin.test.model.* +import org.jetbrains.kotlin.test.services.TestServices + +abstract class IrBackendFacade>( + testServices: TestServices, + binaryKind: BinaryKind +) : BackendFacade(testServices, BackendKinds.IrBackend, binaryKind) diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/ir/IrBackendInput.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/ir/IrBackendInput.kt new file mode 100644 index 00000000000..16fb993d6af --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/ir/IrBackendInput.kt @@ -0,0 +1,32 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.backend.ir + +import org.jetbrains.kotlin.backend.common.phaser.PhaseConfig +import org.jetbrains.kotlin.backend.jvm.JvmGeneratorExtensions +import org.jetbrains.kotlin.backend.jvm.MetadataSerializerFactory +import org.jetbrains.kotlin.codegen.state.GenerationState +import org.jetbrains.kotlin.ir.declarations.IrModuleFragment +import org.jetbrains.kotlin.ir.linkage.IrProvider +import org.jetbrains.kotlin.ir.util.SymbolTable +import org.jetbrains.kotlin.psi2ir.PsiSourceManager +import org.jetbrains.kotlin.test.model.BackendKinds +import org.jetbrains.kotlin.test.model.ResultingArtifact + +// IR backend (JVM, JS, Native) +data class IrBackendInput( + val state: GenerationState, + val irModuleFragment: IrModuleFragment, + val symbolTable: SymbolTable, + val sourceManager: PsiSourceManager, + val phaseConfig: PhaseConfig, + val irProviders: List, + val extensions: JvmGeneratorExtensions, + val serializerFactory: MetadataSerializerFactory +) : ResultingArtifact.BackendInput() { + override val kind: BackendKinds.IrBackend + get() = BackendKinds.IrBackend +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/ir/JvmIrBackendFacade.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/ir/JvmIrBackendFacade.kt new file mode 100644 index 00000000000..600646290a5 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/ir/JvmIrBackendFacade.kt @@ -0,0 +1,36 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.backend.ir + +import org.jetbrains.kotlin.backend.jvm.JvmIrCodegenFactory +import org.jetbrains.kotlin.test.model.* +import org.jetbrains.kotlin.test.services.TestServices + +class JvmIrBackendFacade( + testServices: TestServices +) : IrBackendFacade(testServices, ArtifactKinds.Jvm) { + override fun transform( + module: TestModule, + inputArtifact: IrBackendInput + ): BinaryArtifacts.Jvm { + val (state, irModuleFragment, symbolTable, sourceManager, phaseConfig, irProviders, extensions, serializerFactory) = inputArtifact + + val codegenFactory = state.codegenFactory as JvmIrCodegenFactory + codegenFactory.doGenerateFilesInternal( + state, + irModuleFragment, + symbolTable, + sourceManager, + phaseConfig, + irProviders, + extensions, + serializerFactory + ) + state.factory.done() + + return BinaryArtifacts.Jvm(state.factory) + } +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/builders/DefaultsProviderBuilder.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/builders/DefaultsProviderBuilder.kt new file mode 100644 index 00000000000..e46324d3713 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/builders/DefaultsProviderBuilder.kt @@ -0,0 +1,51 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.builders + +import org.jetbrains.kotlin.config.ApiVersion +import org.jetbrains.kotlin.config.LanguageVersion +import org.jetbrains.kotlin.config.LanguageVersionSettings +import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl +import org.jetbrains.kotlin.fir.PrivateForInline +import org.jetbrains.kotlin.platform.TargetPlatform +import org.jetbrains.kotlin.test.services.DefaultsDsl +import org.jetbrains.kotlin.test.services.DefaultsProvider +import org.jetbrains.kotlin.test.model.BackendKind +import org.jetbrains.kotlin.test.model.DependencyKind +import org.jetbrains.kotlin.test.model.FrontendKind + +@DefaultsDsl +class DefaultsProviderBuilder { + lateinit var backend: BackendKind<*> + lateinit var frontend: FrontendKind<*> + lateinit var targetPlatform: TargetPlatform + lateinit var dependencyKind: DependencyKind + + @PrivateForInline + var languageVersionSettings: LanguageVersionSettings? = null + + @PrivateForInline + var languageVersionSettingsBuilder: LanguageVersionSettingsBuilder? = null + + @OptIn(PrivateForInline::class) + inline fun languageSettings(init: LanguageVersionSettingsBuilder.() -> Unit) { + languageVersionSettings = LanguageVersionSettingsBuilder().apply(init).also { + languageVersionSettingsBuilder = it + }.build() + } + + @OptIn(PrivateForInline::class) + fun build(): DefaultsProvider { + return DefaultsProvider( + backend, + frontend, + languageVersionSettings ?: LanguageVersionSettingsImpl(LanguageVersion.LATEST_STABLE, ApiVersion.LATEST_STABLE), + languageVersionSettingsBuilder ?: LanguageVersionSettingsBuilder(), + targetPlatform, + dependencyKind + ) + } +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/builders/RegisteredDirectivesBuilder.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/builders/RegisteredDirectivesBuilder.kt new file mode 100644 index 00000000000..d40373422f9 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/builders/RegisteredDirectivesBuilder.kt @@ -0,0 +1,45 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.builders + +import org.jetbrains.kotlin.test.directives.model.* + +class RegisteredDirectivesBuilder { + private val simpleDirectives: MutableList = mutableListOf() + private val stringDirectives: MutableMap> = mutableMapOf() + private val valueDirectives: MutableMap, List> = mutableMapOf() + + operator fun SimpleDirective.unaryPlus() { + simpleDirectives += this + } + + infix fun StringDirective.with(value: String) { + with(listOf(value)) + } + + infix fun StringDirective.with(values: List) { + stringDirectives.putWithExistsCheck(this, values) + } + + infix fun ValueDirective.with(value: T) { + with(listOf(value)) + } + + infix fun ValueDirective.with(values: List) { + valueDirectives.putWithExistsCheck(this, values) + } + + private fun MutableMap.putWithExistsCheck(key: K, value: V) { + val alreadyRegistered = put(key, value) + if (alreadyRegistered != null) { + error("Default values for $key directive already registered") + } + } + + fun build(): RegisteredDirectives { + return RegisteredDirectivesImpl(simpleDirectives, stringDirectives, valueDirectives) + } +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/builders/TestConfigurationBuilder.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/builders/TestConfigurationBuilder.kt new file mode 100644 index 00000000000..3f407a61efc --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/builders/TestConfigurationBuilder.kt @@ -0,0 +1,150 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.builders + +import org.jetbrains.kotlin.test.TestConfiguration +import org.jetbrains.kotlin.test.directives.model.DirectivesContainer +import org.jetbrains.kotlin.test.impl.TestConfigurationImpl +import org.jetbrains.kotlin.test.model.* +import org.jetbrains.kotlin.test.services.* + +typealias Constructor = (TestServices) -> T + +@DefaultsDsl +class TestConfigurationBuilder { + val defaultsProviderBuilder: DefaultsProviderBuilder = DefaultsProviderBuilder() + lateinit var assertions: Assertions + + private val facades: MutableList>> = mutableListOf() + + private val handlers: MutableList>> = mutableListOf() + + private val sourcePreprocessors: MutableList> = mutableListOf() + private val additionalMetaInfoProcessors: MutableList> = mutableListOf() + private val environmentConfigurators: MutableList> = mutableListOf() + + private val additionalSourceProviders: MutableList> = mutableListOf() + + private val metaTestConfigurators: MutableList> = mutableListOf() + private val afterAnalysisCheckers: MutableList> = mutableListOf() + + private var metaInfoHandlerEnabled: Boolean = false + + private val directives: MutableList = mutableListOf() + val defaultRegisteredDirectivesBuilder: RegisteredDirectivesBuilder = RegisteredDirectivesBuilder() + + private val configurationsByTestDataCondition: MutableList Unit>> = mutableListOf() + + fun forTestsMatching(pattern: String, configuration: TestConfigurationBuilder.() -> Unit) { + val regex = pattern.toMatchingRegexString().toRegex() + forTestsMatching(regex, configuration) + } + + infix fun String.or(other: String): String { + return """$this|$other""" + } + + private fun String.toMatchingRegexString(): String = """^${replace("*", ".*")}$""" + + fun forTestsMatching(pattern: Regex, configuration: TestConfigurationBuilder.() -> Unit) { + configurationsByTestDataCondition += pattern to configuration + } + + inline fun globalDefaults(init: DefaultsProviderBuilder.() -> Unit) { + defaultsProviderBuilder.apply(init) + } + + fun unregisterAllFacades() { + facades.clear() + } + + fun useFrontendFacades(vararg constructor: Constructor>) { + facades += constructor + } + + fun useBackendFacades(vararg constructor: Constructor>) { + facades += constructor + } + + fun useFrontend2BackendConverters(vararg constructor: Constructor>) { + facades += constructor + } + + fun useFrontendHandlers(vararg constructor: Constructor>) { + handlers += constructor + } + + fun useBackendHandlers(vararg constructor: Constructor>) { + handlers += constructor + } + + fun useArtifactsHandlers(vararg constructor: Constructor>) { + handlers += constructor + } + + fun useSourcePreprocessor(vararg preprocessors: Constructor) { + sourcePreprocessors += preprocessors + } + + fun useDirectives(vararg directives: DirectivesContainer) { + this.directives += directives + } + + fun useConfigurators(vararg environmentConfigurators: Constructor) { + this.environmentConfigurators += environmentConfigurators + } + + fun useMetaInfoProcessors(vararg updaters: Constructor) { + additionalMetaInfoProcessors += updaters + } + + fun useAdditionalSourceProviders(vararg providers: Constructor) { + additionalSourceProviders += providers + } + + fun useMetaTestConfigurators(vararg configurators: Constructor) { + metaTestConfigurators += configurators + } + + fun useAfterAnalysisCheckers(vararg checkers: Constructor) { + afterAnalysisCheckers += checkers + } + + inline fun defaultDirectives(init: RegisteredDirectivesBuilder.() -> Unit) { + defaultRegisteredDirectivesBuilder.apply(init) + } + + fun enableMetaInfoHandler() { + metaInfoHandlerEnabled = true + } + + fun build(testDataPath: String): TestConfiguration { + for ((regex, configuration) in configurationsByTestDataCondition) { + if (regex.matches(testDataPath)) { + this.configuration() + } + } + return TestConfigurationImpl( + defaultsProviderBuilder.build(), + assertions, + facades, + handlers, + sourcePreprocessors, + additionalMetaInfoProcessors, + environmentConfigurators, + additionalSourceProviders, + metaTestConfigurators, + afterAnalysisCheckers, + metaInfoHandlerEnabled, + directives, + defaultRegisteredDirectivesBuilder.build() + ) + } +} + +inline fun testConfiguration(testDataPath: String, init: TestConfigurationBuilder.() -> Unit): TestConfiguration { + return TestConfigurationBuilder().apply(init).build(testDataPath) +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/builders/TestConfigurationDslMarker.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/builders/TestConfigurationDslMarker.kt new file mode 100644 index 00000000000..7e6d523755a --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/builders/TestConfigurationDslMarker.kt @@ -0,0 +1,9 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.builders + +@DslMarker +annotation class TestConfigurationDslMarker() diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/builders/TestPathMatcher.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/builders/TestPathMatcher.kt new file mode 100644 index 00000000000..c9d4830ed09 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/builders/TestPathMatcher.kt @@ -0,0 +1,7 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.builders + diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/builders/TestRunnerBuilder.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/builders/TestRunnerBuilder.kt new file mode 100644 index 00000000000..dc74149064e --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/builders/TestRunnerBuilder.kt @@ -0,0 +1,12 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.builders + +import org.jetbrains.kotlin.test.TestRunner + +inline fun testRunner(testDataPath: String, crossinline init: TestConfigurationBuilder.() -> Unit): TestRunner { + return TestRunner(testConfiguration(testDataPath, init)) +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/directives/AdditionalFilesDirectives.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/directives/AdditionalFilesDirectives.kt new file mode 100644 index 00000000000..f28059996ef --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/directives/AdditionalFilesDirectives.kt @@ -0,0 +1,40 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.directives + +import org.jetbrains.kotlin.test.directives.model.SimpleDirectivesContainer + +object AdditionalFilesDirectives : SimpleDirectivesContainer() { + val CHECK_TYPE by directive( + description = """ + Adds util functions for type checking + See file ./compiler/testData/diagnostics/helpers/types/checkType.kt + """.trimIndent() + ) + + val WITH_COROUTINES by directive( + description = """ + Adds util functions for checking coroutines + See file ./compiler/testData/diagnostics/helpers/coroutines/CoroutineHelpers.kt + """.trimIndent() + ) + + val CHECK_STATE_MACHINE by directive( + description = """ + Adds util functions for checking state machines + May be enabled only with $WITH_COROUTINES directive + See file ./compiler/testData/diagnostics/helpers/coroutines/StateMachineChecker.kt + """.trimIndent() + ) + + val CHECK_TAIL_CALL_OPTIMIZATION by directive( + description = """ + Adds util functions for checking tail call optimizations + May be enabled only with $WITH_COROUTINES directive + See file ./compiler/testData/diagnostics/helpers/coroutines/TailCallOptimizationChecker.kt + """.trimIndent() + ) +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/directives/CodegenTestDirectives.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/directives/CodegenTestDirectives.kt new file mode 100644 index 00000000000..4748194f642 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/directives/CodegenTestDirectives.kt @@ -0,0 +1,15 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.directives + +import org.jetbrains.kotlin.test.TargetBackend +import org.jetbrains.kotlin.test.directives.model.SimpleDirectivesContainer + +object CodegenTestDirectives : SimpleDirectivesContainer() { + val IGNORE_BACKEND by enumDirective( + description = "Ignore failures of test on target backend" + ) +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/directives/DiagnosticsDirectives.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/directives/DiagnosticsDirectives.kt new file mode 100644 index 00000000000..983511bbde4 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/directives/DiagnosticsDirectives.kt @@ -0,0 +1,49 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.directives + +import org.jetbrains.kotlin.test.directives.JvmEnvironmentConfigurationDirectives.USE_JAVAC +import org.jetbrains.kotlin.test.directives.model.SimpleDirectivesContainer + +object DiagnosticsDirectives : SimpleDirectivesContainer() { + val WITH_NEW_INFERENCE by directive( + description = "Enables rendering different diagnostics for old and new inference" + ) + + val DIAGNOSTICS by stringDirective( + description = """ + Enables or disables rendering of specific diagnostics. + Syntax: + Must be '[+-]DIAGNOSTIC_FACTORY_NAME' + where '+' means 'include' + '-' means 'exclude' + '+' May be used in case if some diagnostic was disabled by default in test runner + and it should be enabled in specific test + """.trimIndent() + ) + + val SKIP_TXT by directive( + description = "Disables handler which dumps declarations to testName.txt" + ) + + val NI_EXPECTED_FILE by directive( + description = "Create separate .ni.txt file for declarations dump with new inference enabled" + ) + + val SKIP_JAVAC by directive( + description = "Skip this test if $USE_JAVAC enabled" + ) + + val JAVAC_EXPECTED_FILE by directive( + description = "Dump descriptors to .javac.txt file if $USE_JAVAC enabled" + ) + + val MARK_DYNAMIC_CALLS by directive( + description = """ + Render debug info about dynamic calls + """.trimIndent() + ) +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/directives/FirDiagnosticsDirectives.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/directives/FirDiagnosticsDirectives.kt new file mode 100644 index 00000000000..609cf5ba2a9 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/directives/FirDiagnosticsDirectives.kt @@ -0,0 +1,27 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.directives + +import org.jetbrains.kotlin.test.directives.model.SimpleDirectivesContainer + +object FirDiagnosticsDirectives : SimpleDirectivesContainer() { + val DUMP_CFG by directive( + description = """ + Dumps control flow graphs of all declarations to `testName.dot` file + This directive may be applied only to all modules + """.trimIndent() + ) + + val FIR_DUMP by directive( + description = """ + Dumps resulting fir to `testName.fir` file + """.trimIndent() + ) + + val FIR_IDENTICAL by directive( + description = "Contents of fir test data file and FE 1.0 are identical" + ) +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/directives/JsEnvironmentConfigurationDirectives.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/directives/JsEnvironmentConfigurationDirectives.kt new file mode 100644 index 00000000000..728505eac6d --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/directives/JsEnvironmentConfigurationDirectives.kt @@ -0,0 +1,13 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.directives + +import org.jetbrains.kotlin.serialization.js.ModuleKind +import org.jetbrains.kotlin.test.directives.model.SimpleDirectivesContainer + +object JsEnvironmentConfigurationDirectives : SimpleDirectivesContainer() { + val MODULE_KIND by enumDirective("Specifies kind of js module") +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/directives/JvmEnvironmentConfigurationDirectives.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/directives/JvmEnvironmentConfigurationDirectives.kt new file mode 100644 index 00000000000..a32f9dbb48a --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/directives/JvmEnvironmentConfigurationDirectives.kt @@ -0,0 +1,36 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.directives + +import org.jetbrains.kotlin.config.JvmTarget +import org.jetbrains.kotlin.test.TestJdkKind +import org.jetbrains.kotlin.test.directives.model.SimpleDirectivesContainer + +object JvmEnvironmentConfigurationDirectives : SimpleDirectivesContainer() { + val JVM_TARGET by enumDirective( + description = "Target bytecode version", + additionalParser = JvmTarget.Companion::fromString + ) + + val JDK_KIND by enumDirective("JDK used in tests") + val FULL_JDK by directive("Add full java standard library to classpath") + val STDLIB_JDK8 by directive("Add Java 8 stdlib to classpath") + + val WITH_RUNTIME by directive( + description = """ + Add Kotlin stdlib to classpath + This directive is deprecated, use WITH_STDLIB instead + """.trimIndent() + ) + val WITH_STDLIB by directive("Add Kotlin runtime to classpath") + val WITH_REFLECT by directive("Add Kotlin reflect to classpath") + val NO_RUNTIME by directive("Don't add any runtime libs to classpath") + + val ANDROID_ANNOTATIONS by directive("Add android annotations to classpath") + + val USE_PSI_CLASS_FILES_READING by directive("Use a slower (PSI-based) class files reading implementation") + val USE_JAVAC by directive("Enable javac integration") +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/ClassicFrontend2ClassicBackendConverter.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/ClassicFrontend2ClassicBackendConverter.kt new file mode 100644 index 00000000000..b7a3df856c1 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/ClassicFrontend2ClassicBackendConverter.kt @@ -0,0 +1,32 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.frontend.classic + +import org.jetbrains.kotlin.test.backend.classic.ClassicBackendInput +import org.jetbrains.kotlin.test.services.TestServices +import org.jetbrains.kotlin.test.model.* + +class ClassicFrontend2ClassicBackendConverter( + testServices: TestServices +) : Frontend2BackendConverter( + testServices, + FrontendKinds.ClassicFrontend, + BackendKinds.ClassicBackend +) { + override fun transform( + module: TestModule, + inputArtifact: ClassicFrontendOutputArtifact + ): ClassicBackendInput { + val (psiFiles, analysisResults, project, languageVersionSettings) = inputArtifact + return ClassicBackendInput( + psiFiles.values, + analysisResults.bindingContext, + analysisResults.moduleDescriptor, + project, + languageVersionSettings + ) + } +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/ClassicFrontend2IrConverter.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/ClassicFrontend2IrConverter.kt new file mode 100644 index 00000000000..420fffd775e --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/ClassicFrontend2IrConverter.kt @@ -0,0 +1,158 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.frontend.classic + +import org.jetbrains.kotlin.backend.common.extensions.IrGenerationExtension +import org.jetbrains.kotlin.backend.common.extensions.IrPluginContextImpl +import org.jetbrains.kotlin.backend.common.ir.BuiltinSymbolsBase +import org.jetbrains.kotlin.backend.common.phaser.PhaseConfig +import org.jetbrains.kotlin.backend.jvm.JvmGeneratorExtensions +import org.jetbrains.kotlin.backend.jvm.JvmIrCodegenFactory +import org.jetbrains.kotlin.backend.jvm.JvmNameProvider +import org.jetbrains.kotlin.backend.jvm.codegen.DescriptorMetadataSerializer +import org.jetbrains.kotlin.backend.jvm.jvmPhases +import org.jetbrains.kotlin.backend.jvm.serialization.JvmIdSignatureDescriptor +import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys +import org.jetbrains.kotlin.codegen.ClassBuilderFactories +import org.jetbrains.kotlin.codegen.state.GenerationState +import org.jetbrains.kotlin.descriptors.ModuleDescriptor +import org.jetbrains.kotlin.descriptors.konan.DeserializedKlibModuleOrigin +import org.jetbrains.kotlin.descriptors.konan.KlibModuleOrigin +import org.jetbrains.kotlin.idea.MainFunctionDetector +import org.jetbrains.kotlin.ir.backend.jvm.serialization.EmptyLoggingContext +import org.jetbrains.kotlin.ir.backend.jvm.serialization.JvmIrLinker +import org.jetbrains.kotlin.ir.backend.jvm.serialization.JvmManglerDesc +import org.jetbrains.kotlin.ir.builders.TranslationPluginContext +import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl +import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns +import org.jetbrains.kotlin.ir.descriptors.IrFunctionFactory +import org.jetbrains.kotlin.ir.util.DeclarationStubGenerator +import org.jetbrains.kotlin.ir.util.ReferenceSymbolTable +import org.jetbrains.kotlin.ir.util.SymbolTable +import org.jetbrains.kotlin.ir.util.TypeTranslator +import org.jetbrains.kotlin.psi2ir.Psi2IrConfiguration +import org.jetbrains.kotlin.psi2ir.Psi2IrTranslator +import org.jetbrains.kotlin.resolve.BindingContext +import org.jetbrains.kotlin.test.backend.ir.IrBackendInput +import org.jetbrains.kotlin.test.model.BackendKinds +import org.jetbrains.kotlin.test.model.Frontend2BackendConverter +import org.jetbrains.kotlin.test.model.FrontendKinds +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.TestServices +import org.jetbrains.kotlin.test.services.compilerConfigurationProvider + +class ClassicFrontend2IrConverter( + testServices: TestServices +) : Frontend2BackendConverter( + testServices, + FrontendKinds.ClassicFrontend, + BackendKinds.IrBackend +) { + override fun transform( + module: TestModule, + inputArtifact: ClassicFrontendOutputArtifact + ): IrBackendInput { + val (psiFiles, analysisResult, project, languageVersionSettings) = inputArtifact + + val configuration = testServices.compilerConfigurationProvider.getCompilerConfiguration(module) + + val files = psiFiles.values.toList() + val phaseConfig = configuration.get(CLIConfigurationKeys.PHASE_CONFIG) ?: PhaseConfig(jvmPhases) + val state = GenerationState.Builder( + project, ClassBuilderFactories.TEST, analysisResult.moduleDescriptor, analysisResult.bindingContext, + files, configuration + ).codegenFactory( + JvmIrCodegenFactory(phaseConfig) + ).isIrBackend(true).build() + + val extensions = JvmGeneratorExtensions() + val mangler = JvmManglerDesc(MainFunctionDetector(state.bindingContext, state.languageVersionSettings)) + val psi2ir = Psi2IrTranslator(state.languageVersionSettings, Psi2IrConfiguration()) + val symbolTable = SymbolTable(JvmIdSignatureDescriptor(mangler), IrFactoryImpl, JvmNameProvider) + val psi2irContext = psi2ir.createGeneratorContext(state.module, state.bindingContext, symbolTable, extensions) + val pluginExtensions = IrGenerationExtension.getInstances(state.project) + val functionFactory = IrFunctionFactory(psi2irContext.irBuiltIns, symbolTable) + psi2irContext.irBuiltIns.functionFactory = functionFactory + + val stubGenerator = DeclarationStubGenerator( + psi2irContext.moduleDescriptor, symbolTable, psi2irContext.irBuiltIns.languageVersionSettings, extensions + ) + val frontEndContext = object : TranslationPluginContext { + override val moduleDescriptor: ModuleDescriptor + get() = psi2irContext.moduleDescriptor + override val bindingContext: BindingContext + get() = psi2irContext.bindingContext + override val symbolTable: ReferenceSymbolTable + get() = symbolTable + override val typeTranslator: TypeTranslator + get() = psi2irContext.typeTranslator + override val irBuiltIns: IrBuiltIns + get() = psi2irContext.irBuiltIns + } + val irLinker = JvmIrLinker( + psi2irContext.moduleDescriptor, + EmptyLoggingContext, + psi2irContext.irBuiltIns, + symbolTable, + functionFactory, + frontEndContext, + stubGenerator, + mangler + ) + + val pluginContext by lazy { + psi2irContext.run { + val symbols = BuiltinSymbolsBase(irBuiltIns, moduleDescriptor.builtIns, symbolTable.lazyWrapper) + IrPluginContextImpl( + moduleDescriptor, bindingContext, languageVersionSettings, symbolTable, typeTranslator, irBuiltIns, irLinker, symbols + ) + } + } + + for (extension in pluginExtensions) { + psi2ir.addPostprocessingStep { moduleFragment -> + val old = stubGenerator.unboundSymbolGeneration + try { + stubGenerator.unboundSymbolGeneration = true + extension.generate(moduleFragment, pluginContext) + } finally { + stubGenerator.unboundSymbolGeneration = old + } + } + } + + val dependencies = psi2irContext.moduleDescriptor.allDependencyModules.map { + val kotlinLibrary = (it.getCapability(KlibModuleOrigin.CAPABILITY) as? DeserializedKlibModuleOrigin)?.library + irLinker.deserializeIrModuleHeader(it, kotlinLibrary) + } + val irProviders = listOf(irLinker) + + val irModuleFragment = psi2ir.generateModuleFragment( + psi2irContext, + files, + irProviders, + pluginExtensions, + expectDescriptorToSymbol = null + ) + irLinker.postProcess() + + stubGenerator.unboundSymbolGeneration = true + + // We need to compile all files we reference in Klibs + irModuleFragment.files.addAll(dependencies.flatMap { it.files }) + + return IrBackendInput( + state, + irModuleFragment, + symbolTable, + psi2irContext.sourceManager, + phaseConfig, + irProviders, + extensions, + ::DescriptorMetadataSerializer + ) + } +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/ClassicFrontendFacade.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/ClassicFrontendFacade.kt new file mode 100644 index 00000000000..a15d042fdeb --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/ClassicFrontendFacade.kt @@ -0,0 +1,263 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.frontend.classic + +import com.intellij.openapi.project.Project +import com.intellij.psi.search.GlobalSearchScope +import org.jetbrains.kotlin.analyzer.AnalysisResult +import org.jetbrains.kotlin.analyzer.common.CommonResolverForModuleFactory +import org.jetbrains.kotlin.builtins.jvm.JvmBuiltIns +import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackagePartProvider +import org.jetbrains.kotlin.cli.jvm.compiler.NoScopeRecordCliBindingTrace +import org.jetbrains.kotlin.cli.jvm.compiler.TopDownAnalyzerFacadeForJVM +import org.jetbrains.kotlin.config.CompilerConfiguration +import org.jetbrains.kotlin.config.JVMConfigurationKeys +import org.jetbrains.kotlin.config.JVMConfigurationKeys.JVM_TARGET +import org.jetbrains.kotlin.config.JvmTarget +import org.jetbrains.kotlin.config.LanguageVersionSettings +import org.jetbrains.kotlin.container.get +import org.jetbrains.kotlin.context.ProjectContext +import org.jetbrains.kotlin.context.withModule +import org.jetbrains.kotlin.descriptors.impl.CompositePackageFragmentProvider +import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl +import org.jetbrains.kotlin.frontend.java.di.createContainerForLazyResolveWithJava +import org.jetbrains.kotlin.frontend.java.di.initJvmBuiltInsForTopDownAnalysis +import org.jetbrains.kotlin.incremental.components.ExpectActualTracker +import org.jetbrains.kotlin.incremental.components.LookupTracker +import org.jetbrains.kotlin.js.analyze.TopDownAnalyzerFacadeForJS +import org.jetbrains.kotlin.js.config.JsConfig +import org.jetbrains.kotlin.load.java.lazy.SingleModuleClassResolver +import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.platform.isCommon +import org.jetbrains.kotlin.platform.js.isJs +import org.jetbrains.kotlin.platform.jvm.JvmPlatforms +import org.jetbrains.kotlin.platform.jvm.isJvm +import org.jetbrains.kotlin.platform.konan.isNative +import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.resolve.CompilerEnvironment +import org.jetbrains.kotlin.resolve.LazyTopDownAnalyzer +import org.jetbrains.kotlin.resolve.TopDownAnalysisMode +import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver +import org.jetbrains.kotlin.resolve.lazy.KotlinCodeAnalyzer +import org.jetbrains.kotlin.resolve.lazy.declarations.FileBasedDeclarationProviderFactory +import org.jetbrains.kotlin.serialization.deserialization.MetadataPartProvider +import org.jetbrains.kotlin.test.directives.JvmEnvironmentConfigurationDirectives +import org.jetbrains.kotlin.test.model.DependencyKind +import org.jetbrains.kotlin.test.model.FrontendFacade +import org.jetbrains.kotlin.test.model.FrontendKinds +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.* +import org.jetbrains.kotlin.test.util.KtTestUtil +import org.jetbrains.kotlin.utils.addToStdlib.runIf +import java.io.File + +class ClassicFrontendFacade( + testServices: TestServices +) : FrontendFacade(testServices, FrontendKinds.ClassicFrontend) { + override val additionalServices: List + get() = listOf(service(::ModuleDescriptorProvider)) + + override fun analyze(module: TestModule): ClassicFrontendOutputArtifact { + val dependencyProvider = testServices.dependencyProvider + val moduleDescriptorProvider = testServices.moduleDescriptorProvider + val compilerConfigurationProvider = testServices.compilerConfigurationProvider + val packagePartProviderFactory = compilerConfigurationProvider.getPackagePartProviderFactory(module) + val project = compilerConfigurationProvider.getProject(module) + val configuration = compilerConfigurationProvider.getCompilerConfiguration(module) + + val ktFilesMap = testServices.sourceFileProvider.getKtFilesForSourceFiles(module.files, project).toMutableMap() + val languageVersionSettings = module.languageVersionSettings + + val sourceDependencies = module.dependencies.filter { it.kind == DependencyKind.Source } + val dependentDescriptors = sourceDependencies.map { + val testModule = dependencyProvider.getTestModule(it.moduleName) + moduleDescriptorProvider.getModuleDescriptor(testModule) + } + + var hasCommonModules = false + sourceDependencies.forEach { + val dependencyModule = dependencyProvider.getTestModule(it.moduleName) + if (dependencyModule.targetPlatform.isCommon()) { + val artifact = dependencyProvider.getArtifact(dependencyModule, FrontendKinds.ClassicFrontend) + /* + * We need create KtFiles again with new project because otherwise we can access to some caches using + * old project as key which may leads to missing services in core environment + */ + ktFilesMap.putAll(testServices.sourceFileProvider.getKtFilesForSourceFiles(artifact.allKtFiles.keys, project)) + hasCommonModules = true + } + } + + val ktFiles = ktFilesMap.values.toList() + setupJavacIfNeeded(module, ktFiles, configuration) + val analysisResult = performResolve( + module, + project, + configuration, + packagePartProviderFactory, + ktFiles, + languageVersionSettings, + dependentDescriptors, + hasCommonModules + ) + moduleDescriptorProvider.replaceModuleDescriptorForModule(module, analysisResult.moduleDescriptor) + return ClassicFrontendOutputArtifact( + ktFilesMap, + analysisResult, + project, + languageVersionSettings + ) + } + + private fun setupJavacIfNeeded( + module: TestModule, + ktFiles: List, + configuration: CompilerConfiguration + ) { + if (JvmEnvironmentConfigurationDirectives.USE_JAVAC !in module.directives) return + val mockJdk = runIf(JvmEnvironmentConfigurationDirectives.FULL_JDK !in module.directives) { + File(KtTestUtil.getHomeDirectory(), "compiler/testData/mockJDK/jre/lib/rt.jar") + } + testServices.compilerConfigurationProvider.registerJavacForModule(module, ktFiles, mockJdk) + configuration.put(JVMConfigurationKeys.USE_JAVAC, true) + } + + private fun performResolve( + module: TestModule, + project: Project, + configuration: CompilerConfiguration, + packagePartProviderFactory: (GlobalSearchScope) -> JvmPackagePartProvider, + files: List, + languageVersionSettings: LanguageVersionSettings, + dependentDescriptors: List, + hasCommonModules: Boolean + ): AnalysisResult { + val targetPlatform = module.targetPlatform + return when { + targetPlatform.isJvm() -> performJvmModuleResolve( + module, + project, + configuration, + packagePartProviderFactory, + files, + dependentDescriptors, + hasCommonModules + ) + targetPlatform.isJs() -> performJsModuleResolve(project, configuration, files, dependentDescriptors) + targetPlatform.isNative() -> TODO() + targetPlatform.isCommon() -> performCommonModuleResolve(module, files, languageVersionSettings) + else -> error("Should not be here") + } + } + + @OptIn(ExperimentalStdlibApi::class) + private fun performJvmModuleResolve( + module: TestModule, + project: Project, + configuration: CompilerConfiguration, + packagePartProviderFactory: (GlobalSearchScope) -> JvmPackagePartProvider, + files: List, + dependentDescriptors: List, + hasCommonModules: Boolean + ): AnalysisResult { + val moduleTrace = NoScopeRecordCliBindingTrace() + if (!hasCommonModules) { + return TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration( + project, + files, + moduleTrace, + configuration.copy(), + packagePartProviderFactory, + explicitModuleDependencyList = dependentDescriptors + ) + } + + val projectContext = ProjectContext(project, "test project context") + val storageManager = projectContext.storageManager + + val builtIns = JvmBuiltIns(storageManager, JvmBuiltIns.Kind.FROM_CLASS_LOADER) + val moduleDescriptor = ModuleDescriptorImpl(Name.special("<${module.name}>"), storageManager, builtIns, module.targetPlatform) + val dependencies = buildList { + add(moduleDescriptor) + add(moduleDescriptor.builtIns.builtInsModule) + addAll(dependentDescriptors) + } + moduleDescriptor.setDependencies(dependencies) + + val moduleContentScope = GlobalSearchScope.allScope(project) + val moduleClassResolver = SingleModuleClassResolver() + val moduleContext = projectContext.withModule(moduleDescriptor) + val jvmTarget = configuration[JVM_TARGET] ?: JvmTarget.DEFAULT + val container = createContainerForLazyResolveWithJava( + JvmPlatforms.jvmPlatformByTargetVersion(jvmTarget), // TODO(dsavvinov): do not pass JvmTarget around + moduleContext, + moduleTrace, + FileBasedDeclarationProviderFactory(moduleContext.storageManager, files), + moduleContentScope, + moduleClassResolver, + CompilerEnvironment, LookupTracker.DO_NOTHING, + ExpectActualTracker.DoNothing, + packagePartProviderFactory(moduleContentScope), + module.languageVersionSettings, + useBuiltInsProvider = true + ) + + container.initJvmBuiltInsForTopDownAnalysis() + moduleClassResolver.resolver = container.get() + + moduleDescriptor.initialize( + CompositePackageFragmentProvider( + listOf( + container.get().packageFragmentProvider, + container.get().packageFragmentProvider + ) + ) + ) + + container.get().analyzeDeclarations(TopDownAnalysisMode.TopLevelDeclarations, files) + + return AnalysisResult.success(moduleTrace.bindingContext, moduleDescriptor) + } + + @OptIn(ExperimentalStdlibApi::class) + private fun performJsModuleResolve( + project: Project, + configuration: CompilerConfiguration, + files: List, + dependentDescriptors: List + ): AnalysisResult { + val jsConfig = JsConfig(project, configuration) + val dependentDescriptorsIncludingLibraries = buildList { + addAll(dependentDescriptors) + addAll(jsConfig.moduleDescriptors) + } + return TopDownAnalyzerFacadeForJS.analyzeFiles( + files, + project, + configuration, + moduleDescriptors = dependentDescriptorsIncludingLibraries, + friendModuleDescriptors = emptyList() + ) + } + + private fun performCommonModuleResolve( + module: TestModule, + files: List, + languageVersionSettings: LanguageVersionSettings, + ): AnalysisResult { + return CommonResolverForModuleFactory.analyzeFiles( + files, + Name.special("<${module.name}>"), + dependOnBuiltIns = true, + languageVersionSettings, + module.targetPlatform, + // TODO: add dependency manager + ) { _ -> + // TODO + MetadataPartProvider.Empty + } + } +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/ClassicFrontendOutputArtifact.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/ClassicFrontendOutputArtifact.kt new file mode 100644 index 00000000000..e30b84b8923 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/ClassicFrontendOutputArtifact.kt @@ -0,0 +1,26 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.frontend.classic + +import com.intellij.openapi.project.Project +import org.jetbrains.kotlin.analyzer.AnalysisResult +import org.jetbrains.kotlin.config.LanguageVersionSettings +import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.test.model.FrontendKinds +import org.jetbrains.kotlin.test.model.ResultingArtifact +import org.jetbrains.kotlin.test.model.TestFile + +data class ClassicFrontendOutputArtifact( + val allKtFiles: Map, + val analysisResult: AnalysisResult, + val project: Project, + val languageVersionSettings: LanguageVersionSettings +) : ResultingArtifact.FrontendOutput() { + override val kind: FrontendKinds.ClassicFrontend + get() = FrontendKinds.ClassicFrontend + + val ktFiles: Map = allKtFiles.filterKeys { !it.isAdditional } +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/ModuleDescriptorProvider.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/ModuleDescriptorProvider.kt new file mode 100644 index 00000000000..57717a45165 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/ModuleDescriptorProvider.kt @@ -0,0 +1,32 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.frontend.classic + +import org.jetbrains.kotlin.descriptors.ModuleDescriptor +import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl +import org.jetbrains.kotlin.test.services.TestService +import org.jetbrains.kotlin.test.services.TestServices +import org.jetbrains.kotlin.test.services.assertions +import org.jetbrains.kotlin.test.model.TestModule + +class ModuleDescriptorProvider( + private val testServices: TestServices +) : TestService { + private val moduleDescriptorByModule = mutableMapOf() + + fun getModuleDescriptor(testModule: TestModule): ModuleDescriptorImpl { + return moduleDescriptorByModule[testModule] ?: testServices.assertions.fail { + "Module descriptor for module ${testModule.name} not found" + } + } + + fun replaceModuleDescriptorForModule(testModule: TestModule, moduleDescriptor: ModuleDescriptor) { + require(moduleDescriptor is ModuleDescriptorImpl) + moduleDescriptorByModule[testModule] = moduleDescriptor + } +} + +val TestServices.moduleDescriptorProvider: ModuleDescriptorProvider by TestServices.testServiceAccessor() diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/handlers/ClassicDiagnosticsHandler.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/handlers/ClassicDiagnosticsHandler.kt new file mode 100644 index 00000000000..de29d974388 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/handlers/ClassicDiagnosticsHandler.kt @@ -0,0 +1,253 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.frontend.classic.handlers + +import com.intellij.psi.search.GlobalSearchScope +import com.intellij.psi.util.PsiTreeUtil +import org.jetbrains.kotlin.asJava.getJvmSignatureDiagnostics +import org.jetbrains.kotlin.checkers.diagnostics.SyntaxErrorDiagnostic +import org.jetbrains.kotlin.checkers.utils.CheckerTestUtil +import org.jetbrains.kotlin.checkers.utils.DiagnosticsRenderingConfiguration +import org.jetbrains.kotlin.codeMetaInfo.model.CodeMetaInfo +import org.jetbrains.kotlin.codeMetaInfo.model.DiagnosticCodeMetaInfo +import org.jetbrains.kotlin.codeMetaInfo.model.ParsedCodeMetaInfo +import org.jetbrains.kotlin.config.JVMConfigurationKeys +import org.jetbrains.kotlin.config.LanguageFeature +import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl +import org.jetbrains.kotlin.diagnostics.Diagnostic +import org.jetbrains.kotlin.diagnostics.Errors +import org.jetbrains.kotlin.platform.isCommon +import org.jetbrains.kotlin.platform.js.isJs +import org.jetbrains.kotlin.platform.jvm.isJvm +import org.jetbrains.kotlin.platform.konan.isNative +import org.jetbrains.kotlin.psi.KtDeclaration +import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.resolve.AnalyzingUtils +import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValueFactoryImpl +import org.jetbrains.kotlin.test.directives.AdditionalFilesDirectives +import org.jetbrains.kotlin.test.directives.DiagnosticsDirectives +import org.jetbrains.kotlin.test.directives.DiagnosticsDirectives.MARK_DYNAMIC_CALLS +import org.jetbrains.kotlin.test.directives.LanguageSettingsDirectives +import org.jetbrains.kotlin.test.directives.model.DirectivesContainer +import org.jetbrains.kotlin.test.frontend.classic.ClassicFrontendOutputArtifact +import org.jetbrains.kotlin.test.model.TestFile +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.* +import java.util.* + +class ClassicDiagnosticsHandler(testServices: TestServices) : ClassicFrontendAnalysisHandler(testServices) { + override val directivesContainers: List = + listOf(DiagnosticsDirectives) + + override val additionalServices: List = + listOf(service(::DiagnosticsService)) + + private val globalMetadataInfoHandler: GlobalMetadataInfoHandler + get() = testServices.globalMetadataInfoHandler + + private val diagnosticsService: DiagnosticsService + get() = testServices.diagnosticsService + + @OptIn(ExperimentalStdlibApi::class) + override fun processModule(module: TestModule, info: ClassicFrontendOutputArtifact) { + var allDiagnostics = info.analysisResult.bindingContext.diagnostics + computeJvmSignatureDiagnostics(info) + if (AdditionalFilesDirectives.CHECK_TYPE in module.directives) { + allDiagnostics = allDiagnostics.filter { it.factory.name != Errors.UNDERSCORE_USAGE_WITHOUT_BACKTICKS.name } + } + if (LanguageSettingsDirectives.API_VERSION in module.directives) { + allDiagnostics = allDiagnostics.filter { it.factory.name != Errors.NEWER_VERSION_IN_SINCE_KOTLIN.name } + } + + val diagnosticsPerFile = allDiagnostics.groupBy { it.psiFile } + + val withNewInferenceModeEnabled = testServices.withNewInferenceModeEnabled() + + val configuration = DiagnosticsRenderingConfiguration( + platform = null, + withNewInference = info.languageVersionSettings.supportsFeature(LanguageFeature.NewInference), + languageVersionSettings = info.languageVersionSettings, + skipDebugInfoDiagnostics = testServices.compilerConfigurationProvider.getCompilerConfiguration(module) + .getBoolean(JVMConfigurationKeys.IR) + ) + + for ((file, ktFile) in info.ktFiles) { + val diagnostics = diagnosticsPerFile[ktFile] ?: emptyList() + for (diagnostic in diagnostics) { + if (!diagnostic.isValid) continue + if (!diagnosticsService.shouldRenderDiagnostic(module, diagnostic.factory.name)) continue + globalMetadataInfoHandler.addMetadataInfosForFile( + file, + diagnostic.toMetaInfo( + module, + file, + configuration.withNewInference, + withNewInferenceModeEnabled + ) + ) + } + for (errorElement in AnalyzingUtils.getSyntaxErrorRanges(ktFile)) { + globalMetadataInfoHandler.addMetadataInfosForFile( + file, + SyntaxErrorDiagnostic(errorElement).toMetaInfo( + module, + file, + configuration.withNewInference, + withNewInferenceModeEnabled + ) + ) + } + processDebugInfoDiagnostics(configuration, module, file, ktFile, info, withNewInferenceModeEnabled) + } + } + + private fun computeJvmSignatureDiagnostics(info: ClassicFrontendOutputArtifact): Set { + if (testServices.moduleStructure.modules.any { !it.targetPlatform.isJvm() }) return emptySet() + val bindingContext = info.analysisResult.bindingContext + val project = info.project + val jvmSignatureDiagnostics = HashSet() + for (ktFile in info.ktFiles.values) { + val declarations = PsiTreeUtil.findChildrenOfType(ktFile, KtDeclaration::class.java) + for (declaration in declarations) { + val diagnostics = getJvmSignatureDiagnostics( + declaration, + bindingContext.diagnostics, + GlobalSearchScope.allScope(project) + ) ?: continue + jvmSignatureDiagnostics.addAll(diagnostics.forElement(declaration)) + } + } + return jvmSignatureDiagnostics + } + + private fun Diagnostic.toMetaInfo( + module: TestModule, + file: TestFile, + newInferenceEnabled: Boolean, + withNewInferenceModeEnabled: Boolean + ): List = textRanges.map { range -> + val metaInfo = DiagnosticCodeMetaInfo(range, ClassicMetaInfoUtils.renderDiagnosticNoArgs, this) + if (withNewInferenceModeEnabled) { + metaInfo.attributes += if (newInferenceEnabled) OldNewInferenceMetaInfoProcessor.NI else OldNewInferenceMetaInfoProcessor.OI + } + if (file !in module.files) { + val targetPlatform = module.targetPlatform + metaInfo.attributes += when { + targetPlatform.isJvm() -> "JVM" + targetPlatform.isJs() -> "JS" + targetPlatform.isNative() -> "NATIVE" + targetPlatform.isCommon() -> "COMMON" + else -> error("Should not be here") + } + } + val existing = globalMetadataInfoHandler.getExistingMetaInfosForActualMetadata(file, metaInfo) + if (existing.any { it.description != null }) { + metaInfo.replaceRenderConfiguration(ClassicMetaInfoUtils.renderDiagnosticWithArgs) + } + metaInfo + } + + private fun processDebugInfoDiagnostics( + configuration: DiagnosticsRenderingConfiguration, + module: TestModule, + file: TestFile, + ktFile: KtFile, + info: ClassicFrontendOutputArtifact, + withNewInferenceModeEnabled: Boolean + ) { + val diagnosedRanges = globalMetadataInfoHandler.getExistingMetaInfosForFile(file) + .groupBy( + keySelector = { it.start..it.end }, + valueTransform = { it.tag } + ) + .mapValues { (_, it) -> it.toMutableSet() } + val debugAnnotations = CheckerTestUtil.getDebugInfoDiagnostics( + ktFile, + info.analysisResult.bindingContext, + markDynamicCalls = MARK_DYNAMIC_CALLS in module.directives, + dynamicCallDescriptors = mutableListOf(), + configuration, + dataFlowValueFactory = DataFlowValueFactoryImpl(info.languageVersionSettings), + info.analysisResult.moduleDescriptor as ModuleDescriptorImpl, + diagnosedRanges = diagnosedRanges + ) + debugAnnotations.mapNotNull { debugAnnotation -> + if (!diagnosticsService.shouldRenderDiagnostic(module, debugAnnotation.diagnostic.factory.name)) return@mapNotNull null + globalMetadataInfoHandler.addMetadataInfosForFile( + file, + debugAnnotation.diagnostic.toMetaInfo(module, file, configuration.withNewInference, withNewInferenceModeEnabled) + ) + } + } + + override fun processAfterAllModules(someAssertionWasFailed: Boolean) {} +} + +class OldNewInferenceMetaInfoProcessor(testServices: TestServices) : AdditionalMetaInfoProcessor(testServices) { + companion object { + const val OI = "OI" + const val NI = "NI" + } + + override fun processMetaInfos(module: TestModule, file: TestFile) { + /* + * Rules for OI/NI attribute: + * ┌──────────┬──────┬──────┬──────────┐ + * │ │ OI │ NI │ nothing │ <- reported + * ├──────────┼──────┼──────┼──────────┤ + * │ nothing │ both │ both │ nothing │ + * │ OI │ OI │ both │ OI │ + * │ NI │ both │ NI │ NI │ + * │ both │ both │ both │ opposite │ <- OI if NI enabled in test and vice versa + * └──────────┴──────┴──────┴──────────┘ + * ^ existed + */ + if (!testServices.withNewInferenceModeEnabled()) return + val newInferenceEnabled = module.languageVersionSettings.supportsFeature(LanguageFeature.NewInference) + val (currentFlag, otherFlag) = when (newInferenceEnabled) { + true -> NI to OI + false -> OI to NI + } + val matchedExistedInfos = mutableSetOf() + val matchedReportedInfos = mutableSetOf() + val allReportedInfos = globalMetadataInfoHandler.getReportedMetaInfosForFile(file) + for ((_, reportedInfos) in allReportedInfos.groupBy { Triple(it.start, it.end, it.tag) }) { + val existedInfos = globalMetadataInfoHandler.getExistingMetaInfosForActualMetadata(file, reportedInfos.first()) + for ((reportedInfo, existedInfo) in reportedInfos.zip(existedInfos)) { + matchedExistedInfos += existedInfo + matchedReportedInfos += reportedInfo + if (currentFlag !in reportedInfo.attributes) continue + if (currentFlag in existedInfo.attributes) continue + reportedInfo.attributes.remove(currentFlag) + } + } + + if (allReportedInfos.size != matchedReportedInfos.size) { + for (info in allReportedInfos) { + if (info !in matchedReportedInfos) { + info.attributes.remove(currentFlag) + } + } + } + + val allExistedInfos = globalMetadataInfoHandler.getExistingMetaInfosForFile(file) + if (allExistedInfos.size == matchedExistedInfos.size) return + + val newInfos = allExistedInfos.mapNotNull { + if (it in matchedExistedInfos) return@mapNotNull null + if (currentFlag in it.attributes) return@mapNotNull null + it.copy().apply { + if (otherFlag !in attributes) { + attributes += otherFlag + } + } + } + globalMetadataInfoHandler.addMetadataInfosForFile(file, newInfos) + } +} + +private fun TestServices.withNewInferenceModeEnabled(): Boolean { + return DiagnosticsDirectives.WITH_NEW_INFERENCE in moduleStructure.allDirectives +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/handlers/ClassicFrontendAnalysisHandler.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/handlers/ClassicFrontendAnalysisHandler.kt new file mode 100644 index 00000000000..3d2be8420f2 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/handlers/ClassicFrontendAnalysisHandler.kt @@ -0,0 +1,17 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.frontend.classic.handlers + +import org.jetbrains.kotlin.test.frontend.classic.ClassicFrontendOutputArtifact +import org.jetbrains.kotlin.test.model.FrontendKinds +import org.jetbrains.kotlin.test.model.FrontendOutputHandler +import org.jetbrains.kotlin.test.services.TestServices + +abstract class ClassicFrontendAnalysisHandler( + testServices: TestServices +) : FrontendOutputHandler(testServices, FrontendKinds.ClassicFrontend) + + diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/handlers/ClassicMetaInfoUtils.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/handlers/ClassicMetaInfoUtils.kt new file mode 100644 index 00000000000..0f4425dc76e --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/handlers/ClassicMetaInfoUtils.kt @@ -0,0 +1,13 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.frontend.classic.handlers + +import org.jetbrains.kotlin.codeMetaInfo.renderConfigurations.DiagnosticCodeMetaInfoRenderConfiguration + +object ClassicMetaInfoUtils { + val renderDiagnosticNoArgs = DiagnosticCodeMetaInfoRenderConfiguration().apply { renderParams = false } + val renderDiagnosticWithArgs = DiagnosticCodeMetaInfoRenderConfiguration().apply { renderParams = true } +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/handlers/DeclarationsDumpHandler.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/handlers/DeclarationsDumpHandler.kt new file mode 100644 index 00000000000..5593fe9c115 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/handlers/DeclarationsDumpHandler.kt @@ -0,0 +1,136 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.frontend.classic.handlers + +import org.jetbrains.kotlin.config.LanguageFeature +import org.jetbrains.kotlin.descriptors.DeclarationDescriptor +import org.jetbrains.kotlin.descriptors.ModuleDescriptor +import org.jetbrains.kotlin.descriptors.PackageViewDescriptor +import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.name.SpecialNames +import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.resolve.DescriptorUtils +import org.jetbrains.kotlin.test.directives.AdditionalFilesDirectives +import org.jetbrains.kotlin.test.directives.DiagnosticsDirectives +import org.jetbrains.kotlin.test.directives.JvmEnvironmentConfigurationDirectives +import org.jetbrains.kotlin.test.directives.model.DirectivesContainer +import org.jetbrains.kotlin.test.frontend.classic.ClassicFrontendOutputArtifact +import org.jetbrains.kotlin.test.model.TestFile +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.TestServices +import org.jetbrains.kotlin.test.services.isJavaFile +import org.jetbrains.kotlin.test.services.moduleStructure +import org.jetbrains.kotlin.test.util.DescriptorValidator +import org.jetbrains.kotlin.test.util.RecursiveDescriptorComparator +import org.jetbrains.kotlin.test.util.RecursiveDescriptorComparator.RECURSIVE +import org.jetbrains.kotlin.test.utils.MultiModuleInfoDumper +import org.jetbrains.kotlin.test.utils.MultiModuleInfoDumperImpl +import org.jetbrains.kotlin.utils.keysToMap +import java.util.function.Predicate +import java.util.regex.Pattern + +class DeclarationsDumpHandler( + testServices: TestServices +) : ClassicFrontendAnalysisHandler(testServices) { + companion object { + private val NAMES_OF_CHECK_TYPE_HELPER = listOf("checkSubtype", "CheckTypeInv", "_", "checkType").map { Name.identifier(it) } + + private val JAVA_PACKAGE_PATTERN = Pattern.compile("^\\s*package [.\\w\\d]*", Pattern.MULTILINE) + } + + override val directivesContainers: List + get() = listOf(DiagnosticsDirectives) + + private val dumper: MultiModuleInfoDumper = MultiModuleInfoDumperImpl(moduleHeaderTemplate = "// -- Module: <%s> --") + + override fun processAfterAllModules(someAssertionWasFailed: Boolean) { + if (dumper.isEmpty()) return + val resultDump = dumper.generateResultingDump() + val testDataFile = testServices.moduleStructure.originalTestDataFiles.first() + val allDirectives = testServices.moduleStructure.allDirectives + val prefix = when { + DiagnosticsDirectives.NI_EXPECTED_FILE in allDirectives && + testServices.moduleStructure.modules.any { it.languageVersionSettings.supportsFeature(LanguageFeature.NewInference) } -> ".ni" + + JvmEnvironmentConfigurationDirectives.USE_JAVAC in allDirectives + && DiagnosticsDirectives.JAVAC_EXPECTED_FILE in allDirectives -> ".javac" + + else -> "" + } + val expectedFileName = "${testDataFile.nameWithoutExtension}$prefix.txt" + val expectedFile = testDataFile.parentFile.resolve(expectedFileName) + assertions.assertEqualsToFile(expectedFile, resultDump) + } + + override fun processModule(module: TestModule, info: ClassicFrontendOutputArtifact) { + if (DiagnosticsDirectives.SKIP_TXT in module.directives) return + val moduleDescriptor = info.analysisResult.moduleDescriptor + val checkTypeEnabled = AdditionalFilesDirectives.CHECK_TYPE in module.directives + val comparator = RecursiveDescriptorComparator( + createdAffectedPackagesConfiguration(module.files, info.ktFiles, moduleDescriptor, checkTypeEnabled) + ) + val packages = listOf(FqName.ROOT) + val textByPackage = packages.keysToMap { StringBuilder() } + + for ((packageName, packageText) in textByPackage.entries) { + val aPackage = moduleDescriptor.getPackage(packageName) + assertions.assertFalse(aPackage.isEmpty()) + + val actualSerialized = comparator.serializeRecursively(aPackage) + packageText.append(actualSerialized) + } + val allPackagesText = textByPackage.values.joinToString("\n") + dumper.builderForModule(module).appendLine(allPackagesText) + } + + private fun createdAffectedPackagesConfiguration( + testFiles: List, + ktFiles: Map, + moduleDescriptor: ModuleDescriptor, + checkTypeEnabled: Boolean + ): RecursiveDescriptorComparator.Configuration { + val packagesNames = testFiles.mapNotNullTo(mutableSetOf()) { + val ktFile = ktFiles[it] + when { + ktFile != null -> ktFile.packageFqName.pathSegments().firstOrNull() ?: SpecialNames.ROOT_PACKAGE + it.isJavaFile -> getJavaFilePackage(it) + else -> null + } + } + val stepIntoFilter = Predicate { descriptor -> + val module = DescriptorUtils.getContainingModuleOrNull(descriptor) + if (module != moduleDescriptor) return@Predicate false + + if (descriptor is PackageViewDescriptor) { + val fqName = descriptor.fqName + return@Predicate fqName.isRoot || fqName.pathSegments().first() in packagesNames + } + + if (checkTypeEnabled && descriptor.name in NAMES_OF_CHECK_TYPE_HELPER) return@Predicate false + + true + } + return RECURSIVE.filterRecursion(stepIntoFilter) + .withValidationStrategy(DescriptorValidator.ValidationVisitor.errorTypesAllowed()) + .checkFunctionContracts(true) + } + + private fun getJavaFilePackage(testFile: TestFile): Name { + val matcher = JAVA_PACKAGE_PATTERN.matcher(testFile.originalContent) + + if (matcher.find()) { + return testFile.originalContent + .substring(matcher.start(), matcher.end()) + .split(" ") + .last() + .filter { !it.isWhitespace() } + .let { Name.identifier(it.split(".").first()) } + } + + return SpecialNames.ROOT_PACKAGE + } +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/handlers/DiagnosticTestWithJavacSkipConfigurator.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/handlers/DiagnosticTestWithJavacSkipConfigurator.kt new file mode 100644 index 00000000000..20b1569feb5 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/handlers/DiagnosticTestWithJavacSkipConfigurator.kt @@ -0,0 +1,21 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.frontend.classic.handlers + +import org.jetbrains.kotlin.test.directives.DiagnosticsDirectives +import org.jetbrains.kotlin.test.directives.model.DirectivesContainer +import org.jetbrains.kotlin.test.services.MetaTestConfigurator +import org.jetbrains.kotlin.test.services.TestServices +import org.jetbrains.kotlin.test.services.moduleStructure + +class DiagnosticTestWithJavacSkipConfigurator(testServices: TestServices) : MetaTestConfigurator(testServices) { + override val directives: List + get() = listOf(DiagnosticsDirectives) + + override fun shouldSkipTest(): Boolean { + return DiagnosticsDirectives.SKIP_JAVAC in testServices.moduleStructure.allDirectives + } +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/handlers/FirTestDataConsistencyHandler.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/handlers/FirTestDataConsistencyHandler.kt new file mode 100644 index 00000000000..f98051b3ab3 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/handlers/FirTestDataConsistencyHandler.kt @@ -0,0 +1,46 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.frontend.classic.handlers + +import org.jetbrains.kotlin.codeMetaInfo.clearTextFromDiagnosticMarkup +import org.jetbrains.kotlin.test.directives.FirDiagnosticsDirectives +import org.jetbrains.kotlin.test.directives.model.DirectivesContainer +import org.jetbrains.kotlin.test.model.AfterAnalysisChecker +import org.jetbrains.kotlin.test.runners.AbstractFirDiagnosticTest +import org.jetbrains.kotlin.test.services.TestServices +import org.jetbrains.kotlin.test.services.assertions +import org.jetbrains.kotlin.test.services.moduleStructure +import org.jetbrains.kotlin.test.utils.firTestDataFile +import java.io.File + +class FirTestDataConsistencyHandler(testServices: TestServices) : AfterAnalysisChecker(testServices) { + override val directives: List + get() = listOf(FirDiagnosticsDirectives) + + override fun check(failedAssertions: List) { + val moduleStructure = testServices.moduleStructure + val testData = moduleStructure.originalTestDataFiles.first() + if (testData.extension == "kts") return + if (FirDiagnosticsDirectives.FIR_IDENTICAL in moduleStructure.allDirectives) return + val firTestData = testData.firTestDataFile + if (!firTestData.exists()) { + runFirTestAndGeneratedTestData(testData, firTestData) + return + } + val originalFileContent = clearTextFromDiagnosticMarkup(testData.readText()) + val firFileContent = clearTextFromDiagnosticMarkup(firTestData.readText()) + testServices.assertions.assertEquals(originalFileContent, firFileContent) { + "Original and fir test data aren't identical. " + + "Please, add changes from ${testData.name} to ${firTestData.name}" + } + } + + private fun runFirTestAndGeneratedTestData(testData: File, firTestData: File) { + firTestData.writeText(clearTextFromDiagnosticMarkup(testData.readText())) + val test = object : AbstractFirDiagnosticTest() {} + test.runTest(firTestData.absolutePath) + } +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/Fir2IrResultsConverter.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/Fir2IrResultsConverter.kt new file mode 100644 index 00000000000..d54cda890ba --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/Fir2IrResultsConverter.kt @@ -0,0 +1,96 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.frontend.fir + +import org.jetbrains.kotlin.backend.common.phaser.PhaseConfig +import org.jetbrains.kotlin.backend.jvm.JvmGeneratorExtensions +import org.jetbrains.kotlin.backend.jvm.JvmIrCodegenFactory +import org.jetbrains.kotlin.backend.jvm.jvmPhases +import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys +import org.jetbrains.kotlin.cli.jvm.compiler.NoScopeRecordCliBindingTrace +import org.jetbrains.kotlin.cli.jvm.compiler.TopDownAnalyzerFacadeForJVM +import org.jetbrains.kotlin.codegen.ClassBuilderFactories +import org.jetbrains.kotlin.codegen.state.GenerationState +import org.jetbrains.kotlin.container.get +import org.jetbrains.kotlin.fir.backend.jvm.FirJvmBackendClassResolver +import org.jetbrains.kotlin.fir.backend.jvm.FirMetadataSerializer +import org.jetbrains.kotlin.fir.psi +import org.jetbrains.kotlin.ir.descriptors.IrFunctionFactory +import org.jetbrains.kotlin.ir.util.generateTypicalIrProviderList +import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.resolve.CompilerEnvironment +import org.jetbrains.kotlin.resolve.lazy.declarations.FileBasedDeclarationProviderFactory +import org.jetbrains.kotlin.test.backend.ir.IrBackendInput +import org.jetbrains.kotlin.test.model.BackendKinds +import org.jetbrains.kotlin.test.model.Frontend2BackendConverter +import org.jetbrains.kotlin.test.model.FrontendKinds +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.TestServices +import org.jetbrains.kotlin.test.services.compilerConfigurationProvider + +class Fir2IrResultsConverter( + testServices: TestServices +) : Frontend2BackendConverter( + testServices, + FrontendKinds.FIR, + BackendKinds.IrBackend +) { + override fun transform( + module: TestModule, + inputArtifact: FirOutputArtifact + ): IrBackendInput { + val extensions = JvmGeneratorExtensions() + val (irModuleFragment, symbolTable, sourceManager, components) = inputArtifact.firAnalyzerFacade.convertToIr(extensions) + val dummyBindingContext = NoScopeRecordCliBindingTrace().bindingContext + + val compilerConfigurationProvider = testServices.compilerConfigurationProvider + val configuration = compilerConfigurationProvider.getCompilerConfiguration(module) + + val phaseConfig = configuration.get(CLIConfigurationKeys.PHASE_CONFIG) ?: PhaseConfig(jvmPhases) + val codegenFactory = JvmIrCodegenFactory(phaseConfig) + + // TODO: handle fir from light tree + val ktFiles = inputArtifact.firFiles.values.mapNotNull { it.psi as KtFile? } + + // Create and initialize the module and its dependencies + val project = compilerConfigurationProvider.getProject(module) + val container = TopDownAnalyzerFacadeForJVM.createContainer( + project, ktFiles, NoScopeRecordCliBindingTrace(), configuration, + compilerConfigurationProvider.getPackagePartProviderFactory(module), + ::FileBasedDeclarationProviderFactory, CompilerEnvironment, + TopDownAnalyzerFacadeForJVM.newModuleSearchScope(project, ktFiles), emptyList() + ) + + val generationState = GenerationState.Builder( + project, ClassBuilderFactories.BINARIES, + container.get(), dummyBindingContext, ktFiles, + configuration + ).codegenFactory( + codegenFactory + ).isIrBackend( + true + ).jvmBackendClassResolver( + FirJvmBackendClassResolver(components) + ).build() + + irModuleFragment.irBuiltins.functionFactory = IrFunctionFactory(irModuleFragment.irBuiltins, symbolTable) + val irProviders = generateTypicalIrProviderList( + irModuleFragment.descriptor, irModuleFragment.irBuiltins, symbolTable, extensions = extensions + ) + + return IrBackendInput( + generationState, + irModuleFragment, + symbolTable, + sourceManager, + phaseConfig, + irProviders, + extensions, + ) { context, irClass, _, serializationBindings, parent -> + FirMetadataSerializer(inputArtifact.session, context, irClass, serializationBindings, components, parent) + } + } +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/FirFailingTestSuppressor.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/FirFailingTestSuppressor.kt new file mode 100644 index 00000000000..dc8b4b787f0 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/FirFailingTestSuppressor.kt @@ -0,0 +1,26 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.frontend.fir + +import org.jetbrains.kotlin.test.ExceptionFromTestError +import org.jetbrains.kotlin.test.model.AfterAnalysisChecker +import org.jetbrains.kotlin.test.services.TestServices +import org.jetbrains.kotlin.test.services.moduleStructure + +class FirFailingTestSuppressor(testServices: TestServices) : AfterAnalysisChecker(testServices) { + override fun suppressIfNeeded(failedAssertions: List): List { + val testFile = testServices.moduleStructure.originalTestDataFiles.first() + val failFile = testFile.parentFile.resolve("${testFile.nameWithoutExtension}.fail") + val exceptionFromFir = failedAssertions.firstOrNull { it is ExceptionFromTestError } + return when { + failFile.exists() && exceptionFromFir != null -> emptyList() + failFile.exists() && exceptionFromFir == null -> { + failedAssertions + AssertionError("Fail file exists but no exception was throw. Please remove ${failFile.name}") + } + else -> failedAssertions + } + } +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/FirFrontendFacade.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/FirFrontendFacade.kt new file mode 100644 index 00000000000..643bf466f67 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/FirFrontendFacade.kt @@ -0,0 +1,99 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.frontend.fir + +import com.intellij.openapi.project.Project +import com.intellij.psi.PsiElementFinder +import com.intellij.psi.search.GlobalSearchScope +import com.intellij.psi.search.ProjectScope +import org.jetbrains.kotlin.asJava.finder.JavaElementFinder +import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackagePartProvider +import org.jetbrains.kotlin.cli.jvm.compiler.TopDownAnalyzerFacadeForJVM +import org.jetbrains.kotlin.fir.analysis.FirAnalyzerFacade +import org.jetbrains.kotlin.fir.java.FirProjectSessionProvider +import org.jetbrains.kotlin.fir.session.FirJvmModuleInfo +import org.jetbrains.kotlin.fir.session.FirSessionFactory +import org.jetbrains.kotlin.test.model.* +import org.jetbrains.kotlin.test.services.* + +class FirFrontendFacade( + testServices: TestServices +) : FrontendFacade(testServices, FrontendKinds.FIR) { + override val additionalServices: List + get() = listOf(service(::FirModuleInfoProvider)) + + override fun analyze(module: TestModule): FirOutputArtifact { + val moduleInfoProvider = testServices.firModuleInfoProvider + val compilerConfigurationProvider = testServices.compilerConfigurationProvider + // TODO: add configurable parser + + val project = compilerConfigurationProvider.getProject(module) + + PsiElementFinder.EP.getPoint(project).unregisterExtension(JavaElementFinder::class.java) + + val ktFiles = testServices.sourceFileProvider.getKtFilesForSourceFiles(module.files, project).values + + val sessionProvider = moduleInfoProvider.firSessionProvider + + val languageVersionSettings = module.languageVersionSettings + val builtinsModuleInfo = moduleInfoProvider.builtinsModuleInfoForModule(module) + val packagePartProviderFactory = compilerConfigurationProvider.getPackagePartProviderFactory(module) + + createSessionForBuiltins(builtinsModuleInfo, sessionProvider, project, packagePartProviderFactory) + createSessionForBinaryDependencies(module, sessionProvider, project, packagePartProviderFactory) + + val sourcesScope = TopDownAnalyzerFacadeForJVM.newModuleSearchScope(project, ktFiles) + val sourcesModuleInfo = moduleInfoProvider.convertToFirModuleInfo(module) + val session = FirSessionFactory.createJavaModuleBasedSession( + sourcesModuleInfo, + sessionProvider, + sourcesScope, + project, + languageVersionSettings = languageVersionSettings + ) + + val firAnalyzerFacade = FirAnalyzerFacade(session, languageVersionSettings, ktFiles) + val firFiles = firAnalyzerFacade.runResolution() + val filesMap = firFiles.mapNotNull { firFile -> + val testFile = module.files.firstOrNull { it.name == firFile.name } ?: return@mapNotNull null + testFile to firFile + }.toMap() + + return FirOutputArtifact(session, filesMap, firAnalyzerFacade) + } + + private fun createSessionForBuiltins( + builtinsModuleInfo: FirJvmModuleInfo, + sessionProvider: FirProjectSessionProvider, + project: Project, + packagePartProviderFactory: (GlobalSearchScope) -> JvmPackagePartProvider, + ) { + //For BuiltIns, registered in sessionProvider automatically + val allProjectScope = GlobalSearchScope.allScope(project) + + FirSessionFactory.createLibrarySession( + builtinsModuleInfo, sessionProvider, allProjectScope, project, + packagePartProviderFactory(allProjectScope) + ) + } + + private fun createSessionForBinaryDependencies( + module: TestModule, + sessionProvider: FirProjectSessionProvider, + project: Project, + packagePartProviderFactory: (GlobalSearchScope) -> JvmPackagePartProvider, + ) { + val librariesScope = ProjectScope.getLibrariesScope(project) + val librariesModuleInfo = FirJvmModuleInfo.createForLibraries(module.name) + FirSessionFactory.createLibrarySession( + librariesModuleInfo, + sessionProvider, + librariesScope, + project, + packagePartProviderFactory(librariesScope) + ) + } +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/FirModuleInfoProvider.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/FirModuleInfoProvider.kt new file mode 100644 index 00000000000..2b2fd88df6f --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/FirModuleInfoProvider.kt @@ -0,0 +1,44 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.frontend.fir + +import org.jetbrains.kotlin.fir.java.FirProjectSessionProvider +import org.jetbrains.kotlin.fir.session.FirJvmModuleInfo +import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.test.services.TestService +import org.jetbrains.kotlin.test.services.TestServices +import org.jetbrains.kotlin.test.services.dependencyProvider +import org.jetbrains.kotlin.test.model.TestModule + +class FirModuleInfoProvider( + private val testServices: TestServices +) : TestService { + val firSessionProvider = FirProjectSessionProvider() + + private val builtinsByModule: MutableMap = mutableMapOf() + private val firModuleInfoByModule: MutableMap = mutableMapOf() + + fun convertToFirModuleInfo(module: TestModule): FirJvmModuleInfo { + return firModuleInfoByModule.getOrPut(module) { + val dependencies = mutableListOf(builtinsModuleInfoForModule(module)) + module.dependencies.mapTo(dependencies) { + convertToFirModuleInfo(testServices.dependencyProvider.getTestModule(it.moduleName)) + } + FirJvmModuleInfo( + module.name, + dependencies + ) + } + } + + fun builtinsModuleInfoForModule(module: TestModule): FirJvmModuleInfo { + return builtinsByModule.getOrPut(module) { + FirJvmModuleInfo(Name.special(""), emptyList()) + } + } +} + +val TestServices.firModuleInfoProvider: FirModuleInfoProvider by TestServices.testServiceAccessor() diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/FirOutputArtifact.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/FirOutputArtifact.kt new file mode 100644 index 00000000000..012e0ef2568 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/FirOutputArtifact.kt @@ -0,0 +1,24 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.frontend.fir + +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.analysis.FirAnalyzerFacade +import org.jetbrains.kotlin.fir.declarations.FirFile +import org.jetbrains.kotlin.test.model.FrontendKinds +import org.jetbrains.kotlin.test.model.ResultingArtifact +import org.jetbrains.kotlin.test.model.TestFile + +data class FirOutputArtifact( + val session: FirSession, + val allFirFiles: Map, + val firAnalyzerFacade: FirAnalyzerFacade +) : ResultingArtifact.FrontendOutput() { + override val kind: FrontendKinds.FIR + get() = FrontendKinds.FIR + + val firFiles: Map = allFirFiles.filterKeys { !it.isAdditional } +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirAnalysisHandler.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirAnalysisHandler.kt new file mode 100644 index 00000000000..a8305f22940 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirAnalysisHandler.kt @@ -0,0 +1,19 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.frontend.fir.handlers + +import org.jetbrains.kotlin.test.frontend.fir.FirOutputArtifact +import org.jetbrains.kotlin.test.model.FrontendKinds +import org.jetbrains.kotlin.test.model.FrontendOutputHandler +import org.jetbrains.kotlin.test.services.TestServices +import java.io.File + +abstract class FirAnalysisHandler( + testServices: TestServices +) : FrontendOutputHandler(testServices, FrontendKinds.FIR) { + protected val File.nameWithoutFirExtension: String + get() = nameWithoutExtension.removeSuffix(".fir") +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirCfgConsistencyHandler.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirCfgConsistencyHandler.kt new file mode 100644 index 00000000000..df1afe15cd5 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirCfgConsistencyHandler.kt @@ -0,0 +1,19 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.frontend.fir.handlers + +import org.jetbrains.kotlin.fir.AbstractFirDiagnosticsTest +import org.jetbrains.kotlin.test.frontend.fir.FirOutputArtifact +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.TestServices + +class FirCfgConsistencyHandler(testServices: TestServices) : FirAnalysisHandler(testServices) { + override fun processModule(module: TestModule, info: FirOutputArtifact) { + info.firFiles.values.forEach { it.accept(AbstractFirDiagnosticsTest.CfgConsistencyChecker) } + } + + override fun processAfterAllModules(someAssertionWasFailed: Boolean) {} +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirCfgDumpHandler.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirCfgDumpHandler.kt new file mode 100644 index 00000000000..49afd6fb3e3 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirCfgDumpHandler.kt @@ -0,0 +1,36 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.frontend.fir.handlers + +import org.jetbrains.kotlin.fir.resolve.dfa.cfg.FirControlFlowGraphRenderVisitor +import org.jetbrains.kotlin.test.directives.FirDiagnosticsDirectives +import org.jetbrains.kotlin.test.directives.model.DirectivesContainer +import org.jetbrains.kotlin.test.frontend.fir.FirOutputArtifact +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.TestServices +import org.jetbrains.kotlin.test.services.moduleStructure + +// TODO: adapt to multifile and multimodule tests +class FirCfgDumpHandler(testServices: TestServices) : FirAnalysisHandler(testServices) { + override val directivesContainers: List + get() = listOf(FirDiagnosticsDirectives) + + private val builder = StringBuilder() + private var alreadyDumped: Boolean = false + + override fun processModule(module: TestModule, info: FirOutputArtifact) { + if (alreadyDumped || FirDiagnosticsDirectives.DUMP_CFG !in module.directives) return + val file = info.firFiles.values.first() + file.accept(FirControlFlowGraphRenderVisitor(builder)) + } + + override fun processAfterAllModules(someAssertionWasFailed: Boolean) { + if (!alreadyDumped) return + val testDataFile = testServices.moduleStructure.originalTestDataFiles.first() + val expectedFile = testDataFile.parentFile.resolve("${testDataFile.nameWithoutFirExtension}.dot") + assertions.assertEqualsToFile(expectedFile, builder.toString()) + } +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirDiagnosticCodeMetaInfo.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirDiagnosticCodeMetaInfo.kt new file mode 100644 index 00000000000..fbb6af8262d --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirDiagnosticCodeMetaInfo.kt @@ -0,0 +1,90 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.frontend.fir.handlers + +import com.intellij.openapi.util.TextRange +import com.intellij.psi.PsiElement +import org.jetbrains.kotlin.codeMetaInfo.model.CodeMetaInfo +import org.jetbrains.kotlin.codeMetaInfo.renderConfigurations.AbstractCodeMetaInfoRenderConfiguration +import org.jetbrains.kotlin.diagnostics.PositioningStrategy +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDefaultErrorMessages +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnostic +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderer +import org.jetbrains.kotlin.fir.psi + +object FirMetaInfoUtils { + val renderDiagnosticNoArgs = FirDiagnosticCodeMetaRenderConfiguration().apply { renderParams = false } + val renderDiagnosticWithArgs = FirDiagnosticCodeMetaRenderConfiguration().apply { renderParams = true } +} + +class FirDiagnosticCodeMetaInfo( + val diagnostic: FirDiagnostic<*>, + renderConfiguration: FirDiagnosticCodeMetaRenderConfiguration +) : CodeMetaInfo { + // TODO: this implementation is hacky and doesn't support proper ranges for light tree diagnostics + private val textRangeFromClassicDiagnostic: TextRange? = run { + val psi = diagnostic.element.psi ?: return@run null + + @Suppress("UNCHECKED_CAST") + val positioningStrategy = diagnostic.factory.positioningStrategy.psiStrategy as PositioningStrategy + positioningStrategy.mark(psi).first() + } + + override var renderConfiguration: FirDiagnosticCodeMetaRenderConfiguration = renderConfiguration + private set + + override val start: Int + get() = textRangeFromClassicDiagnostic?.startOffset ?: diagnostic.element.startOffset + + override val end: Int + get() = textRangeFromClassicDiagnostic?.endOffset ?: diagnostic.element.endOffset + + override val tag: String + get() = renderConfiguration.getTag(this) + + override val attributes: MutableList = mutableListOf() + + override fun asString(): String = renderConfiguration.asString(this) + + fun replaceRenderConfiguration(renderConfiguration: FirDiagnosticCodeMetaRenderConfiguration) { + this.renderConfiguration = renderConfiguration + } +} + +class FirDiagnosticCodeMetaRenderConfiguration( + val renderSeverity: Boolean = false, +) : AbstractCodeMetaInfoRenderConfiguration(renderParams = false) { + private val crossPlatformLineBreak = """\r?\n""".toRegex() + + override fun asString(codeMetaInfo: CodeMetaInfo): String { + if (codeMetaInfo !is FirDiagnosticCodeMetaInfo) return "" + return (getTag(codeMetaInfo) + + getPlatformsString(codeMetaInfo) + + getParamsString(codeMetaInfo)) + .replace(crossPlatformLineBreak, "") + } + + private fun getParamsString(codeMetaInfo: FirDiagnosticCodeMetaInfo): String { + if (!renderParams) return "" + val params = mutableListOf() + + val diagnostic = codeMetaInfo.diagnostic + + val renderer = FirDefaultErrorMessages.getRendererForDiagnostic(diagnostic) as FirDiagnosticRenderer> + params.add(renderer.render(diagnostic)) + + if (renderSeverity) + params.add("severity='${diagnostic.severity}'") + + params.add(getAdditionalParams(codeMetaInfo)) + + return "(\"${params.filter { it.isNotEmpty() }.joinToString("; ")}\")" + } + + fun getTag(codeMetaInfo: FirDiagnosticCodeMetaInfo): String { + return codeMetaInfo.diagnostic.factory.name + } +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirDiagnosticsHandler.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirDiagnosticsHandler.kt new file mode 100644 index 00000000000..5a9b08289b3 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirDiagnosticsHandler.kt @@ -0,0 +1,232 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.frontend.fir.handlers + +import com.intellij.psi.PsiElement +import org.jetbrains.kotlin.KtNodeTypes +import org.jetbrains.kotlin.checkers.diagnostics.factories.DebugInfoDiagnosticFactory1 +import org.jetbrains.kotlin.checkers.utils.TypeOfCall +import org.jetbrains.kotlin.diagnostics.rendering.Renderers +import org.jetbrains.kotlin.fir.* +import org.jetbrains.kotlin.fir.analysis.diagnostics.* +import org.jetbrains.kotlin.fir.declarations.FirCallableMemberDeclaration +import org.jetbrains.kotlin.fir.declarations.FirFile +import org.jetbrains.kotlin.fir.declarations.FirFunction +import org.jetbrains.kotlin.fir.declarations.FirProperty +import org.jetbrains.kotlin.fir.expressions.FirExpression +import org.jetbrains.kotlin.fir.expressions.FirExpressionWithSmartcast +import org.jetbrains.kotlin.fir.expressions.FirFunctionCall +import org.jetbrains.kotlin.fir.references.FirNamedReference +import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference +import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol +import org.jetbrains.kotlin.fir.types.ConeKotlinType +import org.jetbrains.kotlin.fir.types.FirTypeRef +import org.jetbrains.kotlin.fir.types.coneTypeSafe +import org.jetbrains.kotlin.fir.visitors.FirDefaultVisitorVoid +import org.jetbrains.kotlin.name.FqNameUnsafe +import org.jetbrains.kotlin.resolve.AnalyzingUtils +import org.jetbrains.kotlin.test.directives.DiagnosticsDirectives +import org.jetbrains.kotlin.test.directives.model.DirectivesContainer +import org.jetbrains.kotlin.test.frontend.fir.FirOutputArtifact +import org.jetbrains.kotlin.test.model.TestFile +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.* +import org.jetbrains.kotlin.util.OperatorNameConventions +import org.jetbrains.kotlin.utils.addIfNotNull + +class FirDiagnosticsHandler(testServices: TestServices) : FirAnalysisHandler(testServices) { + companion object { + private val allowedKindsForDebugInfo = setOf( + FirRealSourceElementKind, + FirFakeSourceElementKind.DesugaredCompoundAssignment, + ) + } + + private val globalMetadataInfoHandler: GlobalMetadataInfoHandler + get() = testServices.globalMetadataInfoHandler + + private val diagnosticsService: DiagnosticsService + get() = testServices.diagnosticsService + + override val directivesContainers: List = + listOf(DiagnosticsDirectives) + + override val additionalServices: List = + listOf(service(::DiagnosticsService)) + + override fun processModule(module: TestModule, info: FirOutputArtifact) { + val diagnosticsPerFile = info.firAnalyzerFacade.runCheckers() + + for (file in module.files) { + val firFile = info.firFiles[file] ?: continue + val diagnostics = diagnosticsPerFile[firFile] ?: continue + val diagnosticsMetadataInfos = diagnostics.mapNotNull { diagnostic -> + if (!diagnosticsService.shouldRenderDiagnostic(module, diagnostic.factory.name)) return@mapNotNull null + // SYNTAX errors will be reported later + if (diagnostic.factory == FirErrors.SYNTAX) return@mapNotNull null + if (!diagnostic.isValid) return@mapNotNull null + diagnostic.toMetaInfo(file) + } + globalMetadataInfoHandler.addMetadataInfosForFile(file, diagnosticsMetadataInfos) + collectSyntaxDiagnostics(file, firFile) + collectDebugInfoDiagnostics(file, firFile) + } + } + + private fun FirDiagnostic<*>.toMetaInfo(file: TestFile, forceRenderArguments: Boolean = false): FirDiagnosticCodeMetaInfo { + val metaInfo = FirDiagnosticCodeMetaInfo(this, FirMetaInfoUtils.renderDiagnosticNoArgs) + val shouldRenderArguments = forceRenderArguments || globalMetadataInfoHandler.getExistingMetaInfosForActualMetadata(file, metaInfo) + .any { it.description != null } + if (shouldRenderArguments) { + metaInfo.replaceRenderConfiguration(FirMetaInfoUtils.renderDiagnosticWithArgs) + } + return metaInfo + } + + private fun collectSyntaxDiagnostics(testFile: TestFile, firFile: FirFile) { + // TODO: support in light tree + val psiFile = firFile.psi ?: return + val metaInfos = AnalyzingUtils.getSyntaxErrorRanges(psiFile).map { + FirErrors.SYNTAX.on(FirRealPsiSourceElement(it)).toMetaInfo(testFile) + } + globalMetadataInfoHandler.addMetadataInfosForFile(testFile, metaInfos) + } + + private fun collectDebugInfoDiagnostics( + testFile: TestFile, + firFile: FirFile, + ) { + val result = mutableListOf>() + val diagnosedRangesToDiagnosticNames = globalMetadataInfoHandler.getExistingMetaInfosForFile(testFile).groupBy( + keySelector = { it.start..it.end }, + valueTransform = { it.tag } + ).mapValues { (_, it) -> it.toSet() } + object : FirDefaultVisitorVoid() { + override fun visitElement(element: FirElement) { + if (element is FirExpression) { + result.addIfNotNull( + createExpressionTypeDiagnosticIfExpected( + element, diagnosedRangesToDiagnosticNames + ) + ) + } + + element.acceptChildren(this) + } + + override fun visitFunctionCall(functionCall: FirFunctionCall) { + result.addIfNotNull( + createCallDiagnosticIfExpected(functionCall, functionCall.calleeReference, diagnosedRangesToDiagnosticNames) + ) + + super.visitFunctionCall(functionCall) + } + }.let(firFile::accept) + globalMetadataInfoHandler.addMetadataInfosForFile(testFile, result.map { it.toMetaInfo(testFile, forceRenderArguments = true) }) + } + + fun createExpressionTypeDiagnosticIfExpected( + element: FirExpression, + diagnosedRangesToDiagnosticNames: Map> + ): FirDiagnosticWithParameters1? = + DebugInfoDiagnosticFactory1.EXPRESSION_TYPE.createDebugInfoDiagnostic(element, diagnosedRangesToDiagnosticNames) { + element.typeRef.renderAsString((element as? FirExpressionWithSmartcast)?.originalType) + } + + private fun FirTypeRef.renderAsString(originalTypeRef: FirTypeRef?): String { + val type = coneTypeSafe() ?: return "Type is unknown" + val rendered = type.renderForDebugInfo() + val originalTypeRendered = originalTypeRef?.coneTypeSafe()?.renderForDebugInfo() ?: return rendered + + return "$rendered & $originalTypeRendered" + } + + private fun createCallDiagnosticIfExpected( + element: FirElement, + reference: FirNamedReference, + diagnosedRangesToDiagnosticNames: Map> + ): FirDiagnosticWithParameters1? = + DebugInfoDiagnosticFactory1.CALL.createDebugInfoDiagnostic(element, diagnosedRangesToDiagnosticNames) { + val resolvedSymbol = (reference as? FirResolvedNamedReference)?.resolvedSymbol + val fqName = resolvedSymbol?.fqNameUnsafe() + Renderers.renderCallInfo(fqName, getTypeOfCall(reference, resolvedSymbol)) + } + + private inline fun DebugInfoDiagnosticFactory1.createDebugInfoDiagnostic( + element: FirElement, + diagnosedRangesToDiagnosticNames: Map>, + argument: () -> String, + ): FirDiagnosticWithParameters1? { + val sourceElement = element.source ?: return null + if (sourceElement.kind !in allowedKindsForDebugInfo) return null + // Lambda argument is always (?) duplicated by function literal + // Block expression is always (?) duplicated by single block expression + if (sourceElement.elementType == KtNodeTypes.LAMBDA_ARGUMENT || sourceElement.elementType == KtNodeTypes.BLOCK) return null + if (diagnosedRangesToDiagnosticNames[sourceElement.startOffset..sourceElement.endOffset]?.contains(this.name) != true) return null + + val argumentText = argument() + return when (sourceElement) { + is FirPsiSourceElement<*> -> FirPsiDiagnosticWithParameters1( + sourceElement, + argumentText, + severity, + FirDiagnosticFactory1( + name, + severity, + ) + ) + is FirLightSourceElement -> FirLightDiagnosticWithParameters1( + sourceElement, + argumentText, + severity, + FirDiagnosticFactory1( + name, + severity + ) + ) + } + } + + private fun getTypeOfCall( + reference: FirNamedReference, + resolvedSymbol: AbstractFirBasedSymbol<*>? + ): String { + if (resolvedSymbol == null) return TypeOfCall.UNRESOLVED.nameToRender + + if ((resolvedSymbol as? FirFunctionSymbol)?.callableId?.callableName == OperatorNameConventions.INVOKE + && reference.name != OperatorNameConventions.INVOKE + ) { + return TypeOfCall.VARIABLE_THROUGH_INVOKE.nameToRender + } + + return when (val fir = resolvedSymbol.fir) { + is FirProperty -> { + TypeOfCall.PROPERTY_GETTER.nameToRender + } + is FirFunction<*> -> buildString { + if (fir is FirCallableMemberDeclaration<*>) { + if (fir.status.isInline) append("inline ") + if (fir.status.isInfix) append("infix ") + if (fir.status.isOperator) append("operator ") + if (fir.receiverTypeRef != null) append("extension ") + } + append(TypeOfCall.FUNCTION.nameToRender) + } + else -> TypeOfCall.OTHER.nameToRender + } + } + + private fun AbstractFirBasedSymbol<*>.fqNameUnsafe(): FqNameUnsafe? = when (this) { + is FirClassLikeSymbol<*> -> classId.asSingleFqName().toUnsafe() + is FirCallableSymbol<*> -> callableId.asFqNameForDebugInfo().toUnsafe() + else -> null + } + + override fun processAfterAllModules(someAssertionWasFailed: Boolean) {} +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirDumpHandler.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirDumpHandler.kt new file mode 100644 index 00000000000..ad3cb818713 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirDumpHandler.kt @@ -0,0 +1,41 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.frontend.fir.handlers + +import org.jetbrains.kotlin.fir.render +import org.jetbrains.kotlin.test.directives.FirDiagnosticsDirectives +import org.jetbrains.kotlin.test.directives.model.DirectivesContainer +import org.jetbrains.kotlin.test.frontend.fir.FirOutputArtifact +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.TestServices +import org.jetbrains.kotlin.test.services.moduleStructure +import org.jetbrains.kotlin.test.utils.MultiModuleInfoDumper +import org.jetbrains.kotlin.test.utils.MultiModuleInfoDumperImpl + +class FirDumpHandler( + testServices: TestServices +) : FirAnalysisHandler(testServices) { + private val dumper: MultiModuleInfoDumper = MultiModuleInfoDumperImpl() + + override val directivesContainers: List + get() = listOf(FirDiagnosticsDirectives) + + override fun processModule(module: TestModule, info: FirOutputArtifact) { + if (FirDiagnosticsDirectives.FIR_DUMP !in module.directives) return + val builderForModule = dumper.builderForModule(module) + val firFiles = info.firFiles + firFiles.values.forEach { builderForModule.append(it.render()) } + } + + override fun processAfterAllModules(someAssertionWasFailed: Boolean) { + if (dumper.isEmpty()) return + // TODO: change according to multiple testdata files + val testDataFile = testServices.moduleStructure.originalTestDataFiles.first() + val expectedFile = testDataFile.parentFile.resolve("${testDataFile.nameWithoutFirExtension}.fir.txt") + val actualText = dumper.generateResultingDump() + assertions.assertEqualsToFile(expectedFile, actualText, message = { "Content is not equal" }) + } +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirIdenticalChecker.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirIdenticalChecker.kt new file mode 100644 index 00000000000..1416eaedd9f --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirIdenticalChecker.kt @@ -0,0 +1,53 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.frontend.fir.handlers + +import org.jetbrains.kotlin.test.directives.FirDiagnosticsDirectives +import org.jetbrains.kotlin.test.model.AfterAnalysisChecker +import org.jetbrains.kotlin.test.services.TestServices +import org.jetbrains.kotlin.test.services.assertions +import org.jetbrains.kotlin.test.services.moduleStructure +import org.jetbrains.kotlin.test.utils.firTestDataFile +import org.jetbrains.kotlin.test.utils.isFirTestData +import org.jetbrains.kotlin.test.utils.originalTestDataFile +import java.io.File + +class FirIdenticalChecker(testServices: TestServices) : AfterAnalysisChecker(testServices) { + override fun check(failedAssertions: List) { + if (failedAssertions.isNotEmpty()) return + val file = testServices.moduleStructure.originalTestDataFiles.first() + if (file.isFirTestData) { + addDirectiveToClassicFile(file) + } else { + removeFirFileIfExist(file) + } + } + + private fun addDirectiveToClassicFile(firFile: File) { + val classicFile = firFile.originalTestDataFile + val classicFileContent = classicFile.readText() + val firFileContent = firFile.readText() + if (classicFileContent == firFileContent) { + classicFile.writer().use { + it.appendLine("// ${FirDiagnosticsDirectives.FIR_IDENTICAL.name}") + it.append(classicFileContent) + } + firFile.delete() + testServices.assertions.fail { + """ + Dumps via FIR & via old FE are the same. + Deleted .fir.txt dump, added // FIR_IDENTICAL to test source + Please re-run the test now + """.trimIndent() + } + } + } + + private fun removeFirFileIfExist(classicFile: File) { + val firFile = classicFile.firTestDataFile + firFile.delete() + } +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/impl/TestConfigurationImpl.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/impl/TestConfigurationImpl.kt new file mode 100644 index 00000000000..ea840bbe034 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/impl/TestConfigurationImpl.kt @@ -0,0 +1,151 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.impl + +import com.intellij.openapi.Disposable +import org.jetbrains.kotlin.test.Constructor +import org.jetbrains.kotlin.test.TestConfiguration +import org.jetbrains.kotlin.test.directives.model.ComposedDirectivesContainer +import org.jetbrains.kotlin.test.directives.model.DirectivesContainer +import org.jetbrains.kotlin.test.directives.model.RegisteredDirectives +import org.jetbrains.kotlin.test.model.* +import org.jetbrains.kotlin.test.services.* +import org.jetbrains.kotlin.test.services.impl.ModuleStructureExtractorImpl +import org.jetbrains.kotlin.test.utils.TestDisposable + +class TestConfigurationImpl( + defaultsProvider: DefaultsProvider, + assertions: Assertions, + + facades: List>>, + + analysisHandlers: List>>, + + sourcePreprocessors: List>, + additionalMetaInfoProcessors: List>, + environmentConfigurators: List>, + + additionalSourceProviders: List>, + metaTestConfigurators: List>, + afterAnalysisCheckers: List>, + + override val metaInfoHandlerEnabled: Boolean, + + directives: List, + override val defaultRegisteredDirectives: RegisteredDirectives +) : TestConfiguration() { + override val rootDisposable: Disposable = TestDisposable() + override val testServices: TestServices = TestServices() + + private val allDirectives = directives.toMutableSet() + override val directives: DirectivesContainer by lazy { + when (allDirectives.size) { + 0 -> DirectivesContainer.Empty + 1 -> allDirectives.single() + else -> ComposedDirectivesContainer(allDirectives) + } + } + + override val moduleStructureExtractor: ModuleStructureExtractor = ModuleStructureExtractorImpl( + testServices, + additionalSourceProviders.map { it.invoke(testServices) }.also { + it.flatMapTo(allDirectives) { provider -> provider.directives } + } + ) + + override val metaTestConfigurators: List = metaTestConfigurators.map { + it.invoke(testServices).also { configurator -> + allDirectives += configurator.directives + } + } + + override val afterAnalysisCheckers: List = afterAnalysisCheckers.map { + it.invoke(testServices).also { checker -> + allDirectives += checker.directives + } + } + + init { + testServices.apply { + @OptIn(ExperimentalStdlibApi::class) + val sourceFilePreprocessors = sourcePreprocessors.map { it.invoke(this@apply) } + val sourceFileProvider = SourceFileProviderImpl(sourceFilePreprocessors) + register(SourceFileProvider::class, sourceFileProvider) + + val configurators = environmentConfigurators.map { it.invoke(this) } + configurators.flatMapTo(allDirectives) { it.directivesContainers } + for (configurator in configurators) { + configurator.additionalServices.forEach { register(it) } + } + val environmentProvider = CompilerConfigurationProviderImpl( + rootDisposable, + configurators + ) + register(CompilerConfigurationProvider::class, environmentProvider) + + register(Assertions::class, assertions) + register(DefaultsProvider::class, defaultsProvider) + + register(DefaultRegisteredDirectivesProvider::class, DefaultRegisteredDirectivesProvider(defaultRegisteredDirectives)) + + val metaInfoProcessors = additionalMetaInfoProcessors.map { it.invoke(this) } + register(GlobalMetadataInfoHandler::class, GlobalMetadataInfoHandler(this, metaInfoProcessors)) + } + } + + private val facades: Map, Map, AbstractTestFacade<*, *>>> = + facades + .map { it.invoke(testServices) } + .groupBy { it.inputKind } + .mapValues { (frontendKind, converters) -> + converters.groupBy { it.outputKind }.mapValues { + it.value.singleOrNull() ?: manyFacadesError("converters", "$frontendKind -> ${it.key}") + } + } + + + private val analysisHandlers: Map, List>> = + analysisHandlers.map { it.invoke(testServices).also(this::registerDirectivesAndServices) } + .groupBy { it.artifactKind } + .withDefault { emptyList() } + + private fun manyFacadesError(name: String, kinds: String): Nothing { + error("Too many $name passed for $kinds configuration") + } + + private fun registerDirectivesAndServices(handler: AnalysisHandler<*>) { + allDirectives += handler.directivesContainers + testServices.register(handler.additionalServices) + } + + init { + testServices.apply { + this@TestConfigurationImpl.facades.values.forEach { it.values.forEach { facade -> register(facade.additionalServices) } } + } + } + + override fun , O : ResultingArtifact> getFacade( + inputKind: TestArtifactKind, + outputKind: TestArtifactKind + ): AbstractTestFacade { + @Suppress("UNCHECKED_CAST") + return facades[inputKind]?.get(outputKind) as AbstractTestFacade? + ?: facadeNotFoundError(inputKind, outputKind) + } + + private fun facadeNotFoundError(from: Any, to: Any): Nothing { + error("Facade for converting '$from' to '$to' not found") + } + + override fun > getHandlers(artifactKind: TestArtifactKind): List> { + @Suppress("UNCHECKED_CAST") + return analysisHandlers.getValue(artifactKind) as List> + } + + override fun getAllHandlers(): List> { + return analysisHandlers.values.flatten() + } +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/model/ResultingArtifacts.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/model/ResultingArtifacts.kt new file mode 100644 index 00000000000..276ff31fe7d --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/model/ResultingArtifacts.kt @@ -0,0 +1,30 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.model + +import org.jetbrains.kotlin.codegen.ClassFileFactory + +object BinaryArtifacts { + class Jvm(val classFileFactory: ClassFileFactory) : ResultingArtifact.Binary() { + override val kind: BinaryKind + get() = ArtifactKinds.Jvm + } + + class Js : ResultingArtifact.Binary() { + override val kind: BinaryKind + get() = ArtifactKinds.Js + } + + class Native : ResultingArtifact.Binary() { + override val kind: BinaryKind + get() = ArtifactKinds.Native + } + + class KLib : ResultingArtifact.Binary() { + override val kind: BinaryKind + get() = ArtifactKinds.KLib + } +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/model/TestArtifactKinds.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/model/TestArtifactKinds.kt new file mode 100644 index 00000000000..72c0974413e --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/model/TestArtifactKinds.kt @@ -0,0 +1,54 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.model + +import org.jetbrains.kotlin.test.backend.classic.ClassicBackendInput +import org.jetbrains.kotlin.test.backend.ir.IrBackendInput +import org.jetbrains.kotlin.test.frontend.classic.ClassicFrontendOutputArtifact +import org.jetbrains.kotlin.test.frontend.fir.FirOutputArtifact + +object FrontendKinds { + object ClassicFrontend : FrontendKind("ClassicFrontend") + object FIR : FrontendKind("FIR") + + fun fromString(string: String): FrontendKind<*>? { + return when (string) { + "ClassicFrontend" -> ClassicFrontend + "FIR" -> FIR + else -> null + } + } +} + +object BackendKinds { + object ClassicBackend : BackendKind("ClassicBackend") + object IrBackend : BackendKind("IrBackend") + + fun fromString(string: String): BackendKind<*>? { + return when (string) { + "ClassicBackend" -> ClassicBackend + "IrBackend" -> IrBackend + else -> null + } + } +} + +object ArtifactKinds { + object Jvm : BinaryKind("JVM") + object Js : BinaryKind("JS") + object Native : BinaryKind("Native") + object KLib : BinaryKind("KLib") + + fun fromString(string: String): BinaryKind<*>? { + return when (string) { + "Jvm" -> Jvm + "Js" -> Js + "Native" -> Native + "KLib" -> KLib + else -> null + } + } +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/preprocessors/MetaInfosCleanupPreprocessor.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/preprocessors/MetaInfosCleanupPreprocessor.kt new file mode 100644 index 00000000000..55ffda76bb3 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/preprocessors/MetaInfosCleanupPreprocessor.kt @@ -0,0 +1,17 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.preprocessors + +import org.jetbrains.kotlin.codeMetaInfo.clearTextFromDiagnosticMarkup +import org.jetbrains.kotlin.test.model.TestFile +import org.jetbrains.kotlin.test.services.SourceFilePreprocessor +import org.jetbrains.kotlin.test.services.TestServices + +class MetaInfosCleanupPreprocessor(testServices: TestServices) : SourceFilePreprocessor(testServices) { + override fun process(file: TestFile, content: String): String { + return clearTextFromDiagnosticMarkup(content) + } +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/AdditionalDiagnosticsSourceFilesProvider.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/AdditionalDiagnosticsSourceFilesProvider.kt new file mode 100644 index 00000000000..cf7953201e4 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/AdditionalDiagnosticsSourceFilesProvider.kt @@ -0,0 +1,32 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.services + +import org.jetbrains.kotlin.test.directives.AdditionalFilesDirectives +import org.jetbrains.kotlin.test.directives.model.DirectivesContainer +import org.jetbrains.kotlin.test.directives.model.RegisteredDirectives +import org.jetbrains.kotlin.test.model.TestFile +import org.jetbrains.kotlin.test.model.TestModule +import java.io.File + +class AdditionalDiagnosticsSourceFilesProvider(testServices: TestServices) : AdditionalSourceProvider(testServices) { + companion object { + private const val HELPERS_PATH = "./compiler/testData/diagnostics/helpers" + private const val CHECK_TYPE_PATH = "$HELPERS_PATH/types/checkType.kt" + } + + override val directives: List = + listOf(AdditionalFilesDirectives) + + @OptIn(ExperimentalStdlibApi::class) + override fun produceAdditionalFiles(globalDirectives: RegisteredDirectives, module: TestModule): List { + return buildList { + if (containsDirective(globalDirectives, module, AdditionalFilesDirectives.CHECK_TYPE)) { + add(File(CHECK_TYPE_PATH).toTestFile()) + } + } + } +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/CompilerConfigurationProvider.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/CompilerConfigurationProvider.kt new file mode 100644 index 00000000000..360a5d48b32 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/CompilerConfigurationProvider.kt @@ -0,0 +1,100 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.services + +import com.intellij.mock.MockProject +import com.intellij.openapi.Disposable +import com.intellij.openapi.project.Project +import com.intellij.psi.search.GlobalSearchScope +import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys +import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity +import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSourceLocation +import org.jetbrains.kotlin.cli.common.messages.MessageCollector +import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles +import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackagePartProvider +import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment +import org.jetbrains.kotlin.config.CommonConfigurationKeys +import org.jetbrains.kotlin.config.CompilerConfiguration +import org.jetbrains.kotlin.config.CompilerConfigurationKey +import org.jetbrains.kotlin.config.languageVersionSettings +import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.test.model.TestFile +import org.jetbrains.kotlin.test.model.TestModule +import java.io.File + +abstract class CompilerConfigurationProvider : TestService { + abstract val testRootDisposable: Disposable + + protected abstract fun getKotlinCoreEnvironment(module: TestModule): KotlinCoreEnvironment + + fun getProject(module: TestModule): Project { + return getKotlinCoreEnvironment(module).project + } + + fun getPackagePartProviderFactory(module: TestModule): (GlobalSearchScope) -> JvmPackagePartProvider { + return getKotlinCoreEnvironment(module)::createPackagePartProvider + } + + fun getCompilerConfiguration(module: TestModule): CompilerConfiguration { + return getKotlinCoreEnvironment(module).configuration + } + + fun registerJavacForModule(module: TestModule, ktFiles: List, mockJdk: File?) { + val environment = getKotlinCoreEnvironment(module) + val bootClasspath = mockJdk?.let { listOf(it) } + environment.registerJavac(kotlinFiles = ktFiles, bootClasspath = bootClasspath) + } +} + +val TestServices.compilerConfigurationProvider: CompilerConfigurationProvider by TestServices.testServiceAccessor() + +class CompilerConfigurationProviderImpl( + override val testRootDisposable: Disposable, + val configurators: List +) : CompilerConfigurationProvider() { + private val cache: MutableMap = mutableMapOf() + + override fun getKotlinCoreEnvironment(module: TestModule): KotlinCoreEnvironment { + return cache.getOrPut(module) { + val projectEnv = KotlinCoreEnvironment.createProjectEnvironmentForTests(testRootDisposable, CompilerConfiguration()) + KotlinCoreEnvironment.createForTests( + projectEnv, + createCompilerConfiguration(module, projectEnv.project), + EnvironmentConfigFiles.JVM_CONFIG_FILES + ) + } + } + + private fun createCompilerConfiguration(module: TestModule, project: MockProject): CompilerConfiguration { + val configuration = CompilerConfiguration() + configuration[CommonConfigurationKeys.MODULE_NAME] = module.name + + configuration[CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY] = object : MessageCollector { + override fun clear() {} + + override fun report(severity: CompilerMessageSeverity, message: String, location: CompilerMessageSourceLocation?) { + if (severity == CompilerMessageSeverity.ERROR) { + val prefix = if (location == null) "" else "(" + location.path + ":" + location.line + ":" + location.column + ") " + throw AssertionError(prefix + message) + } + } + + override fun hasErrors(): Boolean = false + } + configuration.languageVersionSettings = module.languageVersionSettings + + configurators.forEach { it.configureCompilerConfiguration(configuration, module, project) } + + return configuration + } + + private operator fun CompilerConfiguration.set(key: CompilerConfigurationKey, value: T) { + put(key, value) + } +} + +val TestModule.javaFiles: List + get() = files.filter { it.isJavaFile } diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/CoroutineHelpersSourceFilesProvider.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/CoroutineHelpersSourceFilesProvider.kt new file mode 100644 index 00000000000..a02da496757 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/CoroutineHelpersSourceFilesProvider.kt @@ -0,0 +1,42 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.services + +import org.jetbrains.kotlin.test.directives.AdditionalFilesDirectives +import org.jetbrains.kotlin.test.directives.AdditionalFilesDirectives.CHECK_STATE_MACHINE +import org.jetbrains.kotlin.test.directives.AdditionalFilesDirectives.CHECK_TAIL_CALL_OPTIMIZATION +import org.jetbrains.kotlin.test.directives.AdditionalFilesDirectives.WITH_COROUTINES +import org.jetbrains.kotlin.test.directives.model.DirectivesContainer +import org.jetbrains.kotlin.test.directives.model.RegisteredDirectives +import org.jetbrains.kotlin.test.model.TestFile +import org.jetbrains.kotlin.test.model.TestModule +import java.io.File + +class CoroutineHelpersSourceFilesProvider(testServices: TestServices) : AdditionalSourceProvider(testServices) { + companion object { + private const val HELPERS_PATH = "./compiler/testData/diagnostics/helpers/coroutines" + private const val COROUTINE_HELPERS_PATH = "$HELPERS_PATH/CoroutineHelpers.kt" + private const val STATE_MACHINE_CHECKER_PATH = "$HELPERS_PATH/StateMachineChecker.kt" + private const val TAIL_CALL_OPTIMIZATION_CHECKER_PATH = "$HELPERS_PATH/TailCallOptimizationChecker.kt" + } + + override val directives: List = + listOf(AdditionalFilesDirectives) + + @OptIn(ExperimentalStdlibApi::class) + override fun produceAdditionalFiles(globalDirectives: RegisteredDirectives, module: TestModule): List { + if (WITH_COROUTINES !in module.directives) return emptyList() + return buildList { + add(File(COROUTINE_HELPERS_PATH).toTestFile()) + if (CHECK_STATE_MACHINE in module.directives) { + add(File(STATE_MACHINE_CHECKER_PATH).toTestFile()) + } + if (CHECK_TAIL_CALL_OPTIMIZATION in module.directives) { + add(File(TAIL_CALL_OPTIMIZATION_CHECKER_PATH).toTestFile()) + } + } + } +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/DiagnosticsService.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/DiagnosticsService.kt new file mode 100644 index 00000000000..981653b7ac5 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/DiagnosticsService.kt @@ -0,0 +1,49 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.services + +import org.jetbrains.kotlin.test.directives.DiagnosticsDirectives +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.util.* + +class DiagnosticsService(val testServices: TestServices) : TestService { + private val conditionsPerModule: MutableMap> = mutableMapOf() + private val globalDefinedDiagnostics by lazy { + testServices.moduleStructure.allDirectives[DiagnosticsDirectives.DIAGNOSTICS] + } + + fun shouldRenderDiagnostic(module: TestModule, name: String): Boolean { + val condition = conditionsPerModule.getOrPut(module) { + computeDiagnosticConditionForModule(module) + } + return condition(name) + } + + private fun computeDiagnosticConditionForModule(module: TestModule): Condition { + val diagnosticsInDirective = module.directives[DiagnosticsDirectives.DIAGNOSTICS] + globalDefinedDiagnostics + val enabledNames = mutableSetOf() + val disabledNames = mutableSetOf() + for (diagnosticInDirective in diagnosticsInDirective) { + val enabled = when { + diagnosticInDirective.startsWith("+") -> true + diagnosticInDirective.startsWith("-") -> false + else -> error("Incorrect diagnostics directive syntax. See reference:\n${DiagnosticsDirectives.DIAGNOSTICS.description}") + } + val name = diagnosticInDirective.substring(1) + val collection = if (enabled) enabledNames else disabledNames + collection += name + } + if (disabledNames.isEmpty()) return Conditions.alwaysTrue() + var condition = !Conditions.oneOf(disabledNames) + if (enabledNames.isNotEmpty()) { + condition = condition or Conditions.oneOf(enabledNames) + } + return condition.cached() + } + +} + +val TestServices.diagnosticsService: DiagnosticsService by TestServices.testServiceAccessor() diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/JUnit5Assertions.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/JUnit5Assertions.kt new file mode 100644 index 00000000000..670e65e2815 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/JUnit5Assertions.kt @@ -0,0 +1,62 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.services + +import com.intellij.rt.execution.junit.FileComparisonFailure +import org.jetbrains.kotlin.test.util.convertLineSeparators +import org.jetbrains.kotlin.test.util.trimTrailingWhitespacesAndAddNewlineAtEOF +import org.jetbrains.kotlin.utils.rethrow +import org.junit.jupiter.api.function.Executable +import java.io.File +import java.io.IOException +import org.junit.jupiter.api.Assertions as JUnit5PlatformAssertions + +object JUnit5Assertions : Assertions() { + override fun assertEqualsToFile(expectedFile: File, actual: String, sanitizer: (String) -> String, message: () -> String) { + try { + val actualText = actual.trim { it <= ' ' }.convertLineSeparators().trimTrailingWhitespacesAndAddNewlineAtEOF() + if (!expectedFile.exists()) { + expectedFile.writeText(actualText) + org.junit.jupiter.api.fail("Expected data file did not exist. Generating: $expectedFile") + } + val expected = expectedFile.readText().convertLineSeparators() + val expectedText = expected.trim { it <= ' ' }.trimTrailingWhitespacesAndAddNewlineAtEOF() + if (sanitizer.invoke(expectedText) != sanitizer.invoke(actualText)) { + throw FileComparisonFailure( + "${message()}: ${expectedFile.name}", + expected, actual, expectedFile.absolutePath + ) + } + } catch (e: IOException) { + throw rethrow(e) + } + } + + override fun assertEquals(expected: Any?, actual: Any?, message: (() -> String)?) { + JUnit5PlatformAssertions.assertEquals(expected, actual, message?.invoke()) + } + + override fun assertNotEquals(expected: Any?, actual: Any?, message: (() -> String)?) { + JUnit5PlatformAssertions.assertNotEquals(expected, actual, message?.invoke()) + } + + override fun assertTrue(value: Boolean, message: (() -> String)?) { + JUnit5PlatformAssertions.assertTrue(value, message?.invoke()) + } + + override fun assertFalse(value: Boolean, message: (() -> String)?) { + JUnit5PlatformAssertions.assertFalse(value, message?.invoke()) + } + + override fun assertAll(exceptions: List) { + exceptions.singleOrNull()?.let { throw it } + JUnit5PlatformAssertions.assertAll(exceptions.map { Executable { throw it } }) + } + + override fun fail(message: () -> String): Nothing { + org.junit.jupiter.api.fail(message) + } +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/configuration/JsEnvironmentConfigurator.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/configuration/JsEnvironmentConfigurator.kt new file mode 100644 index 00000000000..b7f0929e65f --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/configuration/JsEnvironmentConfigurator.kt @@ -0,0 +1,36 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.services.configuration + +import com.intellij.mock.MockProject +import org.jetbrains.kotlin.config.CompilerConfiguration +import org.jetbrains.kotlin.js.config.JSConfigurationKeys +import org.jetbrains.kotlin.js.config.JsConfig +import org.jetbrains.kotlin.serialization.js.ModuleKind +import org.jetbrains.kotlin.test.directives.JsEnvironmentConfigurationDirectives +import org.jetbrains.kotlin.test.directives.model.DirectivesContainer +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.EnvironmentConfigurator +import org.jetbrains.kotlin.test.services.TestServices +import org.jetbrains.kotlin.test.util.joinToArrayString + +class JsEnvironmentConfigurator(testServices: TestServices) : EnvironmentConfigurator(testServices) { + override val directivesContainers: List + get() = listOf(JsEnvironmentConfigurationDirectives) + + override fun configureCompilerConfiguration(configuration: CompilerConfiguration, module: TestModule, project: MockProject) { + val moduleKinds = module.directives[JsEnvironmentConfigurationDirectives.MODULE_KIND] + val moduleKind = when (moduleKinds.size) { + 0 -> ModuleKind.PLAIN + 1 -> moduleKinds.single() + else -> error("Too many module kinds passed ${moduleKinds.joinToArrayString()}") + } + configuration.put(JSConfigurationKeys.MODULE_KIND, moduleKind) + + configuration.put(JSConfigurationKeys.LIBRARIES, JsConfig.JS_STDLIB) + } +} + diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/configuration/JvmEnvironmentConfigurator.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/configuration/JvmEnvironmentConfigurator.kt new file mode 100644 index 00000000000..8fa8ed5af84 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/configuration/JvmEnvironmentConfigurator.kt @@ -0,0 +1,162 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.services.configuration + +import com.intellij.mock.MockProject +import com.intellij.openapi.util.SystemInfo +import org.jetbrains.kotlin.cli.jvm.config.addJavaSourceRoot +import org.jetbrains.kotlin.cli.jvm.config.addJvmClasspathRoot +import org.jetbrains.kotlin.cli.jvm.config.addJvmClasspathRoots +import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime +import org.jetbrains.kotlin.config.CompilerConfiguration +import org.jetbrains.kotlin.config.JVMConfigurationKeys +import org.jetbrains.kotlin.platform.jvm.JvmPlatforms +import org.jetbrains.kotlin.test.ConfigurationKind +import org.jetbrains.kotlin.test.TestJdkKind +import org.jetbrains.kotlin.test.directives.JvmEnvironmentConfigurationDirectives +import org.jetbrains.kotlin.test.directives.model.DirectivesContainer +import org.jetbrains.kotlin.test.directives.model.RegisteredDirectives +import org.jetbrains.kotlin.test.model.BackendKinds +import org.jetbrains.kotlin.test.model.DependencyKind +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.* +import org.jetbrains.kotlin.test.services.jvm.CompiledJarManager +import org.jetbrains.kotlin.test.services.jvm.compiledJarManager +import org.jetbrains.kotlin.test.util.KtTestUtil +import org.jetbrains.kotlin.test.util.joinToArrayString +import java.io.File + +class JvmEnvironmentConfigurator(testServices: TestServices) : EnvironmentConfigurator(testServices) { + override val directivesContainers: List + get() = listOf(JvmEnvironmentConfigurationDirectives) + + override val additionalServices: List + get() = listOf(service(::CompiledJarManager)) + + override fun configureCompilerConfiguration(configuration: CompilerConfiguration, module: TestModule, project: MockProject) { + if (module.targetPlatform !in JvmPlatforms.allJvmPlatforms) return + val registeredDirectives = module.allRegisteredDirectives + val targets = registeredDirectives[JvmEnvironmentConfigurationDirectives.JVM_TARGET] + when (targets.size) { + 0 -> {} + 1 -> configuration.put(JVMConfigurationKeys.JVM_TARGET, targets.single()) + else -> error("Too many jvm targets passed: ${targets.joinToArrayString()}") + } + + when (extractJdkKind(registeredDirectives)) { + TestJdkKind.MOCK_JDK -> { + configuration.addJvmClasspathRoot(KtTestUtil.findMockJdkRtJar()) + configuration.put(JVMConfigurationKeys.NO_JDK, true) + } + TestJdkKind.MODIFIED_MOCK_JDK -> { + configuration.addJvmClasspathRoot(KtTestUtil.findMockJdkRtModified()) + configuration.put(JVMConfigurationKeys.NO_JDK, true) + } + TestJdkKind.FULL_JDK_6 -> { + val jdk6 = System.getenv("JDK_16") ?: error("Environment variable JDK_16 is not set") + configuration.put(JVMConfigurationKeys.JDK_HOME, File(jdk6)) + } + TestJdkKind.FULL_JDK_9 -> { + configuration.put(JVMConfigurationKeys.JDK_HOME, KtTestUtil.getJdk9Home()) + } + TestJdkKind.FULL_JDK -> { + if (SystemInfo.IS_AT_LEAST_JAVA9) { + configuration.put(JVMConfigurationKeys.JDK_HOME, File(System.getProperty("java.home"))) + } + } + TestJdkKind.ANDROID_API -> { + configuration.addJvmClasspathRoot(KtTestUtil.findAndroidApiJar()) + configuration.put(JVMConfigurationKeys.NO_JDK, true) + } + } + + val configurationKind = extractConfigurationKind(registeredDirectives) + + if (configurationKind.withRuntime) { + configuration.addJvmClasspathRoot(ForTestCompileRuntime.runtimeJarForTests()) + configuration.addJvmClasspathRoot(ForTestCompileRuntime.scriptRuntimeJarForTests()) + configuration.addJvmClasspathRoot(ForTestCompileRuntime.kotlinTestJarForTests()) + } else if (configurationKind.withMockRuntime) { + configuration.addJvmClasspathRoot(ForTestCompileRuntime.minimalRuntimeJarForTests()) + configuration.addJvmClasspathRoot(ForTestCompileRuntime.scriptRuntimeJarForTests()) + } + if (configurationKind.withReflection) { + configuration.addJvmClasspathRoot(ForTestCompileRuntime.reflectJarForTests()) + } + configuration.addJvmClasspathRoot(KtTestUtil.getAnnotationsJar()) + + if (JvmEnvironmentConfigurationDirectives.STDLIB_JDK8 in module.directives) { + configuration.addJvmClasspathRoot(ForTestCompileRuntime.runtimeJarForTestsWithJdk8()) + } + + if (JvmEnvironmentConfigurationDirectives.ANDROID_ANNOTATIONS in module.directives) { + configuration.addJvmClasspathRoot(ForTestCompileRuntime.androidAnnotationsForTests()) + } + + val isIr = module.backendKind == BackendKinds.IrBackend + configuration.put(JVMConfigurationKeys.IR, isIr) + + module.javaFiles.takeIf { it.isNotEmpty() }?.let { javaFiles -> + javaFiles.forEach { testServices.sourceFileProvider.getRealFileForSourceFile(it) } + configuration.addJavaSourceRoot(testServices.sourceFileProvider.javaSourceDirectory) + } + + configuration.registerModuleDependencies(module) + + if (JvmEnvironmentConfigurationDirectives.USE_PSI_CLASS_FILES_READING in module.directives) { + configuration.put(JVMConfigurationKeys.USE_PSI_CLASS_FILES_READING, true) + } + } + + private fun extractJdkKind(registeredDirectives: RegisteredDirectives): TestJdkKind { + val fullJdkEnabled = JvmEnvironmentConfigurationDirectives.FULL_JDK in registeredDirectives + val jdkKinds = registeredDirectives[JvmEnvironmentConfigurationDirectives.JDK_KIND] + + if (fullJdkEnabled) { + if (jdkKinds.isNotEmpty()) { + error("FULL_JDK and JDK_KIND can not be used together") + } + return TestJdkKind.FULL_JDK + } + + return when (jdkKinds.size) { + 0 -> TestJdkKind.MOCK_JDK + 1 -> jdkKinds.single() + else -> error("Too many jdk kinds passed: ${jdkKinds.joinToArrayString()}") + } + } + + private fun extractConfigurationKind(registeredDirectives: RegisteredDirectives): ConfigurationKind { + val withRuntime = JvmEnvironmentConfigurationDirectives.WITH_RUNTIME in registeredDirectives || JvmEnvironmentConfigurationDirectives.WITH_STDLIB in registeredDirectives + val withReflect = JvmEnvironmentConfigurationDirectives.WITH_REFLECT in registeredDirectives + val noRuntime = JvmEnvironmentConfigurationDirectives.NO_RUNTIME in registeredDirectives + if (noRuntime && withRuntime) { + error("NO_RUNTIME and WITH_RUNTIME can not be used together") + } + if (withReflect && !withRuntime) { + error("WITH_REFLECT may be used only with WITH_RUNTIME") + } + return when { + withRuntime && withReflect -> ConfigurationKind.ALL + withRuntime -> ConfigurationKind.NO_KOTLIN_REFLECT + noRuntime -> ConfigurationKind.JDK_NO_RUNTIME + else -> ConfigurationKind.JDK_ONLY + } + } + + private fun CompilerConfiguration.registerModuleDependencies(module: TestModule) { + val dependencyProvider = testServices.dependencyProvider + val modulesFromDependencies = module.dependencies + .filter { it.kind == DependencyKind.Binary } + .map { dependencyProvider.getTestModule(it.moduleName) } + .takeIf { it.isNotEmpty() } + ?: return + val jarManager = testServices.compiledJarManager + val dependenciesClassPath = modulesFromDependencies.map { jarManager.getCompiledJarForModule(it) } + addJvmClasspathRoots(dependenciesClassPath) + } +} + diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/configuration/ScriptingEnvironmentConfigurator.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/configuration/ScriptingEnvironmentConfigurator.kt new file mode 100644 index 00000000000..89aa9fee42f --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/configuration/ScriptingEnvironmentConfigurator.kt @@ -0,0 +1,22 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.services.configuration + +import com.intellij.mock.MockProject +import org.jetbrains.kotlin.config.CompilerConfiguration +import org.jetbrains.kotlin.script.loadScriptingPlugin +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.EnvironmentConfigurator +import org.jetbrains.kotlin.test.services.TestServices +import org.jetbrains.kotlin.test.services.isKtsFile + +class ScriptingEnvironmentConfigurator(testServices: TestServices) : EnvironmentConfigurator(testServices) { + override fun configureCompilerConfiguration(configuration: CompilerConfiguration, module: TestModule, project: MockProject) { + if (module.files.any { it.isKtsFile }) { + loadScriptingPlugin(configuration) + } + } +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/fir/FirOldFrontendMetaConfigurator.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/fir/FirOldFrontendMetaConfigurator.kt new file mode 100644 index 00000000000..ff6d7bc49ec --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/fir/FirOldFrontendMetaConfigurator.kt @@ -0,0 +1,28 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.services.fir + +import org.jetbrains.kotlin.test.directives.FirDiagnosticsDirectives +import org.jetbrains.kotlin.test.services.MetaTestConfigurator +import org.jetbrains.kotlin.test.services.TestServices +import org.jetbrains.kotlin.test.utils.firTestDataFile +import java.io.File + +class FirOldFrontendMetaConfigurator(testServices: TestServices) : MetaTestConfigurator(testServices) { + override fun transformTestDataPath(testDataFileName: String): String { + val originalFile = File(testDataFileName) + val isFirIdentical = originalFile.useLines { it.first() == "// ${FirDiagnosticsDirectives.FIR_IDENTICAL.name}" } + return if (isFirIdentical) { + testDataFileName + } else { + val firFile = originalFile.firTestDataFile + if (!firFile.exists()) { + originalFile.copyTo(firFile) + } + firFile.absolutePath + } + } +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/impl/ModuleStructureExtractorImpl.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/impl/ModuleStructureExtractorImpl.kt new file mode 100644 index 00000000000..eadecfdb5d4 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/impl/ModuleStructureExtractorImpl.kt @@ -0,0 +1,326 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.services.impl + +import org.jetbrains.kotlin.platform.CommonPlatforms +import org.jetbrains.kotlin.platform.TargetPlatform +import org.jetbrains.kotlin.platform.js.JsPlatforms +import org.jetbrains.kotlin.platform.jvm.JvmPlatforms +import org.jetbrains.kotlin.platform.konan.NativePlatforms +import org.jetbrains.kotlin.test.builders.LanguageVersionSettingsBuilder +import org.jetbrains.kotlin.test.directives.ModuleStructureDirectives +import org.jetbrains.kotlin.test.directives.model.ComposedRegisteredDirectives +import org.jetbrains.kotlin.test.directives.model.DirectivesContainer +import org.jetbrains.kotlin.test.directives.model.RegisteredDirectives +import org.jetbrains.kotlin.test.model.* +import org.jetbrains.kotlin.test.services.* +import org.jetbrains.kotlin.test.util.joinToArrayString +import org.jetbrains.kotlin.utils.DFS +import java.io.File + +class ModuleStructureExtractorImpl( + testServices: TestServices, + additionalSourceProviders: List +) : ModuleStructureExtractor(testServices, additionalSourceProviders) { + companion object { + private val allowedExtensionsForFiles = listOf(".kt", ".kts", ".java") + private val moduleDirectiveRegex = """([\w-]+)(\((.*)\))?""".toRegex() + } + + override fun splitTestDataByModules( + testDataFileName: String, + directivesContainer: DirectivesContainer, + ): TestModuleStructure { + val testDataFile = File(testDataFileName) + val extractor = ModuleStructureExtractorWorker(listOf(testDataFile), directivesContainer) + return extractor.splitTestDataByModules() + } + + private inner class ModuleStructureExtractorWorker constructor( + private val testDataFiles: List, + private val directivesContainer: DirectivesContainer, + ) { + private val assertions: Assertions + get() = testServices.assertions + + private val defaultsProvider: DefaultsProvider + get() = testServices.defaultsProvider + + private lateinit var currentTestDataFile: File + + private val defaultFileName: String + get() = currentTestDataFile.name + + private val defaultModuleName: String + get() = "main" + + private var currentModuleName: String? = null + private var currentModuleTargetPlatform: TargetPlatform? = null + private var currentModuleFrontendKind: FrontendKind<*>? = null + private var currentModuleBackendKind: BackendKind<*>? = null + private var currentModuleLanguageVersionSettingsBuilder: LanguageVersionSettingsBuilder = initLanguageSettingsBuilder() + private var dependenciesOfCurrentModule = mutableListOf() + private var filesOfCurrentModule = mutableListOf() + + private var currentFileName: String? = null + private var firstFileInModule: Boolean = true + private var linesOfCurrentFile = mutableListOf() + private var startLineNumberOfCurrentFile = 0 + + private var directivesBuilder = RegisteredDirectivesParser(directivesContainer, assertions) + + private var globalDirectives: RegisteredDirectives? = null + + private val modules = mutableListOf() + + private val moduleDirectiveBuilder = RegisteredDirectivesParser(ModuleStructureDirectives, assertions) + + fun splitTestDataByModules(): TestModuleStructure { + for (testDataFile in testDataFiles) { + currentTestDataFile = testDataFile + val lines = testDataFile.readLines() + lines.forEachIndexed { lineNumber, line -> + val rawDirective = RegisteredDirectivesParser.parseDirective(line) + if (tryParseStructureDirective(rawDirective, lineNumber + 1)) { + linesOfCurrentFile.add(line) + return@forEachIndexed + } + tryParseRegularDirective(rawDirective) + linesOfCurrentFile.add(line) + } + } + finishModule() + val sortedModules = sortModules(modules) + checkCycles(modules) + return TestModuleStructureImpl(sortedModules, testDataFiles) + } + + private fun sortModules(modules: List): List { + val moduleByName = modules.groupBy { it.name }.mapValues { (name, modules) -> + modules.singleOrNull() ?: error("Duplicated modules with name $name") + } + return DFS.topologicalOrder(modules) { module -> + module.dependencies.map { + val moduleName = it.moduleName + moduleByName[moduleName] ?: error("Module \"$moduleName\" not found while observing dependencies of \"${module.name}\"") + } + }.asReversed() + } + + private fun checkCycles(modules: List) { + val visited = mutableSetOf() + for (module in modules) { + val moduleName = module.name + visited.add(moduleName) + for (dependency in module.dependencies) { + val dependencyName = dependency.moduleName + if (dependencyName == moduleName) { + error("Module $moduleName has dependency to itself") + } + if (dependencyName !in visited) { + error("There is cycle in modules dependencies. See modules: $dependencyName, $moduleName") + } + } + } + } + + /* + * returns [true] means that passed directive was module directive and line is processed + */ + private fun tryParseStructureDirective(rawDirective: RegisteredDirectivesParser.RawDirective?, lineNumber: Int): Boolean { + if (rawDirective == null) return false + val (directive, values) = moduleDirectiveBuilder.convertToRegisteredDirective(rawDirective) ?: return false + when (directive) { + ModuleStructureDirectives.MODULE -> { + /* + * There was previous module, so we should save it + */ + if (currentModuleName != null) { + finishModule() + } else { + finishGlobalDirectives() + } + val (moduleName, dependencies) = splitRawModuleStringToNameAndDependencies(values.joinToString(separator = " ")) + currentModuleName = moduleName + dependencies.mapTo(dependenciesOfCurrentModule) { name -> + val kind = defaultsProvider.defaultDependencyKind + DependencyDescription(name, kind, DependencyRelation.Dependency) + } + } + ModuleStructureDirectives.DEPENDENCY, + ModuleStructureDirectives.DEPENDS_ON -> { + val name = values.first() as String + val kind = values.getOrNull(1)?.let { valueOfOrNull(it as String) } ?: defaultsProvider.defaultDependencyKind + val relation = when (directive) { + ModuleStructureDirectives.DEPENDENCY -> DependencyRelation.Dependency + ModuleStructureDirectives.DEPENDS_ON -> DependencyRelation.DependsOn + else -> error("Should not be here") + } + dependenciesOfCurrentModule.add(DependencyDescription(name, kind, relation)) + } + ModuleStructureDirectives.TARGET_FRONTEND -> { + val name = values.singleOrNull() as? String? ?: assertions.fail { + "Target frontend specified incorrectly\nUsage: ${directive.description}" + } + currentModuleFrontendKind = FrontendKinds.fromString(name) ?: assertions.fail { + "Unknown frontend: $name" + } + } + ModuleStructureDirectives.TARGET_BACKEND_KIND -> { + val name = values.singleOrNull() as? String ?: assertions.fail { + "Target backend specified incorrectly\nUsage: ${directive.description}" + } + currentModuleBackendKind = BackendKinds.fromString(name) ?: assertions.fail { + "Unknown backend: $name" + } + } + ModuleStructureDirectives.FILE -> { + if (currentFileName != null) { + finishFile() + } else { + resetFileCaches() + } + currentFileName = (values.first() as String).also(::validateFileName) + startLineNumberOfCurrentFile = lineNumber + } + else -> return false + } + + return true + } + + private fun splitRawModuleStringToNameAndDependencies(moduleDirectiveString: String): Pair> { + val matchResult = moduleDirectiveRegex.matchEntire(moduleDirectiveString) + ?: error("\"$moduleDirectiveString\" doesn't matches with pattern \"moduleName(dep1, dep2)\"") + val (name, _, dependencies) = matchResult.destructured + if (dependencies.isBlank()) return name to emptyList() + return name to dependencies.split(" ") + } + + private fun finishGlobalDirectives() { + globalDirectives = directivesBuilder.build() + resetModuleCaches() + resetFileCaches() + } + + private fun finishModule() { + finishFile() + val moduleDirectives = directivesBuilder.build() + testServices.defaultDirectives + globalDirectives + currentModuleLanguageVersionSettingsBuilder.configureUsingDirectives(moduleDirectives) + val moduleName = currentModuleName ?: defaultModuleName + val testModule = TestModule( + name = moduleName, + targetPlatform = currentModuleTargetPlatform ?: parseModulePlatformByName(moduleName) ?: defaultsProvider.defaultPlatform, + frontendKind = currentModuleFrontendKind ?: defaultsProvider.defaultFrontend, + backendKind = currentModuleBackendKind ?: defaultsProvider.defaultBackend, + files = filesOfCurrentModule, + dependencies = dependenciesOfCurrentModule, + directives = moduleDirectives, + languageVersionSettings = currentModuleLanguageVersionSettingsBuilder.build() + ) + modules += testModule + additionalSourceProviders.flatMapTo(filesOfCurrentModule) { additionalSourceProvider -> + additionalSourceProvider.produceAdditionalFiles( + globalDirectives ?: RegisteredDirectives.Empty, + testModule + ).also { additionalFiles -> + require(additionalFiles.all { it.isAdditional }) { + "Files produced by ${additionalSourceProvider::class.qualifiedName} should have flag `isAdditional = true`" + } + } + } + firstFileInModule = true + resetModuleCaches() + } + + private fun parseModulePlatformByName(moduleName: String): TargetPlatform? { + val nameSuffix = moduleName.substringAfterLast("-", "").toUpperCase() + return when { + nameSuffix == "COMMON" -> CommonPlatforms.defaultCommonPlatform + nameSuffix == "JVM" -> JvmPlatforms.unspecifiedJvmPlatform // TODO(dsavvinov): determine JvmTarget precisely + nameSuffix == "JS" -> JsPlatforms.defaultJsPlatform + nameSuffix == "NATIVE" -> NativePlatforms.unspecifiedNativePlatform + nameSuffix.isEmpty() -> null // TODO(dsavvinov): this leads to 'null'-platform in ModuleDescriptor + else -> throw IllegalStateException("Can't determine platform by name $nameSuffix") + } + } + + private fun finishFile() { + val filename = currentFileName ?: defaultFileName + if (filesOfCurrentModule.any { it.name == filename }) { + error("File with name \"$filename\" already defined in module ${currentModuleName ?: defaultModuleName}") + } + filesOfCurrentModule.add( + TestFile( + relativePath = filename, + originalContent = linesOfCurrentFile.joinToString(separator = System.lineSeparator(), postfix = System.lineSeparator()), + originalFile = currentTestDataFile, + startLineNumberInOriginalFile = startLineNumberOfCurrentFile, + isAdditional = false + ) + ) + firstFileInModule = false + resetFileCaches() + } + + private fun resetModuleCaches() { + firstFileInModule = true + currentModuleName = null + currentModuleTargetPlatform = null + currentModuleFrontendKind = null + currentModuleBackendKind = null + currentModuleLanguageVersionSettingsBuilder = initLanguageSettingsBuilder() + filesOfCurrentModule = mutableListOf() + dependenciesOfCurrentModule = mutableListOf() + directivesBuilder = RegisteredDirectivesParser(directivesContainer, assertions) + } + + private fun resetFileCaches() { + if (!firstFileInModule) { + linesOfCurrentFile = mutableListOf() + } + currentFileName = null + startLineNumberOfCurrentFile = 0 + } + + private fun tryParseRegularDirective(rawDirective: RegisteredDirectivesParser.RawDirective?) { + if (rawDirective == null) return + val parsedDirective = directivesBuilder.convertToRegisteredDirective(rawDirective) ?: return + directivesBuilder.addParsedDirective(parsedDirective) + } + + private fun validateFileName(fileName: String) { + if (!allowedExtensionsForFiles.any { fileName.endsWith(it) }) { + assertions.fail { + "Filename $fileName is not valid. Allowed extensions: ${allowedExtensionsForFiles.joinToArrayString()}" + } + } + } + + private fun initLanguageSettingsBuilder(): LanguageVersionSettingsBuilder { + return defaultsProvider.newLanguageSettingsBuilder() + } + } +} + +private operator fun RegisteredDirectives.plus(other: RegisteredDirectives?): RegisteredDirectives { + return when { + other == null -> this + other.isEmpty() -> this + this.isEmpty() -> other + else -> ComposedRegisteredDirectives(this, other) + } +} + +inline fun > valueOfOrNull(value: String): T? { + for (enumValue in enumValues()) { + if (enumValue.name == value) { + return enumValue + } + } + return null +} + diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/impl/TestModuleStructureImpl.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/impl/TestModuleStructureImpl.kt new file mode 100644 index 00000000000..8b8e0a16151 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/impl/TestModuleStructureImpl.kt @@ -0,0 +1,62 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.services.impl + +import org.jetbrains.kotlin.platform.TargetPlatform +import org.jetbrains.kotlin.platform.js.JsPlatforms +import org.jetbrains.kotlin.platform.jvm.JvmPlatforms +import org.jetbrains.kotlin.platform.konan.NativePlatforms +import org.jetbrains.kotlin.test.directives.model.ComposedRegisteredDirectives +import org.jetbrains.kotlin.test.directives.model.RegisteredDirectives +import org.jetbrains.kotlin.test.model.BinaryKind +import org.jetbrains.kotlin.test.model.ArtifactKinds +import org.jetbrains.kotlin.test.model.DependencyKind +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.TestModuleStructure +import java.io.File + +class TestModuleStructureImpl( + override val modules: List, + override val originalTestDataFiles: List +) : TestModuleStructure() { + override val allDirectives: RegisteredDirectives = ComposedRegisteredDirectives(modules.map { it.directives }) + + @OptIn(ExperimentalStdlibApi::class) + private val targetArtifactsByModule: Map>> = buildMap { + for (module in modules) { + val result = mutableListOf>() + for (dependency in module.dependencies) { + if (dependency.kind == DependencyKind.KLib) { + result += ArtifactKinds.KLib + } + } + module.targetPlatform.toArtifactKind()?.let { result += it } + put(module.name, result) + } + } + + override fun getTargetArtifactKinds(module: TestModule): List> { + return targetArtifactsByModule[module.name] ?: emptyList() + } + + override fun toString(): String { + return buildString { + modules.forEach { + appendLine(it) + appendLine() + } + } + } + + companion object { + private fun TargetPlatform.toArtifactKind(): BinaryKind<*>? = when (this) { + in JvmPlatforms.allJvmPlatforms -> ArtifactKinds.Jvm + in JsPlatforms.allJsPlatforms -> ArtifactKinds.Js + in NativePlatforms.allNativePlatforms -> ArtifactKinds.Native + else -> null + } + } +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/jvm/CompiledJarManager.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/jvm/CompiledJarManager.kt new file mode 100644 index 00000000000..05a7f3da099 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/jvm/CompiledJarManager.kt @@ -0,0 +1,37 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.services.jvm + +import org.jetbrains.kotlin.backend.common.output.SimpleOutputFileCollection +import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys +import org.jetbrains.kotlin.cli.common.output.writeAll +import org.jetbrains.kotlin.test.model.ArtifactKinds +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.TestService +import org.jetbrains.kotlin.test.services.TestServices +import org.jetbrains.kotlin.test.services.compilerConfigurationProvider +import org.jetbrains.kotlin.test.services.dependencyProvider +import java.io.File +import java.nio.file.Files + +class CompiledJarManager(val testServices: TestServices) : TestService { + private val jarCache = mutableMapOf() + + fun getCompiledJarForModule(module: TestModule): File { + return jarCache.getOrPut(module) { + val outputDir = Files.createTempDirectory("module_${module.name}").toFile() + val classFileFactory = testServices.dependencyProvider.getArtifact(module, ArtifactKinds.Jvm).classFileFactory + val outputFileCollection = SimpleOutputFileCollection(classFileFactory.currentOutput) + val messageCollector = testServices.compilerConfigurationProvider.getCompilerConfiguration(module) + .getNotNull(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY) + outputFileCollection.writeAll(outputDir, messageCollector, reportOutputFiles = false) + classFileFactory.releaseGeneratedOutput() + outputDir + } + } +} + +val TestServices.compiledJarManager: CompiledJarManager by TestServices.testServiceAccessor() diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/utils/FileUtils.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/utils/FileUtils.kt new file mode 100644 index 00000000000..89e1a6442b2 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/utils/FileUtils.kt @@ -0,0 +1,28 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.utils + +import java.io.File + +private const val FIR_KT = ".fir.kt" +private const val KT = ".kt" + +val File.isFirTestData: Boolean + get() = name.endsWith(FIR_KT) + +val File.originalTestDataFile: File + get() = if (isFirTestData) { + parentFile.resolve("${name.removeSuffix(FIR_KT)}$KT") + } else { + this + } + +val File.firTestDataFile: File + get() = if (isFirTestData) { + this + } else { + parentFile.resolve("${name.removeSuffix(KT)}$FIR_KT") + } diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/utils/MultiModuleInfoDumper.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/utils/MultiModuleInfoDumper.kt new file mode 100644 index 00000000000..58e705fc21d --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/utils/MultiModuleInfoDumper.kt @@ -0,0 +1,37 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.utils + +import org.jetbrains.kotlin.test.model.TestModule + +abstract class MultiModuleInfoDumper { + abstract fun builderForModule(module: TestModule): StringBuilder + abstract fun generateResultingDump(): String + abstract fun isEmpty(): Boolean +} + +// TODO: consider about tests with multiple testdata files +class MultiModuleInfoDumperImpl(private val moduleHeaderTemplate: String = "Module: %s") : MultiModuleInfoDumper() { + private val builderByModule = LinkedHashMap() + + override fun builderForModule(module: TestModule): StringBuilder { + return builderByModule.getOrPut(module, ::StringBuilder) + } + + override fun generateResultingDump(): String { + builderByModule.values.singleOrNull()?.let { return it.toString() } + return buildString { + for ((module, builder) in builderByModule) { + appendLine(String.format(moduleHeaderTemplate, module.name)) + append(builder) + } + } + } + + override fun isEmpty(): Boolean { + return builderByModule.isEmpty() + } +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/utils/TestDisposable.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/utils/TestDisposable.kt new file mode 100644 index 00000000000..9baa7ebe252 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/utils/TestDisposable.kt @@ -0,0 +1,18 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.utils + +import com.intellij.openapi.Disposable + +class TestDisposable : Disposable { + @Volatile + var isDisposed = false + private set + + override fun dispose() { + isDisposed = true + } +} diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/fir/AbstractFirDiagnosticTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/fir/AbstractFirDiagnosticTest.kt index e3d63ec7f65..d984edb56d9 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/fir/AbstractFirDiagnosticTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/fir/AbstractFirDiagnosticTest.kt @@ -295,7 +295,7 @@ abstract class AbstractFirDiagnosticsTest : AbstractFirBaseDiagnosticsTest() { firFiles.forEach { it.accept(CfgConsistencyChecker) } } - private object CfgConsistencyChecker : FirVisitorVoid() { + object CfgConsistencyChecker : FirVisitorVoid() { override fun visitElement(element: FirElement) { element.acceptChildren(this) } diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/test/KotlinTestUtils.java b/compiler/tests-common/tests/org/jetbrains/kotlin/test/KotlinTestUtils.java index a5390e30c57..fd1d1ba3761 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/test/KotlinTestUtils.java +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/test/KotlinTestUtils.java @@ -52,8 +52,8 @@ import org.jetbrains.kotlin.psi.KtFile; import org.jetbrains.kotlin.psi.KtPsiFactoryKt; import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil; import org.jetbrains.kotlin.storage.LockBasedStorageManager; -import org.jetbrains.kotlin.test.util.JetTestUtilsKt; import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.kotlin.test.util.StringUtilsKt; import org.jetbrains.kotlin.utils.ExceptionUtilsKt; import org.junit.Assert; @@ -291,7 +291,7 @@ public class KotlinTestUtils { public static void assertEqualsToFile(@NotNull String message, @NotNull File expectedFile, @NotNull String actual, @NotNull Function1 sanitizer) { try { - String actualText = JetTestUtilsKt.trimTrailingWhitespacesAndAddNewlineAtEOF(StringUtil.convertLineSeparators(actual.trim())); + String actualText = StringUtilsKt.trimTrailingWhitespacesAndAddNewlineAtEOF(StringUtil.convertLineSeparators(actual.trim())); if (!expectedFile.exists()) { FileUtil.writeToFile(expectedFile, actualText); @@ -299,7 +299,7 @@ public class KotlinTestUtils { } String expected = FileUtil.loadFile(expectedFile, CharsetToolkit.UTF8, true); - String expectedText = JetTestUtilsKt.trimTrailingWhitespacesAndAddNewlineAtEOF(StringUtil.convertLineSeparators(expected.trim())); + String expectedText = StringUtilsKt.trimTrailingWhitespacesAndAddNewlineAtEOF(StringUtil.convertLineSeparators(expected.trim())); if (!Comparing.equal(sanitizer.invoke(expectedText), sanitizer.invoke(actualText))) { throw new FileComparisonFailure(message + ": " + expectedFile.getName(), diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/test/util/jetTestUtils.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/test/util/jetTestUtils.kt index 43c44475b69..c58e214df4e 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/test/util/jetTestUtils.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/test/util/jetTestUtils.kt @@ -24,14 +24,6 @@ import org.jetbrains.kotlin.psi.KtDeclaration import org.jetbrains.kotlin.psi.KtPackageDirective import org.jetbrains.kotlin.psi.KtTreeVisitorVoid -fun String.trimTrailingWhitespaces(): String = - this.split('\n').joinToString(separator = "\n") { it.trimEnd() } - -fun String.trimTrailingWhitespacesAndAddNewlineAtEOF(): String = - this.trimTrailingWhitespaces().let { - result -> if (result.endsWith("\n")) result else result + "\n" - } - fun PsiFile.findElementByCommentPrefix(commentText: String): PsiElement? = findElementsByCommentPrefix(commentText).keys.singleOrNull() diff --git a/js/js.config/src/org/jetbrains/kotlin/platform/js/JsPlatform.kt b/js/js.config/src/org/jetbrains/kotlin/platform/js/JsPlatform.kt index a43f7ceefb3..f0c1c963375 100644 --- a/js/js.config/src/org/jetbrains/kotlin/platform/js/JsPlatform.kt +++ b/js/js.config/src/org/jetbrains/kotlin/platform/js/JsPlatform.kt @@ -15,7 +15,7 @@ abstract class JsPlatform : SimplePlatform("JS") { @Suppress("DEPRECATION_ERROR") object JsPlatforms { - private object DefaultSimpleJsPlatform : JsPlatform() + object DefaultSimpleJsPlatform : JsPlatform() @Deprecated( message = "Should be accessed only by compatibility layer, other clients should use 'defaultJsPlatform'", diff --git a/settings.gradle b/settings.gradle index 09e7e05ae78..4c14693281a 100644 --- a/settings.gradle +++ b/settings.gradle @@ -327,7 +327,8 @@ include ":compiler:fir:cones", ":compiler:fir:analysis-tests" include ":compiler:test-infrastructure", - ":compiler:test-infrastructure-utils" + ":compiler:test-infrastructure-utils", + ":compiler:tests-common-new" include ":idea:idea-frontend-fir:idea-fir-low-level-api" include ":idea:idea-fir-performance-tests" From 32fda13ef9fd55b50b43ac71157de534d5f98ba9 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Wed, 2 Dec 2020 17:23:43 +0300 Subject: [PATCH 092/196] [TEST] Implement test generators for junit 5 based tests --- .../test/generators/NewTestGenerationDSL.kt | 32 +++ .../test/generators/NewTestGeneratorImpl.kt | 262 ++++++++++++++++++ .../kotlin/generators/TestGenerationDSL.kt | 2 +- 3 files changed, 295 insertions(+), 1 deletion(-) create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/generators/NewTestGenerationDSL.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/generators/NewTestGeneratorImpl.kt diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/generators/NewTestGenerationDSL.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/generators/NewTestGenerationDSL.kt new file mode 100644 index 00000000000..1f95054aeb1 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/generators/NewTestGenerationDSL.kt @@ -0,0 +1,32 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.generators + +import org.jetbrains.kotlin.generators.InconsistencyChecker +import org.jetbrains.kotlin.generators.TestGroupSuite +import org.jetbrains.kotlin.generators.testGroupSuite + +fun generateNewTestGroupSuite( + args: Array, + init: TestGroupSuite.() -> Unit +) { + generateNewTestGroupSuite(InconsistencyChecker.hasDryRunArg(args), init) +} + +fun generateNewTestGroupSuite( + dryRun: Boolean = false, + init: TestGroupSuite.() -> Unit +) { + val suite = testGroupSuite(init) + for (testGroup in suite.testGroups) { + for (testClass in testGroup.testClasses) { + val (changed, testSourceFilePath) = NewTestGeneratorImpl.generateAndSave(testClass, dryRun) + if (changed) { + InconsistencyChecker.inconsistencyChecker(dryRun).add(testSourceFilePath) + } + } + } +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/generators/NewTestGeneratorImpl.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/generators/NewTestGeneratorImpl.kt new file mode 100644 index 00000000000..715155167c8 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/generators/NewTestGeneratorImpl.kt @@ -0,0 +1,262 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.generators + +import org.jetbrains.kotlin.generators.MethodGenerator +import org.jetbrains.kotlin.generators.TestGenerator +import org.jetbrains.kotlin.generators.TestGroup +import org.jetbrains.kotlin.generators.impl.* +import org.jetbrains.kotlin.generators.model.* +import org.jetbrains.kotlin.generators.util.GeneratorsFileUtil +import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.TestMetadata +import org.jetbrains.kotlin.utils.Printer +import org.junit.jupiter.api.Nested +import org.junit.jupiter.api.Test +import java.io.File +import java.io.IOException +import java.util.* + +private val METHOD_GENERATORS = listOf( + RunTestMethodGenerator, + SimpleTestClassModelTestAllFilesPresentMethodGenerator, + SimpleTestMethodGenerator, + SingleClassTestModelAllFilesPresentedMethodGenerator +) + +object NewTestGeneratorImpl : TestGenerator(METHOD_GENERATORS) { + private val GENERATED_FILES = HashSet() + + private fun Printer.generateMetadata(testDataSource: TestEntityModel) { + val dataString = testDataSource.dataString + if (dataString != null) { + println("@TestMetadata(\"", dataString, "\")") + } + } + + private fun Printer.generateTestAnnotation() { + println("@Test") + } + + private fun Printer.generateNestedAnnotation(isNested: Boolean) { + if (isNested) { + println("@Nested") + } + } + + private fun Printer.generateTestDataPath(testClassModel: TestClassModel) { + val dataPathRoot = testClassModel.dataPathRoot + if (dataPathRoot != null) { + println("@TestDataPath(\"", dataPathRoot, "\")") + } + } + + private fun Printer.generateParameterAnnotations(testClassModel: TestClassModel) { + for (annotationModel in testClassModel.annotations) { + annotationModel.generate(this) + println() + } + } + + private fun Printer.generateSuppressAllWarnings() { + println("@SuppressWarnings(\"all\")") + } + + override fun generateAndSave(testClass: TestGroup.TestClass, dryRun: Boolean): GenerationResult { + val generatorInstance = TestGeneratorInstance( + testClass.baseDir, + testClass.suiteTestClassName, + testClass.baseTestClassName, + testClass.testModels, + methodGenerators + ) + return generatorInstance.generateAndSave(dryRun) + } + + private class TestGeneratorInstance( + baseDir: String, + suiteTestClassFqName: String, + baseTestClassFqName: String, + private val testClassModels: Collection, + methodGenerators: Map> + ) { + private val methodGenerators = methodGenerators.toMutableMap().apply { + val newGenerator = this.computeIfPresent(CoroutinesTestMethodModel.Kind) { _, _ -> + SimpleTestMethodGenerator + } ?: return@apply + this[CoroutinesTestMethodModel.Kind] = newGenerator + } + + private val baseTestClassPackage: String = baseTestClassFqName.substringBeforeLast('.', "") + private val baseTestClassName: String = baseTestClassFqName.substringAfterLast('.', baseTestClassFqName) + private val suiteClassPackage: String = suiteTestClassFqName.substringBeforeLast('.', baseTestClassPackage) + private val suiteClassName: String = suiteTestClassFqName.substringAfterLast('.', suiteTestClassFqName) + private val testSourceFilePath: String = baseDir + "/" + this.suiteClassPackage.replace(".", "/") + "/" + this.suiteClassName + ".java" + + init { + if (!GENERATED_FILES.add(testSourceFilePath)) { + throw IllegalArgumentException("Same test file already generated in current session: $testSourceFilePath") + } + } + + @Throws(IOException::class) + fun generateAndSave(dryRun: Boolean): GenerationResult { + val generatedCode = generate() + + val testSourceFile = File(testSourceFilePath) + val changed = + GeneratorsFileUtil.isFileContentChangedIgnoringLineSeparators(testSourceFile, generatedCode) + if (!dryRun) { + GeneratorsFileUtil.writeFileIfContentChanged(testSourceFile, generatedCode, false) + } + return GenerationResult(changed, testSourceFilePath) + } + + private fun generate(): String { + val out = StringBuilder() + val p = Printer(out) + + val year = GregorianCalendar()[Calendar.YEAR] + p.println( + """/* + | * Copyright 2010-$year JetBrains s.r.o. and Kotlin Programming Language contributors. + | * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + | */ + |""".trimMargin() + ) + p.println("package $suiteClassPackage;") + p.println() + p.println("import com.intellij.testFramework.TestDataPath;") + p.println("import ${KotlinTestUtils::class.java.canonicalName};") + + for (clazz in testClassModels.flatMapTo(mutableSetOf()) { classModel -> classModel.imports }) { + p.println("import ${clazz.name};") + } + + if (suiteClassPackage != baseTestClassPackage) { + p.println("import $baseTestClassPackage.$baseTestClassName;") + } + + p.println("import ${TestMetadata::class.java.canonicalName};") + p.println("import ${Nested::class.java.canonicalName};") + p.println("import ${Test::class.java.canonicalName};") + p.println() + p.println("import java.io.File;") + p.println("import java.util.regex.Pattern;") + p.println() + p.println("/** This class is generated by {@link ", KotlinTestUtils.TEST_GENERATOR_NAME, "}. DO NOT MODIFY MANUALLY */") + + p.generateSuppressAllWarnings() + + val model: TestClassModel + if (testClassModels.size == 1) { + model = object : DelegatingTestClassModel(testClassModels.single()) { + override val name: String + get() = suiteClassName + } + } else { + model = object : TestClassModel() { + override val innerTestClasses: Collection + get() = testClassModels + + override val methods: Collection + get() = emptyList() + + override val isEmpty: Boolean + get() = false + + override val name: String + get() = suiteClassName + + override val dataString: String? + get() = null + + override val dataPathRoot: String? + get() = null + + override val annotations: Collection + get() = emptyList() + + override val imports: Set> + get() = super.imports + } + } + + generateTestClass(p, model, false) + return out.toString() + } + + private fun generateTestClass(p: Printer, testClassModel: TestClassModel, isNested: Boolean) { + p.generateNestedAnnotation(isNested) + p.generateMetadata(testClassModel) + p.generateTestDataPath(testClassModel) + p.generateParameterAnnotations(testClassModel) + + p.println("public class ${testClassModel.name} extends $baseTestClassName {") + p.pushIndent() + + val testMethods = testClassModel.methods + val innerTestClasses = testClassModel.innerTestClasses + + var first = true + + for (methodModel in testMethods) { + if (methodModel is RunTestMethodModel) continue + if (!methodModel.shouldBeGenerated()) continue + + if (first) { + first = false + } else { + p.println() + } + + generateTestMethod(p, methodModel) + } + + for (innerTestClass in innerTestClasses) { + if (!innerTestClass.isEmpty) { + if (first) { + first = false + } else { + p.println() + } + + generateTestClass(p, innerTestClass, true) + } + } + + p.popIndent() + p.println("}") + } + + private fun generateTestMethod(p: Printer, methodModel: MethodModel) { + val generator = methodGenerators.getValue(methodModel.kind) + + p.generateTestAnnotation() + p.generateMetadata(methodModel) + generator.hackyGenerateSignature(methodModel, p) + p.printWithNoIndent(" {") + p.println() + + p.pushIndent() + + generator.hackyGenerateBody(methodModel, p) + + p.popIndent() + p.println("}") + } + + private fun MethodGenerator.hackyGenerateBody(method: MethodModel, p: Printer) { + @Suppress("UNCHECKED_CAST") + generateBody(method as T, p) + } + + private fun MethodGenerator.hackyGenerateSignature(method: MethodModel, p: Printer) { + @Suppress("UNCHECKED_CAST") + generateSignature(method as T, p) + } + } +} diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/TestGenerationDSL.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/TestGenerationDSL.kt index 9cb4a090161..835cae4cd54 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/TestGenerationDSL.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/TestGenerationDSL.kt @@ -76,7 +76,7 @@ class TestGroup( val testClasses: List get() = _testClasses - inline fun testClass( + inline fun testClass( suiteTestClassName: String = getDefaultSuiteTestClassName(T::class.java.simpleName), useJunit4: Boolean = false, annotations: List = emptyList(), From 3bd3545a05e5ad486e0c89d7a83e6d8ad91b96c7 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Fri, 4 Dec 2020 13:16:56 +0300 Subject: [PATCH 093/196] [TEST] Add abstract test runners for some of compiler test in new infrastructure This commit includes runners for FE 1.0 and FIR diagnostics tests and JVM black box tests for old backend --- .../test/runners/AbstractDiagnosticTest.kt | 65 +++++++++++++++++ .../AbstractDiagnosticUsingJavacTest.kt | 22 ++++++ .../test/runners/AbstractFirDiagnosticTest.kt | 70 +++++++++++++++++++ .../runners/AbstractKotlinCompilerTest.kt | 54 ++++++++++++++ 4 files changed, 211 insertions(+) create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractDiagnosticTest.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractDiagnosticUsingJavacTest.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractFirDiagnosticTest.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractKotlinCompilerTest.kt diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractDiagnosticTest.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractDiagnosticTest.kt new file mode 100644 index 00000000000..9b304e7dd55 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractDiagnosticTest.kt @@ -0,0 +1,65 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.runners + +import org.jetbrains.kotlin.platform.jvm.JvmPlatforms +import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder +import org.jetbrains.kotlin.test.directives.JvmEnvironmentConfigurationDirectives.USE_PSI_CLASS_FILES_READING +import org.jetbrains.kotlin.test.directives.JvmEnvironmentConfigurationDirectives.WITH_STDLIB +import org.jetbrains.kotlin.test.frontend.classic.ClassicFrontendFacade +import org.jetbrains.kotlin.test.frontend.classic.handlers.ClassicDiagnosticsHandler +import org.jetbrains.kotlin.test.frontend.classic.handlers.DeclarationsDumpHandler +import org.jetbrains.kotlin.test.frontend.classic.handlers.FirTestDataConsistencyHandler +import org.jetbrains.kotlin.test.frontend.classic.handlers.OldNewInferenceMetaInfoProcessor +import org.jetbrains.kotlin.test.model.BackendKind +import org.jetbrains.kotlin.test.model.DependencyKind +import org.jetbrains.kotlin.test.model.FrontendKinds +import org.jetbrains.kotlin.test.services.AdditionalDiagnosticsSourceFilesProvider +import org.jetbrains.kotlin.test.services.CoroutineHelpersSourceFilesProvider +import org.jetbrains.kotlin.test.services.configuration.JvmEnvironmentConfigurator +import org.jetbrains.kotlin.test.services.configuration.ScriptingEnvironmentConfigurator + +abstract class AbstractDiagnosticTest : AbstractKotlinCompilerTest() { + override fun TestConfigurationBuilder.configuration() { + globalDefaults { + frontend = FrontendKinds.ClassicFrontend + backend = BackendKind.NoBackend + targetPlatform = JvmPlatforms.defaultJvmPlatform + dependencyKind = DependencyKind.Source + } + + defaultDirectives { + +USE_PSI_CLASS_FILES_READING + } + + enableMetaInfoHandler() + + useConfigurators( + ::JvmEnvironmentConfigurator, + ::ScriptingEnvironmentConfigurator + ) + + useMetaInfoProcessors(::OldNewInferenceMetaInfoProcessor) + useAdditionalSourceProviders( + ::AdditionalDiagnosticsSourceFilesProvider, + ::CoroutineHelpersSourceFilesProvider, + ) + + useFrontendFacades(::ClassicFrontendFacade) + useFrontendHandlers( + ::DeclarationsDumpHandler, + ::ClassicDiagnosticsHandler, + ) + + useAfterAnalysisCheckers(::FirTestDataConsistencyHandler) + + forTestsMatching("compiler/testData/diagnostics/testsWithStdLib/*") { + defaultDirectives { + +WITH_STDLIB + } + } + } +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractDiagnosticUsingJavacTest.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractDiagnosticUsingJavacTest.kt new file mode 100644 index 00000000000..6c9f9bb2a28 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractDiagnosticUsingJavacTest.kt @@ -0,0 +1,22 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.runners + +import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder +import org.jetbrains.kotlin.test.directives.JvmEnvironmentConfigurationDirectives +import org.jetbrains.kotlin.test.frontend.classic.handlers.DiagnosticTestWithJavacSkipConfigurator + +abstract class AbstractDiagnosticUsingJavacTest : AbstractDiagnosticTest() { + override fun configure(builder: TestConfigurationBuilder) { + super.configure(builder) + builder.apply { + defaultDirectives { + +JvmEnvironmentConfigurationDirectives.USE_JAVAC + } + useMetaTestConfigurators(::DiagnosticTestWithJavacSkipConfigurator) + } + } +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractFirDiagnosticTest.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractFirDiagnosticTest.kt new file mode 100644 index 00000000000..1c194a73391 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractFirDiagnosticTest.kt @@ -0,0 +1,70 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.runners + +import org.jetbrains.kotlin.platform.jvm.JvmPlatforms +import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder +import org.jetbrains.kotlin.test.directives.FirDiagnosticsDirectives +import org.jetbrains.kotlin.test.directives.JvmEnvironmentConfigurationDirectives +import org.jetbrains.kotlin.test.frontend.fir.FirFailingTestSuppressor +import org.jetbrains.kotlin.test.frontend.fir.FirFrontendFacade +import org.jetbrains.kotlin.test.frontend.fir.handlers.* +import org.jetbrains.kotlin.test.model.BackendKind +import org.jetbrains.kotlin.test.model.DependencyKind +import org.jetbrains.kotlin.test.model.FrontendKinds +import org.jetbrains.kotlin.test.services.AdditionalDiagnosticsSourceFilesProvider +import org.jetbrains.kotlin.test.services.CoroutineHelpersSourceFilesProvider +import org.jetbrains.kotlin.test.services.configuration.JvmEnvironmentConfigurator +import org.jetbrains.kotlin.test.services.fir.FirOldFrontendMetaConfigurator + +abstract class AbstractFirDiagnosticTest : AbstractKotlinCompilerTest() { + override fun TestConfigurationBuilder.configuration() { + globalDefaults { + frontend = FrontendKinds.FIR + backend = BackendKind.NoBackend + targetPlatform = JvmPlatforms.defaultJvmPlatform + dependencyKind = DependencyKind.Source + } + + enableMetaInfoHandler() + + useConfigurators(::JvmEnvironmentConfigurator) + useAdditionalSourceProviders( + ::AdditionalDiagnosticsSourceFilesProvider, + ::CoroutineHelpersSourceFilesProvider, + ) + useFrontendFacades(::FirFrontendFacade) + useFrontendHandlers( + ::FirDiagnosticsHandler, + ::FirDumpHandler, + ::FirCfgDumpHandler, + ::FirCfgConsistencyHandler, + ) + + forTestsMatching("compiler/testData/diagnostics/*") { + useAfterAnalysisCheckers( + ::FirIdenticalChecker, + ::FirFailingTestSuppressor, + ) + useMetaTestConfigurators(::FirOldFrontendMetaConfigurator) + } + + forTestsMatching("compiler/fir/analysis-tests/testData/*") { + defaultDirectives { + +FirDiagnosticsDirectives.FIR_DUMP + } + } + + forTestsMatching( + "compiler/testData/diagnostics/testsWithStdLib/*" or + "compiler/fir/analysis-tests/testData/resolveWithStdlib/*" + ) { + defaultDirectives { + +JvmEnvironmentConfigurationDirectives.WITH_STDLIB + } + } + } +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractKotlinCompilerTest.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractKotlinCompilerTest.kt new file mode 100644 index 00000000000..89db141e50f --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractKotlinCompilerTest.kt @@ -0,0 +1,54 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.runners + +import com.intellij.testFramework.TestDataFile +import org.jetbrains.kotlin.test.builders.Constructor +import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder +import org.jetbrains.kotlin.test.builders.testRunner +import org.jetbrains.kotlin.test.directives.ConfigurationDirectives +import org.jetbrains.kotlin.test.directives.LanguageSettingsDirectives +import org.jetbrains.kotlin.test.preprocessors.MetaInfosCleanupPreprocessor +import org.jetbrains.kotlin.test.services.JUnit5Assertions +import org.jetbrains.kotlin.test.services.SourceFilePreprocessor +import org.jetbrains.kotlin.types.AbstractTypeChecker +import org.jetbrains.kotlin.types.FlexibleTypeImpl + +abstract class AbstractKotlinCompilerTest { + companion object { + val defaultDirectiveContainers = listOf( + ConfigurationDirectives, + LanguageSettingsDirectives + ) + + val defaultPreprocessors: List> = listOf( + ::MetaInfosCleanupPreprocessor + ) + } + + private val configuration: TestConfigurationBuilder.() -> Unit = { + assertions = JUnit5Assertions + useSourcePreprocessor(*defaultPreprocessors.toTypedArray()) + useDirectives(*defaultDirectiveContainers.toTypedArray()) + configureDebugFlags() + configure(this) + } + + private fun configureDebugFlags() { + AbstractTypeChecker.RUN_SLOW_ASSERTIONS = true + FlexibleTypeImpl.RUN_SLOW_ASSERTIONS = true + } + + abstract fun TestConfigurationBuilder.configuration() + + open fun configure(builder: TestConfigurationBuilder) { + builder.configuration() + } + + fun runTest(@TestDataFile filePath: String) { + testRunner(filePath, configuration).runTest(filePath) + } +} From d7224ad63e531c8abd61e0ee477c52de520e0615 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Fri, 4 Dec 2020 13:28:25 +0300 Subject: [PATCH 094/196] [Build] Add generating and running new compiler tests to gradle --- .idea/runConfigurations/Generate_Compiler_Tests.xml | 3 ++- build.gradle.kts | 2 ++ compiler/tests-common-new/build.gradle.kts | 2 ++ plugins/pill/generate-all-tests/build.gradle.kts | 3 ++- .../test/org/jetbrains/kotlin/pill/generateAllTests/Main.java | 2 ++ 5 files changed, 10 insertions(+), 2 deletions(-) diff --git a/.idea/runConfigurations/Generate_Compiler_Tests.xml b/.idea/runConfigurations/Generate_Compiler_Tests.xml index 6c72d3e9721..44a573c3fb5 100644 --- a/.idea/runConfigurations/Generate_Compiler_Tests.xml +++ b/.idea/runConfigurations/Generate_Compiler_Tests.xml @@ -15,6 +15,7 @@ () } - b checkType { _() } + b checkType { _() } + b checkType { _() } } diff --git a/compiler/testData/diagnostics/tests/classObjects/ClassObjectVisibility.kt b/compiler/testData/diagnostics/tests/classObjects/ClassObjectVisibility.kt index 450938b6ca4..b4a10ef21a4 100644 --- a/compiler/testData/diagnostics/tests/classObjects/ClassObjectVisibility.kt +++ b/compiler/testData/diagnostics/tests/classObjects/ClassObjectVisibility.kt @@ -27,4 +27,4 @@ class CCC() { private companion object { val classObjectVar = 3 } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/classObjects/InnerClassAccessThroughClassObject.kt b/compiler/testData/diagnostics/tests/classObjects/InnerClassAccessThroughClassObject.kt index 13235a7274d..530c42cc791 100644 --- a/compiler/testData/diagnostics/tests/classObjects/InnerClassAccessThroughClassObject.kt +++ b/compiler/testData/diagnostics/tests/classObjects/InnerClassAccessThroughClassObject.kt @@ -48,4 +48,4 @@ fun f() { O.O O.A() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/classObjects/invisibleClassObjects.kt b/compiler/testData/diagnostics/tests/classObjects/invisibleClassObjects.kt index 045e0d7934c..9e882d8676f 100644 --- a/compiler/testData/diagnostics/tests/classObjects/invisibleClassObjects.kt +++ b/compiler/testData/diagnostics/tests/classObjects/invisibleClassObjects.kt @@ -48,4 +48,4 @@ fun test() { a.C.baz() } -fun f(unused: Any) {} \ No newline at end of file +fun f(unused: Any) {} diff --git a/compiler/testData/diagnostics/tests/classObjects/nestedClassInPrivateClassObject.kt b/compiler/testData/diagnostics/tests/classObjects/nestedClassInPrivateClassObject.kt index 95de9ebe69f..500609fcadb 100644 --- a/compiler/testData/diagnostics/tests/classObjects/nestedClassInPrivateClassObject.kt +++ b/compiler/testData/diagnostics/tests/classObjects/nestedClassInPrivateClassObject.kt @@ -12,4 +12,4 @@ class A { fun f1() = A.Companion.B.C -fun f2() = A.Companion.B.C.foo() \ No newline at end of file +fun f2() = A.Companion.B.C.foo() diff --git a/compiler/testData/diagnostics/tests/classObjects/typeParametersInAnnonymousObject.fir.kt b/compiler/testData/diagnostics/tests/classObjects/typeParametersInAnnonymousObject.fir.kt index d55f0669343..e2eb8b5226b 100644 --- a/compiler/testData/diagnostics/tests/classObjects/typeParametersInAnnonymousObject.fir.kt +++ b/compiler/testData/diagnostics/tests/classObjects/typeParametersInAnnonymousObject.fir.kt @@ -1,5 +1,5 @@ // !LANGUAGE: -ProhibitTypeParametersInAnonymousObjects -// !DIAGNOSTICS: -UNUSED_VARIABLE! +// !DIAGNOSTICS: -UNUSED_VARIABLE // ISSUE: KT-28999 fun case_1() { @@ -37,4 +37,4 @@ inline fun case_5() { // z is {T!! & T!!} (smart cast from T) println(z) } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/classObjects/typeParametersInAnnonymousObject.kt b/compiler/testData/diagnostics/tests/classObjects/typeParametersInAnnonymousObject.kt index 6ffa6c57dca..002ce8da2e0 100644 --- a/compiler/testData/diagnostics/tests/classObjects/typeParametersInAnnonymousObject.kt +++ b/compiler/testData/diagnostics/tests/classObjects/typeParametersInAnnonymousObject.kt @@ -1,5 +1,5 @@ // !LANGUAGE: -ProhibitTypeParametersInAnonymousObjects -// !DIAGNOSTICS: -UNUSED_VARIABLE! +// !DIAGNOSTICS: -UNUSED_VARIABLE // ISSUE: KT-28999 fun case_1() { @@ -37,4 +37,4 @@ inline fun case_5() { // z is {T!! & T!!} (smart cast from T) println(z) } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/classObjects/typeParametersInAnnonymousObject_after.fir.kt b/compiler/testData/diagnostics/tests/classObjects/typeParametersInAnnonymousObject_after.fir.kt index 8a5ed8f3ddc..e7f7ba14ef1 100644 --- a/compiler/testData/diagnostics/tests/classObjects/typeParametersInAnnonymousObject_after.fir.kt +++ b/compiler/testData/diagnostics/tests/classObjects/typeParametersInAnnonymousObject_after.fir.kt @@ -1,5 +1,5 @@ // !LANGUAGE: +ProhibitTypeParametersInAnonymousObjects -// !DIAGNOSTICS: -UNUSED_VARIABLE! +// !DIAGNOSTICS: -UNUSED_VARIABLE // ISSUE: KT-28999 fun case_1() { @@ -37,4 +37,4 @@ inline fun case_5() { // z is {T!! & T!!} (smart cast from T) println(z) } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/classObjects/typeParametersInAnnonymousObject_after.kt b/compiler/testData/diagnostics/tests/classObjects/typeParametersInAnnonymousObject_after.kt index 3ebe56c899a..c49a042b252 100644 --- a/compiler/testData/diagnostics/tests/classObjects/typeParametersInAnnonymousObject_after.kt +++ b/compiler/testData/diagnostics/tests/classObjects/typeParametersInAnnonymousObject_after.kt @@ -1,5 +1,5 @@ // !LANGUAGE: +ProhibitTypeParametersInAnonymousObjects -// !DIAGNOSTICS: -UNUSED_VARIABLE! +// !DIAGNOSTICS: -UNUSED_VARIABLE // ISSUE: KT-28999 fun case_1() { @@ -37,4 +37,4 @@ inline fun case_5() { // z is {T!! & T!!} (smart cast from T) println(z) } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/collectionLiterals/argumentsOfAnnotation.fir.kt b/compiler/testData/diagnostics/tests/collectionLiterals/argumentsOfAnnotation.fir.kt index 8d8a92f1776..4e31748b737 100644 --- a/compiler/testData/diagnostics/tests/collectionLiterals/argumentsOfAnnotation.fir.kt +++ b/compiler/testData/diagnostics/tests/collectionLiterals/argumentsOfAnnotation.fir.kt @@ -28,4 +28,4 @@ fun test6() {} fun test7() {} @Foo([two], [], []) -fun test8() {} \ No newline at end of file +fun test8() {} diff --git a/compiler/testData/diagnostics/tests/collectionLiterals/argumentsOfAnnotation.kt b/compiler/testData/diagnostics/tests/collectionLiterals/argumentsOfAnnotation.kt index 6edf95ba193..ceef3df9972 100644 --- a/compiler/testData/diagnostics/tests/collectionLiterals/argumentsOfAnnotation.kt +++ b/compiler/testData/diagnostics/tests/collectionLiterals/argumentsOfAnnotation.kt @@ -9,7 +9,7 @@ fun test1() {} @Foo([], [], []) fun test2() {} -@Foo([1f], [' '], [1]) +@Foo([1f], [' '], [1]) fun test3() {} @Foo(c = [1f], b = [""], a = [1]) @@ -28,4 +28,4 @@ fun test6() {} fun test7() {} @Foo([two], [], []) -fun test8() {} \ No newline at end of file +fun test8() {} diff --git a/compiler/testData/diagnostics/tests/collectionLiterals/argumentsOfAnnotationWithKClass.fir.kt b/compiler/testData/diagnostics/tests/collectionLiterals/argumentsOfAnnotationWithKClass.fir.kt index 7257757a18f..9a5435fc1a9 100644 --- a/compiler/testData/diagnostics/tests/collectionLiterals/argumentsOfAnnotationWithKClass.fir.kt +++ b/compiler/testData/diagnostics/tests/collectionLiterals/argumentsOfAnnotationWithKClass.fir.kt @@ -28,4 +28,4 @@ fun test5() {} fun test6() {} @Bar -fun test7() {} \ No newline at end of file +fun test7() {} diff --git a/compiler/testData/diagnostics/tests/collectionLiterals/argumentsOfAnnotationWithKClass.kt b/compiler/testData/diagnostics/tests/collectionLiterals/argumentsOfAnnotationWithKClass.kt index d6b580b90c3..dd2544879a2 100644 --- a/compiler/testData/diagnostics/tests/collectionLiterals/argumentsOfAnnotationWithKClass.kt +++ b/compiler/testData/diagnostics/tests/collectionLiterals/argumentsOfAnnotationWithKClass.kt @@ -21,11 +21,11 @@ fun test3() {} @Foo([Gen::class]) fun test4() {} -@Foo([""]) +@Foo([""]) fun test5() {} -@Foo([Int::class, 1]) +@Foo([Int::class, 1]) fun test6() {} @Bar -fun test7() {} \ No newline at end of file +fun test7() {} diff --git a/compiler/testData/diagnostics/tests/collectionLiterals/basicCollectionLiterals.kt b/compiler/testData/diagnostics/tests/collectionLiterals/basicCollectionLiterals.kt index 3a7a4ec7c5e..07786079938 100644 --- a/compiler/testData/diagnostics/tests/collectionLiterals/basicCollectionLiterals.kt +++ b/compiler/testData/diagnostics/tests/collectionLiterals/basicCollectionLiterals.kt @@ -3,11 +3,11 @@ // !DIAGNOSTICS: -UNUSED_VARIABLE, -UNSUPPORTED fun test() { - val a = [] + val a = [] val b: Array = [] val c = [1, 2] val d: Array = [1, 2] - val e: Array = [1] + val e: Array = [1] val f: IntArray = [1, 2] val g = [f] @@ -20,5 +20,5 @@ fun check() { val f: IntArray = [1] [f] checkType { _>() } - [1, ""] checkType { _>() } -} \ No newline at end of file + [1, ""] checkType { _>() } +} diff --git a/compiler/testData/diagnostics/tests/collectionLiterals/collectionLiteralsWithVarargs.kt b/compiler/testData/diagnostics/tests/collectionLiterals/collectionLiteralsWithVarargs.kt index 2da19fbbd30..a0006c690cd 100644 --- a/compiler/testData/diagnostics/tests/collectionLiterals/collectionLiteralsWithVarargs.kt +++ b/compiler/testData/diagnostics/tests/collectionLiterals/collectionLiteralsWithVarargs.kt @@ -17,7 +17,7 @@ fun test1_0() {} @Ann1(*["a", "b"]) fun test1_1() {} -@Ann1(*["a", 1, null]) +@Ann1(*["a", 1, null]) fun test1_2() {} @Ann2(*[]) @@ -34,8 +34,8 @@ fun test6() {} annotation class AnnArray(val a: Array) -@AnnArray(*["/"]) +@AnnArray(*["/"]) fun testArray() {} -@Ann1([""]) -fun testVararg() {} \ No newline at end of file +@Ann1([""]) +fun testVararg() {} diff --git a/compiler/testData/diagnostics/tests/collectionLiterals/defaultValuesInAnnotation.fir.kt b/compiler/testData/diagnostics/tests/collectionLiterals/defaultValuesInAnnotation.fir.kt index 430fa697b4d..a1bfe7d140d 100644 --- a/compiler/testData/diagnostics/tests/collectionLiterals/defaultValuesInAnnotation.fir.kt +++ b/compiler/testData/diagnostics/tests/collectionLiterals/defaultValuesInAnnotation.fir.kt @@ -23,4 +23,4 @@ annotation class Base( annotation class Err( val a: IntArray = [1L], val b: Array = [1] -) \ No newline at end of file +) diff --git a/compiler/testData/diagnostics/tests/collectionLiterals/defaultValuesInAnnotation.kt b/compiler/testData/diagnostics/tests/collectionLiterals/defaultValuesInAnnotation.kt index 7cac11d1d28..066ee75a200 100644 --- a/compiler/testData/diagnostics/tests/collectionLiterals/defaultValuesInAnnotation.kt +++ b/compiler/testData/diagnostics/tests/collectionLiterals/defaultValuesInAnnotation.kt @@ -8,9 +8,9 @@ annotation class Foo( ) annotation class Bar( - val a: Array = [' '], - val b: Array = ["", ''], - val c: Array = [1] + val a: Array = [' '], + val b: Array = ["", ''], + val c: Array = [1] ) annotation class Base( @@ -22,5 +22,5 @@ annotation class Base( annotation class Err( val a: IntArray = [1L], - val b: Array = [1] -) \ No newline at end of file + val b: Array = [1] +) diff --git a/compiler/testData/diagnostics/tests/collectionLiterals/noCollectionLiterals.fir.kt b/compiler/testData/diagnostics/tests/collectionLiterals/noCollectionLiterals.fir.kt index 9683fe6ce68..8d9d3afaa65 100644 --- a/compiler/testData/diagnostics/tests/collectionLiterals/noCollectionLiterals.fir.kt +++ b/compiler/testData/diagnostics/tests/collectionLiterals/noCollectionLiterals.fir.kt @@ -13,4 +13,4 @@ fun test(): Array { fun foo(a: Array = [""]) {} -class A(val a: Array = []) \ No newline at end of file +class A(val a: Array = []) diff --git a/compiler/testData/diagnostics/tests/collectionLiterals/noCollectionLiterals.kt b/compiler/testData/diagnostics/tests/collectionLiterals/noCollectionLiterals.kt index c0540ede71d..c304ad29e5a 100644 --- a/compiler/testData/diagnostics/tests/collectionLiterals/noCollectionLiterals.kt +++ b/compiler/testData/diagnostics/tests/collectionLiterals/noCollectionLiterals.kt @@ -6,11 +6,11 @@ fun test(): Array { foo([""]) - val p = [1, 2] + [3, 4] + val p = [1, 2] + [3, 4] return [1, 2] } fun foo(a: Array = [""]) {} -class A(val a: Array = []) \ No newline at end of file +class A(val a: Array = []) diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/UninitializedOrReassignedVariables.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/UninitializedOrReassignedVariables.kt index f05e034c6d9..49aaab0a508 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/UninitializedOrReassignedVariables.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/UninitializedOrReassignedVariables.kt @@ -241,7 +241,7 @@ class Outer() { } class ForwardAccessToBackingField() { //kt-147 - val a = a // error + val a = a // error val b = c // error val c = 1 } diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/elvisNotProcessed.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/elvisNotProcessed.kt index 285fee4684d..b0c9a2b188f 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/elvisNotProcessed.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/elvisNotProcessed.kt @@ -12,16 +12,16 @@ else { } val ww = if (true) { - { true } ?: null!! + { true } ?: null!! } else if (true) { - { true } ?: null!! + { true } ?: null!! } else { null!! } -val n = null ?: (null ?: { true }) +val n = null ?: (null ?: { true }) fun l(): (() -> Boolean)? = null @@ -34,6 +34,6 @@ val bbb = null ?: ( l() ?: null) val bbbb = ( l() ?: null) ?: ( l() ?: null) fun f(x : Long?): Long { - var a = x ?: (fun() {} ?: fun() {}) - return a + var a = x ?: (fun() {} ?: fun() {}) + return a } diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/initializationInLambda.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/initializationInLambda.kt index 82b424397a1..324128fc16e 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/initializationInLambda.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/initializationInLambda.kt @@ -74,4 +74,4 @@ val z = if (true) { } 42 } -else 0 \ No newline at end of file +else 0 diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt10805.fir.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt10805.fir.kt index 35863e4997f..324a2ca54f3 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt10805.fir.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt10805.fir.kt @@ -10,4 +10,4 @@ else if (true) { } else { null!! -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt10805.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt10805.kt index b756f2953c5..e1635a535e2 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt10805.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt10805.kt @@ -2,12 +2,12 @@ // AssertionError for nested ifs with lambdas and Nothing as results // NI_EXPECTED_FILE -val fn = if (true) { - { true } +val fn = if (true) { + { true } } else if (true) { - { true } + { true } } else { null!! -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/lateinitWithErroneousDelegation.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/lateinitWithErroneousDelegation.kt index 36b4329af77..758d32d3b6a 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/lateinitWithErroneousDelegation.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/lateinitWithErroneousDelegation.kt @@ -8,4 +8,4 @@ class Foo { } constructor(x: String, y: String): this(y.hashCode()) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/controlStructures/forLoopWithNullableRange.kt b/compiler/testData/diagnostics/tests/controlStructures/forLoopWithNullableRange.kt index 301875344bf..ee459b76cc7 100644 --- a/compiler/testData/diagnostics/tests/controlStructures/forLoopWithNullableRange.kt +++ b/compiler/testData/diagnostics/tests/controlStructures/forLoopWithNullableRange.kt @@ -13,4 +13,4 @@ fun test(c: Coll?) { if (c != null) { for(x in c) {} } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/controlStructures/ifElseIntersection.fir.kt b/compiler/testData/diagnostics/tests/controlStructures/ifElseIntersection.fir.kt index 659695922fc..b52322eb1bf 100644 --- a/compiler/testData/diagnostics/tests/controlStructures/ifElseIntersection.fir.kt +++ b/compiler/testData/diagnostics/tests/controlStructures/ifElseIntersection.fir.kt @@ -52,4 +52,4 @@ fun bindNoGeneric(r: SimpleOption): SimpleOption { if (true) SimpleNone() else r } else r -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/controlStructures/ifElseIntersection.kt b/compiler/testData/diagnostics/tests/controlStructures/ifElseIntersection.kt index 50ce5450183..70d7296007c 100644 --- a/compiler/testData/diagnostics/tests/controlStructures/ifElseIntersection.kt +++ b/compiler/testData/diagnostics/tests/controlStructures/ifElseIntersection.kt @@ -9,7 +9,7 @@ class None : Option fun bind(r: Option): Option { return if (r is Some) { // Ideally we should infer Option here (see KT-10896) - (if (true) None() else r) checkType { _>() } + (if (true) None() else r) checkType { _>() } // Works correctly if (true) None() else r } @@ -25,9 +25,9 @@ fun bind2(r: Option): Option { } fun bind3(r: Option): Option { - return if (r is Some) { + return if (r is Some) { // Diagnoses an error correctly - if (true) None() else r + if (true) None() else r } else r } @@ -52,4 +52,4 @@ fun bindNoGeneric(r: SimpleOption): SimpleOption { if (true) SimpleNone() else r } else r -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/controlStructures/ifInResultOfLambda.kt b/compiler/testData/diagnostics/tests/controlStructures/ifInResultOfLambda.kt index ddc70e1faf6..81e9c4c25ad 100644 --- a/compiler/testData/diagnostics/tests/controlStructures/ifInResultOfLambda.kt +++ b/compiler/testData/diagnostics/tests/controlStructures/ifInResultOfLambda.kt @@ -1,9 +1,9 @@ // !WITH_NEW_INFERENCE // NI_EXPECTED_FILE -val test1 = { if (true) 1 else "" } +val test1 = { if (true) 1 else "" } -val test2 = { { if (true) 1 else "" } } +val test2 = { { if (true) 1 else "" } } val test3: (Boolean) -> Any = { if (it) 1 else "" } diff --git a/compiler/testData/diagnostics/tests/controlStructures/ifToAnyDiscriminatingUsages.fir.kt b/compiler/testData/diagnostics/tests/controlStructures/ifToAnyDiscriminatingUsages.fir.kt index e51b1f00981..83926c282f8 100644 --- a/compiler/testData/diagnostics/tests/controlStructures/ifToAnyDiscriminatingUsages.fir.kt +++ b/compiler/testData/diagnostics/tests/controlStructures/ifToAnyDiscriminatingUsages.fir.kt @@ -59,4 +59,4 @@ val testUsage3 = else println() val testUsage4: Any get() = - if (true) 42 else println() \ No newline at end of file + if (true) 42 else println() diff --git a/compiler/testData/diagnostics/tests/controlStructures/ifToAnyDiscriminatingUsages.kt b/compiler/testData/diagnostics/tests/controlStructures/ifToAnyDiscriminatingUsages.kt index 0683a8d26f9..13910df8e7a 100644 --- a/compiler/testData/diagnostics/tests/controlStructures/ifToAnyDiscriminatingUsages.kt +++ b/compiler/testData/diagnostics/tests/controlStructures/ifToAnyDiscriminatingUsages.kt @@ -17,8 +17,8 @@ fun testResultOfLambda2() = fun testResultOfAnonFun1() = run(fun () = - if (true) 42 - else println() + if (true) 42 + else println() ) fun testResultOfAnonFun2() = @@ -28,7 +28,7 @@ fun testResultOfAnonFun2() = fun testReturnFromAnonFun() = run(fun () { - return if (true) 42 else println() + return if (true) 42 else println() }) fun testReturn1() = @@ -59,4 +59,4 @@ val testUsage3 = else println() val testUsage4: Any get() = - if (true) 42 else println() \ No newline at end of file + if (true) 42 else println() diff --git a/compiler/testData/diagnostics/tests/controlStructures/ifWhenWithoutElse.kt b/compiler/testData/diagnostics/tests/controlStructures/ifWhenWithoutElse.kt index e1919cfa837..74a3a404a95 100644 --- a/compiler/testData/diagnostics/tests/controlStructures/ifWhenWithoutElse.kt +++ b/compiler/testData/diagnostics/tests/controlStructures/ifWhenWithoutElse.kt @@ -20,10 +20,10 @@ val xx6 = null ?: if (true) 42 val xx7 = "" + if (true) 42 val wxx1 = when { true -> 42 } -val wxx2: Unit = when { true -> 42 } +val wxx2: Unit = when { true -> 42 } val wxx3 = idAny(when { true -> 42 }) val wxx4 = id(when { true -> 42 }) -val wxx5 = idUnit(when { true -> 42 }) +val wxx5 = idUnit(when { true -> 42 }) val wxx6 = null ?: when { true -> 42 } val wxx7 = "" + when { true -> 42 } @@ -51,8 +51,8 @@ fun g1() = when { true -> work() } fun g2() = when { true -> mlist.add() } fun g3() = when { true -> 42 } fun g4(): Unit = when { true -> work() } -fun g5(): Unit = when { true -> mlist.add() } -fun g6(): Unit = when { true -> 42 } +fun g5(): Unit = when { true -> mlist.add() } +fun g6(): Unit = when { true -> 42 } fun foo1(x: String?) { "" + if (true) 42 diff --git a/compiler/testData/diagnostics/tests/controlStructures/improperElseInExpression.fir.kt b/compiler/testData/diagnostics/tests/controlStructures/improperElseInExpression.fir.kt index 37264a2ff93..c36cb381506 100644 --- a/compiler/testData/diagnostics/tests/controlStructures/improperElseInExpression.fir.kt +++ b/compiler/testData/diagnostics/tests/controlStructures/improperElseInExpression.fir.kt @@ -31,4 +31,4 @@ fun example() { } return if (true) true else {} -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/controlStructures/improperElseInExpression.kt b/compiler/testData/diagnostics/tests/controlStructures/improperElseInExpression.kt index d66646b08e3..8d2405da327 100644 --- a/compiler/testData/diagnostics/tests/controlStructures/improperElseInExpression.kt +++ b/compiler/testData/diagnostics/tests/controlStructures/improperElseInExpression.kt @@ -30,5 +30,5 @@ fun example() { return if (true) true } - return if (true) true else {} -} \ No newline at end of file + return if (true) true else {} +} diff --git a/compiler/testData/diagnostics/tests/controlStructures/kt10717.kt b/compiler/testData/diagnostics/tests/controlStructures/kt10717.kt index 9fd3e1f8d1f..b60a60d110b 100644 --- a/compiler/testData/diagnostics/tests/controlStructures/kt10717.kt +++ b/compiler/testData/diagnostics/tests/controlStructures/kt10717.kt @@ -1,21 +1,21 @@ // !DIAGNOSTICS: -UNUSED_EXPRESSION -UNREACHABLE_CODE -UNUSED_PARAMETER -RETURN_NOT_ALLOWED fun test1() = run { - return "OK" + return "OK" } fun test2() = run { fun local(): String { return "" } - return "" + return "" } inline fun Iterable.map(transform: (T) -> R): List = null!! fun test3(a: List, b: List) = a.map { - if (it.length == 3) return ")!>null - if (it.length == 4) return ")!>"" - if (it.length == 4) return ")!>5 + if (it.length == 3) return ")!>null + if (it.length == 4) return ")!>"" + if (it.length == 4) return ")!>5 if (it.length == 4) return b 1 } diff --git a/compiler/testData/diagnostics/tests/controlStructures/kt1075.fir.kt b/compiler/testData/diagnostics/tests/controlStructures/kt1075.fir.kt index 6883418762e..467ad06f857 100644 --- a/compiler/testData/diagnostics/tests/controlStructures/kt1075.fir.kt +++ b/compiler/testData/diagnostics/tests/controlStructures/kt1075.fir.kt @@ -9,4 +9,4 @@ fun foo(b: String) { in 1..10 -> 1 //no type mismatch, but it should be here else -> 2 } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/controlStructures/kt1075.kt b/compiler/testData/diagnostics/tests/controlStructures/kt1075.kt index 98b5c0b356a..e7adc4b5300 100644 --- a/compiler/testData/diagnostics/tests/controlStructures/kt1075.kt +++ b/compiler/testData/diagnostics/tests/controlStructures/kt1075.kt @@ -5,8 +5,8 @@ package kt1075 fun foo(b: String) { if (b in 1..10) {} //type mismatch - when (b) { + when (b) { in 1..10 -> 1 //no type mismatch, but it should be here else -> 2 } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/controlStructures/kt4310.fir.kt b/compiler/testData/diagnostics/tests/controlStructures/kt4310.fir.kt index 4096d674340..257f5363802 100644 --- a/compiler/testData/diagnostics/tests/controlStructures/kt4310.fir.kt +++ b/compiler/testData/diagnostics/tests/controlStructures/kt4310.fir.kt @@ -9,4 +9,4 @@ fun test(a: Boolean, b: Boolean): Int { 3 } } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/controlStructures/kt4310.kt b/compiler/testData/diagnostics/tests/controlStructures/kt4310.kt index 90d1e3ba2f7..61d0be8b5de 100644 --- a/compiler/testData/diagnostics/tests/controlStructures/kt4310.kt +++ b/compiler/testData/diagnostics/tests/controlStructures/kt4310.kt @@ -4,9 +4,9 @@ package f fun test(a: Boolean, b: Boolean): Int { return if(a) { 1 - } else { - if (b) { + } else { + if (b) { 3 } } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/controlStructures/kt770.kt351.kt735_StatementType.fir.kt b/compiler/testData/diagnostics/tests/controlStructures/kt770.kt351.kt735_StatementType.fir.kt new file mode 100644 index 00000000000..2588f6cc895 --- /dev/null +++ b/compiler/testData/diagnostics/tests/controlStructures/kt770.kt351.kt735_StatementType.fir.kt @@ -0,0 +1,160 @@ +// !WITH_NEW_INFERENCE +// !DIAGNOSTICS: -UNREACHABLE_CODE +package kt770_351_735 + + +//KT-770 Reference is not resolved to anything, but is not marked unresolved +fun main() { + var i = 0 + when (i) { + 1 -> i-- + 2 -> i = 2 // i is surrounded by a black border + else -> j = 2 + } + System.out.println(i) +} + +//KT-351 Distinguish statement and expression positions +val w = while (true) {} + +fun foo() { + var z = 2 + val r = { // type fun(): Any is inferred + if (true) { + 2 + } + else { + z = 34 + } + } + val f: ()-> Int = r + val g: ()-> Any = r +} + +//KT-735 Statements without braces are prohibited on the right side of when entries. +fun box() : Int { + val d = 2 + var z = 0 + when(d) { + 5, 3 -> z++ + else -> z = -1000 + } + return z +} + +//More tests + +fun test1() { while(true) {} } +fun test2(): Unit { while(true) {} } + +fun testCoercionToUnit() { + val simple: ()-> Unit = { + 41 + } + val withIf: ()-> Unit = { + if (true) { + 3 + } else { + 45 + } + } + val i = 34 + val withWhen : () -> Unit = { + when(i) { + 1 -> { + val d = 34 + "1" + doSmth(d) + + } + 2 -> '4' + else -> true + } + } + + var x = 43 + val checkType = { + if (true) { + x = 4 + } else { + 45 + } + } + val f : () -> String = checkType +} + +fun doSmth(i: Int) {} + +fun testImplicitCoercion() { + val d = 21 + var z = 0 + var i = when(d) { + 3 -> null + 4 -> { val z = 23 } + else -> z = 20 + } + + var u = when(d) { + 3 -> { z = 34 } + else -> z-- + } + + var iff = if (true) { + z = 34 + } + val g = if (true) 4 + val h = if (false) 4 else {} + + bar(if (true) { + 4 + } else { + z = 342 + }) +} + +fun fooWithAnyArg(arg: Any) {} +fun fooWithAnyNullableArg(arg: Any?) {} + +fun testCoercionToAny() { + val d = 21 + val x1: Any = if (1>2) 1 else 2.0 + val x2: Any? = if (1>2) 1 else 2.0 + val x3: Any? = if (1>2) 1 else (if (1>2) null else 2.0) + + fooWithAnyArg(if (1>2) 1 else 2.0) + fooWithAnyNullableArg(if (1>2) 1 else 2.0) + fooWithAnyNullableArg(if (1>2) 1 else (if (1>2) null else 2.0)) + + val y1: Any = when(d) { 1 -> 1.0 else -> 2.0 } + val y2: Any? = when(d) { 1 -> 1.0 else -> 2.0 } + val y3: Any? = when(d) { 1 -> 1.0; 2 -> null; else -> 2.0 } + + fooWithAnyArg(when(d) { 1 -> 1.0 else -> 2.0 }) + fooWithAnyNullableArg(when(d) { 1 -> 1.0 else -> 2.0 }) + fooWithAnyNullableArg(when(d) { 1 -> 1.0; 2 -> null; else -> 2.0 }) +} + +fun fooWithAnuNullableResult(s: String?, name: String, optional: Boolean): Any? { + return if (s == null) { + if (!optional) { + throw java.lang.IllegalArgumentException("Parameter '$name' was not found in the request") + } + null + } else { + name + } +} + +fun bar(a: Unit) {} + +fun testStatementInExpressionContext() { + var z = 34 + val a1: Unit = z = 334 + val f = for (i in 1..10) {} + if (true) return z = 34 + return while (true) {} +} + +fun testStatementInExpressionContext2() { + val a2: Unit = while(true) {} +} diff --git a/compiler/testData/diagnostics/tests/controlStructures/kt770.kt351.kt735_StatementType.kt b/compiler/testData/diagnostics/tests/controlStructures/kt770.kt351.kt735_StatementType.kt index 801f663679e..f1a587fb3e9 100644 --- a/compiler/testData/diagnostics/tests/controlStructures/kt770.kt351.kt735_StatementType.kt +++ b/compiler/testData/diagnostics/tests/controlStructures/kt770.kt351.kt735_StatementType.kt @@ -95,9 +95,7 @@ fun testImplicitCoercion() { } var u = when(d) { - 3 -> { - z = 34 - } + 3 -> { z = 34 } else -> z-- } @@ -107,10 +105,9 @@ fun testImplicitCoercion() { val g = if (true) 4 val h = if (false) 4 else {} - bar(if (true) { - 4 - } - else { + bar(if (true) { + 4 + } else { z = 342 }) } @@ -160,4 +157,4 @@ fun testStatementInExpressionContext() { fun testStatementInExpressionContext2() { val a2: Unit = while(true) {} -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/controlStructures/lambdasInExclExclAndElvis.fir.kt b/compiler/testData/diagnostics/tests/controlStructures/lambdasInExclExclAndElvis.fir.kt index f4dc5a89eb4..438b7887dd8 100644 --- a/compiler/testData/diagnostics/tests/controlStructures/lambdasInExclExclAndElvis.fir.kt +++ b/compiler/testData/diagnostics/tests/controlStructures/lambdasInExclExclAndElvis.fir.kt @@ -13,4 +13,4 @@ fun test() { 1 ?: { } use(1 ?: { }) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/controlStructures/lambdasInExclExclAndElvis.kt b/compiler/testData/diagnostics/tests/controlStructures/lambdasInExclExclAndElvis.kt index 595266bd73c..f1af079ad20 100644 --- a/compiler/testData/diagnostics/tests/controlStructures/lambdasInExclExclAndElvis.kt +++ b/compiler/testData/diagnostics/tests/controlStructures/lambdasInExclExclAndElvis.kt @@ -8,9 +8,9 @@ fun test() { use({ }!!); // KT-KT-9070 - { } ?: 1 + { } ?: 1 use({ 2 } ?: 1); - 1 ?: { } + 1 ?: { } use(1 ?: { }) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/controlStructures/tryReturnType.kt b/compiler/testData/diagnostics/tests/controlStructures/tryReturnType.kt index 44b9f7eb7a3..40149769d1b 100644 --- a/compiler/testData/diagnostics/tests/controlStructures/tryReturnType.kt +++ b/compiler/testData/diagnostics/tests/controlStructures/tryReturnType.kt @@ -14,11 +14,11 @@ fun foo() : Int { } fun bar() : Int = - try { - doSmth() + try { + doSmth() } - catch (e: Exception) { - "" + catch (e: Exception) { + "" } finally { "" diff --git a/compiler/testData/diagnostics/tests/controlStructures/typeInferenceForExclExcl.fir.kt b/compiler/testData/diagnostics/tests/controlStructures/typeInferenceForExclExcl.fir.kt index 195ba2a2ef4..f6e4e1acd21 100644 --- a/compiler/testData/diagnostics/tests/controlStructures/typeInferenceForExclExcl.fir.kt +++ b/compiler/testData/diagnostics/tests/controlStructures/typeInferenceForExclExcl.fir.kt @@ -18,4 +18,4 @@ fun test11() { // not 'String!' A.foo()!! checkType { _() } A.foo()!! checkType { _() } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/controlStructures/typeInferenceForExclExcl.kt b/compiler/testData/diagnostics/tests/controlStructures/typeInferenceForExclExcl.kt index 61b56f1dee4..eb61e614c46 100644 --- a/compiler/testData/diagnostics/tests/controlStructures/typeInferenceForExclExcl.kt +++ b/compiler/testData/diagnostics/tests/controlStructures/typeInferenceForExclExcl.kt @@ -13,9 +13,9 @@ fun exclExcl(t: T?): T = t!! fun test11() { // not 'String!' exclExcl(A.foo()) checkType { _() } - exclExcl(A.foo()) checkType { _() } + exclExcl(A.foo()) checkType { _() } // not 'String!' A.foo()!! checkType { _() } - A.foo()!! checkType { _() } -} \ No newline at end of file + A.foo()!! checkType { _() } +} diff --git a/compiler/testData/diagnostics/tests/controlStructures/when.kt234.kt973.fir.kt b/compiler/testData/diagnostics/tests/controlStructures/when.kt234.kt973.fir.kt new file mode 100644 index 00000000000..fc5d5665024 --- /dev/null +++ b/compiler/testData/diagnostics/tests/controlStructures/when.kt234.kt973.fir.kt @@ -0,0 +1,41 @@ +//KT-234 Force when() expressions to have an 'else' branch +//KT-973 Unreachable code + +package kt234_kt973 + +class Pair(a: A, b: B) + +fun test(t : Pair) : Int { + when (t) { + Pair(10, 10) -> return 1 + } + return 0 // unreachable code +} + +fun test1(t : Pair) : Int { + when (t) { + Pair(10, 10) -> return 1 + else -> return 2 + } + return 0 // unreachable code +} + +//more tests +fun t1(x: Int) = when(x) { + else -> 1 +} + +fun t5(x: Int) = when (x) { + is Int -> 1 + 2 -> 2 +} + +fun foo3(x: Int) = when(x) { + else -> 1 + 2 -> 2 +} + +fun foo4(x: Int) = when(x) { + 2 -> x + else -> 3 +} diff --git a/compiler/testData/diagnostics/tests/controlStructures/when.kt234.kt973.kt b/compiler/testData/diagnostics/tests/controlStructures/when.kt234.kt973.kt index 3df703a08dd..313dbe03628 100644 --- a/compiler/testData/diagnostics/tests/controlStructures/when.kt234.kt973.kt +++ b/compiler/testData/diagnostics/tests/controlStructures/when.kt234.kt973.kt @@ -38,4 +38,4 @@ fun foo3(x: Int) = when(x) { fun foo4(x: Int) = when(x) { 2 -> x else -> 3 -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/controlStructures/whenInResultOfLambda.kt b/compiler/testData/diagnostics/tests/controlStructures/whenInResultOfLambda.kt index aadd5e8df21..cbd87e68ebe 100644 --- a/compiler/testData/diagnostics/tests/controlStructures/whenInResultOfLambda.kt +++ b/compiler/testData/diagnostics/tests/controlStructures/whenInResultOfLambda.kt @@ -1,9 +1,9 @@ // !WITH_NEW_INFERENCE // NI_EXPECTED_FILE -val test1 = { when (true) { true -> 1; else -> "" } } +val test1 = { when (true) { true -> 1; else -> "" } } -val test2 = { { when (true) { true -> 1; else -> "" } } } +val test2 = { { when (true) { true -> 1; else -> "" } } } val test3: (Boolean) -> Any = { when (true) { true -> 1; else -> "" } } diff --git a/compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion/noMembers_before.kt b/compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion/noMembers_before.kt index 5848a03a29e..8c903d2ab6b 100644 --- a/compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion/noMembers_before.kt +++ b/compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion/noMembers_before.kt @@ -12,4 +12,4 @@ public class C { class Foo : Data() companion object : DerivedAbstract() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/dataClasses/extensionComponentsOnNullable.kt b/compiler/testData/diagnostics/tests/dataClasses/extensionComponentsOnNullable.kt index 73f40f6d67d..37949e24699 100644 --- a/compiler/testData/diagnostics/tests/dataClasses/extensionComponentsOnNullable.kt +++ b/compiler/testData/diagnostics/tests/dataClasses/extensionComponentsOnNullable.kt @@ -9,7 +9,7 @@ fun foo(): Int { val d: Data? = null // An error must be here val (x, y) = d - return x + y + return x + y } data class NormalData(val x: T, val y: T) @@ -18,5 +18,5 @@ fun bar(): Int { val d: NormalData? = null // An error must be here val (x, y) = d - return x + y + return x + y } diff --git a/compiler/testData/diagnostics/tests/dataFlow/IsExpression.kt b/compiler/testData/diagnostics/tests/dataFlow/IsExpression.kt index 269dae1d105..2b33b708e80 100644 --- a/compiler/testData/diagnostics/tests/dataFlow/IsExpression.kt +++ b/compiler/testData/diagnostics/tests/dataFlow/IsExpression.kt @@ -3,4 +3,4 @@ fun f(a: Boolean, b: Int) {} fun foo(a: Any) { f(a is Int, a) 1 + a -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/dataFlow/local/LocalClassInitializer.kt b/compiler/testData/diagnostics/tests/dataFlow/local/LocalClassInitializer.kt index 38b9340f85a..9be2ebf0d6d 100644 --- a/compiler/testData/diagnostics/tests/dataFlow/local/LocalClassInitializer.kt +++ b/compiler/testData/diagnostics/tests/dataFlow/local/LocalClassInitializer.kt @@ -13,4 +13,4 @@ fun f(a: Any?) { interface B { fun foo() {} } -open class X(b: B) \ No newline at end of file +open class X(b: B) diff --git a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpression.kt b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpression.kt index 48408d23083..2cb8c28f603 100644 --- a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpression.kt +++ b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpression.kt @@ -6,6 +6,6 @@ fun foo() { val x: Int? = null bar(1 + (if (x == null) 0 else x)) - bar(if (x == null) x else x) + bar(if (x == null) x else x) if (x != null) bar(x + x/(x-x*x)) } diff --git a/compiler/testData/diagnostics/tests/declarationChecks/MultiDeclarationErrors.fir.kt b/compiler/testData/diagnostics/tests/declarationChecks/MultiDeclarationErrors.fir.kt index 049a47d1388..321146b1b63 100644 --- a/compiler/testData/diagnostics/tests/declarationChecks/MultiDeclarationErrors.fir.kt +++ b/compiler/testData/diagnostics/tests/declarationChecks/MultiDeclarationErrors.fir.kt @@ -18,4 +18,4 @@ fun test(mc1: MyClass, mc2: MyClass2) { use(a, b, c) } -fun use(vararg a: Any?) = a \ No newline at end of file +fun use(vararg a: Any?) = a diff --git a/compiler/testData/diagnostics/tests/declarationChecks/MultiDeclarationErrors.kt b/compiler/testData/diagnostics/tests/declarationChecks/MultiDeclarationErrors.kt index 5679433248b..c754b55d98d 100644 --- a/compiler/testData/diagnostics/tests/declarationChecks/MultiDeclarationErrors.kt +++ b/compiler/testData/diagnostics/tests/declarationChecks/MultiDeclarationErrors.kt @@ -12,10 +12,10 @@ class MyClass2 {} fun test(mc1: MyClass, mc2: MyClass2) { val (a, b) = mc1 - val (c) = mc2 + val (c) = mc2 //a,b,c are error types use(a, b, c) } -fun use(vararg a: Any?) = a \ No newline at end of file +fun use(vararg a: Any?) = a diff --git a/compiler/testData/diagnostics/tests/declarationChecks/illegalModifiersOnClass.fir.kt b/compiler/testData/diagnostics/tests/declarationChecks/illegalModifiersOnClass.fir.kt index 4905cc7020e..3edf127831d 100644 --- a/compiler/testData/diagnostics/tests/declarationChecks/illegalModifiersOnClass.fir.kt +++ b/compiler/testData/diagnostics/tests/declarationChecks/illegalModifiersOnClass.fir.kt @@ -3,10 +3,10 @@ // KT-3464 Front-end shouldn't allow override modifier in class declaration override class A { - override companion object {} - open companion object {} - abstract companion object {} - final companion object {} + override companion object {} + open companion object {} + abstract companion object {} + final companion object {} } override object B1 {} @@ -16,4 +16,4 @@ final object B4 {} override enum class C {} override interface D {} -override annotation class E \ No newline at end of file +override annotation class E diff --git a/compiler/testData/diagnostics/tests/declarationChecks/illegalModifiersOnClass.kt b/compiler/testData/diagnostics/tests/declarationChecks/illegalModifiersOnClass.kt index a2f8773eb3c..1dbaf72091f 100644 --- a/compiler/testData/diagnostics/tests/declarationChecks/illegalModifiersOnClass.kt +++ b/compiler/testData/diagnostics/tests/declarationChecks/illegalModifiersOnClass.kt @@ -16,4 +16,4 @@ final object B4 {} override enum class C {} override interface D {} -override annotation class E \ No newline at end of file +override annotation class E diff --git a/compiler/testData/diagnostics/tests/declarationChecks/localVariablesWithTypeParameters_1_3.kt b/compiler/testData/diagnostics/tests/declarationChecks/localVariablesWithTypeParameters_1_3.kt index b151998c589..2e17cc98e51 100644 --- a/compiler/testData/diagnostics/tests/declarationChecks/localVariablesWithTypeParameters_1_3.kt +++ b/compiler/testData/diagnostics/tests/declarationChecks/localVariablesWithTypeParameters_1_3.kt @@ -11,10 +11,10 @@ fun test() { const val a3 = 0 lateinit val a4 = 0 val a5 by Delegate() - val a6 by Delegate<T>() + val a6 by Delegate<T>() } class Delegate { operator fun getValue(thisRef: Any?, property: KProperty<*>): String = "" operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {} -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/declarationChecks/localVariablesWithTypeParameters_1_4.kt b/compiler/testData/diagnostics/tests/declarationChecks/localVariablesWithTypeParameters_1_4.kt index 2efda07b425..07574de6669 100644 --- a/compiler/testData/diagnostics/tests/declarationChecks/localVariablesWithTypeParameters_1_4.kt +++ b/compiler/testData/diagnostics/tests/declarationChecks/localVariablesWithTypeParameters_1_4.kt @@ -11,10 +11,10 @@ fun test() { const val a3 = 0 lateinit val a4 = 0 val a5 by Delegate() - val a6 by Delegate<T>() + val a6 by Delegate<T>() } class Delegate { operator fun getValue(thisRef: Any?, property: KProperty<*>): String = "" operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {} -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/declarationChecks/mulitpleVarargParameters.fir.kt b/compiler/testData/diagnostics/tests/declarationChecks/mulitpleVarargParameters.fir.kt index f8e2c2e73d7..a51b6884050 100644 --- a/compiler/testData/diagnostics/tests/declarationChecks/mulitpleVarargParameters.fir.kt +++ b/compiler/testData/diagnostics/tests/declarationChecks/mulitpleVarargParameters.fir.kt @@ -2,7 +2,7 @@ fun test(vararg x1: Int, vararg x2: Int) { fun test2(vararg x1: Int, vararg x2: Int) { class LocalClass(vararg x1: Int, vararg x2: Int) { - constructor(vararg x1: Int, vararg x2: Int, xx: Int) {} + constructor(vararg x1: Int, vararg x2: Int, xx: Int) {} } fun test3(vararg x1: Int, vararg x2: Int) {} } @@ -20,7 +20,7 @@ abstract class C(vararg x1: Int, vararg x2: Int, b: Boolean) { abstract fun test2(vararg x1: Int, vararg x2: Int) class CC(vararg x1: Int, vararg x2: Int, b: Boolean) { - constructor(vararg x1: Int, vararg x2: Int) {} + constructor(vararg x1: Int, vararg x2: Int) {} fun test(vararg x1: Int, vararg x2: Int) {} } } @@ -29,7 +29,7 @@ object O { fun test(vararg x1: Int, vararg x2: Int) {} class CC(vararg x1: Int, vararg x2: Int, b: Boolean) { - constructor(vararg x1: Int, vararg x2: Int) {} + constructor(vararg x1: Int, vararg x2: Int) {} fun test(vararg x1: Int, vararg x2: Int) {} } } diff --git a/compiler/testData/diagnostics/tests/declarationChecks/namedFunAsLastExpressionInBlock.kt b/compiler/testData/diagnostics/tests/declarationChecks/namedFunAsLastExpressionInBlock.kt index 9c6548e0a8a..baff5fa8bbd 100644 --- a/compiler/testData/diagnostics/tests/declarationChecks/namedFunAsLastExpressionInBlock.kt +++ b/compiler/testData/diagnostics/tests/declarationChecks/namedFunAsLastExpressionInBlock.kt @@ -7,8 +7,8 @@ fun test() { val x = fun named1(x: Int): Int { return 1 } x checkType { _>() } - foo { Int")!>fun named2(): Int {return 1} } - foo({ fun named3() = 1 }) + foo { Int")!>fun named2(): Int {return 1} } + foo({ fun named3() = 1 }) val x1 = if (1 == 1) @@ -27,15 +27,15 @@ fun test() { fun named7() = 1 val x3 = when (1) { - 0 -> fun named8(): Int {return 1} - else -> fun named9() = 1 + 0 -> fun named8(): Int {return 1} + else -> fun named9() = 1 } val x31 = when (1) { 0 -> { - fun named10(): Int {return 1} + fun named10(): Int {return 1} } - else -> fun named11() = 1 + else -> fun named11() = 1 } val x4 = { @@ -65,11 +65,11 @@ fun success() { val y = when (1) { 0 -> { - fun named4(): Int {return 1} + fun named4(): Int {return 1} } else -> { - fun named5(): Int {return 1} + fun named5(): Int {return 1} } } - y checkType { _() } + y checkType { _() } } diff --git a/compiler/testData/diagnostics/tests/declarationChecks/nonExpansiveInheritanceRestriction/JavaWithKotlin.fir.kt b/compiler/testData/diagnostics/tests/declarationChecks/nonExpansiveInheritanceRestriction/JavaWithKotlin.fir.kt index f26dc514958..b0de7ed12c4 100644 --- a/compiler/testData/diagnostics/tests/declarationChecks/nonExpansiveInheritanceRestriction/JavaWithKotlin.fir.kt +++ b/compiler/testData/diagnostics/tests/declarationChecks/nonExpansiveInheritanceRestriction/JavaWithKotlin.fir.kt @@ -1,6 +1,6 @@ // !DIAGNOSTICS: -UPPER_BOUND_VIOLATED -//// FILE: D.java +// FILE: D.java public interface D {} // FILE: Q.java diff --git a/compiler/testData/diagnostics/tests/declarationChecks/nonExpansiveInheritanceRestriction/JavaWithKotlin.kt b/compiler/testData/diagnostics/tests/declarationChecks/nonExpansiveInheritanceRestriction/JavaWithKotlin.kt index 42f0721e23d..ae3d83acd23 100644 --- a/compiler/testData/diagnostics/tests/declarationChecks/nonExpansiveInheritanceRestriction/JavaWithKotlin.kt +++ b/compiler/testData/diagnostics/tests/declarationChecks/nonExpansiveInheritanceRestriction/JavaWithKotlin.kt @@ -1,6 +1,6 @@ // !DIAGNOSTICS: -UPPER_BOUND_VIOLATED -//// FILE: D.java +// FILE: D.java public interface D {} // FILE: Q.java diff --git a/compiler/testData/diagnostics/tests/declarationChecks/nonExpansiveInheritanceRestriction/JavaWithKotlin2.fir.kt b/compiler/testData/diagnostics/tests/declarationChecks/nonExpansiveInheritanceRestriction/JavaWithKotlin2.fir.kt index 0e95d892f06..df74bc5ac09 100644 --- a/compiler/testData/diagnostics/tests/declarationChecks/nonExpansiveInheritanceRestriction/JavaWithKotlin2.fir.kt +++ b/compiler/testData/diagnostics/tests/declarationChecks/nonExpansiveInheritanceRestriction/JavaWithKotlin2.fir.kt @@ -1,6 +1,6 @@ // !DIAGNOSTICS: -UPPER_BOUND_VIOLATED -//// FILE: D.java +// FILE: D.java public interface D {} // FILE: Q.java @@ -13,4 +13,4 @@ public interface C extends D> {} public interface P extends Q, C>> {} // FILE: 1.kt -interface P1 : P \ No newline at end of file +interface P1 : P diff --git a/compiler/testData/diagnostics/tests/declarationChecks/nonExpansiveInheritanceRestriction/JavaWithKotlin2.kt b/compiler/testData/diagnostics/tests/declarationChecks/nonExpansiveInheritanceRestriction/JavaWithKotlin2.kt index 112724526b5..3fd3aba4f5b 100644 --- a/compiler/testData/diagnostics/tests/declarationChecks/nonExpansiveInheritanceRestriction/JavaWithKotlin2.kt +++ b/compiler/testData/diagnostics/tests/declarationChecks/nonExpansiveInheritanceRestriction/JavaWithKotlin2.kt @@ -1,6 +1,6 @@ // !DIAGNOSTICS: -UPPER_BOUND_VIOLATED -//// FILE: D.java +// FILE: D.java public interface D {} // FILE: Q.java @@ -13,4 +13,4 @@ public interface C extends D> {} public interface P extends Q, C>> {} // FILE: 1.kt -interface P1 : P \ No newline at end of file +interface P1 : P diff --git a/compiler/testData/diagnostics/tests/defaultArguments/superCall.fir.kt b/compiler/testData/diagnostics/tests/defaultArguments/superCall.fir.kt index d61a4e53aae..2361d21397f 100644 --- a/compiler/testData/diagnostics/tests/defaultArguments/superCall.fir.kt +++ b/compiler/testData/diagnostics/tests/defaultArguments/superCall.fir.kt @@ -18,11 +18,11 @@ open class B : A() { super.foo2("123") super.foo2() - super.foo3("123") - super.foo3() + super.foo3("123") + super.foo3() } override fun foo3(a: String) { throw UnsupportedOperationException() } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/defaultArguments/superCall.kt b/compiler/testData/diagnostics/tests/defaultArguments/superCall.kt index d1c64d8efcb..7091ae75d08 100644 --- a/compiler/testData/diagnostics/tests/defaultArguments/superCall.kt +++ b/compiler/testData/diagnostics/tests/defaultArguments/superCall.kt @@ -25,4 +25,4 @@ open class B : A() { override fun foo3(a: String) { throw UnsupportedOperationException() } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/inference/differentDelegatedExpressions.kt b/compiler/testData/diagnostics/tests/delegatedProperty/inference/differentDelegatedExpressions.kt index b6f86b26639..a7b588e8532 100644 --- a/compiler/testData/diagnostics/tests/delegatedProperty/inference/differentDelegatedExpressions.kt +++ b/compiler/testData/diagnostics/tests/delegatedProperty/inference/differentDelegatedExpressions.kt @@ -10,10 +10,10 @@ class A(outer: Outer) { var g: String by outer.getContainer().getMyProperty() - var b: String by foo(getMyProperty()) - var r: String by foo(outer.getContainer().getMyProperty()) - var e: String by + foo(getMyProperty()) - var f: String by foo(getMyProperty()) - 1 + var b: String by foo(getMyProperty()) + var r: String by foo(outer.getContainer().getMyProperty()) + var e: String by + foo(getMyProperty()) + var f: String by foo(getMyProperty()) - 1 } fun foo(a: Any?) = MyProperty() diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/inference/extensionProperty.kt b/compiler/testData/diagnostics/tests/delegatedProperty/inference/extensionProperty.kt index 352b8c0ae37..2f324ff3368 100644 --- a/compiler/testData/diagnostics/tests/delegatedProperty/inference/extensionProperty.kt +++ b/compiler/testData/diagnostics/tests/delegatedProperty/inference/extensionProperty.kt @@ -4,10 +4,10 @@ package foo import kotlin.reflect.KProperty open class A { - val B.w: Int by MyProperty() + val B.w: Int by MyProperty() } -val B.r: Int by MyProperty() +val B.r: Int by MyProperty() val A.e: Int by MyProperty() diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/inference/genericMethodInGenericClass.kt b/compiler/testData/diagnostics/tests/delegatedProperty/inference/genericMethodInGenericClass.kt index aac12d41280..35f9b9fd1a3 100644 --- a/compiler/testData/diagnostics/tests/delegatedProperty/inference/genericMethodInGenericClass.kt +++ b/compiler/testData/diagnostics/tests/delegatedProperty/inference/genericMethodInGenericClass.kt @@ -8,7 +8,7 @@ class A() { operator fun setValue(t: Any?, p: KProperty<*>, x: T) = Unit } -var a1: Int by A() +var a1: Int by A() var a2: Int by A() class B() { @@ -25,4 +25,4 @@ class C() { } var c1: Int by C() -var c2: Int by C() +var c2: Int by C() diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/inference/manyIncompleteCandidates.fir.kt b/compiler/testData/diagnostics/tests/delegatedProperty/inference/manyIncompleteCandidates.fir.kt index 1814104f163..6fc5a1d7f20 100644 --- a/compiler/testData/diagnostics/tests/delegatedProperty/inference/manyIncompleteCandidates.fir.kt +++ b/compiler/testData/diagnostics/tests/delegatedProperty/inference/manyIncompleteCandidates.fir.kt @@ -23,4 +23,4 @@ package second import first.A import kotlin.reflect.KProperty -public operator fun A.getValue(thisRef: Any?, property: KProperty<*>): T = null!! \ No newline at end of file +public operator fun A.getValue(thisRef: Any?, property: KProperty<*>): T = null!! diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/inference/manyIncompleteCandidates.kt b/compiler/testData/diagnostics/tests/delegatedProperty/inference/manyIncompleteCandidates.kt index 48d970aad18..42617293537 100644 --- a/compiler/testData/diagnostics/tests/delegatedProperty/inference/manyIncompleteCandidates.kt +++ b/compiler/testData/diagnostics/tests/delegatedProperty/inference/manyIncompleteCandidates.kt @@ -5,7 +5,7 @@ package test import first.* import second.* -val a12 by A() +val a12 by A() // FILE: first.kt package first @@ -23,4 +23,4 @@ package second import first.A import kotlin.reflect.KProperty -public operator fun A.getValue(thisRef: Any?, property: KProperty<*>): T = null!! \ No newline at end of file +public operator fun A.getValue(thisRef: Any?, property: KProperty<*>): T = null!! diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/inference/noErrorsForImplicitConstraints.kt b/compiler/testData/diagnostics/tests/delegatedProperty/inference/noErrorsForImplicitConstraints.kt index 5227d682af4..5d01b27f7c9 100644 --- a/compiler/testData/diagnostics/tests/delegatedProperty/inference/noErrorsForImplicitConstraints.kt +++ b/compiler/testData/diagnostics/tests/delegatedProperty/inference/noErrorsForImplicitConstraints.kt @@ -4,8 +4,8 @@ package foo import kotlin.reflect.KProperty class A { - var a5: String by MyProperty1() - var b5: String by getMyProperty1() + var a5: String by MyProperty1() + var b5: String by getMyProperty1() } fun getMyProperty1() = MyProperty1() @@ -24,8 +24,8 @@ class MyProperty1 { // ----------------- class B { - var a5: String by MyProperty2() - var b5: String by getMyProperty2() + var a5: String by MyProperty2() + var b5: String by getMyProperty2() } fun getMyProperty2() = MyProperty2() diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/inference/noExpectedTypeForSupertypeConstraint.kt b/compiler/testData/diagnostics/tests/delegatedProperty/inference/noExpectedTypeForSupertypeConstraint.kt index 7e0fb50564f..d45fa55448f 100644 --- a/compiler/testData/diagnostics/tests/delegatedProperty/inference/noExpectedTypeForSupertypeConstraint.kt +++ b/compiler/testData/diagnostics/tests/delegatedProperty/inference/noExpectedTypeForSupertypeConstraint.kt @@ -3,7 +3,7 @@ import kotlin.reflect.KProperty class A { - var a by MyProperty() + var a by MyProperty() } class MyProperty { diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/missedGetter.kt b/compiler/testData/diagnostics/tests/delegatedProperty/missedGetter.kt index 71f08682264..e781087d43f 100644 --- a/compiler/testData/diagnostics/tests/delegatedProperty/missedGetter.kt +++ b/compiler/testData/diagnostics/tests/delegatedProperty/missedGetter.kt @@ -1,3 +1,3 @@ -val a: Int by )", "A", "delegate")!>A() +val a: Int by ); A; delegate")!>A() class A diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/missedSetter.kt b/compiler/testData/diagnostics/tests/delegatedProperty/missedSetter.kt index e47ac927b04..0efa688953e 100644 --- a/compiler/testData/diagnostics/tests/delegatedProperty/missedSetter.kt +++ b/compiler/testData/diagnostics/tests/delegatedProperty/missedSetter.kt @@ -2,7 +2,7 @@ import kotlin.reflect.KProperty -var a: Int by , Int)", "A", "delegate for var (read-write property)")!>A() +var a: Int by , Int); A; delegate for var (read-write property)")!>A() class A { operator fun getValue(t: Any?, p: KProperty<*>): Int { diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/propertyDefferedType.kt b/compiler/testData/diagnostics/tests/delegatedProperty/propertyDefferedType.kt index 7a2be4ecb26..d52d6595da2 100644 --- a/compiler/testData/diagnostics/tests/delegatedProperty/propertyDefferedType.kt +++ b/compiler/testData/diagnostics/tests/delegatedProperty/propertyDefferedType.kt @@ -5,7 +5,7 @@ import kotlin.reflect.KProperty class B { - val c by Delegate(ag) + val c by Delegate(ag) } class Delegate(val init: T) { diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/commonCaseForInference.fir.kt b/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/commonCaseForInference.fir.kt index 1da5044c59f..d2af39476f1 100644 --- a/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/commonCaseForInference.fir.kt +++ b/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/commonCaseForInference.fir.kt @@ -11,4 +11,4 @@ object CommonCase { val Long.test1: String by delegate() // common test, not working because of Inference1 val Long.test2: String by delegate() // should work -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/commonCaseForInference.kt b/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/commonCaseForInference.kt index 52a71f4abe5..4ef9df38b8a 100644 --- a/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/commonCaseForInference.kt +++ b/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/commonCaseForInference.kt @@ -9,6 +9,6 @@ object CommonCase { operator fun Fas.provideDelegate(host: D, p: Any?): Fas = TODO() operator fun Fas.getValue(receiver: E, p: Any?): R = TODO() - val Long.test1: String by delegate() // common test, not working because of Inference1 + val Long.test1: String by delegate() // common test, not working because of Inference1 val Long.test2: String by delegate() // should work -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/hostAndReceiver2.fir.kt b/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/hostAndReceiver2.fir.kt index da6ca89dba2..6fb1bd69fdd 100644 --- a/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/hostAndReceiver2.fir.kt +++ b/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/hostAndReceiver2.fir.kt @@ -11,4 +11,4 @@ object T2 { val String.test1: String by delegate() val test2: String by delegate() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/hostAndReceiver2.kt b/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/hostAndReceiver2.kt index fe84deddff2..644faba331d 100644 --- a/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/hostAndReceiver2.kt +++ b/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/hostAndReceiver2.kt @@ -10,5 +10,5 @@ object T2 { operator fun Foo.getValue(receiver: String, p: Any?): T = TODO() val String.test1: String by delegate() - val test2: String by delegate() -} \ No newline at end of file + val test2: String by delegate() +} diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/inferenceFromReceiver1.kt b/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/inferenceFromReceiver1.kt index 052baa62c34..8684d3a2324 100644 --- a/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/inferenceFromReceiver1.kt +++ b/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/inferenceFromReceiver1.kt @@ -9,7 +9,7 @@ object Inference1 { operator fun Foo.getValue(receiver: T, p: Any?): String = TODO() // not working because resulting descriptor for getValue contains type `???` instead of `T` - val test1: String by delegate() + val test1: String by delegate() val test2: String by delegate() } diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/inferenceFromReceiver2.kt b/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/inferenceFromReceiver2.kt index f1b9220922f..5fc6f90c5a1 100644 --- a/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/inferenceFromReceiver2.kt +++ b/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/inferenceFromReceiver2.kt @@ -9,6 +9,6 @@ object Inference2 { operator fun Foo.provideDelegate(host: T, p: Any?): Foo = TODO() operator fun Foo.getValue(receiver: Inference2, p: Any?): String = TODO() - val test1: String by delegate() // same story like in Inference1 + val test1: String by delegate() // same story like in Inference1 val test2: String by delegate() } diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/noOperatorModifierOnProvideDelegate.kt b/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/noOperatorModifierOnProvideDelegate.kt index cd106361977..fb1953e5a2d 100644 --- a/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/noOperatorModifierOnProvideDelegate.kt +++ b/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/noOperatorModifierOnProvideDelegate.kt @@ -13,6 +13,6 @@ fun String.provideDelegate(a: Any?, p: KProperty<*>) = StringDelegate(this) operator fun String.getValue(a: Any?, p: KProperty<*>) = this val test1: String by "OK" -val test2: Int by "OK" +val test2: Int by "OK" val test3 by "OK" diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/setValue.fir.kt b/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/setValue.fir.kt index 03d0eae31be..5983c6ad6d7 100644 --- a/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/setValue.fir.kt +++ b/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/setValue.fir.kt @@ -14,4 +14,4 @@ var test2: String by Delegate() var test3: String by "OK" var test4: String by "OK".provideDelegate(null, "") -var test5: String by "OK".provideDelegate(null, "") \ No newline at end of file +var test5: String by "OK".provideDelegate(null, "") diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/setValue.kt b/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/setValue.kt index d2fa2d829b6..414d14999a2 100644 --- a/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/setValue.kt +++ b/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/setValue.kt @@ -8,10 +8,10 @@ operator fun Delegate.setValue(receiver: Any?, p: Any, value: T) {} operator fun String.provideDelegate(receiver: Any?, p: Any) = Delegate() -var test1: String by Delegate() +var test1: String by Delegate() var test2: String by Delegate() -var test3: String by "OK" +var test3: String by "OK" -var test4: String by "OK".provideDelegate(null, "") -var test5: String by "OK".provideDelegate(null, "") \ No newline at end of file +var test4: String by "OK".provideDelegate(null, "") +var test5: String by "OK".provideDelegate(null, "") diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/unsupportedOperatorProvideDelegate.fir.kt b/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/unsupportedOperatorProvideDelegate.fir.kt index cd1410a8fc1..18936afb9d9 100644 --- a/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/unsupportedOperatorProvideDelegate.fir.kt +++ b/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/unsupportedOperatorProvideDelegate.fir.kt @@ -12,4 +12,4 @@ operator fun String.getValue(thisRef: Any?, prop: Any) = this val test1: String by "OK" val test2: Int by "OK" -val test3 by "OK" \ No newline at end of file +val test3 by "OK" diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/unsupportedOperatorProvideDelegate.kt b/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/unsupportedOperatorProvideDelegate.kt index 1e2af347ffe..d1eb083a09d 100644 --- a/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/unsupportedOperatorProvideDelegate.kt +++ b/compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/unsupportedOperatorProvideDelegate.kt @@ -11,5 +11,5 @@ class WrongDelegate(val x: Int) { operator fun String.getValue(thisRef: Any?, prop: Any) = this val test1: String by "OK" -val test2: Int by "OK" -val test3 by "OK" \ No newline at end of file +val test2: Int by "OK" +val test3 by "OK" diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/recursiveType.kt b/compiler/testData/diagnostics/tests/delegatedProperty/recursiveType.kt index 476124fd689..d74411e9801 100644 --- a/compiler/testData/diagnostics/tests/delegatedProperty/recursiveType.kt +++ b/compiler/testData/diagnostics/tests/delegatedProperty/recursiveType.kt @@ -4,12 +4,12 @@ import kotlin.reflect.KProperty -val a by a +val a by a -val b by Delegate(b) +val b by Delegate(b) val c by d -val d by c +val d by c class Delegate(i: Int) { operator fun getValue(t: Any?, p: KProperty<*>): Int { diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/typeMismatchForGetReturnType.kt b/compiler/testData/diagnostics/tests/delegatedProperty/typeMismatchForGetReturnType.kt index d86d06065ff..71d1c3892b4 100644 --- a/compiler/testData/diagnostics/tests/delegatedProperty/typeMismatchForGetReturnType.kt +++ b/compiler/testData/diagnostics/tests/delegatedProperty/typeMismatchForGetReturnType.kt @@ -3,7 +3,7 @@ import kotlin.reflect.KProperty -val c: Int by Delegate() +val c: Int by Delegate() class Delegate { operator fun getValue(t: Any?, p: KProperty<*>): String { diff --git a/compiler/testData/diagnostics/tests/delegation/DelegationExpectedType.fir.kt b/compiler/testData/diagnostics/tests/delegation/DelegationExpectedType.fir.kt index 3a14bea8dbe..54e8098621f 100644 --- a/compiler/testData/diagnostics/tests/delegation/DelegationExpectedType.fir.kt +++ b/compiler/testData/diagnostics/tests/delegation/DelegationExpectedType.fir.kt @@ -23,4 +23,4 @@ fun boo(t: T): A = AImpl() class E : A by boo("") -class F : A by AImpl() \ No newline at end of file +class F : A by AImpl() diff --git a/compiler/testData/diagnostics/tests/delegation/DelegationExpectedType.kt b/compiler/testData/diagnostics/tests/delegation/DelegationExpectedType.kt index 6b1fb85839c..f077deba150 100644 --- a/compiler/testData/diagnostics/tests/delegation/DelegationExpectedType.kt +++ b/compiler/testData/diagnostics/tests/delegation/DelegationExpectedType.kt @@ -21,6 +21,6 @@ class D : A by baz({ it + 1 }) fun boo(t: T): A = AImpl() -class E : A by boo("") +class E : A by boo("") -class F : A by AImpl() \ No newline at end of file +class F : A by AImpl() diff --git a/compiler/testData/diagnostics/tests/deparenthesize/checkDeparenthesizedType.kt b/compiler/testData/diagnostics/tests/deparenthesize/checkDeparenthesizedType.kt index 20ed233ab7c..e27eeeae382 100644 --- a/compiler/testData/diagnostics/tests/deparenthesize/checkDeparenthesizedType.kt +++ b/compiler/testData/diagnostics/tests/deparenthesize/checkDeparenthesizedType.kt @@ -16,7 +16,7 @@ fun test(i: Int?) { val a: Int = l4@ "" val b: Int = ("") val c: Int = checkSubtype("") - val d: Int = checkSubtype("") + val d: Int = checkSubtype("") foo(l4@ "") diff --git a/compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin/deprecatedSinceKotlinDeclaration.kt b/compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin/deprecatedSinceKotlinDeclaration.kt index bf687e49b2a..6a70d00b41b 100644 --- a/compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin/deprecatedSinceKotlinDeclaration.kt +++ b/compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin/deprecatedSinceKotlinDeclaration.kt @@ -41,4 +41,4 @@ fun fooDefault() {} @Deprecated("") @DeprecatedSinceKotlin("1.1", "1.1", "1.1") -fun fooEqual() {} \ No newline at end of file +fun fooEqual() {} diff --git a/compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin/messageFromDeprecatedAnnotation.fir.kt b/compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin/messageFromDeprecatedAnnotation.fir.kt index c7c4185d33f..3caf335a2aa 100644 --- a/compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin/messageFromDeprecatedAnnotation.fir.kt +++ b/compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin/messageFromDeprecatedAnnotation.fir.kt @@ -6,4 +6,4 @@ fun foo() {} fun test() { foo() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin/messageFromDeprecatedAnnotation.kt b/compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin/messageFromDeprecatedAnnotation.kt index 50900ce316a..c786d91af9d 100644 --- a/compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin/messageFromDeprecatedAnnotation.kt +++ b/compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin/messageFromDeprecatedAnnotation.kt @@ -5,5 +5,5 @@ package kotlin fun foo() {} fun test() { - foo() -} \ No newline at end of file + foo() +} diff --git a/compiler/testData/diagnostics/tests/dynamicTypes/withInvisibleSynthesized.kt b/compiler/testData/diagnostics/tests/dynamicTypes/withInvisibleSynthesized.kt index f2ff95977a5..0cf6063c8de 100644 --- a/compiler/testData/diagnostics/tests/dynamicTypes/withInvisibleSynthesized.kt +++ b/compiler/testData/diagnostics/tests/dynamicTypes/withInvisibleSynthesized.kt @@ -32,4 +32,4 @@ class K: J.C() { sam(null) } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/enum/kt8972_cloneNotAllowed.kt b/compiler/testData/diagnostics/tests/enum/kt8972_cloneNotAllowed.kt index 17a55c71aec..7e54fe89e29 100644 --- a/compiler/testData/diagnostics/tests/enum/kt8972_cloneNotAllowed.kt +++ b/compiler/testData/diagnostics/tests/enum/kt8972_cloneNotAllowed.kt @@ -2,6 +2,6 @@ enum class E : Cloneable { A; override fun clone(): Any { - return super.clone() + return super.clone() } } diff --git a/compiler/testData/diagnostics/tests/evaluate/binaryMinusDepOnExpType.kt b/compiler/testData/diagnostics/tests/evaluate/binaryMinusDepOnExpType.kt index bcdc62dcf12..9a9aa2db970 100644 --- a/compiler/testData/diagnostics/tests/evaluate/binaryMinusDepOnExpType.kt +++ b/compiler/testData/diagnostics/tests/evaluate/binaryMinusDepOnExpType.kt @@ -27,4 +27,4 @@ fun test() { fooShort(1 - 1.toByte()) fooShort(1 - 1.toLong()) fooShort(1 - 1.toShort()) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/evaluate/inlineClasses/constructorOfUnsignedType.fir.kt b/compiler/testData/diagnostics/tests/evaluate/inlineClasses/constructorOfUnsignedType.fir.kt index e01ed0a6cd6..7620688ffe8 100644 --- a/compiler/testData/diagnostics/tests/evaluate/inlineClasses/constructorOfUnsignedType.fir.kt +++ b/compiler/testData/diagnostics/tests/evaluate/inlineClasses/constructorOfUnsignedType.fir.kt @@ -1,5 +1,5 @@ // !LANGUAGE: +InlineClasses -// JAVAC_SKIP +// SKIP_JAVAC // FILE: uint.kt @@ -41,4 +41,4 @@ const val explicit: UInt = UI const val nullable: UInt? = UInt(3) -annotation class NullableAnno(val u: UInt?) \ No newline at end of file +annotation class NullableAnno(val u: UInt?) diff --git a/compiler/testData/diagnostics/tests/evaluate/inlineClasses/constructorOfUnsignedType.kt b/compiler/testData/diagnostics/tests/evaluate/inlineClasses/constructorOfUnsignedType.kt index 58aced46d5b..125438f99e8 100644 --- a/compiler/testData/diagnostics/tests/evaluate/inlineClasses/constructorOfUnsignedType.kt +++ b/compiler/testData/diagnostics/tests/evaluate/inlineClasses/constructorOfUnsignedType.kt @@ -1,5 +1,5 @@ // !LANGUAGE: +InlineClasses -// JAVAC_SKIP +// SKIP_JAVAC // FILE: uint.kt @@ -41,4 +41,4 @@ const val explicit: UInt = UInt(2) const val nullable: UInt? = UInt(3) -annotation class NullableAnno(val u: UInt?) \ No newline at end of file +annotation class NullableAnno(val u: UInt?) diff --git a/compiler/testData/diagnostics/tests/evaluate/logicWithNumber.kt b/compiler/testData/diagnostics/tests/evaluate/logicWithNumber.kt index 0ca70e913b1..6042fe96bd7 100644 --- a/compiler/testData/diagnostics/tests/evaluate/logicWithNumber.kt +++ b/compiler/testData/diagnostics/tests/evaluate/logicWithNumber.kt @@ -5,4 +5,4 @@ fun bar() { // See exception in KT-13421 fun foo() { 42 and false -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/evaluate/numberBinaryOperationsInfixCall.kt b/compiler/testData/diagnostics/tests/evaluate/numberBinaryOperationsInfixCall.kt index 8c42ae04c06..28abfb82456 100644 --- a/compiler/testData/diagnostics/tests/evaluate/numberBinaryOperationsInfixCall.kt +++ b/compiler/testData/diagnostics/tests/evaluate/numberBinaryOperationsInfixCall.kt @@ -23,4 +23,4 @@ fun test() { fooByte(1 rem 1) fooLong(1 rem 1) fooShort(1 rem 1) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/evaluate/unaryMinusIndepWoExpType.kt b/compiler/testData/diagnostics/tests/evaluate/unaryMinusIndepWoExpType.kt index 40a393d0021..aca2edfe15c 100644 --- a/compiler/testData/diagnostics/tests/evaluate/unaryMinusIndepWoExpType.kt +++ b/compiler/testData/diagnostics/tests/evaluate/unaryMinusIndepWoExpType.kt @@ -38,4 +38,4 @@ fun test() { fooByte(p4) fooByte(p5) fooByte(p6) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/extensions/ExtensionFunctions.fir.kt b/compiler/testData/diagnostics/tests/extensions/ExtensionFunctions.fir.kt index efd4ec1e4d1..44614eb1728 100644 --- a/compiler/testData/diagnostics/tests/extensions/ExtensionFunctions.fir.kt +++ b/compiler/testData/diagnostics/tests/extensions/ExtensionFunctions.fir.kt @@ -1,5 +1,5 @@ // !WITH_NEW_INFERENCE -// FILE: b.kt +// FILE: a.kt package outer fun Int?.optint() : Unit {} diff --git a/compiler/testData/diagnostics/tests/extensions/ExtensionFunctions.kt b/compiler/testData/diagnostics/tests/extensions/ExtensionFunctions.kt index ee0741ebe16..a50ae0c9328 100644 --- a/compiler/testData/diagnostics/tests/extensions/ExtensionFunctions.kt +++ b/compiler/testData/diagnostics/tests/extensions/ExtensionFunctions.kt @@ -1,5 +1,5 @@ // !WITH_NEW_INFERENCE -// FILE: b.kt +// FILE: a.kt package outer fun Int?.optint() : Unit {} @@ -20,7 +20,7 @@ class A infix operator fun A.plus(a : Any) { 1.foo() - true.foo() + true.foo() 1 } diff --git a/compiler/testData/diagnostics/tests/extensions/kt1875.kt b/compiler/testData/diagnostics/tests/extensions/kt1875.kt index 107e9706daf..f626f080da3 100644 --- a/compiler/testData/diagnostics/tests/extensions/kt1875.kt +++ b/compiler/testData/diagnostics/tests/extensions/kt1875.kt @@ -18,4 +18,4 @@ fun test1(t: T?) { t?.f(1) t.f?.invoke(1) t?.f?.invoke(1) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/extensions/throwOutCandidatesByReceiver.fir.kt b/compiler/testData/diagnostics/tests/extensions/throwOutCandidatesByReceiver.fir.kt index 101fc69277d..fa574807616 100644 --- a/compiler/testData/diagnostics/tests/extensions/throwOutCandidatesByReceiver.fir.kt +++ b/compiler/testData/diagnostics/tests/extensions/throwOutCandidatesByReceiver.fir.kt @@ -53,4 +53,4 @@ fun test7(l: List) { fun test8(l: List?) { l.b() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/extensions/throwOutCandidatesByReceiver.kt b/compiler/testData/diagnostics/tests/extensions/throwOutCandidatesByReceiver.kt index d8b20080c1d..89da8c15289 100644 --- a/compiler/testData/diagnostics/tests/extensions/throwOutCandidatesByReceiver.kt +++ b/compiler/testData/diagnostics/tests/extensions/throwOutCandidatesByReceiver.kt @@ -35,22 +35,22 @@ fun test4() { // should be an error on receiver, shouldn't be thrown away fun test5() { - 1.(fun String.()=1)() + 1.(fun String.()=1)() } fun R?.sure() : R = this!! fun test6(l: List?) { - l.sure<T>() + l.sure<T>() } fun List.b() {} fun test7(l: List) { - l.b() + l.b() } fun test8(l: List?) { - l.b() -} \ No newline at end of file + l.b() +} diff --git a/compiler/testData/diagnostics/tests/funInterface/funInterfaceDeclarationCheck.kt b/compiler/testData/diagnostics/tests/funInterface/funInterfaceDeclarationCheck.kt index 7df2da4d4a0..bda27bd3ca9 100644 --- a/compiler/testData/diagnostics/tests/funInterface/funInterfaceDeclarationCheck.kt +++ b/compiler/testData/diagnostics/tests/funInterface/funInterfaceDeclarationCheck.kt @@ -101,3 +101,4 @@ interface BaseWithDefaultValue { } fun interface DeriveDefault : BaseWithDefaultValue + diff --git a/compiler/testData/diagnostics/tests/funInterface/noCompatibilityResolveForFunInterfaces.kt b/compiler/testData/diagnostics/tests/funInterface/noCompatibilityResolveForFunInterfaces.kt index 97a44d5746c..630092b5763 100644 --- a/compiler/testData/diagnostics/tests/funInterface/noCompatibilityResolveForFunInterfaces.kt +++ b/compiler/testData/diagnostics/tests/funInterface/noCompatibilityResolveForFunInterfaces.kt @@ -62,4 +62,4 @@ object Test5 { foo { } } } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/functionAsExpression/InferenceParametersTypes.fir.kt b/compiler/testData/diagnostics/tests/functionAsExpression/InferenceParametersTypes.fir.kt index 8a6a7e6d36b..d5cd7b305ed 100644 --- a/compiler/testData/diagnostics/tests/functionAsExpression/InferenceParametersTypes.fir.kt +++ b/compiler/testData/diagnostics/tests/functionAsExpression/InferenceParametersTypes.fir.kt @@ -17,4 +17,4 @@ fun test2(a: () -> List) { val a: (Int) -> Unit = fun(x) { checkSubtype(x) } -val b: (Int) -> Unit = fun(x: String) {} \ No newline at end of file +val b: (Int) -> Unit = fun(x: String) {} diff --git a/compiler/testData/diagnostics/tests/functionAsExpression/InferenceParametersTypes.kt b/compiler/testData/diagnostics/tests/functionAsExpression/InferenceParametersTypes.kt index 0fce1feccb1..f8cbaed0d9e 100644 --- a/compiler/testData/diagnostics/tests/functionAsExpression/InferenceParametersTypes.kt +++ b/compiler/testData/diagnostics/tests/functionAsExpression/InferenceParametersTypes.kt @@ -12,9 +12,9 @@ fun test(a: (Int) -> Int) { } fun test2(a: () -> List) { - test2(fun () = listOf()) + test2(fun () = listOf()) } val a: (Int) -> Unit = fun(x) { checkSubtype(x) } -val b: (Int) -> Unit = fun(x: String) {} \ No newline at end of file +val b: (Int) -> Unit = fun(x: String) {} diff --git a/compiler/testData/diagnostics/tests/functionAsExpression/MissingParameterTypes.fir.kt b/compiler/testData/diagnostics/tests/functionAsExpression/MissingParameterTypes.fir.kt index 1ce99177991..46d054100dc 100644 --- a/compiler/testData/diagnostics/tests/functionAsExpression/MissingParameterTypes.fir.kt +++ b/compiler/testData/diagnostics/tests/functionAsExpression/MissingParameterTypes.fir.kt @@ -24,4 +24,4 @@ fun test2(a: (Int) -> Unit) { fun test3(a: (Int, String) -> Unit) { test3(fun (x: String) {}) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/functionAsExpression/MissingParameterTypes.kt b/compiler/testData/diagnostics/tests/functionAsExpression/MissingParameterTypes.kt index 2a4e5fbf600..5b37017cfc2 100644 --- a/compiler/testData/diagnostics/tests/functionAsExpression/MissingParameterTypes.kt +++ b/compiler/testData/diagnostics/tests/functionAsExpression/MissingParameterTypes.kt @@ -19,9 +19,9 @@ fun test1(a: (Int) -> Unit) { } fun test2(a: (Int) -> Unit) { - test2(fun (x: String) {}) + test2(fun (x: String) {}) } fun test3(a: (Int, String) -> Unit) { - test3(fun (x: String) {}) -} \ No newline at end of file + test3(fun (x: String) {}) +} diff --git a/compiler/testData/diagnostics/tests/functionAsExpression/ReceiverByExpectedType.fir.kt b/compiler/testData/diagnostics/tests/functionAsExpression/ReceiverByExpectedType.fir.kt index bcfd7229a3b..a4249156f1e 100644 --- a/compiler/testData/diagnostics/tests/functionAsExpression/ReceiverByExpectedType.fir.kt +++ b/compiler/testData/diagnostics/tests/functionAsExpression/ReceiverByExpectedType.fir.kt @@ -1,3 +1,3 @@ // !WITH_NEW_INFERENCE fun foo(f: String.() -> Int) {} -val test = foo(fun () = length) \ No newline at end of file +val test = foo(fun () = length) diff --git a/compiler/testData/diagnostics/tests/functionAsExpression/ReceiverByExpectedType.kt b/compiler/testData/diagnostics/tests/functionAsExpression/ReceiverByExpectedType.kt index f517152c8f1..d5123b957fa 100644 --- a/compiler/testData/diagnostics/tests/functionAsExpression/ReceiverByExpectedType.kt +++ b/compiler/testData/diagnostics/tests/functionAsExpression/ReceiverByExpectedType.kt @@ -1,3 +1,3 @@ // !WITH_NEW_INFERENCE fun foo(f: String.() -> Int) {} -val test = foo(fun () = length) \ No newline at end of file +val test = foo(fun () = length) diff --git a/compiler/testData/diagnostics/tests/functionAsExpression/WithGenericParameters.fir.kt b/compiler/testData/diagnostics/tests/functionAsExpression/WithGenericParameters.fir.kt index 78ce746b50e..d6e72349531 100644 --- a/compiler/testData/diagnostics/tests/functionAsExpression/WithGenericParameters.fir.kt +++ b/compiler/testData/diagnostics/tests/functionAsExpression/WithGenericParameters.fir.kt @@ -16,4 +16,4 @@ fun outer() { devNull(fun (): T = null!!) devNull(fun (t: T) {}) devNull(fun () where T:A {}) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/functionAsExpression/WithGenericParameters.kt b/compiler/testData/diagnostics/tests/functionAsExpression/WithGenericParameters.kt index 16c1fafa81c..b0ba25b3c96 100644 --- a/compiler/testData/diagnostics/tests/functionAsExpression/WithGenericParameters.kt +++ b/compiler/testData/diagnostics/tests/functionAsExpression/WithGenericParameters.kt @@ -12,8 +12,8 @@ fun fun_with_where() = fun T.(t: T): T whe fun outer() { devNull(fun () {}) - devNull(fun T.() {}) - devNull(fun (): T = null!!) - devNull(fun (t: T) {}) + devNull(fun T.() {}) + devNull(fun (): T = null!!) + devNull(fun (t: T) {}) devNull(fun () where T:A {}) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/functionLiterals/ExpectedParameterTypeMismatchVariance.kt b/compiler/testData/diagnostics/tests/functionLiterals/ExpectedParameterTypeMismatchVariance.kt index 2bf2645eee8..89294444aab 100644 --- a/compiler/testData/diagnostics/tests/functionLiterals/ExpectedParameterTypeMismatchVariance.kt +++ b/compiler/testData/diagnostics/tests/functionLiterals/ExpectedParameterTypeMismatchVariance.kt @@ -16,6 +16,6 @@ fun test(s: Sub) { t: Trait -> s } - foo(fun(t: Sub) = s) + foo(fun(t: Sub) = s) foo(fun(t): Super = s) } diff --git a/compiler/testData/diagnostics/tests/functionLiterals/ExpectedParametersTypesMismatch.kt b/compiler/testData/diagnostics/tests/functionLiterals/ExpectedParametersTypesMismatch.kt index cc3dc836f84..1d277074ce7 100644 --- a/compiler/testData/diagnostics/tests/functionLiterals/ExpectedParametersTypesMismatch.kt +++ b/compiler/testData/diagnostics/tests/functionLiterals/ExpectedParametersTypesMismatch.kt @@ -9,37 +9,37 @@ fun test1() { foo0 { "" } - foo0 { + foo0 { s: String-> "" } - foo0 { + foo0 { x, y -> "" } foo1 { "" } - foo1 { + foo1 { s: String -> "" } - foo1 { + foo1 { x, y -> "" } - foo1 { - -> 42 + foo1 { + -> 42 } foo2 { "" } - foo2 { + foo2 { s: String -> "" } - foo2 { + foo2 { x -> "" } - foo2 { - -> 42 + foo2 { + -> 42 } } diff --git a/compiler/testData/diagnostics/tests/functionLiterals/LabeledFunctionLiterals.kt b/compiler/testData/diagnostics/tests/functionLiterals/LabeledFunctionLiterals.kt index 4309c625107..2d2440d2ffa 100644 --- a/compiler/testData/diagnostics/tests/functionLiterals/LabeledFunctionLiterals.kt +++ b/compiler/testData/diagnostics/tests/functionLiterals/LabeledFunctionLiterals.kt @@ -10,7 +10,7 @@ fun foo(a: A, f: () -> T): T = f() fun foo(b: B, f: () -> T): T = f() fun test(c: C) { - foo(c) f@ { + foo(c) f@ { c!! } } diff --git a/compiler/testData/diagnostics/tests/functionLiterals/assignmentOperationInLambdaWithExpectedType.kt b/compiler/testData/diagnostics/tests/functionLiterals/assignmentOperationInLambdaWithExpectedType.kt index 25f8f6c12fa..b1fb7adeecf 100644 --- a/compiler/testData/diagnostics/tests/functionLiterals/assignmentOperationInLambdaWithExpectedType.kt +++ b/compiler/testData/diagnostics/tests/functionLiterals/assignmentOperationInLambdaWithExpectedType.kt @@ -12,5 +12,5 @@ fun test(bal: Array) { val e: Unit = run { bar += 4 } - val f: Int = run { bar += 4 } + val f: Int = run { bar += 4 } } diff --git a/compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/complexInference.kt b/compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/complexInference.kt index 80f29ecddf8..c0c10550f24 100644 --- a/compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/complexInference.kt +++ b/compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/complexInference.kt @@ -30,10 +30,10 @@ fun bar(aInstance: A, bInstance: B) { d checkType { _() } } - foo(bInstance) { + foo(bInstance) { (a, b), (c, d) -> - a checkType { _() } - b checkType { _() } + a checkType { _() } + b checkType { _() } c checkType { _() } d checkType { _() } } diff --git a/compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/inferredFunctionalType.kt b/compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/inferredFunctionalType.kt index 0a571abc9d0..e37741fc27a 100644 --- a/compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/inferredFunctionalType.kt +++ b/compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/inferredFunctionalType.kt @@ -27,8 +27,8 @@ fun bar(aList: List) { b checkType { _() } } - aList.foo { (a, b): B -> - b checkType { _() } - a checkType { _() } + aList.foo { (a, b): B -> + b checkType { _() } + a checkType { _() } } } diff --git a/compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/noExpectedType.kt b/compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/noExpectedType.kt index f4b19e76869..7e9b68f8dc5 100644 --- a/compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/noExpectedType.kt +++ b/compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/noExpectedType.kt @@ -26,7 +26,7 @@ fun bar() { y2 checkType { _<(A) -> Unit>() } val z = { (a: Int, b: String) -> - a checkType { _() } - b checkType { _() } + a checkType { _() } + b checkType { _() } } } diff --git a/compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/redeclaration.kt b/compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/redeclaration.kt index 3c6b2355a3b..b6936a6d809 100644 --- a/compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/redeclaration.kt +++ b/compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/redeclaration.kt @@ -8,23 +8,23 @@ fun foo(block: (A, B) -> Unit) { } fun bar() { foo { (a, a), b -> - a checkType { _() } - b checkType { _() } + a checkType { _() } + b checkType { _() } } foo { (a, b), a -> - a checkType { _() } + a checkType { _() } b checkType { _() } } foo { a, (a, b) -> - a checkType { _() } - b checkType { _() } + a checkType { _() } + b checkType { _() } } foo { (a, b), (c, b) -> a checkType { _() } - b checkType { _() } - c checkType { _() } + b checkType { _() } + c checkType { _() } } } diff --git a/compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/simple.kt b/compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/simple.kt index 5ef660246c2..11e4b0ed95c 100644 --- a/compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/simple.kt +++ b/compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/simple.kt @@ -47,7 +47,7 @@ fun bar() { b checkType { _() } } - foo { (a, b): B -> + foo { (a, b): B -> a checkType { _() } b checkType { _() } } diff --git a/compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/underscore.kt b/compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/underscore.kt index 8178d868850..a786272443d 100644 --- a/compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/underscore.kt +++ b/compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/underscore.kt @@ -8,35 +8,35 @@ fun foo(block: (A) -> Unit) { } fun bar() { foo { (_, b) -> - _.hashCode() + _.hashCode() b checkType { _() } } foo { (a, _) -> a checkType { _() } - _.hashCode() + _.hashCode() } foo { (_, _) -> - _.hashCode() + _.hashCode() } foo { (_: Int, b: String) -> - _.hashCode() + _.hashCode() b checkType { _() } } foo { (a: Int, _: String) -> a checkType { _() } - _.hashCode() + _.hashCode() } foo { (_: Int, _: String) -> - _.hashCode() + _.hashCode() } foo { (_, _): A -> - _.hashCode() + _.hashCode() } foo { (`_`, _) -> @@ -52,12 +52,12 @@ fun bar() { } foo { (_: String, b) -> - _.hashCode() + _.hashCode() b checkType { _() } } - foo { (_, b): B -> - _.hashCode() + foo { (_, b): B -> + _.hashCode() b checkType { _() } } } diff --git a/compiler/testData/diagnostics/tests/functionLiterals/kt7383_starProjectedFunction.kt b/compiler/testData/diagnostics/tests/functionLiterals/kt7383_starProjectedFunction.kt index de7b36e9e14..0b06daa66a4 100644 --- a/compiler/testData/diagnostics/tests/functionLiterals/kt7383_starProjectedFunction.kt +++ b/compiler/testData/diagnostics/tests/functionLiterals/kt7383_starProjectedFunction.kt @@ -3,5 +3,5 @@ fun foo() { val f : Function1<*, *> = { x -> x.toString() } - f(1) + f(1) } diff --git a/compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnsWithExplicitReturnType.kt b/compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnsWithExplicitReturnType.kt index ea7ca3be1ac..dd114afd6b4 100644 --- a/compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnsWithExplicitReturnType.kt +++ b/compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnsWithExplicitReturnType.kt @@ -1,10 +1,10 @@ // !WITH_NEW_INFERENCE fun test(a: Int) { runf@{ - if (a > 0) return@f "" + if (a > 0) return@f "" return@f 1 } - run{ "" } + run{ "" } run{ 1 } } diff --git a/compiler/testData/diagnostics/tests/functionLiterals/return/NoCommonSystem.fir.kt b/compiler/testData/diagnostics/tests/functionLiterals/return/NoCommonSystem.fir.kt index 22e46bb749e..350f0877d5d 100644 --- a/compiler/testData/diagnostics/tests/functionLiterals/return/NoCommonSystem.fir.kt +++ b/compiler/testData/diagnostics/tests/functionLiterals/return/NoCommonSystem.fir.kt @@ -16,4 +16,4 @@ fun commonSystemFailed(a: List) { if (it == 0) listOf() else listOf(it) } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/functionLiterals/return/NoCommonSystem.kt b/compiler/testData/diagnostics/tests/functionLiterals/return/NoCommonSystem.kt index 633740ece71..a415838ef30 100644 --- a/compiler/testData/diagnostics/tests/functionLiterals/return/NoCommonSystem.kt +++ b/compiler/testData/diagnostics/tests/functionLiterals/return/NoCommonSystem.kt @@ -6,14 +6,14 @@ fun listOf(vararg values: T): List = null!! fun commonSystemFailed(a: List) { a.map { if (it == 0) return@map listOf(it) - listOf() + listOf() } a.map { - if (it == 0) return@map listOf() + if (it == 0) return@map listOf() listOf(it) } a.map { if (it == 0) listOf() else listOf(it) } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/functionLiterals/return/SmartCast.fir.kt b/compiler/testData/diagnostics/tests/functionLiterals/return/SmartCast.fir.kt index a9649e4b4db..428aa4895de 100644 --- a/compiler/testData/diagnostics/tests/functionLiterals/return/SmartCast.fir.kt +++ b/compiler/testData/diagnostics/tests/functionLiterals/return/SmartCast.fir.kt @@ -16,4 +16,4 @@ val b /*: Int? */ = let { // but must be Int val c /*: Int*/ = let { if (it != null) it else 5 -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/functionLiterals/return/SmartCast.kt b/compiler/testData/diagnostics/tests/functionLiterals/return/SmartCast.kt index 40da50eef87..3b988552a87 100644 --- a/compiler/testData/diagnostics/tests/functionLiterals/return/SmartCast.kt +++ b/compiler/testData/diagnostics/tests/functionLiterals/return/SmartCast.kt @@ -10,10 +10,10 @@ val a /* :(Int?) -> Int? */ = l@ { it: Int? -> // but must be (Int?) -> Int fun let(f: (Int?) -> R): R = null!! val b /*: Int? */ = let { // but must be Int - if (it != null) return@let it + if (it != null) return@let it 5 } val c /*: Int*/ = let { if (it != null) it else 5 -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/functionLiterals/returnNullWithReturn.fir.kt b/compiler/testData/diagnostics/tests/functionLiterals/returnNullWithReturn.fir.kt index 491a77d8ad3..98fce09583a 100644 --- a/compiler/testData/diagnostics/tests/functionLiterals/returnNullWithReturn.fir.kt +++ b/compiler/testData/diagnostics/tests/functionLiterals/returnNullWithReturn.fir.kt @@ -8,4 +8,4 @@ fun test(handlers: MapUnit>) { handlers.getOrElse("name", l@ { return@l null }) } -fun Map.getOrElse(key: K, defaultValue: ()-> V) : V = throw Exception("$key $defaultValue") \ No newline at end of file +fun Map.getOrElse(key: K, defaultValue: ()-> V) : V = throw Exception("$key $defaultValue") diff --git a/compiler/testData/diagnostics/tests/functionLiterals/returnNullWithReturn.kt b/compiler/testData/diagnostics/tests/functionLiterals/returnNullWithReturn.kt index ffab35ee182..97c1866b3d7 100644 --- a/compiler/testData/diagnostics/tests/functionLiterals/returnNullWithReturn.kt +++ b/compiler/testData/diagnostics/tests/functionLiterals/returnNullWithReturn.kt @@ -5,7 +5,7 @@ interface Element fun test(handlers: MapUnit>) { - handlers.getOrElse("name", l@ { return@l null }) + handlers.getOrElse("name", l@ { return@l null }) } -fun Map.getOrElse(key: K, defaultValue: ()-> V) : V = throw Exception("$key $defaultValue") \ No newline at end of file +fun Map.getOrElse(key: K, defaultValue: ()-> V) : V = throw Exception("$key $defaultValue") diff --git a/compiler/testData/diagnostics/tests/generics/Projections.fir.kt b/compiler/testData/diagnostics/tests/generics/Projections.fir.kt index e28b7ae63cd..65ab20e0ec9 100644 --- a/compiler/testData/diagnostics/tests/generics/Projections.fir.kt +++ b/compiler/testData/diagnostics/tests/generics/Projections.fir.kt @@ -51,4 +51,4 @@ fun testInOut() { (null as Inv<*>).outf() Inv().outf(1) // Wrong Arg -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/generics/Projections.kt b/compiler/testData/diagnostics/tests/generics/Projections.kt index 8c3847e51af..820d719ae62 100644 --- a/compiler/testData/diagnostics/tests/generics/Projections.kt +++ b/compiler/testData/diagnostics/tests/generics/Projections.kt @@ -37,13 +37,13 @@ fun testInOut() { Inv().f(1) (null as Inv).f(1) - (null as Inv).f(1) // !! - (null as Inv<*>).f(1) // !! + (null as Inv).f(1) // !! + (null as Inv<*>).f(1) // !! Inv().inf(1) (null as Inv).inf(1) - (null as Inv).inf(1) // !! - (null as Inv<*>).inf(1) // !! + (null as Inv).inf(1) // !! + (null as Inv<*>).inf(1) // !! Inv().outf() checkSubtype((null as Inv).outf()) // Type mismatch @@ -51,4 +51,4 @@ fun testInOut() { (null as Inv<*>).outf() Inv().outf(1) // Wrong Arg -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/generics/bareTypesWithStarProjections.fir.kt b/compiler/testData/diagnostics/tests/generics/bareTypesWithStarProjections.fir.kt deleted file mode 100644 index 6c8fcf68cb7..00000000000 --- a/compiler/testData/diagnostics/tests/generics/bareTypesWithStarProjections.fir.kt +++ /dev/null @@ -1,40 +0,0 @@ -// SKIP_TXT -// IGNORE_FIR -// !CHECK_TYPE -// !LANGUAGE: +NewInference -// !DIAGNOSTICS: -UNUSED_PARAMETER -// !FIR_IGNORE - -interface FirMemberDeclaration : FirDeclaration -interface TypeConstructorMarker - -interface FirElement -interface FirDeclaration : FirElement -interface FirStatement : FirElement -interface FirSymbolOwner : FirElement where E : FirSymbolOwner, E : FirDeclaration - -interface FirCallableDeclaration> : FirDeclaration, FirSymbolOwner - -interface FirBasedSymbol where E : FirSymbolOwner, E : FirDeclaration -interface AbstractFirBasedSymbol : FirBasedSymbol where E : FirSymbolOwner, E : FirDeclaration - -interface FirVariable> : FirCallableDeclaration, FirDeclaration, FirStatement - -interface FirCallableSymbol> : AbstractFirBasedSymbol -interface FirVariableSymbol> : FirCallableSymbol -interface FirPropertySymbol : FirVariableSymbol - -interface FirCallableMemberDeclaration> : FirCallableDeclaration, FirMemberDeclaration - -interface FirProperty : FirVariable, FirCallableMemberDeclaration - -fun AbstractFirBasedSymbol.phasedFir(): D where D : FirDeclaration, D : FirSymbolOwner = TODO() - -fun foo(coneSymbol: AbstractFirBasedSymbol<*>) { - if (coneSymbol !is FirVariableSymbol) return - // For bare types, smart cast should be performed to FirVariableSymbol<*> not to FirVariableSymbol> - coneSymbol.phasedFir() checkType { _>() } - - if (coneSymbol !is FirPropertySymbol) return - coneSymbol.phasedFir() checkType { _() } -} diff --git a/compiler/testData/diagnostics/tests/generics/bareTypesWithStarProjections.kt b/compiler/testData/diagnostics/tests/generics/bareTypesWithStarProjections.kt index 6c8fcf68cb7..3d7a9391c30 100644 --- a/compiler/testData/diagnostics/tests/generics/bareTypesWithStarProjections.kt +++ b/compiler/testData/diagnostics/tests/generics/bareTypesWithStarProjections.kt @@ -1,9 +1,8 @@ +// FIR_IDENTICAL // SKIP_TXT -// IGNORE_FIR // !CHECK_TYPE // !LANGUAGE: +NewInference // !DIAGNOSTICS: -UNUSED_PARAMETER -// !FIR_IGNORE interface FirMemberDeclaration : FirDeclaration interface TypeConstructorMarker diff --git a/compiler/testData/diagnostics/tests/generics/capturedParameters/captured.kt b/compiler/testData/diagnostics/tests/generics/capturedParameters/captured.kt index b69a24e3589..df1878010e7 100644 --- a/compiler/testData/diagnostics/tests/generics/capturedParameters/captured.kt +++ b/compiler/testData/diagnostics/tests/generics/capturedParameters/captured.kt @@ -10,11 +10,11 @@ class X { fun testStar(y: X.Y<*>, t: Any) { - X().foo(y, t) + X().foo(y, t) } fun testOut(y: X.Y, t: Any) { - X().foo(y, t) + X().foo(y, t) } fun testIn(y: X.Y, t: Any) { @@ -22,9 +22,9 @@ fun testIn(y: X.Y, t: Any) { } fun testWithParameter(y: X.Y, t: Any) { - X().foo(y, t) + X().foo(y, t) } fun testWithCapturedParameter(y: X.Y, t: Any) { - X().foo(y, t) + X().foo(y, t) } diff --git a/compiler/testData/diagnostics/tests/generics/finalUpperBoundWithoutOverride.kt b/compiler/testData/diagnostics/tests/generics/finalUpperBoundWithoutOverride.kt index 546c9eab658..a35a01fc012 100644 --- a/compiler/testData/diagnostics/tests/generics/finalUpperBoundWithoutOverride.kt +++ b/compiler/testData/diagnostics/tests/generics/finalUpperBoundWithoutOverride.kt @@ -79,4 +79,4 @@ object MessageManager15 : Manager { var Int> T.y get() = 10 set(value) {} -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClassesLocal.kt b/compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClassesLocal.kt index e4967fe102f..b47238bcf09 100644 --- a/compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClassesLocal.kt +++ b/compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClassesLocal.kt @@ -45,7 +45,7 @@ fun test() { x().foo().a() checkType { _>() } x().bar() checkType { _>() } - x = foobar() + x = foobar() var y = noParameters() y = noParameters() diff --git a/compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClassesLocalInsideInner.kt b/compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClassesLocalInsideInner.kt index d5fdd6a53e9..0dde5e49efa 100644 --- a/compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClassesLocalInsideInner.kt +++ b/compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClassesLocalInsideInner.kt @@ -46,8 +46,8 @@ class Outer { x().foo().a() checkType { _>() } x().bar() checkType { _>() } - x = foobar() - x = z.foobar() + x = foobar() + x = z.foobar() var y = noParameters() y = noParameters() diff --git a/compiler/testData/diagnostics/tests/generics/innerClasses/innerTP.kt b/compiler/testData/diagnostics/tests/generics/innerClasses/innerTP.kt index 6719bcf122f..1e47b515c93 100644 --- a/compiler/testData/diagnostics/tests/generics/innerClasses/innerTP.kt +++ b/compiler/testData/diagnostics/tests/generics/innerClasses/innerTP.kt @@ -32,7 +32,7 @@ fun main() { checkSubtype.Inner<*>>(outer.Inner()) checkSubtype.Inner>(outer.bar()) - checkSubtype.Inner>(outer.Inner()) + checkSubtype.Inner>(outer.Inner()) outer.set(outer.bar()) outer.set(outer.Inner()) diff --git a/compiler/testData/diagnostics/tests/generics/innerClasses/innerUncheckedCast.kt b/compiler/testData/diagnostics/tests/generics/innerClasses/innerUncheckedCast.kt index d766cbcf95a..54281b0ef71 100644 --- a/compiler/testData/diagnostics/tests/generics/innerClasses/innerUncheckedCast.kt +++ b/compiler/testData/diagnostics/tests/generics/innerClasses/innerUncheckedCast.kt @@ -15,7 +15,7 @@ class Outer { if (y is Inner) return if (z is Inner) { - z.prop.checkType { _() } + z.prop.checkType { _() } return } diff --git a/compiler/testData/diagnostics/tests/generics/innerClasses/iterator.kt b/compiler/testData/diagnostics/tests/generics/innerClasses/iterator.kt index ed2212cf62a..64b3a129de1 100644 --- a/compiler/testData/diagnostics/tests/generics/innerClasses/iterator.kt +++ b/compiler/testData/diagnostics/tests/generics/innerClasses/iterator.kt @@ -33,5 +33,5 @@ fun foo() { val csIt: Iterator = A().iterator() - commonSupertype(A().iterator(), A().iterator()).checkType { _.MyIt>() } + commonSupertype(A().iterator(), A().iterator()).checkType { _.MyIt>() } } diff --git a/compiler/testData/diagnostics/tests/generics/innerClasses/qualifiedOuter.kt b/compiler/testData/diagnostics/tests/generics/innerClasses/qualifiedOuter.kt index c8b9fbeb0b9..c9c5da69d80 100644 --- a/compiler/testData/diagnostics/tests/generics/innerClasses/qualifiedOuter.kt +++ b/compiler/testData/diagnostics/tests/generics/innerClasses/qualifiedOuter.kt @@ -6,7 +6,7 @@ class Outer { inner class Inner fun foo(x: Outer.Inner, y: Outer.Inner, z: Inner) { var inner = Inner() - x.checkType { _() } + x.checkType { _() } x.checkType { _.Inner>() } z.checkType { _() } z.checkType { _.Inner>() } diff --git a/compiler/testData/diagnostics/tests/generics/innerClasses/simpleOutUseSite.kt b/compiler/testData/diagnostics/tests/generics/innerClasses/simpleOutUseSite.kt index 11897eb8fcc..c7b41148d8c 100644 --- a/compiler/testData/diagnostics/tests/generics/innerClasses/simpleOutUseSite.kt +++ b/compiler/testData/diagnostics/tests/generics/innerClasses/simpleOutUseSite.kt @@ -29,9 +29,9 @@ fun main() { checkSubtype.Inner>(outer.bar()) checkSubtype.Inner>(outer.Inner()) - outer.set(outer.bar()) - outer.set(outer.Inner()) + outer.set(outer.bar()) + outer.set(outer.Inner()) val x: Outer.Inner = factoryString() - outer.set(x) + outer.set(x) } diff --git a/compiler/testData/diagnostics/tests/generics/kt30590.kt b/compiler/testData/diagnostics/tests/generics/kt30590.kt index b66ca971e1d..9e5d418b52f 100644 --- a/compiler/testData/diagnostics/tests/generics/kt30590.kt +++ b/compiler/testData/diagnostics/tests/generics/kt30590.kt @@ -6,4 +6,4 @@ interface A fun emptyStrangeMap(): Map = TODO() fun test7() : Map = emptyStrangeMap() -fun test() = emptyStrangeMap() +fun test() = emptyStrangeMap() diff --git a/compiler/testData/diagnostics/tests/generics/kt34729.kt b/compiler/testData/diagnostics/tests/generics/kt34729.kt index 665129cf9bd..f07d2e3ee0c 100644 --- a/compiler/testData/diagnostics/tests/generics/kt34729.kt +++ b/compiler/testData/diagnostics/tests/generics/kt34729.kt @@ -14,6 +14,6 @@ fun bar(a: (Int) -> T) { } fun test() { - foo { } - bar { } + foo { } + bar { } } diff --git a/compiler/testData/diagnostics/tests/generics/kt9203.kt b/compiler/testData/diagnostics/tests/generics/kt9203.kt index 83f420d2152..93fcc651c8a 100644 --- a/compiler/testData/diagnostics/tests/generics/kt9203.kt +++ b/compiler/testData/diagnostics/tests/generics/kt9203.kt @@ -8,4 +8,4 @@ fun main() { val xs = IntStream.range(0, 10).mapToObj { it.toString() } .collect(Collectors.toList()) xs[0] -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/generics/nullability/expressionsBoundsViolation.kt b/compiler/testData/diagnostics/tests/generics/nullability/expressionsBoundsViolation.kt index aba7d454da2..73ec1f43bd2 100644 --- a/compiler/testData/diagnostics/tests/generics/nullability/expressionsBoundsViolation.kt +++ b/compiler/testData/diagnostics/tests/generics/nullability/expressionsBoundsViolation.kt @@ -7,13 +7,13 @@ fun foo1(x: E) {} fun E.foo2() {} fun bar(x: F) { - A(x) + A(x) A<F>(x) - foo1(x) + foo1(x) foo1<F>(x) - x.foo2() + x.foo2() x.foo2<F>() } diff --git a/compiler/testData/diagnostics/tests/generics/nullability/functionalBound.kt b/compiler/testData/diagnostics/tests/generics/nullability/functionalBound.kt index 2944a0a2b31..16f0fb94a1a 100644 --- a/compiler/testData/diagnostics/tests/generics/nullability/functionalBound.kt +++ b/compiler/testData/diagnostics/tests/generics/nullability/functionalBound.kt @@ -10,4 +10,4 @@ fun Unit)?> foo(x: E, y: T) { if (x != null && y != null) { y(x) } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/generics/nullability/nullToGeneric.fir.kt b/compiler/testData/diagnostics/tests/generics/nullability/nullToGeneric.fir.kt index 3cba1b9f73f..98f6fa489f0 100644 --- a/compiler/testData/diagnostics/tests/generics/nullability/nullToGeneric.fir.kt +++ b/compiler/testData/diagnostics/tests/generics/nullability/nullToGeneric.fir.kt @@ -1,4 +1,4 @@ -// !DIAGNOSTICS: -UNUSED_PARAMETER,-UNUSED_VARIABLE +// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE fun bar(x: E) {} diff --git a/compiler/testData/diagnostics/tests/generics/nullability/nullToGeneric.kt b/compiler/testData/diagnostics/tests/generics/nullability/nullToGeneric.kt index c831d9dc3f4..b6be648e521 100644 --- a/compiler/testData/diagnostics/tests/generics/nullability/nullToGeneric.kt +++ b/compiler/testData/diagnostics/tests/generics/nullability/nullToGeneric.kt @@ -1,4 +1,4 @@ -// !DIAGNOSTICS: -UNUSED_PARAMETER,-UNUSED_VARIABLE +// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE fun bar(x: E) {} diff --git a/compiler/testData/diagnostics/tests/generics/nullability/smartCasts.kt b/compiler/testData/diagnostics/tests/generics/nullability/smartCasts.kt index daa9c8164a1..25d9392afdb 100644 --- a/compiler/testData/diagnostics/tests/generics/nullability/smartCasts.kt +++ b/compiler/testData/diagnostics/tests/generics/nullability/smartCasts.kt @@ -15,9 +15,9 @@ fun foo(x: T) { x.length x?.length - x.bar1() + x.bar1() x.bar2() - x.bar3() + x.bar3() x.bar4() @@ -30,7 +30,7 @@ fun foo(x: T) { x.length x?.length - x.bar1() + x.bar1() x.bar2() x.bar3() } @@ -39,7 +39,7 @@ fun foo(x: T) { x.length x?.length - x.bar1() + x.bar1() x.bar2() x.bar3() } diff --git a/compiler/testData/diagnostics/tests/generics/nullability/smartCastsOnThis.kt b/compiler/testData/diagnostics/tests/generics/nullability/smartCastsOnThis.kt index 2cf4d6f80ab..4196c852c6e 100644 --- a/compiler/testData/diagnostics/tests/generics/nullability/smartCastsOnThis.kt +++ b/compiler/testData/diagnostics/tests/generics/nullability/smartCastsOnThis.kt @@ -11,13 +11,13 @@ fun T.foo() { if (this != null) { if (this != null) {} - length + length this?.length - bar1() + bar1() bar2() - bar3() - bar4() + bar3() + bar4() this?.bar1() @@ -29,8 +29,8 @@ fun T.foo() { length this?.length - bar1() + bar1() bar2() - bar3() + bar3() } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/generics/nullability/smartCastsValueArgument.fir.kt b/compiler/testData/diagnostics/tests/generics/nullability/smartCastsValueArgument.fir.kt index 8c40082a63f..75812a0174a 100644 --- a/compiler/testData/diagnostics/tests/generics/nullability/smartCastsValueArgument.fir.kt +++ b/compiler/testData/diagnostics/tests/generics/nullability/smartCastsValueArgument.fir.kt @@ -1,5 +1,5 @@ // !WITH_NEW_INFERENCE -// !DIAGNOSTICS: -UNUSED_EXPRESSION,-UNUSED_VARIABLE,-UNUSED_PARAMETER,-ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE,-UNUSED_VALUE +// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_VARIABLE -UNUSED_PARAMETER -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE fun bar1(x: T) {} fun bar2(x: CharSequence) {} diff --git a/compiler/testData/diagnostics/tests/generics/nullability/smartCastsValueArgument.kt b/compiler/testData/diagnostics/tests/generics/nullability/smartCastsValueArgument.kt index 7449ffe9b10..a9c752df1e0 100644 --- a/compiler/testData/diagnostics/tests/generics/nullability/smartCastsValueArgument.kt +++ b/compiler/testData/diagnostics/tests/generics/nullability/smartCastsValueArgument.kt @@ -1,5 +1,5 @@ // !WITH_NEW_INFERENCE -// !DIAGNOSTICS: -UNUSED_EXPRESSION,-UNUSED_VARIABLE,-UNUSED_PARAMETER,-ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE,-UNUSED_VALUE +// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_VARIABLE -UNUSED_PARAMETER -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE fun bar1(x: T) {} fun bar2(x: CharSequence) {} @@ -14,7 +14,7 @@ fun foo(x: T) { y1 = x y2 = x - bar1(x) + bar1(x) bar1(x) bar2(x) bar3(x) @@ -40,13 +40,13 @@ fun foo(x: T) { if (1 == 1) { val y = x!! - bar1(x) + bar1(x) bar1(x) bar2(x) bar3(x) - bar1(y) - bar2(y) + bar1(y) + bar2(y) bar3(y) } } diff --git a/compiler/testData/diagnostics/tests/generics/nullability/tpBoundsViolation.fir.kt b/compiler/testData/diagnostics/tests/generics/nullability/tpBoundsViolation.fir.kt index a9741f314d2..2d2cdac7f92 100644 --- a/compiler/testData/diagnostics/tests/generics/nullability/tpBoundsViolation.fir.kt +++ b/compiler/testData/diagnostics/tests/generics/nullability/tpBoundsViolation.fir.kt @@ -1,6 +1,6 @@ // !WITH_NEW_INFERENCE // !CHECK_TYPE -// !DIAGNOSTICS: -UNUSED_PARAMETER,-UNUSED_VARIABLE +// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE class A { fun foo1(x: E) = x diff --git a/compiler/testData/diagnostics/tests/generics/nullability/tpBoundsViolation.kt b/compiler/testData/diagnostics/tests/generics/nullability/tpBoundsViolation.kt index 254e02a3aa8..851db406158 100644 --- a/compiler/testData/diagnostics/tests/generics/nullability/tpBoundsViolation.kt +++ b/compiler/testData/diagnostics/tests/generics/nullability/tpBoundsViolation.kt @@ -1,6 +1,6 @@ // !WITH_NEW_INFERENCE // !CHECK_TYPE -// !DIAGNOSTICS: -UNUSED_PARAMETER,-UNUSED_VARIABLE +// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE class A { fun foo1(x: E) = x @@ -18,7 +18,7 @@ class A { x2.checkType { _() } foo1<F?>(y) - foo1(y) + foo1(y) foo2(y) val x3 = foo2(y) @@ -38,7 +38,7 @@ class A { x4.checkType { _() } foo1<W>(w) - foo1(w) + foo1(w) foo2(w) val x6 = foo2(w) diff --git a/compiler/testData/diagnostics/tests/generics/nullability/tpBoundsViolationVariance.kt b/compiler/testData/diagnostics/tests/generics/nullability/tpBoundsViolationVariance.kt index dd1e245e7a5..990c6ae3038 100644 --- a/compiler/testData/diagnostics/tests/generics/nullability/tpBoundsViolationVariance.kt +++ b/compiler/testData/diagnostics/tests/generics/nullability/tpBoundsViolationVariance.kt @@ -20,7 +20,7 @@ class A { fooInv1>(Inv()) fooInv2<Inv>(Inv()) fooInv1(Inv()) - fooInv2(Inv()) + fooInv2(Inv()) fooIn1>(In()) fooIn2>(In()) @@ -35,13 +35,13 @@ class A { // Z fooInv1<Inv>(Inv()) fooInv2<Inv>(Inv()) - fooInv1(Inv()) - fooInv2(Inv()) + fooInv1(Inv()) + fooInv2(Inv()) fooIn1<In>(In()) fooIn2<In>(In()) - fooIn1(In()) - fooIn2(In()) + fooIn1(In()) + fooIn2(In()) fooOut1>(Out()) fooOut2>(Out()) @@ -51,17 +51,17 @@ class A { // W fooInv1<Inv>(Inv()) fooInv2<Inv>(Inv()) - fooInv1(Inv()) - fooInv2(Inv()) + fooInv1(Inv()) + fooInv2(Inv()) fooIn1<In>(In()) fooIn2<In>(In()) - fooIn1(In()) - fooIn2(In()) + fooIn1(In()) + fooIn2(In()) fooOut1<Out>(Out()) fooOut2>(Out()) - fooOut1(Out()) + fooOut1(Out()) fooOut2(Out()) } } diff --git a/compiler/testData/diagnostics/tests/generics/nullability/tpInBounds.fir.kt b/compiler/testData/diagnostics/tests/generics/nullability/tpInBounds.fir.kt index 3e24720fdd3..de78b5e4e64 100644 --- a/compiler/testData/diagnostics/tests/generics/nullability/tpInBounds.fir.kt +++ b/compiler/testData/diagnostics/tests/generics/nullability/tpInBounds.fir.kt @@ -1,5 +1,5 @@ // !WITH_NEW_INFERENCE -// !DIAGNOSTICS: -UNUSED_VALUE,-UNUSED_VARIABLE,-ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE,-VARIABLE_WITH_REDUNDANT_INITIALIZER +// !DIAGNOSTICS: -UNUSED_VALUE -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -VARIABLE_WITH_REDUNDANT_INITIALIZER class A { fun T.bar() {} diff --git a/compiler/testData/diagnostics/tests/generics/nullability/tpInBounds.kt b/compiler/testData/diagnostics/tests/generics/nullability/tpInBounds.kt index 2294e02915e..0f76856a0b6 100644 --- a/compiler/testData/diagnostics/tests/generics/nullability/tpInBounds.kt +++ b/compiler/testData/diagnostics/tests/generics/nullability/tpInBounds.kt @@ -1,5 +1,5 @@ // !WITH_NEW_INFERENCE -// !DIAGNOSTICS: -UNUSED_VALUE,-UNUSED_VARIABLE,-ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE,-VARIABLE_WITH_REDUNDANT_INITIALIZER +// !DIAGNOSTICS: -UNUSED_VALUE -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -VARIABLE_WITH_REDUNDANT_INITIALIZER class A { fun T.bar() {} diff --git a/compiler/testData/diagnostics/tests/generics/nullability/useAsReceiver.kt b/compiler/testData/diagnostics/tests/generics/nullability/useAsReceiver.kt index dd60e28621f..d17ab31de17 100644 --- a/compiler/testData/diagnostics/tests/generics/nullability/useAsReceiver.kt +++ b/compiler/testData/diagnostics/tests/generics/nullability/useAsReceiver.kt @@ -21,7 +21,7 @@ fun foo(x: T) { x?.bar1() x?.bar2() - x.bar3() + x.bar3() - x?.let { it.length } + x?.let { it.length } } diff --git a/compiler/testData/diagnostics/tests/generics/nullability/useAsValueArgument.fir.kt b/compiler/testData/diagnostics/tests/generics/nullability/useAsValueArgument.fir.kt index 5cb21bcd5fb..311cb420ec3 100644 --- a/compiler/testData/diagnostics/tests/generics/nullability/useAsValueArgument.fir.kt +++ b/compiler/testData/diagnostics/tests/generics/nullability/useAsValueArgument.fir.kt @@ -1,5 +1,5 @@ // !WITH_NEW_INFERENCE -// !DIAGNOSTICS: -UNUSED_PARAMETER,-UNUSED_VARIABLE +// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE fun bar1(x: T) {} diff --git a/compiler/testData/diagnostics/tests/generics/nullability/useAsValueArgument.kt b/compiler/testData/diagnostics/tests/generics/nullability/useAsValueArgument.kt index 2567d0a09f3..b3436752d5c 100644 --- a/compiler/testData/diagnostics/tests/generics/nullability/useAsValueArgument.kt +++ b/compiler/testData/diagnostics/tests/generics/nullability/useAsValueArgument.kt @@ -1,5 +1,5 @@ // !WITH_NEW_INFERENCE -// !DIAGNOSTICS: -UNUSED_PARAMETER,-UNUSED_VARIABLE +// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE fun bar1(x: T) {} @@ -13,6 +13,6 @@ fun foo(x: T) { bar1(x) bar2(x) - bar3(x) + bar3(x) bar4(x) } diff --git a/compiler/testData/diagnostics/tests/generics/projectionsScope/addAll.kt b/compiler/testData/diagnostics/tests/generics/projectionsScope/addAll.kt index 8ee2dc801f5..2f66883b44b 100644 --- a/compiler/testData/diagnostics/tests/generics/projectionsScope/addAll.kt +++ b/compiler/testData/diagnostics/tests/generics/projectionsScope/addAll.kt @@ -15,18 +15,18 @@ fun mc(): MC = null!! fun c(): C = null!! fun foo(x: MC) { - x.addAll(x) - x.addAllMC(x) + x.addAll(x) + x.addAllMC(x) - x.addAll(mc()) - x.addAllMC(mc()) + x.addAll(mc()) + x.addAllMC(mc()) - x.addAll(mc()) - x.addAllMC(mc()) + x.addAll(mc()) + x.addAllMC(mc()) x.addAll(c()) x.addAll(c()) - x.addAllInv(mc()) + x.addAllInv(mc()) x.addAll(1) } diff --git a/compiler/testData/diagnostics/tests/generics/projectionsScope/extensionReceiverTypeMismatch.kt b/compiler/testData/diagnostics/tests/generics/projectionsScope/extensionReceiverTypeMismatch.kt index dc3b18c6bc2..6a65475cc85 100644 --- a/compiler/testData/diagnostics/tests/generics/projectionsScope/extensionReceiverTypeMismatch.kt +++ b/compiler/testData/diagnostics/tests/generics/projectionsScope/extensionReceiverTypeMismatch.kt @@ -9,10 +9,10 @@ fun test(x: A, y: Out) { with(x) { // TODO: this diagnostic could be replaced with TYPE_MISMATCH_DUE_TO_TYPE_PROJECTION "".foo() - y.bar() + y.bar() with(y) { - bar() + bar() } } } diff --git a/compiler/testData/diagnostics/tests/generics/projectionsScope/inValueParameter.kt b/compiler/testData/diagnostics/tests/generics/projectionsScope/inValueParameter.kt index deec48f3d5b..a4ecece652a 100644 --- a/compiler/testData/diagnostics/tests/generics/projectionsScope/inValueParameter.kt +++ b/compiler/testData/diagnostics/tests/generics/projectionsScope/inValueParameter.kt @@ -5,5 +5,5 @@ interface B { } fun foo(x: B, y: A) { - x.foo(y) + x.foo(y) } diff --git a/compiler/testData/diagnostics/tests/generics/projectionsScope/multipleArgumentProjectedOut.kt b/compiler/testData/diagnostics/tests/generics/projectionsScope/multipleArgumentProjectedOut.kt index b007e3623e8..280493caf68 100644 --- a/compiler/testData/diagnostics/tests/generics/projectionsScope/multipleArgumentProjectedOut.kt +++ b/compiler/testData/diagnostics/tests/generics/projectionsScope/multipleArgumentProjectedOut.kt @@ -6,5 +6,5 @@ class A { } fun test(a: A) { - a.foo("", "") + a.foo("", "") } diff --git a/compiler/testData/diagnostics/tests/generics/projectionsScope/projectedOutConventions.kt b/compiler/testData/diagnostics/tests/generics/projectionsScope/projectedOutConventions.kt index b3461fe40b9..0af707c81eb 100644 --- a/compiler/testData/diagnostics/tests/generics/projectionsScope/projectedOutConventions.kt +++ b/compiler/testData/diagnostics/tests/generics/projectionsScope/projectedOutConventions.kt @@ -8,7 +8,7 @@ class A { } fun test(a: A) { - a + "" - a[1] = "" - a[""] + a + "" + a[1] = "" + a[""] } diff --git a/compiler/testData/diagnostics/tests/generics/projectionsScope/projectedOutSmartCast.kt b/compiler/testData/diagnostics/tests/generics/projectionsScope/projectedOutSmartCast.kt index 32877a619a6..afe772cfb44 100644 --- a/compiler/testData/diagnostics/tests/generics/projectionsScope/projectedOutSmartCast.kt +++ b/compiler/testData/diagnostics/tests/generics/projectionsScope/projectedOutSmartCast.kt @@ -6,18 +6,18 @@ class C { } fun foo(x: Any?, y: C<*>) { - y.bindTo("") + y.bindTo("") if (x is C<*>) { - x.bindTo("") + x.bindTo("") with(x) { - bindTo("") + bindTo("") } } with(x) { if (this is C<*>) { - bindTo("") + bindTo("") } } } diff --git a/compiler/testData/diagnostics/tests/generics/projectionsScope/typeMismatchConventions.kt b/compiler/testData/diagnostics/tests/generics/projectionsScope/typeMismatchConventions.kt index 16b8448b167..dcb3fddb8b9 100644 --- a/compiler/testData/diagnostics/tests/generics/projectionsScope/typeMismatchConventions.kt +++ b/compiler/testData/diagnostics/tests/generics/projectionsScope/typeMismatchConventions.kt @@ -10,9 +10,9 @@ class A { class Out fun test(a: A, y: Out) { - a + y - a[1] = y - a[y] + a + y + a[1] = y + a[y] a + Out() a[1] = Out() diff --git a/compiler/testData/diagnostics/tests/generics/projectionsScope/typeMismatchInLambda.kt b/compiler/testData/diagnostics/tests/generics/projectionsScope/typeMismatchInLambda.kt index be388ac63a8..2fc1b3659f2 100644 --- a/compiler/testData/diagnostics/tests/generics/projectionsScope/typeMismatchInLambda.kt +++ b/compiler/testData/diagnostics/tests/generics/projectionsScope/typeMismatchInLambda.kt @@ -14,14 +14,14 @@ class A { fun test(a: A, z: Out) { a.foo { val x: String = 1 // Should be no TYPE_MISMATCH_DUE_TO_TYPE_PROJECTIONS - "" + "" } - a.bar { Out() } + a.bar { Out() } a.bar { Out() } - a.bar { z.id() } + a.bar { z.id() } a.foo { - z.foobar(if (1 > 2) return@foo "" else "") - "" + z.foobar(if (1 > 2) return@foo "" else "") + "" } } diff --git a/compiler/testData/diagnostics/tests/generics/projectionsScope/typeParameterBounds.kt b/compiler/testData/diagnostics/tests/generics/projectionsScope/typeParameterBounds.kt index e5d8d0dc248..9b3e6464052 100644 --- a/compiler/testData/diagnostics/tests/generics/projectionsScope/typeParameterBounds.kt +++ b/compiler/testData/diagnostics/tests/generics/projectionsScope/typeParameterBounds.kt @@ -13,15 +13,15 @@ class A { } fun foo2(a: A, b: A) { - a.foo1(Out()) - a.foo1<Out>(Out()) + a.foo1(Out()) + a.foo1<Out>(Out()) a.foo1(Out()) a.foo1(Out()) - a.foo2(Inv()) - a.foo2(Inv()) - a.foo2<Inv>(Inv()) + a.foo2(Inv()) + a.foo2(Inv()) + a.foo2<Inv>(Inv()) a.foo3(In()) a.foo3(In()) @@ -31,13 +31,13 @@ fun foo2(a: A, b: A) { b.foo1(Out()) b.foo1>(Out()) - b.foo2(Inv()) - b.foo2(Inv()) - b.foo2<Inv>(Inv()) + b.foo2(Inv()) + b.foo2(Inv()) + b.foo2<Inv>(Inv()) - b.foo3(In()) - b.foo3<In>(In()) + b.foo3(In()) + b.foo3<In>(In()) b.foo3(In()) b.foo3(In()) diff --git a/compiler/testData/diagnostics/tests/generics/projectionsScope/varargs.kt b/compiler/testData/diagnostics/tests/generics/projectionsScope/varargs.kt index d5dfe3c9f6b..1b7ec4bcafe 100644 --- a/compiler/testData/diagnostics/tests/generics/projectionsScope/varargs.kt +++ b/compiler/testData/diagnostics/tests/generics/projectionsScope/varargs.kt @@ -6,8 +6,8 @@ class A { } fun test(a: A, y: Array) { - a.foo("", "", "") - a.foo(*y) + a.foo("", "", "") + a.foo(*y) // TODO: TYPE_MISMATCH_DUE_TO_TYPE_PROJECTIONS probably redundant - a.foo(*y, "") + a.foo(*y, "") } diff --git a/compiler/testData/diagnostics/tests/generics/starProjections/invalid.kt b/compiler/testData/diagnostics/tests/generics/starProjections/invalid.kt index 6c61d165fb9..40880d0e20f 100644 --- a/compiler/testData/diagnostics/tests/generics/starProjections/invalid.kt +++ b/compiler/testData/diagnostics/tests/generics/starProjections/invalid.kt @@ -17,7 +17,7 @@ fun main(a: A<*>, j: JavaClass<*>, i2: Inv2<*>) { j.foo() checkType { _() } i2.x checkType { _() } - j.bar(1, 2, Any()) + j.bar(1, 2, Any()) j.bar(null) } diff --git a/compiler/testData/diagnostics/tests/generics/tpAsReified/InConstructor.fir.kt b/compiler/testData/diagnostics/tests/generics/tpAsReified/InConstructor.fir.kt index 241f164149f..9016284cedf 100644 --- a/compiler/testData/diagnostics/tests/generics/tpAsReified/InConstructor.fir.kt +++ b/compiler/testData/diagnostics/tests/generics/tpAsReified/InConstructor.fir.kt @@ -14,4 +14,4 @@ fun main() { // TODO svtk, uncomment when extensions are called for nested calls! //val < !UNUSED_VARIABLE!>с< !>: C = id(< !TYPE_PARAMETER_AS_REIFIED!>C< !>()) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/generics/tpAsReified/InConstructor.kt b/compiler/testData/diagnostics/tests/generics/tpAsReified/InConstructor.kt index 3597b3f194c..75fc67d093b 100644 --- a/compiler/testData/diagnostics/tests/generics/tpAsReified/InConstructor.kt +++ b/compiler/testData/diagnostics/tests/generics/tpAsReified/InConstructor.kt @@ -4,7 +4,7 @@ class C<reified T> fun id(p: T): T = p fun main() { - C() + C() val a: C = C() C<A>() @@ -14,4 +14,4 @@ fun main() { // TODO svtk, uncomment when extensions are called for nested calls! //val < !UNUSED_VARIABLE!>с< !>: C = id(< !TYPE_PARAMETER_AS_REIFIED!>C< !>()) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/generics/tpAsReified/InFunction.fir.kt b/compiler/testData/diagnostics/tests/generics/tpAsReified/InFunction.fir.kt index bdac536027a..fd1d243cb7e 100644 --- a/compiler/testData/diagnostics/tests/generics/tpAsReified/InFunction.fir.kt +++ b/compiler/testData/diagnostics/tests/generics/tpAsReified/InFunction.fir.kt @@ -15,4 +15,4 @@ fun main() { f() val с: A = id(f()) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/generics/tpAsReified/InFunction.kt b/compiler/testData/diagnostics/tests/generics/tpAsReified/InFunction.kt index 7bc217846ee..154c954adb1 100644 --- a/compiler/testData/diagnostics/tests/generics/tpAsReified/InFunction.kt +++ b/compiler/testData/diagnostics/tests/generics/tpAsReified/InFunction.kt @@ -6,7 +6,7 @@ inline fun f(): T = throw UnsupportedOperationException() fun id(p: T): T = p fun main() { - f() + f() val a: A = f() f<A>() @@ -15,4 +15,4 @@ fun main() { f() val с: A = id(f()) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/generics/wildcardInValueParameter.fir.kt b/compiler/testData/diagnostics/tests/generics/wildcardInValueParameter.fir.kt index 4cb4e519fcf..f0568b2dff3 100644 --- a/compiler/testData/diagnostics/tests/generics/wildcardInValueParameter.fir.kt +++ b/compiler/testData/diagnostics/tests/generics/wildcardInValueParameter.fir.kt @@ -1,4 +1,4 @@ -// JAVAC_SKIP +// SKIP_JAVAC // FILE: JavaClass.java public class JavaClass { public void foo(? x) {} diff --git a/compiler/testData/diagnostics/tests/generics/wildcardInValueParameter.kt b/compiler/testData/diagnostics/tests/generics/wildcardInValueParameter.kt index f66b9bb2389..6281dc58eda 100644 --- a/compiler/testData/diagnostics/tests/generics/wildcardInValueParameter.kt +++ b/compiler/testData/diagnostics/tests/generics/wildcardInValueParameter.kt @@ -1,4 +1,4 @@ -// JAVAC_SKIP +// SKIP_JAVAC // FILE: JavaClass.java public class JavaClass { public void foo(? x) {} diff --git a/compiler/testData/diagnostics/tests/generics/wrongNumberOfTypeArgumentsDiagnostic.kt b/compiler/testData/diagnostics/tests/generics/wrongNumberOfTypeArgumentsDiagnostic.kt index f3ff59c862a..dbe5097d6f5 100644 --- a/compiler/testData/diagnostics/tests/generics/wrongNumberOfTypeArgumentsDiagnostic.kt +++ b/compiler/testData/diagnostics/tests/generics/wrongNumberOfTypeArgumentsDiagnostic.kt @@ -5,12 +5,12 @@ fun myFun(i : String) {} fun myFun(i : Int) {} fun test1() { - myFun(3) + myFun(3) myFun('a') } fun test2() { - val m0 = java.util.HashMap() + val m0 = java.util.HashMap() val m1 = java.util.HashMap() val m2 = java.util.HashMap() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/implicitIntersection.fir.kt b/compiler/testData/diagnostics/tests/implicitIntersection.fir.kt index 2877bb09372..603d7123d64 100644 --- a/compiler/testData/diagnostics/tests/implicitIntersection.fir.kt +++ b/compiler/testData/diagnostics/tests/implicitIntersection.fir.kt @@ -27,4 +27,4 @@ fun bar(b: B): String { // Error: local function fun foo(b: B) = if (b is A && b is C) b else null return tmp.toString() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/implicitIntersection.kt b/compiler/testData/diagnostics/tests/implicitIntersection.kt index 590eef5ab5b..228697fac03 100644 --- a/compiler/testData/diagnostics/tests/implicitIntersection.kt +++ b/compiler/testData/diagnostics/tests/implicitIntersection.kt @@ -7,24 +7,24 @@ interface A interface C // Error! -fun foo(b: B) = if (b is A && b is C) b else null +fun foo(b: B) = if (b is A && b is C) b else null // Ok: given explicitly fun gav(b: B): A? = if (b is A && b is C) b else null class My(b: B) { // Error! - val x = if (b is A && b is C) b else null + val x = if (b is A && b is C) b else null // Ok: given explicitly val y: C? = if (b is A && b is C) b else null // Error! - fun foo(b: B) = if (b is A && b is C) b else null + fun foo(b: B) = if (b is A && b is C) b else null } fun bar(b: B): String { // Ok: local variable val tmp = if (b is A && b is C) b else null // Error: local function - fun foo(b: B) = if (b is A && b is C) b else null + fun foo(b: B) = if (b is A && b is C) b else null return tmp.toString() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/implicitNestedIntersection.kt b/compiler/testData/diagnostics/tests/implicitNestedIntersection.kt index 29c06aa94ef..02a83df85a8 100644 --- a/compiler/testData/diagnostics/tests/implicitNestedIntersection.kt +++ b/compiler/testData/diagnostics/tests/implicitNestedIntersection.kt @@ -8,7 +8,7 @@ open class B : In fun select(x: T, y: T) = x -fun foo2() = select(A(), B()) // Type "In" is prohibited in return position +fun foo2() = select(A(), B()) // Type "In" is prohibited in return position @@ -21,4 +21,4 @@ open class H : In fun select8(a: S, b: S, c: S, d: S, e: S, f: S, g: S, h: S) = a -fun foo8() = select8(A(), B(), C(), D(), E(), F(), G(), H()) +fun foo8() = select8(A(), B(), C(), D(), E(), F(), G(), H()) diff --git a/compiler/testData/diagnostics/tests/imports/CheckJavaVisibility2.kt b/compiler/testData/diagnostics/tests/imports/CheckJavaVisibility2.kt index 16f5465c871..5c27abda677 100644 --- a/compiler/testData/diagnostics/tests/imports/CheckJavaVisibility2.kt +++ b/compiler/testData/diagnostics/tests/imports/CheckJavaVisibility2.kt @@ -22,24 +22,24 @@ import j.JavaProtected import j.JavaPackageLocal class A { - val p1 = JavaPackageLocal.javaPPackage - val p2 = JavaProtected.javaPProtectedStatic - val p3 = JavaProtected().javaPProtectedPackage + val p1 = JavaPackageLocal.javaPPackage + val p2 = JavaProtected.javaPProtectedStatic + val p3 = JavaProtected().javaPProtectedPackage fun test() { - JavaProtected.javaMProtectedStatic() - JavaPackageLocal.javaMPackage() + JavaProtected.javaMProtectedStatic() + JavaPackageLocal.javaMPackage() } } class B : JavaProtected() { - val p1 = JavaPackageLocal.javaPPackage + val p1 = JavaPackageLocal.javaPPackage val p2 = JavaProtected.javaPProtectedStatic val p3 = javaPProtectedPackage fun test() { JavaProtected.javaMProtectedStatic() - JavaPackageLocal.javaMPackage() + JavaPackageLocal.javaMPackage() } } @@ -59,4 +59,4 @@ class C { JavaProtected.javaMProtectedStatic() JavaPackageLocal.javaMPackage() } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/imports/CheckVisibility.txt b/compiler/testData/diagnostics/tests/imports/CheckVisibility.txt index 6af6faf3f6d..5b4adcaeb22 100644 --- a/compiler/testData/diagnostics/tests/imports/CheckVisibility.txt +++ b/compiler/testData/diagnostics/tests/imports/CheckVisibility.txt @@ -39,7 +39,7 @@ package k { } } - // -- Module: -- package + diff --git a/compiler/testData/diagnostics/tests/imports/ClassClash.txt b/compiler/testData/diagnostics/tests/imports/ClassClash.txt index e92c79007c4..bd9dd8cb9c5 100644 --- a/compiler/testData/diagnostics/tests/imports/ClassClash.txt +++ b/compiler/testData/diagnostics/tests/imports/ClassClash.txt @@ -12,7 +12,6 @@ package a { } } - // -- Module: -- package @@ -27,13 +26,11 @@ package a { } } - // -- Module: -- package public fun test(/*0*/ b: a.B): kotlin.Unit - // -- Module: -- package @@ -45,7 +42,6 @@ public final class B { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package @@ -57,9 +53,9 @@ public final class B { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package public fun test(/*0*/ b: B): kotlin.Unit public fun test2(/*0*/ b: B): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/imports/ClassClashStarImport.fir.kt b/compiler/testData/diagnostics/tests/imports/ClassClashStarImport.fir.kt index 73e0517a257..4d6a9736661 100644 --- a/compiler/testData/diagnostics/tests/imports/ClassClashStarImport.fir.kt +++ b/compiler/testData/diagnostics/tests/imports/ClassClashStarImport.fir.kt @@ -73,4 +73,4 @@ fun test(b: B) { val b_4 = a.B() b_4.m2() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/imports/ClassClashStarImport.kt b/compiler/testData/diagnostics/tests/imports/ClassClashStarImport.kt index 4d71e4b4e5f..54fe75a775d 100644 --- a/compiler/testData/diagnostics/tests/imports/ClassClashStarImport.kt +++ b/compiler/testData/diagnostics/tests/imports/ClassClashStarImport.kt @@ -71,6 +71,6 @@ fun test(b: B) { val b_3 = B() b_3.m2() - val b_4 = a.B() - b_4.m2() -} \ No newline at end of file + val b_4 = a.B() + b_4.m2() +} diff --git a/compiler/testData/diagnostics/tests/imports/ClassClashStarImport.txt b/compiler/testData/diagnostics/tests/imports/ClassClashStarImport.txt index d57fdc91579..7d582071e4d 100644 --- a/compiler/testData/diagnostics/tests/imports/ClassClashStarImport.txt +++ b/compiler/testData/diagnostics/tests/imports/ClassClashStarImport.txt @@ -12,7 +12,6 @@ package a { } } - // -- Module: -- package @@ -27,13 +26,11 @@ package a { } } - // -- Module: -- package public fun test(/*0*/ b: a.B): kotlin.Unit - // -- Module: -- package @@ -45,7 +42,6 @@ public final class B { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package @@ -57,8 +53,8 @@ public final class B { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package public fun test(/*0*/ b: B): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/imports/ImportFromRootPackage.fir.kt b/compiler/testData/diagnostics/tests/imports/ImportFromRootPackage.fir.kt index 1c31f98ab46..9894d98ef89 100644 --- a/compiler/testData/diagnostics/tests/imports/ImportFromRootPackage.fir.kt +++ b/compiler/testData/diagnostics/tests/imports/ImportFromRootPackage.fir.kt @@ -15,7 +15,7 @@ fun foo(): Klass { return Klass() } -// FILE: anotherFromRootPackage.kt +// FILE: yetAnotherFromRootPackage.kt package pkg import Klass @@ -29,4 +29,4 @@ fun foo(): Klass { } val v: Nested = Nested() -val x: NotImported = NotImported() \ No newline at end of file +val x: NotImported = NotImported() diff --git a/compiler/testData/diagnostics/tests/imports/ImportFromRootPackage.kt b/compiler/testData/diagnostics/tests/imports/ImportFromRootPackage.kt index db84d03504d..cbfa85a8f91 100644 --- a/compiler/testData/diagnostics/tests/imports/ImportFromRootPackage.kt +++ b/compiler/testData/diagnostics/tests/imports/ImportFromRootPackage.kt @@ -15,7 +15,7 @@ fun foo(): Klass { return Klass() } -// FILE: anotherFromRootPackage.kt +// FILE: yetAnotherFromRootPackage.kt package pkg import Klass @@ -29,4 +29,4 @@ fun foo(): Klass { } val v: Nested = Nested() -val x: NotImported = NotImported() \ No newline at end of file +val x: NotImported = NotImported() diff --git a/compiler/testData/diagnostics/tests/imports/ImportOverloadFunctions.kt b/compiler/testData/diagnostics/tests/imports/ImportOverloadFunctions.kt index 223bc346c43..d6d091c0325 100644 --- a/compiler/testData/diagnostics/tests/imports/ImportOverloadFunctions.kt +++ b/compiler/testData/diagnostics/tests/imports/ImportOverloadFunctions.kt @@ -42,4 +42,4 @@ fun test() { all() all(1) all("") -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/imports/ImportPrivateMember.kt b/compiler/testData/diagnostics/tests/imports/ImportPrivateMember.kt index 568b1a01e0c..97c25f8d526 100644 --- a/compiler/testData/diagnostics/tests/imports/ImportPrivateMember.kt +++ b/compiler/testData/diagnostics/tests/imports/ImportPrivateMember.kt @@ -34,4 +34,4 @@ fun testAccess() { InNested() NestedEntry inObject() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/imports/ImportResolutionOrder.kt b/compiler/testData/diagnostics/tests/imports/ImportResolutionOrder.kt index ea887baae85..d764dd4e60b 100644 --- a/compiler/testData/diagnostics/tests/imports/ImportResolutionOrder.kt +++ b/compiler/testData/diagnostics/tests/imports/ImportResolutionOrder.kt @@ -1,5 +1,5 @@ // FIR_IDENTICAL -// FILE: b.kt +// FILE: a.kt // KT-355 Resolve imports after all symbols are built package a @@ -12,12 +12,12 @@ package b } -// FILE: b.kt +// FILE: c.kt package c import d.X val x : X = X() -// FILE: b.kt +// FILE: d.kt package d class X() { diff --git a/compiler/testData/diagnostics/tests/imports/Imports.fir.kt b/compiler/testData/diagnostics/tests/imports/Imports.fir.kt index e0d485a9252..592aaf07f9b 100644 --- a/compiler/testData/diagnostics/tests/imports/Imports.fir.kt +++ b/compiler/testData/diagnostics/tests/imports/Imports.fir.kt @@ -99,4 +99,4 @@ class A() { open class B() {} object C : B() {} } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/imports/Imports.kt b/compiler/testData/diagnostics/tests/imports/Imports.kt index 3c311aaa7e1..fdd7ddd18f6 100644 --- a/compiler/testData/diagnostics/tests/imports/Imports.kt +++ b/compiler/testData/diagnostics/tests/imports/Imports.kt @@ -82,7 +82,7 @@ object C { } fun foo() { - if (i == 3) f() + if (i == 3) f() } //FILE:d.kt @@ -99,4 +99,4 @@ class A() { open class B() {} object C : B() {} } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/imports/PackageLocalClassReferencedError.kt b/compiler/testData/diagnostics/tests/imports/PackageLocalClassReferencedError.kt index 1919f02f6de..8e95fd5850d 100644 --- a/compiler/testData/diagnostics/tests/imports/PackageLocalClassReferencedError.kt +++ b/compiler/testData/diagnostics/tests/imports/PackageLocalClassReferencedError.kt @@ -8,4 +8,4 @@ package a import pack1.* -private class X : SomeClass() \ No newline at end of file +private class X : SomeClass() diff --git a/compiler/testData/diagnostics/tests/imports/PackageVsClass.txt b/compiler/testData/diagnostics/tests/imports/PackageVsClass.txt index 53b074e7577..691923f3175 100644 --- a/compiler/testData/diagnostics/tests/imports/PackageVsClass.txt +++ b/compiler/testData/diagnostics/tests/imports/PackageVsClass.txt @@ -24,7 +24,6 @@ package a { } } - // -- Module: -- package @@ -48,7 +47,6 @@ package a { } } - // -- Module: -- package @@ -60,7 +58,6 @@ package a { public fun test2(/*0*/ ab_c: a.b.c): kotlin.Unit } - // -- Module: -- package @@ -71,3 +68,4 @@ package a { public fun test(/*0*/ a_b: a.b): kotlin.Unit public fun test2(/*0*/ ab_c: a.b.c): kotlin.Unit } + diff --git a/compiler/testData/diagnostics/tests/imports/PrivateClassReferencedError.kt b/compiler/testData/diagnostics/tests/imports/PrivateClassReferencedError.kt index 496ea86f828..9be9ddb70ef 100644 --- a/compiler/testData/diagnostics/tests/imports/PrivateClassReferencedError.kt +++ b/compiler/testData/diagnostics/tests/imports/PrivateClassReferencedError.kt @@ -11,4 +11,4 @@ package a import pack1.SomeClass.* -private class X : N() \ No newline at end of file +private class X : N() diff --git a/compiler/testData/diagnostics/tests/imports/TopLevelClassVsPackage.txt b/compiler/testData/diagnostics/tests/imports/TopLevelClassVsPackage.txt index 21b3b083234..061a09d153b 100644 --- a/compiler/testData/diagnostics/tests/imports/TopLevelClassVsPackage.txt +++ b/compiler/testData/diagnostics/tests/imports/TopLevelClassVsPackage.txt @@ -21,7 +21,6 @@ package a { } } - // -- Module: -- package @@ -43,10 +42,10 @@ public final class a { } } - // -- Module: -- package public fun test(/*0*/ a_b: a.b): kotlin.Unit public fun test2(/*0*/ _a: a): kotlin.Unit public fun test3(/*0*/ _a: a): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/imports/WrongImport.fir.kt b/compiler/testData/diagnostics/tests/imports/WrongImport.fir.kt index 5cd8ecce24e..a27c1812348 100644 --- a/compiler/testData/diagnostics/tests/imports/WrongImport.fir.kt +++ b/compiler/testData/diagnostics/tests/imports/WrongImport.fir.kt @@ -1,7 +1,7 @@ // FILE:a.kt package a.b -// FILE:a.kt +// FILE:b.kt package a val foo = object { @@ -47,7 +47,7 @@ class D { } -// FILE:b.kt +// FILE:c.kt import a import a.b @@ -75,4 +75,4 @@ import a.D.bar.foo import a.D.Companion.foo import a.D.Companion.foo.bar import a.D.Companion.bar -import a.D.Companion.bar.foo \ No newline at end of file +import a.D.Companion.bar.foo diff --git a/compiler/testData/diagnostics/tests/imports/WrongImport.kt b/compiler/testData/diagnostics/tests/imports/WrongImport.kt index 6124b2f935a..75ec168560f 100644 --- a/compiler/testData/diagnostics/tests/imports/WrongImport.kt +++ b/compiler/testData/diagnostics/tests/imports/WrongImport.kt @@ -1,7 +1,7 @@ // FILE:a.kt package a.b -// FILE:a.kt +// FILE:b.kt package a val foo = object { @@ -47,7 +47,7 @@ class D { } -// FILE:b.kt +// FILE:c.kt import a import a.b @@ -75,4 +75,4 @@ import a.D.bar.foofoo.bar import a.D.Companion.bar -import a.D.Companion.bar.foo \ No newline at end of file +import a.D.Companion.bar.foo diff --git a/compiler/testData/diagnostics/tests/imports/invisibleFakeReferenceInImport.kt b/compiler/testData/diagnostics/tests/imports/invisibleFakeReferenceInImport.kt index 575c053a893..c96ca429845 100644 --- a/compiler/testData/diagnostics/tests/imports/invisibleFakeReferenceInImport.kt +++ b/compiler/testData/diagnostics/tests/imports/invisibleFakeReferenceInImport.kt @@ -13,4 +13,4 @@ object B : C() open class C { private var foo: String = "abc" -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/imports/twoImportLists.kt b/compiler/testData/diagnostics/tests/imports/twoImportLists.kt index beb036785ad..e9d4ec5ce4a 100644 --- a/compiler/testData/diagnostics/tests/imports/twoImportLists.kt +++ b/compiler/testData/diagnostics/tests/imports/twoImportLists.kt @@ -85,7 +85,7 @@ object C { } fun foo() { - if (i == 3) f() + if (i == 3) f() } //FILE:d.kt diff --git a/compiler/testData/diagnostics/tests/incompleteCode/NoSenselessComparisonForErrorType.fir.kt b/compiler/testData/diagnostics/tests/incompleteCode/NoSenselessComparisonForErrorType.fir.kt index cb1263a3d90..9910f306a43 100644 --- a/compiler/testData/diagnostics/tests/incompleteCode/NoSenselessComparisonForErrorType.fir.kt +++ b/compiler/testData/diagnostics/tests/incompleteCode/NoSenselessComparisonForErrorType.fir.kt @@ -6,4 +6,4 @@ fun foo() { if (a == null) { //no senseless comparison } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/incompleteCode/NoSenselessComparisonForErrorType.kt b/compiler/testData/diagnostics/tests/incompleteCode/NoSenselessComparisonForErrorType.kt index 507dcafdfd7..aa75c6f6be8 100644 --- a/compiler/testData/diagnostics/tests/incompleteCode/NoSenselessComparisonForErrorType.kt +++ b/compiler/testData/diagnostics/tests/incompleteCode/NoSenselessComparisonForErrorType.kt @@ -3,7 +3,7 @@ package a fun foo() { val a = getErrorType() - if (a == null) { //no senseless comparison + if (a == null) { //no senseless comparison } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/incompleteCode/checkNothingIsSubtype.fir.kt b/compiler/testData/diagnostics/tests/incompleteCode/checkNothingIsSubtype.fir.kt index fbbf473506b..da8923cfadc 100644 --- a/compiler/testData/diagnostics/tests/incompleteCode/checkNothingIsSubtype.fir.kt +++ b/compiler/testData/diagnostics/tests/incompleteCode/checkNothingIsSubtype.fir.kt @@ -13,4 +13,4 @@ fun test(nothing: Nothing?) { fun sum(a : IntArray) : Int { for (n return "?" -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/incompleteCode/checkNothingIsSubtype.kt b/compiler/testData/diagnostics/tests/incompleteCode/checkNothingIsSubtype.kt index 4f13ef0db58..30fb9691a7b 100644 --- a/compiler/testData/diagnostics/tests/incompleteCode/checkNothingIsSubtype.kt +++ b/compiler/testData/diagnostics/tests/incompleteCode/checkNothingIsSubtype.kt @@ -7,10 +7,10 @@ interface A fun infer(a: A) : T {} fun test(nothing: Nothing?) { - val i = infer(nothing) + val i = infer(nothing) } fun sum(a : IntArray) : Int { for (n return "?" -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/incompleteCode/controlStructuresErrors.fir.kt b/compiler/testData/diagnostics/tests/incompleteCode/controlStructuresErrors.fir.kt index 45a84fffb57..08b91385fad 100644 --- a/compiler/testData/diagnostics/tests/incompleteCode/controlStructuresErrors.fir.kt +++ b/compiler/testData/diagnostics/tests/incompleteCode/controlStructuresErrors.fir.kt @@ -23,4 +23,4 @@ fun test2(l: List) { l.map { it!! } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/incompleteCode/controlStructuresErrors.kt b/compiler/testData/diagnostics/tests/incompleteCode/controlStructuresErrors.kt index d0a850944a2..8e85b832182 100644 --- a/compiler/testData/diagnostics/tests/incompleteCode/controlStructuresErrors.kt +++ b/compiler/testData/diagnostics/tests/incompleteCode/controlStructuresErrors.kt @@ -3,18 +3,18 @@ fun test1() { if (rr) { if (l) { - a.q() + a.q() } else { - a.w() + a.w() } } else { if (n) { - a.t() + a.t() } else { - a.u() + a.u() } } } @@ -23,4 +23,4 @@ fun test2(l: List<AA>) { l.map { it!! } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/arrayExpression.fir.kt b/compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/arrayExpression.fir.kt index d25e0ca5648..72d6ba7470d 100644 --- a/compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/arrayExpression.fir.kt +++ b/compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/arrayExpression.fir.kt @@ -5,4 +5,4 @@ fun main() { class Some Some[] names = ["ads"] -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/arrayExpression.kt b/compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/arrayExpression.kt index 1f872430702..c08815a2914 100644 --- a/compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/arrayExpression.kt +++ b/compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/arrayExpression.kt @@ -4,5 +4,5 @@ package bar fun main() { class Some - Some[] names = ["ads"] -} \ No newline at end of file + Some[] names = ["ads"] +} diff --git a/compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/noTypeParamsInReturnType.kt b/compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/noTypeParamsInReturnType.kt index 16e9526a5dc..1ee4851ed31 100644 --- a/compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/noTypeParamsInReturnType.kt +++ b/compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/noTypeParamsInReturnType.kt @@ -6,6 +6,6 @@ fun foo(map: Map) : R = throw Exception() fun getMap() : Map = throw Exception() fun bar123() { - foo(getMap( + foo(getMap( } diff --git a/compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/typeReferenceError.kt b/compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/typeReferenceError.kt index 5fc835b5310..8d6e152a049 100644 --- a/compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/typeReferenceError.kt +++ b/compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/typeReferenceError.kt @@ -1,3 +1,3 @@ package typeReferenceError -class Pair<:(val c: fun main() \ No newline at end of file +class Pair<:(val c: fun main() diff --git a/compiler/testData/diagnostics/tests/incompleteCode/incompleteEquals.fir.kt b/compiler/testData/diagnostics/tests/incompleteCode/incompleteEquals.fir.kt index bd83db1679b..5cc0f92201f 100644 --- a/compiler/testData/diagnostics/tests/incompleteCode/incompleteEquals.fir.kt +++ b/compiler/testData/diagnostics/tests/incompleteCode/incompleteEquals.fir.kt @@ -1,3 +1,3 @@ package a -fun foo(a: Any) = a == \ No newline at end of file +fun foo(a: Any) = a == diff --git a/compiler/testData/diagnostics/tests/incompleteCode/incompleteEquals.kt b/compiler/testData/diagnostics/tests/incompleteCode/incompleteEquals.kt index 0c8f84176ae..e3da41d2750 100644 --- a/compiler/testData/diagnostics/tests/incompleteCode/incompleteEquals.kt +++ b/compiler/testData/diagnostics/tests/incompleteCode/incompleteEquals.kt @@ -1,3 +1,3 @@ package a -fun foo(a: Any) = a == \ No newline at end of file +fun foo(a: Any) = a == diff --git a/compiler/testData/diagnostics/tests/incompleteCode/kt2014.kt b/compiler/testData/diagnostics/tests/incompleteCode/kt2014.kt index 63cec9e0adc..3e54c78d122 100644 --- a/compiler/testData/diagnostics/tests/incompleteCode/kt2014.kt +++ b/compiler/testData/diagnostics/tests/incompleteCode/kt2014.kt @@ -17,4 +17,4 @@ fun x(f : Foo) { R() } -object R {} \ No newline at end of file +object R {} diff --git a/compiler/testData/diagnostics/tests/incompleteCode/pseudocodeTraverseNextInstructions.fir.kt b/compiler/testData/diagnostics/tests/incompleteCode/pseudocodeTraverseNextInstructions.fir.kt index b79f12bebde..18062c5cbda 100644 --- a/compiler/testData/diagnostics/tests/incompleteCode/pseudocodeTraverseNextInstructions.fir.kt +++ b/compiler/testData/diagnostics/tests/incompleteCode/pseudocodeTraverseNextInstructions.fir.kt @@ -5,4 +5,4 @@ fun foo() { { break } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/incompleteCode/pseudocodeTraverseNextInstructions.kt b/compiler/testData/diagnostics/tests/incompleteCode/pseudocodeTraverseNextInstructions.kt index 94fb4030208..93bb360e871 100644 --- a/compiler/testData/diagnostics/tests/incompleteCode/pseudocodeTraverseNextInstructions.kt +++ b/compiler/testData/diagnostics/tests/incompleteCode/pseudocodeTraverseNextInstructions.kt @@ -5,4 +5,4 @@ fun foo() { { break } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/inference/NoInferenceFromDeclaredBounds.kt b/compiler/testData/diagnostics/tests/inference/NoInferenceFromDeclaredBounds.kt index 601fe8f3cb6..37e7f6ca7d1 100644 --- a/compiler/testData/diagnostics/tests/inference/NoInferenceFromDeclaredBounds.kt +++ b/compiler/testData/diagnostics/tests/inference/NoInferenceFromDeclaredBounds.kt @@ -4,7 +4,7 @@ fun fooT22() : T? { } fun foo1() { - fooT22() + fooT22() } val n : Nothing = null.sure() diff --git a/compiler/testData/diagnostics/tests/inference/cannotCompleteResolveAmbiguity.kt b/compiler/testData/diagnostics/tests/inference/cannotCompleteResolveAmbiguity.kt index 1f1748f38e1..52279435645 100644 --- a/compiler/testData/diagnostics/tests/inference/cannotCompleteResolveAmbiguity.kt +++ b/compiler/testData/diagnostics/tests/inference/cannotCompleteResolveAmbiguity.kt @@ -5,5 +5,5 @@ fun g(i: Int, a: Any): List fun g(a: Any, i: Int): Collection {throw Exception()} fun test() { - val c: List = g(1, 1) + val c: List = g(1, 1) } diff --git a/compiler/testData/diagnostics/tests/inference/cannotCompleteResolveFunctionLiteralsNoUse.kt b/compiler/testData/diagnostics/tests/inference/cannotCompleteResolveFunctionLiteralsNoUse.kt index 965935937bd..aacfd90bf3c 100644 --- a/compiler/testData/diagnostics/tests/inference/cannotCompleteResolveFunctionLiteralsNoUse.kt +++ b/compiler/testData/diagnostics/tests/inference/cannotCompleteResolveFunctionLiteralsNoUse.kt @@ -4,4 +4,4 @@ package f fun h(i: Int, a: Any, r: R, f: (Boolean) -> Int) = 1 fun h(a: Any, i: Int, r: R, f: (Boolean) -> Int) = 1 -fun test() = h(1, 1, 1, { b -> 42 }) +fun test() = h(1, 1, 1, { b -> 42 }) diff --git a/compiler/testData/diagnostics/tests/inference/cannotCompleteResolveNoInfoForParameter.kt b/compiler/testData/diagnostics/tests/inference/cannotCompleteResolveNoInfoForParameter.kt index c931bfe6635..ab48eba9767 100644 --- a/compiler/testData/diagnostics/tests/inference/cannotCompleteResolveNoInfoForParameter.kt +++ b/compiler/testData/diagnostics/tests/inference/cannotCompleteResolveNoInfoForParameter.kt @@ -5,7 +5,7 @@ fun f(i: Int, c: Collection fun f(a: Any, l: List): Collection {throw Exception()} fun test(l: List) { - f(1, emptyList()) + f(1, emptyList()) } fun emptyList(): List {throw Exception()} diff --git a/compiler/testData/diagnostics/tests/inference/cannotCompleteResolveWithFunctionLiterals.kt b/compiler/testData/diagnostics/tests/inference/cannotCompleteResolveWithFunctionLiterals.kt index d7f43c72444..db059c80eb6 100644 --- a/compiler/testData/diagnostics/tests/inference/cannotCompleteResolveWithFunctionLiterals.kt +++ b/compiler/testData/diagnostics/tests/inference/cannotCompleteResolveWithFunctionLiterals.kt @@ -5,7 +5,7 @@ package f fun h(f: (Boolean) -> R) = 1 fun h(f: (String) -> R) = 2 -fun test() = h{ i -> getAnswer() } +fun test() = h{ i -> getAnswer() } fun getAnswer() = 42 diff --git a/compiler/testData/diagnostics/tests/inference/capturedTypes/avoidCreatingUselessCapturedTypes.kt b/compiler/testData/diagnostics/tests/inference/capturedTypes/avoidCreatingUselessCapturedTypes.kt index b7758a20fdb..7c473c054b8 100644 --- a/compiler/testData/diagnostics/tests/inference/capturedTypes/avoidCreatingUselessCapturedTypes.kt +++ b/compiler/testData/diagnostics/tests/inference/capturedTypes/avoidCreatingUselessCapturedTypes.kt @@ -1192,7 +1192,7 @@ object Entities { // "↮" to 8622, // "⇎" to 8654, // "⫲" to 10994, -// "∋" to 8715, +// "&" to 8715{NI}, // "⋼" to 8956, // "⋺" to 8954, // "∋" to 8715, @@ -1260,7 +1260,7 @@ object Entities { // "≴" to 8820, // "⪢̸" to 10914, // "⪡̸" to 10913, -// "∌" to 8716, +// "¬" to 8716{NI}, // "∌" to 8716, // "⋾" to 8958, // "⋽" to 8957, diff --git a/compiler/testData/diagnostics/tests/inference/capturedTypes/cannotCaptureInProjection.fir.kt b/compiler/testData/diagnostics/tests/inference/capturedTypes/cannotCaptureInProjection.fir.kt index a62783a1480..f340ddb3f7e 100644 --- a/compiler/testData/diagnostics/tests/inference/capturedTypes/cannotCaptureInProjection.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/capturedTypes/cannotCaptureInProjection.fir.kt @@ -14,4 +14,4 @@ fun foo(l: Array): Array> = null!! fun test2(a: Array) { val r: Array> = foo(a) foo(a) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/inference/capturedTypes/cannotCaptureInProjection.kt b/compiler/testData/diagnostics/tests/inference/capturedTypes/cannotCaptureInProjection.kt index c5b21167335..50b478363d3 100644 --- a/compiler/testData/diagnostics/tests/inference/capturedTypes/cannotCaptureInProjection.kt +++ b/compiler/testData/diagnostics/tests/inference/capturedTypes/cannotCaptureInProjection.kt @@ -5,13 +5,13 @@ fun bar(a: Array): Array = null!! fun test1(a: Array) { - val r: Array = bar(a) - bar(a) + val r: Array = bar(a) + bar(a) } fun foo(l: Array): Array> = null!! fun test2(a: Array) { - val r: Array> = foo(a) - foo(a) -} \ No newline at end of file + val r: Array> = foo(a) + foo(a) +} diff --git a/compiler/testData/diagnostics/tests/inference/capturedTypes/captureForNullableTypes.kt b/compiler/testData/diagnostics/tests/inference/capturedTypes/captureForNullableTypes.kt index 9d789bbac19..775986e5020 100644 --- a/compiler/testData/diagnostics/tests/inference/capturedTypes/captureForNullableTypes.kt +++ b/compiler/testData/diagnostics/tests/inference/capturedTypes/captureForNullableTypes.kt @@ -5,15 +5,15 @@ fun bar(a: Array): Array = null!! fun test1(a: Array) { - val r: Array = bar(a) - val t = bar(a) - t checkType { _>() } + val r: Array = bar(a) + val t = bar(a) + t checkType { _>() } } fun foo(l: Array): Array> = null!! fun test2(a: Array) { - val r: Array> = foo(a) - val t = foo(a) - t checkType { _>>() } -} \ No newline at end of file + val r: Array> = foo(a) + val t = foo(a) + t checkType { _>>() } +} diff --git a/compiler/testData/diagnostics/tests/inference/capturedTypes/captureFromNullableTypeVariable.kt b/compiler/testData/diagnostics/tests/inference/capturedTypes/captureFromNullableTypeVariable.kt index 798a873c6ce..1ea84475a5f 100644 --- a/compiler/testData/diagnostics/tests/inference/capturedTypes/captureFromNullableTypeVariable.kt +++ b/compiler/testData/diagnostics/tests/inference/capturedTypes/captureFromNullableTypeVariable.kt @@ -4,11 +4,11 @@ fun Array.filterNotNull(): List = throw Exception() fun test1(a: Array) { - val list = a.filterNotNull() - list checkType { _>() } + val list = a.filterNotNull() + list checkType { _>() } } fun test2(vararg a: Int?) { - val list = a.filterNotNull() - list checkType { _>() } -} \ No newline at end of file + val list = a.filterNotNull() + list checkType { _>() } +} diff --git a/compiler/testData/diagnostics/tests/inference/capturedTypes/captureFromTypeParameterUpperBound.kt b/compiler/testData/diagnostics/tests/inference/capturedTypes/captureFromTypeParameterUpperBound.kt index 603295865f2..d7ddb904184 100644 --- a/compiler/testData/diagnostics/tests/inference/capturedTypes/captureFromTypeParameterUpperBound.kt +++ b/compiler/testData/diagnostics/tests/inference/capturedTypes/captureFromTypeParameterUpperBound.kt @@ -8,4 +8,4 @@ fun > foo(x: X, y: Y) { rY.length } -fun bar(l: Inv): Y = TODO() \ No newline at end of file +fun bar(l: Inv): Y = TODO() diff --git a/compiler/testData/diagnostics/tests/inference/capturedTypes/captureTypeOnlyOnTopLevel.kt b/compiler/testData/diagnostics/tests/inference/capturedTypes/captureTypeOnlyOnTopLevel.kt index 1330874b71a..6876c77decb 100644 --- a/compiler/testData/diagnostics/tests/inference/capturedTypes/captureTypeOnlyOnTopLevel.kt +++ b/compiler/testData/diagnostics/tests/inference/capturedTypes/captureTypeOnlyOnTopLevel.kt @@ -4,7 +4,7 @@ fun foo(array: Array>): Array> = array fun test(array: Array>) { - foo(array) + foo(array) - val f: Array> = foo(array) + val f: Array> = foo(array) } diff --git a/compiler/testData/diagnostics/tests/inference/capturedTypes/capturingFromArgumentOfFlexibleType.fir.kt b/compiler/testData/diagnostics/tests/inference/capturedTypes/capturingFromArgumentOfFlexibleType.fir.kt index da9fcf8d4e8..9170ce1d4fc 100644 --- a/compiler/testData/diagnostics/tests/inference/capturedTypes/capturingFromArgumentOfFlexibleType.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/capturedTypes/capturingFromArgumentOfFlexibleType.fir.kt @@ -14,5 +14,5 @@ fun id(x: T) = null as T fun test() { Test.getFoo() - ")!>id(Test.getFoo()) + id(Test.getFoo()) } diff --git a/compiler/testData/diagnostics/tests/inference/capturedTypes/expectedTypeMismatchWithInVariance.kt b/compiler/testData/diagnostics/tests/inference/capturedTypes/expectedTypeMismatchWithInVariance.kt index a7bc59387b6..c014b688f9f 100644 --- a/compiler/testData/diagnostics/tests/inference/capturedTypes/expectedTypeMismatchWithInVariance.kt +++ b/compiler/testData/diagnostics/tests/inference/capturedTypes/expectedTypeMismatchWithInVariance.kt @@ -5,6 +5,6 @@ fun foo(a1: Array, a2: Array): T = null!! fun test(a1: Array, a2: Array) { - val c: Int = foo(a1, a2) + val c: Int = foo(a1, a2) } diff --git a/compiler/testData/diagnostics/tests/inference/capturedTypes/kt2872.kt b/compiler/testData/diagnostics/tests/inference/capturedTypes/kt2872.kt index c76464333f8..562c08ffc59 100644 --- a/compiler/testData/diagnostics/tests/inference/capturedTypes/kt2872.kt +++ b/compiler/testData/diagnostics/tests/inference/capturedTypes/kt2872.kt @@ -3,5 +3,5 @@ fun Array.foo() {} fun test(array: Array) { array.foo() - array.foo<out Int>() -} \ No newline at end of file + array.foo<out Int>() +} diff --git a/compiler/testData/diagnostics/tests/inference/capturedTypes/noCaptureTypeErrorForNonTopLevel.kt b/compiler/testData/diagnostics/tests/inference/capturedTypes/noCaptureTypeErrorForNonTopLevel.kt index 5e81dc3ae06..b0762e26070 100644 --- a/compiler/testData/diagnostics/tests/inference/capturedTypes/noCaptureTypeErrorForNonTopLevel.kt +++ b/compiler/testData/diagnostics/tests/inference/capturedTypes/noCaptureTypeErrorForNonTopLevel.kt @@ -11,7 +11,7 @@ fun bar(b: B>, bOut: B>, bOut2: B(b) - baz(bOut) + baz(bOut) baz(bOut) baz(bOut2) diff --git a/compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionToUnitWithNothingType.kt b/compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionToUnitWithNothingType.kt index c12790a34b9..80f7da81a83 100644 --- a/compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionToUnitWithNothingType.kt +++ b/compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionToUnitWithNothingType.kt @@ -50,4 +50,4 @@ fun test(i: Inv, iUnit: Inv) { run(A.flexible(iUnit)) { 42 } } } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithExpectedTypeAndBound.fir.kt b/compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithExpectedTypeAndBound.fir.kt index fd1e8bfd4cf..e8c9562b975 100644 --- a/compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithExpectedTypeAndBound.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithExpectedTypeAndBound.fir.kt @@ -10,4 +10,4 @@ fun b(): Unit = run { run { materializeNumber() } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithExpectedTypeAndBound.kt b/compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithExpectedTypeAndBound.kt index 313b0300703..1092e4d8ec9 100644 --- a/compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithExpectedTypeAndBound.kt +++ b/compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithExpectedTypeAndBound.kt @@ -3,11 +3,11 @@ fun materializeNumber(): T = TODO() fun a(): Unit = run { - materializeNumber() + materializeNumber() } fun b(): Unit = run { run { - materializeNumber() + materializeNumber() } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithoutExpectedType.fir.kt b/compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithoutExpectedType.fir.kt index ff5fd940d7f..400b2680b95 100644 --- a/compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithoutExpectedType.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithoutExpectedType.fir.kt @@ -16,4 +16,4 @@ fun implicitCoercion() { // Error: block doesn't have an expected type, so call can't be inferred! return@l materialize() } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithoutExpectedType.kt b/compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithoutExpectedType.kt index 9cfb3f61ced..0dc0c387722 100644 --- a/compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithoutExpectedType.kt +++ b/compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithoutExpectedType.kt @@ -14,6 +14,6 @@ fun implicitCoercion() { val c = l@{ // Error: block doesn't have an expected type, so call can't be inferred! - return@l materialize() + return@l materialize() } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/inference/coercionToUnit/coersionWithAnonymousFunctionsAndUnresolved.kt b/compiler/testData/diagnostics/tests/inference/coercionToUnit/coersionWithAnonymousFunctionsAndUnresolved.kt index 7b021ff6e25..cbf72205d7a 100644 --- a/compiler/testData/diagnostics/tests/inference/coercionToUnit/coersionWithAnonymousFunctionsAndUnresolved.kt +++ b/compiler/testData/diagnostics/tests/inference/coercionToUnit/coersionWithAnonymousFunctionsAndUnresolved.kt @@ -54,7 +54,7 @@ fun testParameter() { takeFnToParameter { Unit } takeFnToParameter { unresolved() } takeFnToParameter { if (true) unresolved() } - takeFnToParameter { + takeFnToParameter { if (true) unresolved() else unresolved() } takeFnToParameter(fun() = Unit) diff --git a/compiler/testData/diagnostics/tests/inference/coercionToUnit/indirectCoercionWithExpectedType.fir.kt b/compiler/testData/diagnostics/tests/inference/coercionToUnit/indirectCoercionWithExpectedType.fir.kt index 692bf78d0c0..db9d05d735c 100644 --- a/compiler/testData/diagnostics/tests/inference/coercionToUnit/indirectCoercionWithExpectedType.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/coercionToUnit/indirectCoercionWithExpectedType.fir.kt @@ -33,4 +33,4 @@ fun e(): Unit = run outer@{ run inner@{ return@outer materialize() } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/inference/coercionToUnit/indirectCoercionWithExpectedType.kt b/compiler/testData/diagnostics/tests/inference/coercionToUnit/indirectCoercionWithExpectedType.kt index 18767e081e6..eb00be09446 100644 --- a/compiler/testData/diagnostics/tests/inference/coercionToUnit/indirectCoercionWithExpectedType.kt +++ b/compiler/testData/diagnostics/tests/inference/coercionToUnit/indirectCoercionWithExpectedType.kt @@ -5,7 +5,7 @@ fun materialize(): T = TODO() fun a(): Unit = run { run { // Ok, block is coerced, because it has (indirectly) Unit-expected type - "hello" + "hello" } } @@ -19,13 +19,13 @@ fun c(): Unit = run { // Attention! // In OI expected type 'Unit' isn't applied here because of implementation quirks (note that OI still applies Unit in case 'e') // In NI, it is applied and call is correctly inferred, which is consistent with the previous case - materialize() + materialize() } } fun d(): Unit = run outer@{ run inner@{ - return@inner materialize() + return@inner materialize() } } @@ -33,4 +33,4 @@ fun e(): Unit = run outer@{ run inner@{ return@outer materialize() } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/inference/coercionToUnit/kt30242.fir.kt b/compiler/testData/diagnostics/tests/inference/coercionToUnit/kt30242.fir.kt index 0ad0a0b5f99..d93c8e8e792 100644 --- a/compiler/testData/diagnostics/tests/inference/coercionToUnit/kt30242.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/coercionToUnit/kt30242.fir.kt @@ -61,4 +61,4 @@ fun test_6(b: Boolean) { } if (b) {} } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/inference/coercionToUnit/kt30242.kt b/compiler/testData/diagnostics/tests/inference/coercionToUnit/kt30242.kt index 88859a3e087..1b03a5bc33e 100644 --- a/compiler/testData/diagnostics/tests/inference/coercionToUnit/kt30242.kt +++ b/compiler/testData/diagnostics/tests/inference/coercionToUnit/kt30242.kt @@ -48,7 +48,7 @@ fun bar(block: () -> String) {} fun test_5(b: Boolean) { bar { - if (b) { + if (b) { println("meh") } } @@ -61,4 +61,4 @@ fun test_6(b: Boolean) { } if (b) {} } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/inference/commonSystem/kt32818.fir.kt b/compiler/testData/diagnostics/tests/inference/commonSystem/kt32818.fir.kt index 80392808388..87354f76355 100644 --- a/compiler/testData/diagnostics/tests/inference/commonSystem/kt32818.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/commonSystem/kt32818.fir.kt @@ -5,4 +5,4 @@ fun nullable(): T? = null fun test() { val value = nullable() ?: nullable() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/inference/commonSystem/kt32818.kt b/compiler/testData/diagnostics/tests/inference/commonSystem/kt32818.kt index ab85e52ed9a..eff7f8de893 100644 --- a/compiler/testData/diagnostics/tests/inference/commonSystem/kt32818.kt +++ b/compiler/testData/diagnostics/tests/inference/commonSystem/kt32818.kt @@ -4,5 +4,5 @@ fun nullable(): T? = null fun test() { - val value = nullable() ?: nullable() -} \ No newline at end of file + val value = nullable() ?: nullable() +} diff --git a/compiler/testData/diagnostics/tests/inference/completeInferenceIfManyFailed.kt b/compiler/testData/diagnostics/tests/inference/completeInferenceIfManyFailed.kt index dacf903b75b..de77530c91f 100644 --- a/compiler/testData/diagnostics/tests/inference/completeInferenceIfManyFailed.kt +++ b/compiler/testData/diagnostics/tests/inference/completeInferenceIfManyFailed.kt @@ -14,6 +14,6 @@ fun joinT(x: Comparable<*>, } fun test() { - val x2 = joinT(Unit, "2") + val x2 = joinT(Unit, "2") checkSubtype(x2) } diff --git a/compiler/testData/diagnostics/tests/inference/conflictingSubstitutions.kt b/compiler/testData/diagnostics/tests/inference/conflictingSubstitutions.kt index aa8a7108ab6..319d3edec7b 100644 --- a/compiler/testData/diagnostics/tests/inference/conflictingSubstitutions.kt +++ b/compiler/testData/diagnostics/tests/inference/conflictingSubstitutions.kt @@ -8,9 +8,9 @@ fun elemAndList(r: R, t: MutableList): R = r fun R.elemAndListWithReceiver(r: R, t: MutableList): R = r fun test() { - val s = elemAndList(11, list("72")) + val s = elemAndList(11, list("72")) - val u = 11.elemAndListWithReceiver(4, list("7")) + val u = 11.elemAndListWithReceiver(4, list("7")) } fun list(value: T) : ArrayList { diff --git a/compiler/testData/diagnostics/tests/inference/constraints/constraintFromVariantTypeWithNestedProjection.fir.kt b/compiler/testData/diagnostics/tests/inference/constraints/constraintFromVariantTypeWithNestedProjection.fir.kt index 17b3ea6aa8c..f8f2a5ee9e9 100644 --- a/compiler/testData/diagnostics/tests/inference/constraints/constraintFromVariantTypeWithNestedProjection.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/constraints/constraintFromVariantTypeWithNestedProjection.fir.kt @@ -13,4 +13,4 @@ fun f(o: Out>, i: In>, inv: Inv>) { choose1(o) choose2(i) choose3(inv) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/inference/constraints/constraintFromVariantTypeWithNestedProjection.kt b/compiler/testData/diagnostics/tests/inference/constraints/constraintFromVariantTypeWithNestedProjection.kt index c643d8c7f05..74bc67a8203 100644 --- a/compiler/testData/diagnostics/tests/inference/constraints/constraintFromVariantTypeWithNestedProjection.kt +++ b/compiler/testData/diagnostics/tests/inference/constraints/constraintFromVariantTypeWithNestedProjection.kt @@ -11,6 +11,6 @@ fun choose3(c: Inv>) {} fun f(o: Out>, i: In>, inv: Inv>) { choose1(o) - choose2(i) - choose3(inv) -} \ No newline at end of file + choose2(i) + choose3(inv) +} diff --git a/compiler/testData/diagnostics/tests/inference/constraints/constraintOnFunctionLiteral.kt b/compiler/testData/diagnostics/tests/inference/constraints/constraintOnFunctionLiteral.kt index 664b27f623f..564011e52c2 100644 --- a/compiler/testData/diagnostics/tests/inference/constraints/constraintOnFunctionLiteral.kt +++ b/compiler/testData/diagnostics/tests/inference/constraints/constraintOnFunctionLiteral.kt @@ -3,7 +3,7 @@ package c import java.util.ArrayList -fun Array.toIntArray(): IntArray = this.mapTo(IntArray(size), {it}) +fun Array.toIntArray(): IntArray = this.mapTo(IntArray(size), {it}) fun Array.toArrayList(): ArrayList = this.mapTo(ArrayList(size), {it}) diff --git a/compiler/testData/diagnostics/tests/inference/constraints/definitelyNotNullTypeInReturnPosition.kt b/compiler/testData/diagnostics/tests/inference/constraints/definitelyNotNullTypeInReturnPosition.kt index 088cc29d558..024ec3106f1 100644 --- a/compiler/testData/diagnostics/tests/inference/constraints/definitelyNotNullTypeInReturnPosition.kt +++ b/compiler/testData/diagnostics/tests/inference/constraints/definitelyNotNullTypeInReturnPosition.kt @@ -262,8 +262,8 @@ class Main(x: L?, y: L) { val x471 = >>")!>foo47(y) fun takeLambda(block: () -> R): R = materialize() - val x480 = ")!>takeLambda { foo48 { x } } - val x481 = ")!>takeLambda { foo48 { y } } + val x480 = ")!>takeLambda { foo48 { x } } + val x481 = ")!>takeLambda { foo48 { y } } val x482 = ")!>takeLambda { foo48 { null } } } diff --git a/compiler/testData/diagnostics/tests/inference/constraints/kt6320.fir.kt b/compiler/testData/diagnostics/tests/inference/constraints/kt6320.fir.kt index 14a5aea2e24..4c494a58fa8 100644 --- a/compiler/testData/diagnostics/tests/inference/constraints/kt6320.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/constraints/kt6320.fir.kt @@ -18,4 +18,4 @@ class D(foo: C) { fun test(a: C) { val d: D = D(a) } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/inference/constraints/kt6320.kt b/compiler/testData/diagnostics/tests/inference/constraints/kt6320.kt index 7e5d332a515..4d638bb2270 100644 --- a/compiler/testData/diagnostics/tests/inference/constraints/kt6320.kt +++ b/compiler/testData/diagnostics/tests/inference/constraints/kt6320.kt @@ -16,6 +16,6 @@ class C class D(foo: C) { fun test(a: C) { - val d: D = D(a) + val d: D = D(a) } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/inference/constraints/kt8879.fir.kt b/compiler/testData/diagnostics/tests/inference/constraints/kt8879.fir.kt index 3aa989f59b7..32a391b14a8 100644 --- a/compiler/testData/diagnostics/tests/inference/constraints/kt8879.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/constraints/kt8879.fir.kt @@ -10,4 +10,4 @@ fun bar(): Inv = null!! fun test() { foo(bar()) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/inference/constraints/kt8879.kt b/compiler/testData/diagnostics/tests/inference/constraints/kt8879.kt index 12ffb646fa1..e357d1dc8f5 100644 --- a/compiler/testData/diagnostics/tests/inference/constraints/kt8879.kt +++ b/compiler/testData/diagnostics/tests/inference/constraints/kt8879.kt @@ -9,5 +9,5 @@ fun > foo(klass: Inv): String? = null fun bar(): Inv = null!! fun test() { - foo(bar()) -} \ No newline at end of file + foo(bar()) +} diff --git a/compiler/testData/diagnostics/tests/inference/constraints/manyConstraintsDueToFlexibleRawTypes.fir.kt b/compiler/testData/diagnostics/tests/inference/constraints/manyConstraintsDueToFlexibleRawTypes.fir.kt index 85124e82e7f..66206f17c5c 100644 --- a/compiler/testData/diagnostics/tests/inference/constraints/manyConstraintsDueToFlexibleRawTypes.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/constraints/manyConstraintsDueToFlexibleRawTypes.fir.kt @@ -29,4 +29,4 @@ fun test() { val a = MySettings.getSettings() a.getLinkedProjectsSettings() a.linkedProjectsSettings -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/inference/constraints/manyConstraintsDueToFlexibleRawTypes.kt b/compiler/testData/diagnostics/tests/inference/constraints/manyConstraintsDueToFlexibleRawTypes.kt index 72fc32469ec..d19f12d2a13 100644 --- a/compiler/testData/diagnostics/tests/inference/constraints/manyConstraintsDueToFlexibleRawTypes.kt +++ b/compiler/testData/diagnostics/tests/inference/constraints/manyConstraintsDueToFlexibleRawTypes.kt @@ -28,5 +28,5 @@ abstract class MySettingsListener {} fun test() { val a = MySettings.getSettings() a.getLinkedProjectsSettings() - a.linkedProjectsSettings -} \ No newline at end of file + a.linkedProjectsSettings +} diff --git a/compiler/testData/diagnostics/tests/inference/constraints/manyConstraintsDueToRecursiveFlexibleTypesWithWildcards.fir.kt b/compiler/testData/diagnostics/tests/inference/constraints/manyConstraintsDueToRecursiveFlexibleTypesWithWildcards.fir.kt index 499b2716ebd..a64feb0db8c 100644 --- a/compiler/testData/diagnostics/tests/inference/constraints/manyConstraintsDueToRecursiveFlexibleTypesWithWildcards.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/constraints/manyConstraintsDueToRecursiveFlexibleTypesWithWildcards.fir.kt @@ -29,4 +29,4 @@ fun test() { val a = MySettings.getSettings() a.getLinkedProjectsSettings() a.linkedProjectsSettings -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/inference/constraints/manyConstraintsDueToRecursiveFlexibleTypesWithWildcards.kt b/compiler/testData/diagnostics/tests/inference/constraints/manyConstraintsDueToRecursiveFlexibleTypesWithWildcards.kt index 0e0bb5b1f3e..c3217126fad 100644 --- a/compiler/testData/diagnostics/tests/inference/constraints/manyConstraintsDueToRecursiveFlexibleTypesWithWildcards.kt +++ b/compiler/testData/diagnostics/tests/inference/constraints/manyConstraintsDueToRecursiveFlexibleTypesWithWildcards.kt @@ -28,5 +28,5 @@ abstract class MySettingsListener {} fun test() { val a = MySettings.getSettings() a.getLinkedProjectsSettings() - a.linkedProjectsSettings -} \ No newline at end of file + a.linkedProjectsSettings +} diff --git a/compiler/testData/diagnostics/tests/inference/constraints/notNullConstraintOnNullableType.kt b/compiler/testData/diagnostics/tests/inference/constraints/notNullConstraintOnNullableType.kt index c8fab579ed8..7cb0539a24c 100644 --- a/compiler/testData/diagnostics/tests/inference/constraints/notNullConstraintOnNullableType.kt +++ b/compiler/testData/diagnostics/tests/inference/constraints/notNullConstraintOnNullableType.kt @@ -18,8 +18,8 @@ fun test(out: Out, i: In, inv: A) { r checkType { _() } // T? <: Int => error - doIn(i) + doIn(i) // T? >: Int => error - doA(inv) + doA(inv) } diff --git a/compiler/testData/diagnostics/tests/inference/dependantOnVariance.fir.kt b/compiler/testData/diagnostics/tests/inference/dependantOnVariance.fir.kt index 14f7068d274..754a8b78dc7 100644 --- a/compiler/testData/diagnostics/tests/inference/dependantOnVariance.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/dependantOnVariance.fir.kt @@ -66,4 +66,4 @@ fun test1(int: Int, any: Any) { use(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) } -fun use(vararg a: Any) = a \ No newline at end of file +fun use(vararg a: Any) = a diff --git a/compiler/testData/diagnostics/tests/inference/dependantOnVariance.kt b/compiler/testData/diagnostics/tests/inference/dependantOnVariance.kt index 328611b1157..b621e8df1d8 100644 --- a/compiler/testData/diagnostics/tests/inference/dependantOnVariance.kt +++ b/compiler/testData/diagnostics/tests/inference/dependantOnVariance.kt @@ -14,7 +14,7 @@ fun readFromMyList(l: MyList, = getMyList(int) - val a1 : MyList = getMyList(any) + val a1 : MyList = getMyList(any) val a2 : MyList = getMyList(int) @@ -25,27 +25,27 @@ fun test1(int: Int, any: Any) { val a5 : MyList = getMyListToWriteTo(any) - val a6 : MyList = getMyList(int) + val a6 : MyList = getMyList(int) val a7 : MyList = getMyList(int) - val a8 : MyList = getMyListToReadFrom(int) - val a9 : MyList = getMyListToReadFrom(int) + val a8 : MyList = getMyListToReadFrom(int) + val a9 : MyList = getMyListToReadFrom(int) - val a10 : MyList = getMyList(any) - val a11 : MyList = getMyList(any) + val a10 : MyList = getMyList(any) + val a11 : MyList = getMyList(any) - val a12 : MyList = getMyListToWriteTo(any) - val a13 : MyList = getMyListToWriteTo(any) + val a12 : MyList = getMyListToWriteTo(any) + val a13 : MyList = getMyListToWriteTo(any) useMyList(getMyList(int), int) useMyList(getMyList(any), int) - useMyList(getMyList(int), any) + useMyList(getMyList(int), any) readFromMyList(getMyList(int), any) readFromMyList(getMyList(any), int) - readFromMyList(getMyList(any), int) + readFromMyList(getMyList(any), int) - readFromMyList(getMyListToReadFrom(any), int) + readFromMyList(getMyListToReadFrom(any), int) readFromMyList(getMyListToReadFrom(any), int) readFromMyList(getMyListToReadFrom(int), any) @@ -54,16 +54,16 @@ fun test1(int: Int, any: Any) { writeToMyList(getMyList(any), int) writeToMyList(getMyList(int), any) writeToMyList(getMyList(int), any) - writeToMyList(getMyList(int), any) + writeToMyList(getMyList(int), any) writeToMyList(getMyListToWriteTo(any), int) - writeToMyList(getMyListToWriteTo(int), any) + writeToMyList(getMyListToWriteTo(int), any) readFromMyList(getMyListToWriteTo(any), any) - writeToMyList(getMyListToReadFrom(any), any) + writeToMyList(getMyListToReadFrom(any), any) use(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13) } -fun use(vararg a: Any) = a \ No newline at end of file +fun use(vararg a: Any) = a diff --git a/compiler/testData/diagnostics/tests/inference/expectedTypeAdditionalTest.fir.kt b/compiler/testData/diagnostics/tests/inference/expectedTypeAdditionalTest.fir.kt index 1dac5d3aeb0..d7e5f529abb 100644 --- a/compiler/testData/diagnostics/tests/inference/expectedTypeAdditionalTest.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/expectedTypeAdditionalTest.fir.kt @@ -10,4 +10,4 @@ fun foo2(): T = TODO() val test = foo2().plus("") as String fun T.bar() = this -val barTest = "".bar() as Number \ No newline at end of file +val barTest = "".bar() as Number diff --git a/compiler/testData/diagnostics/tests/inference/expectedTypeAdditionalTest.kt b/compiler/testData/diagnostics/tests/inference/expectedTypeAdditionalTest.kt index d74ac39652f..7debdb39f03 100644 --- a/compiler/testData/diagnostics/tests/inference/expectedTypeAdditionalTest.kt +++ b/compiler/testData/diagnostics/tests/inference/expectedTypeAdditionalTest.kt @@ -7,7 +7,7 @@ fun foo() = foo() as T fun foo2(): T = TODO() -val test = foo2().plus("") as String +val test = foo2().plus("") as String fun T.bar() = this -val barTest = "".bar() as Number \ No newline at end of file +val barTest = "".bar() as Number diff --git a/compiler/testData/diagnostics/tests/inference/expectedTypeDoubleReceiver.kt b/compiler/testData/diagnostics/tests/inference/expectedTypeDoubleReceiver.kt index 1745e3d04a5..d77ed65040f 100644 --- a/compiler/testData/diagnostics/tests/inference/expectedTypeDoubleReceiver.kt +++ b/compiler/testData/diagnostics/tests/inference/expectedTypeDoubleReceiver.kt @@ -9,10 +9,10 @@ class A { fun id(value: V) = value -val asA = foo().fooA() as A +val asA = foo().fooA() as A -val receiverParenthesized = (foo()).fooA() as A -val no2A = A().fooA().fooA() as A +val receiverParenthesized = (foo()).fooA() as A +val no2A = A().fooA().fooA() as A val correct1 = A().fooA() as A val correct2 = foo().fooA() as A diff --git a/compiler/testData/diagnostics/tests/inference/expectedTypeFromCast.kt b/compiler/testData/diagnostics/tests/inference/expectedTypeFromCast.kt index 16c79581202..88e0d3f9ed5 100644 --- a/compiler/testData/diagnostics/tests/inference/expectedTypeFromCast.kt +++ b/compiler/testData/diagnostics/tests/inference/expectedTypeFromCast.kt @@ -7,7 +7,7 @@ fun id(value: V) = value val asString = foo() as String -val viaId = id(foo()) as String +val viaId = id(foo()) as String val insideId = id(foo() as String) @@ -17,5 +17,5 @@ val asStarList = foo() as List<*> val safeAs = foo() as? String -val fromIs = foo() is String -val fromNoIs = foo() !is String +val fromIs = foo() is String +val fromNoIs = foo() !is String diff --git a/compiler/testData/diagnostics/tests/inference/expectedTypeWithGenerics.fir.kt b/compiler/testData/diagnostics/tests/inference/expectedTypeWithGenerics.fir.kt index c1054a13671..0f25ac22342 100644 --- a/compiler/testData/diagnostics/tests/inference/expectedTypeWithGenerics.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/expectedTypeWithGenerics.fir.kt @@ -15,4 +15,4 @@ fun g() { val y = foo() as Int val y2 = foo() as D -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/inference/expectedTypeWithGenerics.kt b/compiler/testData/diagnostics/tests/inference/expectedTypeWithGenerics.kt index 523db01ca2d..bf83286aed6 100644 --- a/compiler/testData/diagnostics/tests/inference/expectedTypeWithGenerics.kt +++ b/compiler/testData/diagnostics/tests/inference/expectedTypeWithGenerics.kt @@ -12,7 +12,7 @@ fun test(x: X) { fun g() { fun foo(): T = TODO() - val y = foo() as Int + val y = foo() as Int val y2 = foo() as D -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/inference/fixationOrderForProperConstraints.fir.kt b/compiler/testData/diagnostics/tests/inference/fixationOrderForProperConstraints.fir.kt index 705e7193760..4b14922b7a1 100644 --- a/compiler/testData/diagnostics/tests/inference/fixationOrderForProperConstraints.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/fixationOrderForProperConstraints.fir.kt @@ -4,4 +4,4 @@ fun foo(f: (Y) -> Z, g: (X) -> Y, x: X): Z = f(g(x)) // TODO: Actually, this is a bug and will work when new inference is enabled // see ([NI] Select variable with proper non-trivial constraint first) for more details -fun test() = foo({ it + 1 }, { it.length }, "") \ No newline at end of file +fun test() = foo({ it + 1 }, { it.length }, "") diff --git a/compiler/testData/diagnostics/tests/inference/fixationOrderForProperConstraints.kt b/compiler/testData/diagnostics/tests/inference/fixationOrderForProperConstraints.kt index 8de287264d8..1cf0161c059 100644 --- a/compiler/testData/diagnostics/tests/inference/fixationOrderForProperConstraints.kt +++ b/compiler/testData/diagnostics/tests/inference/fixationOrderForProperConstraints.kt @@ -4,4 +4,4 @@ fun foo(f: (Y) -> Z, g: (X) -> Y, x: X): Z = f(g(x)) // TODO: Actually, this is a bug and will work when new inference is enabled // see ([NI] Select variable with proper non-trivial constraint first) for more details -fun test() = foo({ it + 1 }, { it.length }, "") \ No newline at end of file +fun test() = foo({ it + 1 }, { it.length }, "") diff --git a/compiler/testData/diagnostics/tests/inference/functionPlaceholderError.kt b/compiler/testData/diagnostics/tests/inference/functionPlaceholderError.kt index 9f543b11387..593c530fff0 100644 --- a/compiler/testData/diagnostics/tests/inference/functionPlaceholderError.kt +++ b/compiler/testData/diagnostics/tests/inference/functionPlaceholderError.kt @@ -13,5 +13,5 @@ fun test() { val q = foo(fun Int.() {}, emptyList()) //type inference no information for parameter error checkSubtype(q) - foo({}, emptyList()) + foo({}, emptyList()) } diff --git a/compiler/testData/diagnostics/tests/inference/implicitInvokeExtensionWithFunctionalArgument.fir.kt b/compiler/testData/diagnostics/tests/inference/implicitInvokeExtensionWithFunctionalArgument.fir.kt index 8d7337641a6..4f080355f6b 100644 --- a/compiler/testData/diagnostics/tests/inference/implicitInvokeExtensionWithFunctionalArgument.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/implicitInvokeExtensionWithFunctionalArgument.fir.kt @@ -26,4 +26,4 @@ fun test(s: SelectorFor): Double { e checkType { _>() } return null!! -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/inference/implicitInvokeExtensionWithFunctionalArgument.kt b/compiler/testData/diagnostics/tests/inference/implicitInvokeExtensionWithFunctionalArgument.kt index 2b134d0d5d5..afbb3233dc7 100644 --- a/compiler/testData/diagnostics/tests/inference/implicitInvokeExtensionWithFunctionalArgument.kt +++ b/compiler/testData/diagnostics/tests/inference/implicitInvokeExtensionWithFunctionalArgument.kt @@ -25,5 +25,5 @@ fun test(s: SelectorFor): Double { val e = s { return p1 } e checkType { _>() } - return null!! -} \ No newline at end of file + return null!! +} diff --git a/compiler/testData/diagnostics/tests/inference/implicitInvokeInCompanionObjectWithFunctionalArgument.kt b/compiler/testData/diagnostics/tests/inference/implicitInvokeInCompanionObjectWithFunctionalArgument.kt index 97ce5d18665..5a490697679 100644 --- a/compiler/testData/diagnostics/tests/inference/implicitInvokeInCompanionObjectWithFunctionalArgument.kt +++ b/compiler/testData/diagnostics/tests/inference/implicitInvokeInCompanionObjectWithFunctionalArgument.kt @@ -14,4 +14,4 @@ fun test(s: String): String { val b = TestClass { return s } b checkType { _() } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/inference/kt28598.fir.kt b/compiler/testData/diagnostics/tests/inference/kt28598.fir.kt index ca11b71ef73..79603513ffe 100644 --- a/compiler/testData/diagnostics/tests/inference/kt28598.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/kt28598.fir.kt @@ -82,4 +82,4 @@ fun case_3(a: MutableList?>?>?>?>?>?>?) { if (a != null) { - val b = a[0] // no SMARTCAST diagnostic + val b = a[0] // no SMARTCAST diagnostic if (b != null) { val c = b[0] if (c != null) { @@ -31,19 +31,19 @@ fun case_1(a: MutableList?>?>?>?>?>?>?) { if (a != null) { - val b = a[0] // no SMARTCAST diagnostic + val b = a[0] // no SMARTCAST diagnostic if (b != null) { val c = b[0] if (c != null) { val d = c[0] if (d != null) { - val e = d[0] // no SMARTCAST diagnostic + val e = d[0] // no SMARTCAST diagnostic if (e != null) { val f = e[0] if (f != null) { val g = f[0] if (g != null) { - val h = g[0] // no SMARTCAST diagnostic + val h = g[0] // no SMARTCAST diagnostic if (h != null) { h.inc() } @@ -82,4 +82,4 @@ fun case_3(a: MutableList select(): K = run { } fun test() { val x: Int = select() val t = select() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/inference/kt28654.kt b/compiler/testData/diagnostics/tests/inference/kt28654.kt index fd601d32661..87aa044e490 100644 --- a/compiler/testData/diagnostics/tests/inference/kt28654.kt +++ b/compiler/testData/diagnostics/tests/inference/kt28654.kt @@ -2,9 +2,9 @@ // !DIAGNOSTICS: -UNUSED_VARIABLE // Related issue: KT-28654 -fun select(): K = run { } +fun select(): K = run { } fun test() { val x: Int = select() - val t = select() -} \ No newline at end of file + val t = select() +} diff --git a/compiler/testData/diagnostics/tests/inference/kt6175.fir.kt b/compiler/testData/diagnostics/tests/inference/kt6175.fir.kt index ec110cd53a7..75ccd5a614d 100644 --- a/compiler/testData/diagnostics/tests/inference/kt6175.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/kt6175.fir.kt @@ -46,4 +46,4 @@ fun test4() { } } -fun fail(): Nothing = throw Exception() \ No newline at end of file +fun fail(): Nothing = throw Exception() diff --git a/compiler/testData/diagnostics/tests/inference/kt6175.kt b/compiler/testData/diagnostics/tests/inference/kt6175.kt index d06a41f36f1..18728dd16ab 100644 --- a/compiler/testData/diagnostics/tests/inference/kt6175.kt +++ b/compiler/testData/diagnostics/tests/inference/kt6175.kt @@ -4,10 +4,10 @@ fun foo(body: (R?) -> T): T = fail() fun test1() { - foo { + foo { true } - foo { x -> + foo { x -> true } } @@ -16,10 +16,10 @@ fun test1() { fun bar(body: (R) -> T): T = fail() fun test2() { - bar { + bar { true } - bar { x -> + bar { x -> true } } @@ -27,10 +27,10 @@ fun test2() { fun baz(body: (List) -> T): T = fail() fun test3() { - baz { + baz { true } - baz { x -> + baz { x -> true } } @@ -38,12 +38,12 @@ fun test3() { fun brr(body: (List) -> T): T = fail() fun test4() { - brr { + brr { true } - brr { x -> + brr { x -> true } } -fun fail(): Nothing = throw Exception() \ No newline at end of file +fun fail(): Nothing = throw Exception() diff --git a/compiler/testData/diagnostics/tests/inference/nestedCalls/binaryExpressions.fir.kt b/compiler/testData/diagnostics/tests/inference/nestedCalls/binaryExpressions.fir.kt index 8abe5806286..3f42aaa8e0b 100644 --- a/compiler/testData/diagnostics/tests/inference/nestedCalls/binaryExpressions.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/nestedCalls/binaryExpressions.fir.kt @@ -69,4 +69,4 @@ fun test5() { } //use -fun use(vararg a: Any?) = a \ No newline at end of file +fun use(vararg a: Any?) = a diff --git a/compiler/testData/diagnostics/tests/inference/nestedCalls/binaryExpressions.kt b/compiler/testData/diagnostics/tests/inference/nestedCalls/binaryExpressions.kt index 6ae1bb2865e..0cc066b7744 100644 --- a/compiler/testData/diagnostics/tests/inference/nestedCalls/binaryExpressions.kt +++ b/compiler/testData/diagnostics/tests/inference/nestedCalls/binaryExpressions.kt @@ -14,7 +14,7 @@ fun id(t: T): T = t infix fun Z.foo(a: A): A = a fun test(z: Z) { - z foo newA() + z foo newA() val a: A = id(z foo newA()) val b: A = id(z.foo(newA())) use(a, b) @@ -24,7 +24,7 @@ fun test(z: Z) { operator fun Z.plus(a: A): A = a fun test1(z: Z) { - id(z + newA()) + id(z + newA()) val a: A = z + newA() val b: A = z.plus(newA()) val c: A = id(z + newA()) @@ -36,7 +36,7 @@ fun test1(z: Z) { operator fun Z.compareTo(a: A): Int { use(a); return 1 } fun test2(z: Z) { - val a: Boolean = id(z < newA()) + val a: Boolean = id(z < newA()) val b: Boolean = id(z < newA()) use(a, b) } @@ -45,18 +45,18 @@ fun test2(z: Z) { fun Z.equals(any: Any): Int { use(any); return 1 } fun test3(z: Z) { - z == newA() + z == newA() z == newA() - id(z == newA()) + id(z == newA()) id(z == newA()) - id(z === newA()) + id(z === newA()) id(z === newA()) } //'in' operation fun test4(collection: Collection>) { - id(newA() in collection) + id(newA() in collection) id(newA() in collection) } @@ -64,9 +64,9 @@ fun test4(collection: Collection>) { fun toBeOrNot(): Boolean = throw Exception() fun test5() { - if (toBeOrNot() && toBeOrNot()) {} + if (toBeOrNot() && toBeOrNot()) {} if (toBeOrNot() && toBeOrNot()) {} } //use -fun use(vararg a: Any?) = a \ No newline at end of file +fun use(vararg a: Any?) = a diff --git a/compiler/testData/diagnostics/tests/inference/noInformationForParameter.fir.kt b/compiler/testData/diagnostics/tests/inference/noInformationForParameter.fir.kt index 1c9eed8c115..293293ec857 100644 --- a/compiler/testData/diagnostics/tests/inference/noInformationForParameter.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/noInformationForParameter.fir.kt @@ -12,4 +12,4 @@ fun test() { fun newList() : ArrayList { return ArrayList() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/inference/noInformationForParameter.kt b/compiler/testData/diagnostics/tests/inference/noInformationForParameter.kt index b08fc1b568f..b2f2d163bf9 100644 --- a/compiler/testData/diagnostics/tests/inference/noInformationForParameter.kt +++ b/compiler/testData/diagnostics/tests/inference/noInformationForParameter.kt @@ -5,11 +5,11 @@ package noInformationForParameter import java.util.* fun test() { - val n = newList() + val n = newList() val n1 : List = newList() } fun newList() : ArrayList { return ArrayList() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/inference/nonFunctionalExpectedTypeForLambdaArgument.kt b/compiler/testData/diagnostics/tests/inference/nonFunctionalExpectedTypeForLambdaArgument.kt index 1aefa65531d..bea54d8c504 100644 --- a/compiler/testData/diagnostics/tests/inference/nonFunctionalExpectedTypeForLambdaArgument.kt +++ b/compiler/testData/diagnostics/tests/inference/nonFunctionalExpectedTypeForLambdaArgument.kt @@ -15,19 +15,19 @@ fun testAny() { fun testAnyCall() { callAny { - error -> error() + error -> error() } } fun testParam() { - callParam { + callParam { param -> param } } fun testParamCall() { - callParam { - param -> param() + callParam { + param -> param() } } diff --git a/compiler/testData/diagnostics/tests/inference/nothingType/kt34335.kt b/compiler/testData/diagnostics/tests/inference/nothingType/kt34335.kt index 282d2b8ac78..d4cd160d60e 100644 --- a/compiler/testData/diagnostics/tests/inference/nothingType/kt34335.kt +++ b/compiler/testData/diagnostics/tests/inference/nothingType/kt34335.kt @@ -11,9 +11,9 @@ fun foo(action: (Int) -> Unit) { } fun test1() { - call({ x -> println(x::class) }) // x inside the lambda is inferred to `Nothing`, the lambda is `(Nothing) -> Unit`. + call({ x -> println(x::class) }) // x inside the lambda is inferred to `Nothing`, the lambda is `(Nothing) -> Unit`. } fun test2() { - ::foo.call({ x -> println(x::class) }) + ::foo.call({ x -> println(x::class) }) } diff --git a/compiler/testData/diagnostics/tests/inference/nothingType/lambdaNothingAndExpectedType.kt b/compiler/testData/diagnostics/tests/inference/nothingType/lambdaNothingAndExpectedType.kt index a119e762694..8e07c6a6294 100644 --- a/compiler/testData/diagnostics/tests/inference/nothingType/lambdaNothingAndExpectedType.kt +++ b/compiler/testData/diagnostics/tests/inference/nothingType/lambdaNothingAndExpectedType.kt @@ -5,8 +5,8 @@ fun select2(x: K, y: K): K = TODO() fun select3(x: K, y: K, z: K): K = TODO() fun test2(f: ((String) -> Int)?) { - val a0: ((Int) -> Int)? = select2({ it -> it }, null) - val b0: ((Nothing) -> Unit)? = select2({ it -> it }, null) + val a0: ((Int) -> Int)? = select2({ it -> it }, null) + val b0: ((Nothing) -> Unit)? = select2({ it -> it }, null) select3({ it.length }, f, null) } diff --git a/compiler/testData/diagnostics/tests/inference/nothingType/notEnoughInformationFromNullabilityConstraint.kt b/compiler/testData/diagnostics/tests/inference/nothingType/notEnoughInformationFromNullabilityConstraint.kt index d3623a6b6a3..161b292d409 100644 --- a/compiler/testData/diagnostics/tests/inference/nothingType/notEnoughInformationFromNullabilityConstraint.kt +++ b/compiler/testData/diagnostics/tests/inference/nothingType/notEnoughInformationFromNullabilityConstraint.kt @@ -6,11 +6,11 @@ fun id(arg: I): I = arg fun select(vararg args: S): S = TODO() fun test() { - id( - make() + id( + make() ) select(make(), null) - if (true) make() else TODO() + if (true) make() else TODO() } diff --git a/compiler/testData/diagnostics/tests/inference/possibleCycleOnConstraints.fir.kt b/compiler/testData/diagnostics/tests/inference/possibleCycleOnConstraints.fir.kt index 9a3c0019831..f8302f0d9b8 100644 --- a/compiler/testData/diagnostics/tests/inference/possibleCycleOnConstraints.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/possibleCycleOnConstraints.fir.kt @@ -11,4 +11,4 @@ fun test() { val y = g { Collections.emptyList() } val z : List = g { Collections.emptyList() } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/inference/possibleCycleOnConstraints.kt b/compiler/testData/diagnostics/tests/inference/possibleCycleOnConstraints.kt index b02a17c8f3c..6110eee09a3 100644 --- a/compiler/testData/diagnostics/tests/inference/possibleCycleOnConstraints.kt +++ b/compiler/testData/diagnostics/tests/inference/possibleCycleOnConstraints.kt @@ -7,8 +7,8 @@ fun g (f: () -> List) : T {x = g { Collections.emptyList() } + val x = g { Collections.emptyList() } val y = g { Collections.emptyList() } - val z : List = g { Collections.emptyList() } -} \ No newline at end of file + val z : List = g { Collections.emptyList() } +} diff --git a/compiler/testData/diagnostics/tests/inference/publicApproximation/chainedLambdas.kt b/compiler/testData/diagnostics/tests/inference/publicApproximation/chainedLambdas.kt index 89184ee31a2..9c65de5ded1 100644 --- a/compiler/testData/diagnostics/tests/inference/publicApproximation/chainedLambdas.kt +++ b/compiler/testData/diagnostics/tests/inference/publicApproximation/chainedLambdas.kt @@ -29,6 +29,6 @@ fun chained2(arg: First) = run { } fun test(arg: First) { - chained1(arg).first() - chained2(arg).first() + chained1(arg).first() + chained2(arg).first() } diff --git a/compiler/testData/diagnostics/tests/inference/publicApproximation/intersectionAfterSmartCastInLambdaReturn.kt b/compiler/testData/diagnostics/tests/inference/publicApproximation/intersectionAfterSmartCastInLambdaReturn.kt index c8c08df2c07..bd23b67db6e 100644 --- a/compiler/testData/diagnostics/tests/inference/publicApproximation/intersectionAfterSmartCastInLambdaReturn.kt +++ b/compiler/testData/diagnostics/tests/inference/publicApproximation/intersectionAfterSmartCastInLambdaReturn.kt @@ -17,11 +17,11 @@ fun intersect(vararg elements: S): S = TODO() fun intersectAfterSmartCast(arg: Base, arg2: Base) = intersect( run { if (arg !is One) throw Exception() - arg + arg }, run { if (arg2 !is Two) throw Exception() - arg2 + arg2 } ) @@ -33,6 +33,6 @@ fun intersectArgWithSmartCastFromLambda(arg: One, arg2: Base) = argOrFn(arg) { } fun test() { - intersectAfterSmartCast(O1, O2).base() - intersectArgWithSmartCastFromLambda(O1, O2).base() + intersectAfterSmartCast(O1, O2).base() + intersectArgWithSmartCastFromLambda(O1, O2).base() } diff --git a/compiler/testData/diagnostics/tests/inference/publicApproximation/smartCastInLambdaReturnAfterIntersection.kt b/compiler/testData/diagnostics/tests/inference/publicApproximation/smartCastInLambdaReturnAfterIntersection.kt index 42665f9e35b..21b2d66a2b5 100644 --- a/compiler/testData/diagnostics/tests/inference/publicApproximation/smartCastInLambdaReturnAfterIntersection.kt +++ b/compiler/testData/diagnostics/tests/inference/publicApproximation/smartCastInLambdaReturnAfterIntersection.kt @@ -18,5 +18,5 @@ fun smartCastAfterIntersection(a: One, b: Two) = run { } fun test(one: One, two: Two) { - smartCastAfterIntersection(one, two)?.base() + smartCastAfterIntersection(one, two)?.base() } diff --git a/compiler/testData/diagnostics/tests/inference/publicApproximation/twoIntersections.kt b/compiler/testData/diagnostics/tests/inference/publicApproximation/twoIntersections.kt index c9260062a90..fb48437117c 100644 --- a/compiler/testData/diagnostics/tests/inference/publicApproximation/twoIntersections.kt +++ b/compiler/testData/diagnostics/tests/inference/publicApproximation/twoIntersections.kt @@ -21,5 +21,5 @@ fun intersectNoBound(vararg elements: S): S = TODO() fun some(a: One, b: Two, c: Three) = intersectNoBound(intersect(a, b), c) fun test(arg: Base, arg2: Base) { - some(O1, O2, O3).base() + some(O1, O2, O3).base() } diff --git a/compiler/testData/diagnostics/tests/inference/recursiveLocalFuns/localFactorial.kt b/compiler/testData/diagnostics/tests/inference/recursiveLocalFuns/localFactorial.kt index 65b80fa267d..b46cb2378ed 100644 --- a/compiler/testData/diagnostics/tests/inference/recursiveLocalFuns/localFactorial.kt +++ b/compiler/testData/diagnostics/tests/inference/recursiveLocalFuns/localFactorial.kt @@ -3,7 +3,7 @@ fun foo() { fun fact(n: Int) = { if (n > 0) { - fact(n - 1) * n + fact(n - 1) * n } else { 1 diff --git a/compiler/testData/diagnostics/tests/inference/recursiveLocalFuns/selfCall.kt b/compiler/testData/diagnostics/tests/inference/recursiveLocalFuns/selfCall.kt index 695d1762643..45213345f01 100644 --- a/compiler/testData/diagnostics/tests/inference/recursiveLocalFuns/selfCall.kt +++ b/compiler/testData/diagnostics/tests/inference/recursiveLocalFuns/selfCall.kt @@ -2,8 +2,8 @@ fun foo() { fun bar1() = bar1() - fun bar2() = 1 + bar2() - fun bar3() = id(bar3()) + fun bar2() = 1 + bar2() + fun bar3() = id(bar3()) } fun id(x: T) = x diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt1127.fir.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt1127.fir.kt index bef26ff67bc..bfd456688bc 100644 --- a/compiler/testData/diagnostics/tests/inference/regressions/kt1127.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/regressions/kt1127.fir.kt @@ -7,4 +7,4 @@ fun asList(t: T) : List? {} fun main() { val list : List = asList("") -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt1127.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt1127.kt index 7718028a1cf..fd661b51400 100644 --- a/compiler/testData/diagnostics/tests/inference/regressions/kt1127.kt +++ b/compiler/testData/diagnostics/tests/inference/regressions/kt1127.kt @@ -6,5 +6,5 @@ package d fun asList(t: T) : List? {} fun main() { - val list : List = asList("") -} \ No newline at end of file + val list : List = asList("") +} diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt2200.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt2200.kt index 531db47b897..bd5f419506a 100644 --- a/compiler/testData/diagnostics/tests/inference/regressions/kt2200.kt +++ b/compiler/testData/diagnostics/tests/inference/regressions/kt2200.kt @@ -6,7 +6,7 @@ package n import checkSubtype fun main() { - val a = array(array()) + val a = array(array()) val a0 : Array> = array(array()) val a1 = array(array()) checkSubtype>>(a1) diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt2283.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt2283.kt index 7ead3c4ae8b..d3c758841bd 100644 --- a/compiler/testData/diagnostics/tests/inference/regressions/kt2283.kt +++ b/compiler/testData/diagnostics/tests/inference/regressions/kt2283.kt @@ -10,5 +10,5 @@ fun Foo.map(f: (A) -> B): Foo = object : Foo fun foo() { val l: Foo = object : Foo {} - val m: Foo = l.map { ppp -> 1 } + val m: Foo = l.map { ppp -> 1 } } diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt2286.fir.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt2286.fir.kt index dc8b9a5cb70..9750fce3ffa 100644 --- a/compiler/testData/diagnostics/tests/inference/regressions/kt2286.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/regressions/kt2286.fir.kt @@ -25,4 +25,4 @@ abstract class Buggy { } //from library -fun Iterable.find(predicate: (T) -> Boolean) : T? {} \ No newline at end of file +fun Iterable.find(predicate: (T) -> Boolean) : T? {} diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt2286.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt2286.kt index b3f2414cddd..7131f595301 100644 --- a/compiler/testData/diagnostics/tests/inference/regressions/kt2286.kt +++ b/compiler/testData/diagnostics/tests/inference/regressions/kt2286.kt @@ -12,17 +12,17 @@ abstract class Buggy { } val anotherThree : Int - get() = coll.find{ it > 3 } // does not work here + get() = coll.find{ it > 3 } // does not work here val yetAnotherThree : Int - get() = coll.find({ v:Int -> v > 3 }) // neither here + get() = coll.find({ v:Int -> v > 3 }) // neither here val extendedGetter : Int get() { - return coll.find{ it > 3 } // not even here! + return coll.find{ it > 3 } // not even here! } } //from library -fun Iterable.find(predicate: (T) -> Boolean) : T? {} \ No newline at end of file +fun Iterable.find(predicate: (T) -> Boolean) : T? {} diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt2445.fir.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt2445.fir.kt index 2cef6dc4105..96938cad1ec 100644 --- a/compiler/testData/diagnostics/tests/inference/regressions/kt2445.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/regressions/kt2445.fir.kt @@ -9,4 +9,4 @@ fun main() { } } -fun test(callback: (R) -> Unit):Unit = callback(null!!) \ No newline at end of file +fun test(callback: (R) -> Unit):Unit = callback(null!!) diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt2445.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt2445.kt index a9d9f2a8bd1..45cbc5ce470 100644 --- a/compiler/testData/diagnostics/tests/inference/regressions/kt2445.kt +++ b/compiler/testData/diagnostics/tests/inference/regressions/kt2445.kt @@ -4,9 +4,9 @@ package a fun main() { - test { + test { } } -fun test(callback: (R) -> Unit):Unit = callback(null!!) \ No newline at end of file +fun test(callback: (R) -> Unit):Unit = callback(null!!) diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt2741.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt2741.kt index dc6a3ce7806..8717cf23160 100644 --- a/compiler/testData/diagnostics/tests/inference/regressions/kt2741.kt +++ b/compiler/testData/diagnostics/tests/inference/regressions/kt2741.kt @@ -9,5 +9,5 @@ fun _arrayList(vararg values: T) : List = throw Ex class _Pair(val a: A) fun test() { - _arrayList(_Pair(1))._sortBy { it -> xxx } + _arrayList(_Pair(1))._sortBy { it -> xxx } } diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt2838.fir.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt2838.fir.kt index 45478c1fbf0..eb292dfecd2 100644 --- a/compiler/testData/diagnostics/tests/inference/regressions/kt2838.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/regressions/kt2838.fir.kt @@ -16,4 +16,4 @@ fun test1(a: Int) { fun test2(a: Int) { bar(a, throw Exception()) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt2838.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt2838.kt index 871c61e5f5c..30528f3fab6 100644 --- a/compiler/testData/diagnostics/tests/inference/regressions/kt2838.kt +++ b/compiler/testData/diagnostics/tests/inference/regressions/kt2838.kt @@ -8,7 +8,7 @@ fun bar(a: T, b: Map) = b.get(a) fun test(a: Int) { foo(a, null) - bar(a, null) + bar(a, null) } fun test1(a: Int) { foo(a, throw Exception()) @@ -16,4 +16,4 @@ fun test1(a: Int) { fun test2(a: Int) { bar(a, throw Exception()) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt2883.fir.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt2883.fir.kt index 6e9756905d9..82db36f9aa0 100644 --- a/compiler/testData/diagnostics/tests/inference/regressions/kt2883.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/regressions/kt2883.fir.kt @@ -30,4 +30,4 @@ fun testWithoutInference(col: MutableCollection) { doAction { col.add(2) } val u: Unit = col.add(2) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt2883.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt2883.kt index 31cb85319f3..4cd5c6a2764 100644 --- a/compiler/testData/diagnostics/tests/inference/regressions/kt2883.kt +++ b/compiler/testData/diagnostics/tests/inference/regressions/kt2883.kt @@ -22,7 +22,7 @@ fun test() { doAction { bar(12) } - val u: Unit = bar(11) + val u: Unit = bar(11) } fun testWithoutInference(col: MutableCollection) { @@ -30,4 +30,4 @@ fun testWithoutInference(col: MutableCollection) { doAction { col.add(2) } val u: Unit = col.add(2) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt32862_both.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt32862_both.kt index 3e94df7f850..35470d64a5c 100644 --- a/compiler/testData/diagnostics/tests/inference/regressions/kt32862_both.kt +++ b/compiler/testData/diagnostics/tests/inference/regressions/kt32862_both.kt @@ -12,5 +12,5 @@ fun G.foo(vararg values: V2) = build() fun forReference(ref: Any?) {} fun test() { - forReference(G::foo) + forReference(G::foo) } diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt32862_none.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt32862_none.kt index 30aa30da9b5..2e4ae2b6767 100644 --- a/compiler/testData/diagnostics/tests/inference/regressions/kt32862_none.kt +++ b/compiler/testData/diagnostics/tests/inference/regressions/kt32862_none.kt @@ -7,5 +7,5 @@ fun foo(i: Long) {} fun bar(f: (Boolean) -> Unit) {} fun test() { - bar(::foo) + bar(::foo) } diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt33629.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt33629.kt index 065b0801b11..44f0512eb4f 100644 --- a/compiler/testData/diagnostics/tests/inference/regressions/kt33629.kt +++ b/compiler/testData/diagnostics/tests/inference/regressions/kt33629.kt @@ -17,5 +17,5 @@ fun acquireIntervals(): List = TODO() fun main() { buildTree(acquireIntervals()) - ?: emptyList() + ?: emptyList() } diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt36342.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt36342.kt index a47c7211b08..c5ac3622711 100644 --- a/compiler/testData/diagnostics/tests/inference/regressions/kt36342.kt +++ b/compiler/testData/diagnostics/tests/inference/regressions/kt36342.kt @@ -6,7 +6,7 @@ fun id(arg: K): K = arg fun test() { id(unresolved)!! - unresolved!!!! + unresolved!!!! try { id(unresolved) } catch (e: Exception) { diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt36342_2.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt36342_2.kt index d2625902a26..46346cda080 100644 --- a/compiler/testData/diagnostics/tests/inference/regressions/kt36342_2.kt +++ b/compiler/testData/diagnostics/tests/inference/regressions/kt36342_2.kt @@ -4,11 +4,11 @@ fun id(arg: K): K = arg fun materialize(): M = TODO() fun test(b: Boolean) { - id(if (b) { + id(if (b) { id(unresolved) } else { - id( - materialize() + id( + materialize() ) }) } diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt41394.fir.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt41394.fir.kt deleted file mode 100644 index 50cc43d36a4..00000000000 --- a/compiler/testData/diagnostics/tests/inference/regressions/kt41394.fir.kt +++ /dev/null @@ -1,10 +0,0 @@ -// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_ANONYMOUS_PARAMETER -// !LANGUAGE: +InferenceCompatibility - -fun foo(x: T, fn: (VR?, T) -> Unit) {} - -fun takeInt(x: Int) {} - -fun main(x: Int) { - foo(x) { prev: Int?, new -> takeInt(new) } // `new` is `Int` in OI, `Int?` in NI -} diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt41394.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt41394.kt index ba68e417ef0..6f7c27a0989 100644 --- a/compiler/testData/diagnostics/tests/inference/regressions/kt41394.kt +++ b/compiler/testData/diagnostics/tests/inference/regressions/kt41394.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_ANONYMOUS_PARAMETER // !LANGUAGE: +InferenceCompatibility @@ -7,4 +8,4 @@ fun takeInt(x: Int) {} fun main(x: Int) { foo(x) { prev: Int?, new -> takeInt(new) } // `new` is `Int` in OI, `Int?` in NI -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt702.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt702.kt index 71f5142a0f6..189b7d2ebdb 100644 --- a/compiler/testData/diagnostics/tests/inference/regressions/kt702.kt +++ b/compiler/testData/diagnostics/tests/inference/regressions/kt702.kt @@ -17,4 +17,4 @@ public class Throwables() { propagateIfInstanceOf(throwable, getJavaClass()) // Type inference failed: Mismatch while expanding constraints } } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt731.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt731.kt index e8a55a78751..c4e1d0d98e5 100644 --- a/compiler/testData/diagnostics/tests/inference/regressions/kt731.kt +++ b/compiler/testData/diagnostics/tests/inference/regressions/kt731.kt @@ -16,6 +16,6 @@ fun A.foo(x: (T)-> G): G { fun main() { val a = A(1) - val t: String = a.foo({p -> p}) + val t: String = a.foo({p -> p}) checkSubtype(t) } diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt742.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt742.kt index aff7a34c740..f1d0df486da 100644 --- a/compiler/testData/diagnostics/tests/inference/regressions/kt742.kt +++ b/compiler/testData/diagnostics/tests/inference/regressions/kt742.kt @@ -10,4 +10,4 @@ fun List.map1(f: (T)-> Q): List? = tail!!.map1(f) fun List.map2(f: (T)-> Q): List? = tail.sure().map2(f) -fun List.map3(f: (T)-> Q): List? = tail.sure<T>().map3(f) \ No newline at end of file +fun List.map3(f: (T)-> Q): List? = tail.sure<T>().map3(f) diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt832.fir.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt832.fir.kt index d7f6d23d92a..892754ed03c 100644 --- a/compiler/testData/diagnostics/tests/inference/regressions/kt832.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/regressions/kt832.fir.kt @@ -8,4 +8,4 @@ fun fooT2() : (t : T) -> T { fun test() { fooT2()(1) // here 1 should not be marked with an error -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt832.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt832.kt index 5f0417bd072..4e7c917d2fb 100644 --- a/compiler/testData/diagnostics/tests/inference/regressions/kt832.kt +++ b/compiler/testData/diagnostics/tests/inference/regressions/kt832.kt @@ -7,5 +7,5 @@ fun fooT2() : (t : T) -> T { } fun test() { - fooT2()(1) // here 1 should not be marked with an error -} \ No newline at end of file + fooT2()(1) // here 1 should not be marked with an error +} diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt948.kt b/compiler/testData/diagnostics/tests/inference/regressions/kt948.kt index 4459f60c7a4..421fb2445e1 100644 --- a/compiler/testData/diagnostics/tests/inference/regressions/kt948.kt +++ b/compiler/testData/diagnostics/tests/inference/regressions/kt948.kt @@ -13,7 +13,7 @@ fun emptyList() : List? = ArrayList() fun foo() { // type arguments shouldn't be required val l : List = emptyList()!! - val l1 = emptyList()!! + val l1 = emptyList()!! checkSubtype>(emptyList()!!) checkSubtype?>(emptyList()) diff --git a/compiler/testData/diagnostics/tests/inference/reportingImprovements/FunctionPlaceholder.fir.kt b/compiler/testData/diagnostics/tests/inference/reportingImprovements/FunctionPlaceholder.fir.kt index b2ae4f1fe28..06cc3058d82 100644 --- a/compiler/testData/diagnostics/tests/inference/reportingImprovements/FunctionPlaceholder.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/reportingImprovements/FunctionPlaceholder.fir.kt @@ -14,4 +14,4 @@ fun test() { bar { it + 1 } bar { x -> x + 1} bar { x: Int -> x + 1} -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/inference/reportingImprovements/FunctionPlaceholder.kt b/compiler/testData/diagnostics/tests/inference/reportingImprovements/FunctionPlaceholder.kt index 1bc71031708..666c2bf038b 100644 --- a/compiler/testData/diagnostics/tests/inference/reportingImprovements/FunctionPlaceholder.kt +++ b/compiler/testData/diagnostics/tests/inference/reportingImprovements/FunctionPlaceholder.kt @@ -7,11 +7,11 @@ fun foo(a: A) = a fun bar(f: (T) -> R) = f fun test() { - foo { it } - foo { x -> x} - foo { x: Int -> x} + foo { it } + foo { x -> x} + foo { x: Int -> x} - bar { it + 1 } - bar { x -> x + 1} + bar { it + 1 } + bar { x -> x + 1} bar { x: Int -> x + 1} -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/inference/reportingImprovements/cannotInferParameterTypeWithInference.kt b/compiler/testData/diagnostics/tests/inference/reportingImprovements/cannotInferParameterTypeWithInference.kt index e97fdd3c825..c68608f66a6 100644 --- a/compiler/testData/diagnostics/tests/inference/reportingImprovements/cannotInferParameterTypeWithInference.kt +++ b/compiler/testData/diagnostics/tests/inference/reportingImprovements/cannotInferParameterTypeWithInference.kt @@ -4,7 +4,7 @@ package aa fun foo(block: (T)-> R) = block fun test1() { - foo { + foo { x -> // here we have 'cannot infer parameter type' error 43 } diff --git a/compiler/testData/diagnostics/tests/inference/reportingImprovements/inferTypeFromUnresolvedArgument.fir.kt b/compiler/testData/diagnostics/tests/inference/reportingImprovements/inferTypeFromUnresolvedArgument.fir.kt index 14ef9857089..7874eeadf0e 100644 --- a/compiler/testData/diagnostics/tests/inference/reportingImprovements/inferTypeFromUnresolvedArgument.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/reportingImprovements/inferTypeFromUnresolvedArgument.fir.kt @@ -10,4 +10,4 @@ fun test() { ret("foo") ret(42) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/inference/reportingImprovements/inferTypeFromUnresolvedArgument.kt b/compiler/testData/diagnostics/tests/inference/reportingImprovements/inferTypeFromUnresolvedArgument.kt index 6bde24e0526..95f2d3a8dc8 100644 --- a/compiler/testData/diagnostics/tests/inference/reportingImprovements/inferTypeFromUnresolvedArgument.kt +++ b/compiler/testData/diagnostics/tests/inference/reportingImprovements/inferTypeFromUnresolvedArgument.kt @@ -8,6 +8,6 @@ fun test() { id2(unresolved, "foo") id2(unresolved, 42) - ret("foo") - ret(42) -} \ No newline at end of file + ret("foo") + ret(42) +} diff --git a/compiler/testData/diagnostics/tests/inference/reportingImprovements/reportUnresolvedReferenceWrongReceiverForManyCandidates.kt b/compiler/testData/diagnostics/tests/inference/reportingImprovements/reportUnresolvedReferenceWrongReceiverForManyCandidates.kt index 1bbfca02be7..a39d4876be5 100644 --- a/compiler/testData/diagnostics/tests/inference/reportingImprovements/reportUnresolvedReferenceWrongReceiverForManyCandidates.kt +++ b/compiler/testData/diagnostics/tests/inference/reportingImprovements/reportUnresolvedReferenceWrongReceiverForManyCandidates.kt @@ -5,4 +5,4 @@ fun test() { operator fun A.unaryMinus() {} operator fun B.unaryMinus() {} class A -class B \ No newline at end of file +class B diff --git a/compiler/testData/diagnostics/tests/inference/reportingImprovements/subtypeForInvariantWithErrorGenerics.fir.kt b/compiler/testData/diagnostics/tests/inference/reportingImprovements/subtypeForInvariantWithErrorGenerics.fir.kt index 984f1fee42b..36b993c41cd 100644 --- a/compiler/testData/diagnostics/tests/inference/reportingImprovements/subtypeForInvariantWithErrorGenerics.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/reportingImprovements/subtypeForInvariantWithErrorGenerics.fir.kt @@ -10,4 +10,4 @@ fun test() { } // from standard library -fun arrayListOf(vararg values: T) : MutableList {} \ No newline at end of file +fun arrayListOf(vararg values: T) : MutableList {} diff --git a/compiler/testData/diagnostics/tests/inference/reportingImprovements/subtypeForInvariantWithErrorGenerics.kt b/compiler/testData/diagnostics/tests/inference/reportingImprovements/subtypeForInvariantWithErrorGenerics.kt index 567a463e450..9c6e5bccc09 100644 --- a/compiler/testData/diagnostics/tests/inference/reportingImprovements/subtypeForInvariantWithErrorGenerics.kt +++ b/compiler/testData/diagnostics/tests/inference/reportingImprovements/subtypeForInvariantWithErrorGenerics.kt @@ -5,9 +5,9 @@ fun foo (f: ()->R, r: MutableList) = r.add(f()) fun bar (r: MutableList, f: ()->R) = r.add(f()) fun test() { - val a = foo({1}, arrayListOf("")) //no type inference error on 'arrayListOf' - val b = bar(arrayListOf(""), {1}) + val a = foo({1}, arrayListOf("")) //no type inference error on 'arrayListOf' + val b = bar(arrayListOf(""), {1}) } // from standard library -fun arrayListOf(vararg values: T) : MutableList {} \ No newline at end of file +fun arrayListOf(vararg values: T) : MutableList {} diff --git a/compiler/testData/diagnostics/tests/inference/reportingImprovements/typeInferenceFailedOnComponentN.fir.kt b/compiler/testData/diagnostics/tests/inference/reportingImprovements/typeInferenceFailedOnComponentN.fir.kt index 2a4bbf399ba..a3deb300a16 100644 --- a/compiler/testData/diagnostics/tests/inference/reportingImprovements/typeInferenceFailedOnComponentN.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/reportingImprovements/typeInferenceFailedOnComponentN.fir.kt @@ -7,4 +7,4 @@ operator fun X.component1(): T = TODO() fun test() { val (y) = X() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/inference/reportingImprovements/typeInferenceFailedOnComponentN.kt b/compiler/testData/diagnostics/tests/inference/reportingImprovements/typeInferenceFailedOnComponentN.kt index 7bae629094a..44d9ec08cd5 100644 --- a/compiler/testData/diagnostics/tests/inference/reportingImprovements/typeInferenceFailedOnComponentN.kt +++ b/compiler/testData/diagnostics/tests/inference/reportingImprovements/typeInferenceFailedOnComponentN.kt @@ -6,5 +6,5 @@ class X operator fun X.component1(): T = TODO() fun test() { - val (y) = X() -} \ No newline at end of file + val (y) = X() +} diff --git a/compiler/testData/diagnostics/tests/inference/reportingImprovements/typeInferenceFailedOnIteratorCall.fir.kt b/compiler/testData/diagnostics/tests/inference/reportingImprovements/typeInferenceFailedOnIteratorCall.fir.kt index 065818b1da8..1ae94dc5341 100644 --- a/compiler/testData/diagnostics/tests/inference/reportingImprovements/typeInferenceFailedOnIteratorCall.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/reportingImprovements/typeInferenceFailedOnIteratorCall.fir.kt @@ -6,4 +6,4 @@ operator fun X.iterator(): Iterable = TODO() fun test() { for (i in X()) { } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/inference/reportingImprovements/typeInferenceFailedOnIteratorCall.kt b/compiler/testData/diagnostics/tests/inference/reportingImprovements/typeInferenceFailedOnIteratorCall.kt index bf07e2b5f72..1e6454a861b 100644 --- a/compiler/testData/diagnostics/tests/inference/reportingImprovements/typeInferenceFailedOnIteratorCall.kt +++ b/compiler/testData/diagnostics/tests/inference/reportingImprovements/typeInferenceFailedOnIteratorCall.kt @@ -4,6 +4,6 @@ class X operator fun X.iterator(): Iterable = TODO() fun test() { - for (i in X()) { + for (i in X()) { } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/inference/typeConstructorMismatch.kt b/compiler/testData/diagnostics/tests/inference/typeConstructorMismatch.kt index 2857bd951f9..6585c269550 100644 --- a/compiler/testData/diagnostics/tests/inference/typeConstructorMismatch.kt +++ b/compiler/testData/diagnostics/tests/inference/typeConstructorMismatch.kt @@ -5,9 +5,9 @@ package typeConstructorMismatch import java.util.* fun test(set: Set) { - elemAndList("2", set) + elemAndList("2", set) - "".elemAndListWithReceiver("", set) + "".elemAndListWithReceiver("", set) } fun elemAndList(r: R, t: List): R = r diff --git a/compiler/testData/diagnostics/tests/inference/typeInferenceExpectedTypeMismatch.fir.kt b/compiler/testData/diagnostics/tests/inference/typeInferenceExpectedTypeMismatch.fir.kt index e620f3720a9..65adab20a79 100644 --- a/compiler/testData/diagnostics/tests/inference/typeInferenceExpectedTypeMismatch.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/typeInferenceExpectedTypeMismatch.fir.kt @@ -39,4 +39,4 @@ fun test2(outA: Out, inC: In) { use(b) } -fun use(vararg a: Any?) = a \ No newline at end of file +fun use(vararg a: Any?) = a diff --git a/compiler/testData/diagnostics/tests/inference/typeInferenceExpectedTypeMismatch.kt b/compiler/testData/diagnostics/tests/inference/typeInferenceExpectedTypeMismatch.kt index 999c6a6a498..4a9573ce1aa 100644 --- a/compiler/testData/diagnostics/tests/inference/typeInferenceExpectedTypeMismatch.kt +++ b/compiler/testData/diagnostics/tests/inference/typeInferenceExpectedTypeMismatch.kt @@ -4,7 +4,7 @@ package typeInferenceExpectedTypeMismatch import java.util.* fun test() { - val s : Set = newList() + val s : Set = newList() use(s) } @@ -26,17 +26,17 @@ fun foo(o: Out, i: In): Two = throw Exception("$o $i") fun test1(outA: Out, inB: In) { foo(outA, inB) - val b: Two = foo(outA, inB) + val b: Two = foo(outA, inB) use(b) } fun bar(o: Out, i: In): Two = throw Exception("$o $i") fun test2(outA: Out, inC: In) { - bar(outA, inC) + bar(outA, inC) - val b: Two = bar(outA, inC) + val b: Two = bar(outA, inC) use(b) } -fun use(vararg a: Any?) = a \ No newline at end of file +fun use(vararg a: Any?) = a diff --git a/compiler/testData/diagnostics/tests/inference/upperBounds/doNotInferFromBoundsOnly.kt b/compiler/testData/diagnostics/tests/inference/upperBounds/doNotInferFromBoundsOnly.kt index e10a80675fc..b0de8d3f355 100644 --- a/compiler/testData/diagnostics/tests/inference/upperBounds/doNotInferFromBoundsOnly.kt +++ b/compiler/testData/diagnostics/tests/inference/upperBounds/doNotInferFromBoundsOnly.kt @@ -6,7 +6,7 @@ interface A fun emptyList(): List = throw Exception() fun test1() { - emptyList() + emptyList() } //-------------- @@ -14,7 +14,7 @@ fun test1() { fun emptyListOfA(): List = throw Exception() fun test2() { - emptyListOfA() + emptyListOfA() } //-------------- @@ -22,7 +22,7 @@ fun test2() { fun emptyStrangeMap(): Map = throw Exception() fun test3() { - emptyStrangeMap() + emptyStrangeMap() } //-------------- diff --git a/compiler/testData/diagnostics/tests/inference/upperBounds/intersectUpperBounds.kt b/compiler/testData/diagnostics/tests/inference/upperBounds/intersectUpperBounds.kt index 9c7631f212b..1eb55cc189a 100644 --- a/compiler/testData/diagnostics/tests/inference/upperBounds/intersectUpperBounds.kt +++ b/compiler/testData/diagnostics/tests/inference/upperBounds/intersectUpperBounds.kt @@ -15,7 +15,7 @@ fun foo(in1: In, in2: In): T = throw Exception("$in1 $in2") fun test(inA: In, inB: In, inC: In) { - foo(inA, inB) + foo(inA, inB) val r = foo(inA, inC) checkSubtype(r) diff --git a/compiler/testData/diagnostics/tests/inference/upperBounds/typeParameterAsUpperBound.kt b/compiler/testData/diagnostics/tests/inference/upperBounds/typeParameterAsUpperBound.kt index 4c57d990a7b..ac059f090e5 100644 --- a/compiler/testData/diagnostics/tests/inference/upperBounds/typeParameterAsUpperBound.kt +++ b/compiler/testData/diagnostics/tests/inference/upperBounds/typeParameterAsUpperBound.kt @@ -13,4 +13,4 @@ fun usage(c: List) { val cs = c.ifEmpty { listOf("x") } cs checkType { _>() } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/inference/upperBounds/useBoundsToInferTypeParamsSimple.fir.kt b/compiler/testData/diagnostics/tests/inference/upperBounds/useBoundsToInferTypeParamsSimple.fir.kt index 17a39c6633e..5980f137ce2 100644 --- a/compiler/testData/diagnostics/tests/inference/upperBounds/useBoundsToInferTypeParamsSimple.fir.kt +++ b/compiler/testData/diagnostics/tests/inference/upperBounds/useBoundsToInferTypeParamsSimple.fir.kt @@ -20,4 +20,4 @@ fun test(a: Any, s: MutableSet) { } //from standard library -fun arrayListOf(vararg t: T): MutableList {} \ No newline at end of file +fun arrayListOf(vararg t: T): MutableList {} diff --git a/compiler/testData/diagnostics/tests/inference/upperBounds/useBoundsToInferTypeParamsSimple.kt b/compiler/testData/diagnostics/tests/inference/upperBounds/useBoundsToInferTypeParamsSimple.kt index 0ad0211a464..eb4d5600c16 100644 --- a/compiler/testData/diagnostics/tests/inference/upperBounds/useBoundsToInferTypeParamsSimple.kt +++ b/compiler/testData/diagnostics/tests/inference/upperBounds/useBoundsToInferTypeParamsSimple.kt @@ -16,8 +16,8 @@ fun checkItIsExactlyAny(t: T, l baz(v: V, u: MutableSet) = u fun test(a: Any, s: MutableSet) { - baz(a, s) + baz(a, s) } //from standard library -fun arrayListOf(vararg t: T): MutableList {} \ No newline at end of file +fun arrayListOf(vararg t: T): MutableList {} diff --git a/compiler/testData/diagnostics/tests/infos/SmartCasts.kt b/compiler/testData/diagnostics/tests/infos/SmartCasts.kt index fd99a7e520e..d95e16160d6 100644 --- a/compiler/testData/diagnostics/tests/infos/SmartCasts.kt +++ b/compiler/testData/diagnostics/tests/infos/SmartCasts.kt @@ -89,17 +89,17 @@ fun f13(a : A?) { } else { a?.foo() - c.bar() + c.bar() } a?.foo() if (!(a is B)) { a?.foo() - c.bar() + c.bar() } else { a.foo() - c.bar() + c.bar() } a?.foo() @@ -109,7 +109,7 @@ fun f13(a : A?) { } else { a?.foo() - c.bar() + c.bar() } if (!(a is B) || !(a is C)) { @@ -202,7 +202,7 @@ fun mergeSmartCasts(a: Any?) { val i: Int = a.compareTo("") } if (a is String && a.compareTo("") == 0) {} - if (a is String || a.compareTo("") == 0) {} + if (a is String || a.compareTo("") == 0) {} } //mutability diff --git a/compiler/testData/diagnostics/tests/inline/binaryExpressions/mathOperations.fir.kt b/compiler/testData/diagnostics/tests/inline/binaryExpressions/mathOperations.fir.kt index 16901d9e259..d641299f7b2 100644 --- a/compiler/testData/diagnostics/tests/inline/binaryExpressions/mathOperations.fir.kt +++ b/compiler/testData/diagnostics/tests/inline/binaryExpressions/mathOperations.fir.kt @@ -15,15 +15,15 @@ inline operator fun @ExtensionFunctionType Function2.plus(p: this - p } -inline fun inlineFunWithInvoke(s: (p: T) -> U, ext: T.(p: U) -> V) { +inline fun inlineFunWithInvoke(s: (p: T) -> U, ext: T.(p: U) -> V) { s + s ext + ext -} +} -inline fun inlineFunWithInvoke(s: (p: T) -> U, ext: T.(p: U) -> V) { +inline fun inlineFunWithInvoke(s: (p: T) -> U, ext: T.(p: U) -> V) { s + s ext + ext -} +} inline fun Function1.submit() { this + this diff --git a/compiler/testData/diagnostics/tests/inline/kt15410.fir.kt b/compiler/testData/diagnostics/tests/inline/kt15410.fir.kt index 5ab655383bb..3f918cef175 100644 --- a/compiler/testData/diagnostics/tests/inline/kt15410.fir.kt +++ b/compiler/testData/diagnostics/tests/inline/kt15410.fir.kt @@ -7,4 +7,4 @@ inline fun foo(f: () -> Unit) = object: Foo() {} class A : Foo() { inline fun foo(f: () -> Unit) = Foo() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/inline/kt15410.kt b/compiler/testData/diagnostics/tests/inline/kt15410.kt index f2421a1319f..4946119d85a 100644 --- a/compiler/testData/diagnostics/tests/inline/kt15410.kt +++ b/compiler/testData/diagnostics/tests/inline/kt15410.kt @@ -6,5 +6,5 @@ open class Foo protected constructor() inline fun foo(f: () -> Unit) = object: Foo() {} class A : Foo() { - inline fun foo(f: () -> Unit) = Foo() -} \ No newline at end of file + inline fun foo(f: () -> Unit) = Foo() +} diff --git a/compiler/testData/diagnostics/tests/inline/nonLocalReturns/lambdaAsGeneric.fir.kt b/compiler/testData/diagnostics/tests/inline/nonLocalReturns/lambdaAsGeneric.fir.kt index acb2535e663..c41c4bee41e 100644 --- a/compiler/testData/diagnostics/tests/inline/nonLocalReturns/lambdaAsGeneric.fir.kt +++ b/compiler/testData/diagnostics/tests/inline/nonLocalReturns/lambdaAsGeneric.fir.kt @@ -10,4 +10,4 @@ fun box() : String { inline fun test(p: T) { p.toString() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/inline/nonLocalReturns/lambdaAsGeneric.kt b/compiler/testData/diagnostics/tests/inline/nonLocalReturns/lambdaAsGeneric.kt index 5354f13093f..80dd51c42ad 100644 --- a/compiler/testData/diagnostics/tests/inline/nonLocalReturns/lambdaAsGeneric.kt +++ b/compiler/testData/diagnostics/tests/inline/nonLocalReturns/lambdaAsGeneric.kt @@ -1,7 +1,7 @@ // !WITH_NEW_INFERENCE fun box() : String { - test { + test { return@box "123" } @@ -10,4 +10,4 @@ fun box() : String { inline fun test(p: T) { p.toString() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/inline/nonPublicMember/publishedApi.fir.kt b/compiler/testData/diagnostics/tests/inline/nonPublicMember/publishedApi.fir.kt index 256104c9f47..9c03541d22a 100644 --- a/compiler/testData/diagnostics/tests/inline/nonPublicMember/publishedApi.fir.kt +++ b/compiler/testData/diagnostics/tests/inline/nonPublicMember/publishedApi.fir.kt @@ -1,7 +1,7 @@ // !DIAGNOSTICS: -EXPOSED_PARAMETER_TYPE -NOTHING_TO_INLINE -inline fun call(a: A) { +inline fun call(a: A) { a.test() privateFun() @@ -45,4 +45,4 @@ private fun privateFun() { internal fun internalFun() { -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/inline/nonPublicMember/publishedApi.kt b/compiler/testData/diagnostics/tests/inline/nonPublicMember/publishedApi.kt index a6136f84109..238a1580f88 100644 --- a/compiler/testData/diagnostics/tests/inline/nonPublicMember/publishedApi.kt +++ b/compiler/testData/diagnostics/tests/inline/nonPublicMember/publishedApi.kt @@ -45,4 +45,4 @@ private fun privateFun() { internal fun internalFun() { -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/inline/privateClass.fir.kt b/compiler/testData/diagnostics/tests/inline/privateClass.fir.kt index 6c1705a771c..eacf2e30adb 100644 --- a/compiler/testData/diagnostics/tests/inline/privateClass.fir.kt +++ b/compiler/testData/diagnostics/tests/inline/privateClass.fir.kt @@ -6,7 +6,7 @@ private class S public constructor() { } } -internal inline fun x(s: S, z: () -> Unit) { +internal inline fun x(s: S, z: () -> Unit) { z() S() s.a() @@ -22,4 +22,4 @@ private inline fun x2(s: S, z: () -> Unit) { private fun test(): S { return S() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/inline/privateClass.kt b/compiler/testData/diagnostics/tests/inline/privateClass.kt index 15e1cfd7dba..c68bd5d2a77 100644 --- a/compiler/testData/diagnostics/tests/inline/privateClass.kt +++ b/compiler/testData/diagnostics/tests/inline/privateClass.kt @@ -22,4 +22,4 @@ private inline fun x2(s: S, z: () -> Unit) { private fun test(): S { return S() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/inline/property/propertyWithBackingField.fir.kt b/compiler/testData/diagnostics/tests/inline/property/propertyWithBackingField.fir.kt index d857444247e..39a890ae51d 100644 --- a/compiler/testData/diagnostics/tests/inline/property/propertyWithBackingField.fir.kt +++ b/compiler/testData/diagnostics/tests/inline/property/propertyWithBackingField.fir.kt @@ -1,4 +1,5 @@ // WITH_REFLECT +// WITH_RUNTIME import kotlin.reflect.KProperty diff --git a/compiler/testData/diagnostics/tests/inline/property/propertyWithBackingField.kt b/compiler/testData/diagnostics/tests/inline/property/propertyWithBackingField.kt index 65af2083da2..dd07b222fc8 100644 --- a/compiler/testData/diagnostics/tests/inline/property/propertyWithBackingField.kt +++ b/compiler/testData/diagnostics/tests/inline/property/propertyWithBackingField.kt @@ -1,4 +1,5 @@ // WITH_REFLECT +// WITH_RUNTIME import kotlin.reflect.KProperty diff --git a/compiler/testData/diagnostics/tests/inline/publishedApi.fir.kt b/compiler/testData/diagnostics/tests/inline/publishedApi.fir.kt index 710e5f7d9ee..02f7b85ffd2 100644 --- a/compiler/testData/diagnostics/tests/inline/publishedApi.fir.kt +++ b/compiler/testData/diagnostics/tests/inline/publishedApi.fir.kt @@ -1,5 +1,5 @@ // !DIAGNOSTICS: -EXPOSED_PARAMETER_TYPE -NOTHING_TO_INLINE -inline fun call(a: A) { +inline fun call(a: A) { a.test() publishedTopLevel() @@ -172,4 +172,4 @@ var publicVarTopLevel = 1 internal var internalVarTopLevel = 1 -private var privateVarTopLevel = 1 \ No newline at end of file +private var privateVarTopLevel = 1 diff --git a/compiler/testData/diagnostics/tests/inline/publishedApi.kt b/compiler/testData/diagnostics/tests/inline/publishedApi.kt index 99840bbfe1c..bb08464c881 100644 --- a/compiler/testData/diagnostics/tests/inline/publishedApi.kt +++ b/compiler/testData/diagnostics/tests/inline/publishedApi.kt @@ -172,4 +172,4 @@ var publicVarTopLevel = 1 internal var internalVarTopLevel = 1 -private var privateVarTopLevel = 1 \ No newline at end of file +private var privateVarTopLevel = 1 diff --git a/compiler/testData/diagnostics/tests/inlineClasses/presenceOfInitializerBlockInsideInlineClass.kt b/compiler/testData/diagnostics/tests/inlineClasses/presenceOfInitializerBlockInsideInlineClass.kt index 78df5903e38..7def378d5e2 100644 --- a/compiler/testData/diagnostics/tests/inlineClasses/presenceOfInitializerBlockInsideInlineClass.kt +++ b/compiler/testData/diagnostics/tests/inlineClasses/presenceOfInitializerBlockInsideInlineClass.kt @@ -1,6 +1,6 @@ +// FIR_IDENTICAL // !LANGUAGE: +InlineClasses // !DIAGNOSTICS: -UNUSED_VARIABLE -// FIR_IDENTICAL inline class Foo(val x: Int) { init {} diff --git a/compiler/testData/diagnostics/tests/inlineClasses/presenceOfPublicPrimaryConstructorForInlineClass.kt b/compiler/testData/diagnostics/tests/inlineClasses/presenceOfPublicPrimaryConstructorForInlineClass.kt index a0863381f7e..0224c26082e 100644 --- a/compiler/testData/diagnostics/tests/inlineClasses/presenceOfPublicPrimaryConstructorForInlineClass.kt +++ b/compiler/testData/diagnostics/tests/inlineClasses/presenceOfPublicPrimaryConstructorForInlineClass.kt @@ -1,5 +1,5 @@ -// !LANGUAGE: +InlineClasses // FIR_IDENTICAL +// !LANGUAGE: +InlineClasses inline class ConstructorWithDefaultVisibility(val x: Int) inline class PublicConstructor public constructor(val x: Int) diff --git a/compiler/testData/diagnostics/tests/inlineClasses/varPropertyWithInlineClassReceiver.kt b/compiler/testData/diagnostics/tests/inlineClasses/varPropertyWithInlineClassReceiver.kt index e005b0cbf2a..b47aed89b60 100644 --- a/compiler/testData/diagnostics/tests/inlineClasses/varPropertyWithInlineClassReceiver.kt +++ b/compiler/testData/diagnostics/tests/inlineClasses/varPropertyWithInlineClassReceiver.kt @@ -9,4 +9,4 @@ inline class IC(val a: Any) { var IC.extension: Any get() = a - set(value) {} \ No newline at end of file + set(value) {} diff --git a/compiler/testData/diagnostics/tests/inner/innerThisSuper.kt b/compiler/testData/diagnostics/tests/inner/innerThisSuper.kt index 4d38f0523c5..19c0259177f 100644 --- a/compiler/testData/diagnostics/tests/inner/innerThisSuper.kt +++ b/compiler/testData/diagnostics/tests/inner/innerThisSuper.kt @@ -19,4 +19,4 @@ class Outer : Trait { val t = this@Outer.bar() val s = super@Outer.bar() } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/inner/nestedClassAccessedViaInstanceReference.kt b/compiler/testData/diagnostics/tests/inner/nestedClassAccessedViaInstanceReference.kt index 8a773d7b240..64be57590f5 100644 --- a/compiler/testData/diagnostics/tests/inner/nestedClassAccessedViaInstanceReference.kt +++ b/compiler/testData/diagnostics/tests/inner/nestedClassAccessedViaInstanceReference.kt @@ -50,4 +50,4 @@ fun test(with: WithClassObject, without: WithoutClassObject, obj: Obj) { obj.NestedObj obj.NestedObj() obj.NestedObj.foo() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/inner/qualifiedExpression/genericNestedClass.kt b/compiler/testData/diagnostics/tests/inner/qualifiedExpression/genericNestedClass.kt index da716cf468c..884c9fb8584 100644 --- a/compiler/testData/diagnostics/tests/inner/qualifiedExpression/genericNestedClass.kt +++ b/compiler/testData/diagnostics/tests/inner/qualifiedExpression/genericNestedClass.kt @@ -5,6 +5,6 @@ class Outer { } fun nested() = Outer.Nested() -fun noArguments() = Outer.Nested() +fun noArguments() = Outer.Nested() fun noArgumentsExpectedType(): Outer.Nested = Outer.Nested() fun manyArguments() = Outer.Nested() diff --git a/compiler/testData/diagnostics/tests/j+k/differentFilename.fir.kt b/compiler/testData/diagnostics/tests/j+k/differentFilename.fir.kt index b0ae18cce3c..59ed771217c 100644 --- a/compiler/testData/diagnostics/tests/j+k/differentFilename.fir.kt +++ b/compiler/testData/diagnostics/tests/j+k/differentFilename.fir.kt @@ -1,4 +1,4 @@ -// JAVAC_SKIP +// SKIP_JAVAC // FILE: A.java public class A { public B b() {} diff --git a/compiler/testData/diagnostics/tests/j+k/differentFilename.kt b/compiler/testData/diagnostics/tests/j+k/differentFilename.kt index 9b712e67acd..545704650fc 100644 --- a/compiler/testData/diagnostics/tests/j+k/differentFilename.kt +++ b/compiler/testData/diagnostics/tests/j+k/differentFilename.kt @@ -1,4 +1,4 @@ -// JAVAC_SKIP +// SKIP_JAVAC // FILE: A.java public class A { public B b() {} diff --git a/compiler/testData/diagnostics/tests/j+k/genericConstructor/classTypeParameterInferredFromArgument.kt b/compiler/testData/diagnostics/tests/j+k/genericConstructor/classTypeParameterInferredFromArgument.kt index aaacea638de..448249692cd 100644 --- a/compiler/testData/diagnostics/tests/j+k/genericConstructor/classTypeParameterInferredFromArgument.kt +++ b/compiler/testData/diagnostics/tests/j+k/genericConstructor/classTypeParameterInferredFromArgument.kt @@ -9,9 +9,9 @@ public class A { // FILE: main.kt fun test(x: List, y: List) { - A("", x) checkType { _>() } + A("", x) checkType { _>() } A("", y) checkType { _>() } - A("", x) + A("", x) A("", y) } diff --git a/compiler/testData/diagnostics/tests/j+k/genericConstructor/innerClass.kt b/compiler/testData/diagnostics/tests/j+k/genericConstructor/innerClass.kt index 9b45fba814c..fd9bb366698 100644 --- a/compiler/testData/diagnostics/tests/j+k/genericConstructor/innerClass.kt +++ b/compiler/testData/diagnostics/tests/j+k/genericConstructor/innerClass.kt @@ -13,6 +13,6 @@ fun test(x: List, y: List) { Outer().Inner("", y, 1) checkType { _.Inner>() } Outer().Inner("", y, 1) checkType { _.Inner>() } - Outer().Inner("", x, 1) checkType { _.Inner>() } - Outer().Inner("", x, 1) + Outer().Inner("", x, 1) checkType { _.Inner>() } + Outer().Inner("", x, 1) } diff --git a/compiler/testData/diagnostics/tests/j+k/genericConstructor/noClassTypeParametersInvParameter.kt b/compiler/testData/diagnostics/tests/j+k/genericConstructor/noClassTypeParametersInvParameter.kt index f06758b278c..fb1b0079501 100644 --- a/compiler/testData/diagnostics/tests/j+k/genericConstructor/noClassTypeParametersInvParameter.kt +++ b/compiler/testData/diagnostics/tests/j+k/genericConstructor/noClassTypeParametersInvParameter.kt @@ -10,12 +10,12 @@ public class A { class Inv fun test(x: Inv, y: Inv) { - A("", x) + A("", x) A("", y) - A("", x) + A("", x) - A("", x) + A("", x) A("", y) A("", y) } diff --git a/compiler/testData/diagnostics/tests/j+k/genericConstructor/recursive.kt b/compiler/testData/diagnostics/tests/j+k/genericConstructor/recursive.kt index 1be2d3fb5a1..cee6eaeff2b 100644 --- a/compiler/testData/diagnostics/tests/j+k/genericConstructor/recursive.kt +++ b/compiler/testData/diagnostics/tests/j+k/genericConstructor/recursive.kt @@ -9,4 +9,4 @@ public class C { // FILE: main.kt -fun foo() = C() +fun foo() = C() diff --git a/compiler/testData/diagnostics/tests/j+k/genericConstructor/superCall.kt b/compiler/testData/diagnostics/tests/j+k/genericConstructor/superCall.kt index fac99ec5df8..852545278fe 100644 --- a/compiler/testData/diagnostics/tests/j+k/genericConstructor/superCall.kt +++ b/compiler/testData/diagnostics/tests/j+k/genericConstructor/superCall.kt @@ -10,9 +10,9 @@ public class A { // FILE: main.kt class B1(x: List) : A("", x) -class B2(x: List) : A("", x) +class B2(x: List) : A("", x) class C : A { constructor(x: List) : super("", x) - constructor(x: List, y: Int) : super("", x) + constructor(x: List, y: Int) : super("", x) } diff --git a/compiler/testData/diagnostics/tests/j+k/genericConstructor/superCallImpossibleToInfer.kt b/compiler/testData/diagnostics/tests/j+k/genericConstructor/superCallImpossibleToInfer.kt index a1501124a88..c9235bef874 100644 --- a/compiler/testData/diagnostics/tests/j+k/genericConstructor/superCallImpossibleToInfer.kt +++ b/compiler/testData/diagnostics/tests/j+k/genericConstructor/superCallImpossibleToInfer.kt @@ -12,10 +12,10 @@ public class A { // TODO: It's effectively impossible to perform super call to such constructor // if there is not enough information to infer corresponding arguments // May be we could add some special syntax for such arguments -class B1(x: List) : A("", x) -class B2(x: List) : A("", x) +class B1(x: List) : A("", x) +class B2(x: List) : A("", x) class C : A { - constructor(x: List) : super("", x) - constructor(x: List, y: Int) : super("", x) + constructor(x: List) : super("", x) + constructor(x: List, y: Int) : super("", x) } diff --git a/compiler/testData/diagnostics/tests/j+k/genericConstructorWithMultipleBounds.kt b/compiler/testData/diagnostics/tests/j+k/genericConstructorWithMultipleBounds.kt index 7a807f41e85..ec44ac464fe 100644 --- a/compiler/testData/diagnostics/tests/j+k/genericConstructorWithMultipleBounds.kt +++ b/compiler/testData/diagnostics/tests/j+k/genericConstructorWithMultipleBounds.kt @@ -11,8 +11,8 @@ public class J { import java.io.Serializable -fun cloneable(c: Cloneable) = J(c) +fun cloneable(c: Cloneable) = J(c) -fun serializable(s: Serializable) = J(s) +fun serializable(s: Serializable) = J(s) fun both(t: T) where T : Cloneable, T : Serializable = J(t) diff --git a/compiler/testData/diagnostics/tests/j+k/kt36856.fir.kt b/compiler/testData/diagnostics/tests/j+k/kt36856.fir.kt deleted file mode 100644 index 3be6d64511f..00000000000 --- a/compiler/testData/diagnostics/tests/j+k/kt36856.fir.kt +++ /dev/null @@ -1,19 +0,0 @@ -// !CHECK_TYPE -// FILE: Test.java -public class Test { - public T with(Foo matcher) { - return null; - } - public boolean with(Foo matcher) { - return false; - } -} - -// FILE: main.kt -class Foo -fun main(foo1: Foo, foo2: Foo) { - val x = object : Test() {} // FE exception is thrown here - - x.with(foo1) checkType { _() } - x.with(foo2) checkType { _() } -} diff --git a/compiler/testData/diagnostics/tests/j+k/kt36856.kt b/compiler/testData/diagnostics/tests/j+k/kt36856.kt index 45a424773a3..c3fe76b4d18 100644 --- a/compiler/testData/diagnostics/tests/j+k/kt36856.kt +++ b/compiler/testData/diagnostics/tests/j+k/kt36856.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // !CHECK_TYPE // FILE: Test.java public class Test { diff --git a/compiler/testData/diagnostics/tests/j+k/packageVisibility.kt b/compiler/testData/diagnostics/tests/j+k/packageVisibility.kt index 0dd93379278..5e2fcf02cc7 100644 --- a/compiler/testData/diagnostics/tests/j+k/packageVisibility.kt +++ b/compiler/testData/diagnostics/tests/j+k/packageVisibility.kt @@ -41,4 +41,4 @@ val mc1 = M val x = MyJavaClass.staticMethod() val y = MyJavaClass.NestedClass.staticMethodOfNested() -val z = MyJavaClass.NestedClass() \ No newline at end of file +val z = MyJavaClass.NestedClass() diff --git a/compiler/testData/diagnostics/tests/j+k/sam/enhancedSamConstructor.kt b/compiler/testData/diagnostics/tests/j+k/sam/enhancedSamConstructor.kt index 472abc6bf48..668a31570fa 100644 --- a/compiler/testData/diagnostics/tests/j+k/sam/enhancedSamConstructor.kt +++ b/compiler/testData/diagnostics/tests/j+k/sam/enhancedSamConstructor.kt @@ -16,13 +16,13 @@ public interface J2 extends J { // FILE: main.kt fun main() { - J { s: String -> s} // should be prohibited, because SAM value parameter has nullable type + J { s: String -> s} // should be prohibited, because SAM value parameter has nullable type J { "" + it.length } - J { null } - J { it?.length?.toString() } + J { null } + J { it?.length?.toString() } - J2 { s: String -> s} + J2 { s: String -> s} J2 { "" + it.length } - J2 { null } - J2 { it?.length?.toString() } + J2 { null } + J2 { it?.length?.toString() } } diff --git a/compiler/testData/diagnostics/tests/j+k/sam/privateCandidatesWithWrongArguments.kt b/compiler/testData/diagnostics/tests/j+k/sam/privateCandidatesWithWrongArguments.kt index 26d15658ffa..8e03cd3828f 100644 --- a/compiler/testData/diagnostics/tests/j+k/sam/privateCandidatesWithWrongArguments.kt +++ b/compiler/testData/diagnostics/tests/j+k/sam/privateCandidatesWithWrongArguments.kt @@ -18,4 +18,4 @@ package bar fun main() { foo.A.f {} -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/j+k/sam/referenceToSamFunctionAgainstExpectedType.kt b/compiler/testData/diagnostics/tests/j+k/sam/referenceToSamFunctionAgainstExpectedType.kt index 3b93f3042c6..9250bf81ac7 100644 --- a/compiler/testData/diagnostics/tests/j+k/sam/referenceToSamFunctionAgainstExpectedType.kt +++ b/compiler/testData/diagnostics/tests/j+k/sam/referenceToSamFunctionAgainstExpectedType.kt @@ -21,4 +21,4 @@ fun test(inv: Inv) { take(inv::map) } -fun take(f: ((String) -> String) -> Inv) {} \ No newline at end of file +fun take(f: ((String) -> String) -> Inv) {} diff --git a/compiler/testData/diagnostics/tests/j+k/samByProjectedType/genericInReturnType.kt b/compiler/testData/diagnostics/tests/j+k/samByProjectedType/genericInReturnType.kt index d5cbb3e3f9b..c4c1b925342 100644 --- a/compiler/testData/diagnostics/tests/j+k/samByProjectedType/genericInReturnType.kt +++ b/compiler/testData/diagnostics/tests/j+k/samByProjectedType/genericInReturnType.kt @@ -34,7 +34,7 @@ fun main() { } A.baz { - x -> x.hashCode() + x -> x.hashCode() } val block: (String) -> Any? = { diff --git a/compiler/testData/diagnostics/tests/j+k/serializable.kt b/compiler/testData/diagnostics/tests/j+k/serializable.kt index 1f4a6f031e5..38be344f048 100644 --- a/compiler/testData/diagnostics/tests/j+k/serializable.kt +++ b/compiler/testData/diagnostics/tests/j+k/serializable.kt @@ -57,4 +57,4 @@ package aa; public class A { public static void use(java.io.Serializable s) { } public static void useList(java.util.List s) { } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/j+k/wrongVarianceInJava.kt b/compiler/testData/diagnostics/tests/j+k/wrongVarianceInJava.kt index f1bfaa68674..c4bdfdd1563 100644 --- a/compiler/testData/diagnostics/tests/j+k/wrongVarianceInJava.kt +++ b/compiler/testData/diagnostics/tests/j+k/wrongVarianceInJava.kt @@ -20,5 +20,5 @@ class In { fun test() { A.foo().x() checkType { _() } - A.bar().y(null) + A.bar().y(null) } diff --git a/compiler/testData/diagnostics/tests/library/Collections.kt b/compiler/testData/diagnostics/tests/library/Collections.kt index 0cd0c7e695e..fe7dd330ad2 100644 --- a/compiler/testData/diagnostics/tests/library/Collections.kt +++ b/compiler/testData/diagnostics/tests/library/Collections.kt @@ -108,4 +108,4 @@ fun testMutableMap(m: MutableMap) { val mutableSet1: MutableSet> = m.entries } -fun array(vararg t: T): Array {} \ No newline at end of file +fun array(vararg t: T): Array {} diff --git a/compiler/testData/diagnostics/tests/modifiers/const/applicability.fir.kt b/compiler/testData/diagnostics/tests/modifiers/const/applicability.fir.kt index f500a17d974..b6d572f84d9 100644 --- a/compiler/testData/diagnostics/tests/modifiers/const/applicability.fir.kt +++ b/compiler/testData/diagnostics/tests/modifiers/const/applicability.fir.kt @@ -1,4 +1,4 @@ -// !DIAGNOSTICS:-UNUSED_VARIABLE,-CAST_NEVER_SUCCEEDS,-DIVISION_BY_ZERO +// !DIAGNOSTICS: -UNUSED_VARIABLE -CAST_NEVER_SUCCEEDS -DIVISION_BY_ZERO import kotlin.reflect.KProperty diff --git a/compiler/testData/diagnostics/tests/modifiers/const/applicability.kt b/compiler/testData/diagnostics/tests/modifiers/const/applicability.kt index ffa79e0fe1e..6b53b8d7874 100644 --- a/compiler/testData/diagnostics/tests/modifiers/const/applicability.kt +++ b/compiler/testData/diagnostics/tests/modifiers/const/applicability.kt @@ -1,4 +1,4 @@ -// !DIAGNOSTICS:-UNUSED_VARIABLE,-CAST_NEVER_SUCCEEDS,-DIVISION_BY_ZERO +// !DIAGNOSTICS: -UNUSED_VARIABLE -CAST_NEVER_SUCCEEDS -DIVISION_BY_ZERO import kotlin.reflect.KProperty diff --git a/compiler/testData/diagnostics/tests/modifiers/const/arrayInAnnotationArgumentType.fir.kt b/compiler/testData/diagnostics/tests/modifiers/const/arrayInAnnotationArgumentType.fir.kt index 1eb5fb247ea..b0b57c817da 100644 --- a/compiler/testData/diagnostics/tests/modifiers/const/arrayInAnnotationArgumentType.fir.kt +++ b/compiler/testData/diagnostics/tests/modifiers/const/arrayInAnnotationArgumentType.fir.kt @@ -1,3 +1,3 @@ // !WITH_NEW_INFERENCE annotation class A(val a: IntArray = arrayOf(1)) -annotation class B(val a: IntArray = intArrayOf(1)) \ No newline at end of file +annotation class B(val a: IntArray = intArrayOf(1)) diff --git a/compiler/testData/diagnostics/tests/modifiers/const/arrayInAnnotationArgumentType.kt b/compiler/testData/diagnostics/tests/modifiers/const/arrayInAnnotationArgumentType.kt index 234ee876117..855b8c22283 100644 --- a/compiler/testData/diagnostics/tests/modifiers/const/arrayInAnnotationArgumentType.kt +++ b/compiler/testData/diagnostics/tests/modifiers/const/arrayInAnnotationArgumentType.kt @@ -1,3 +1,3 @@ // !WITH_NEW_INFERENCE -annotation class A(val a: IntArray = arrayOf(1)) -annotation class B(val a: IntArray = intArrayOf(1)) \ No newline at end of file +annotation class A(val a: IntArray = arrayOf(1)) +annotation class B(val a: IntArray = intArrayOf(1)) diff --git a/compiler/testData/diagnostics/tests/modifiers/operatorInfix/MemberFunctions.kt b/compiler/testData/diagnostics/tests/modifiers/operatorInfix/MemberFunctions.kt index 118c18e1137..08ef0773ee0 100644 --- a/compiler/testData/diagnostics/tests/modifiers/operatorInfix/MemberFunctions.kt +++ b/compiler/testData/diagnostics/tests/modifiers/operatorInfix/MemberFunctions.kt @@ -42,4 +42,4 @@ fun a() { } fun consumeInt(i: Int) {} -fun consumeString(s: String) {} \ No newline at end of file +fun consumeString(s: String) {} diff --git a/compiler/testData/diagnostics/tests/multimodule/duplicateClass/differentGenericArguments.txt b/compiler/testData/diagnostics/tests/multimodule/duplicateClass/differentGenericArguments.txt index 298558bf59a..fa343d01245 100644 --- a/compiler/testData/diagnostics/tests/multimodule/duplicateClass/differentGenericArguments.txt +++ b/compiler/testData/diagnostics/tests/multimodule/duplicateClass/differentGenericArguments.txt @@ -19,7 +19,6 @@ package p { } } - // -- Module: -- package @@ -34,8 +33,8 @@ package p { } } - // -- Module: -- package public fun test(): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/multimodule/duplicateClass/differentGenericArgumentsReversed.txt b/compiler/testData/diagnostics/tests/multimodule/duplicateClass/differentGenericArgumentsReversed.txt index 862a633d9be..8dd7ca063d8 100644 --- a/compiler/testData/diagnostics/tests/multimodule/duplicateClass/differentGenericArgumentsReversed.txt +++ b/compiler/testData/diagnostics/tests/multimodule/duplicateClass/differentGenericArgumentsReversed.txt @@ -19,7 +19,6 @@ package p { } } - // -- Module: -- package @@ -34,8 +33,8 @@ package p { } } - // -- Module: -- package public fun test(): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/multimodule/duplicateClass/duplicateClass.txt b/compiler/testData/diagnostics/tests/multimodule/duplicateClass/duplicateClass.txt index 4a47222838a..e167260ac89 100644 --- a/compiler/testData/diagnostics/tests/multimodule/duplicateClass/duplicateClass.txt +++ b/compiler/testData/diagnostics/tests/multimodule/duplicateClass/duplicateClass.txt @@ -19,7 +19,6 @@ package p { } } - // -- Module: -- package @@ -35,8 +34,8 @@ package p { } } - // -- Module: -- package public fun test(): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/multimodule/duplicateClass/duplicateNestedClasses.txt b/compiler/testData/diagnostics/tests/multimodule/duplicateClass/duplicateNestedClasses.txt index 042ee7a5fe4..412c4778ecc 100644 --- a/compiler/testData/diagnostics/tests/multimodule/duplicateClass/duplicateNestedClasses.txt +++ b/compiler/testData/diagnostics/tests/multimodule/duplicateClass/duplicateNestedClasses.txt @@ -74,7 +74,6 @@ package p { } } - // -- Module: -- package @@ -144,8 +143,8 @@ package p { } } - // -- Module: -- package public fun test(/*0*/ m1: p.M1): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/multimodule/duplicateClass/duplicateSuperClass.txt b/compiler/testData/diagnostics/tests/multimodule/duplicateClass/duplicateSuperClass.txt index 02213b764aa..1cb91d74907 100644 --- a/compiler/testData/diagnostics/tests/multimodule/duplicateClass/duplicateSuperClass.txt +++ b/compiler/testData/diagnostics/tests/multimodule/duplicateClass/duplicateSuperClass.txt @@ -25,7 +25,6 @@ package p { } } - // -- Module: -- package @@ -39,8 +38,8 @@ package p { } } - // -- Module: -- package public fun test(): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/multimodule/duplicateClass/genericArgumentNumberMismatch.txt b/compiler/testData/diagnostics/tests/multimodule/duplicateClass/genericArgumentNumberMismatch.txt index 09ee56f2780..e709e60a9ae 100644 --- a/compiler/testData/diagnostics/tests/multimodule/duplicateClass/genericArgumentNumberMismatch.txt +++ b/compiler/testData/diagnostics/tests/multimodule/duplicateClass/genericArgumentNumberMismatch.txt @@ -19,7 +19,6 @@ package p { } } - // -- Module: -- package @@ -34,8 +33,8 @@ package p { } } - // -- Module: -- package public fun test(): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/multimodule/duplicateClass/genericSuperClass.txt b/compiler/testData/diagnostics/tests/multimodule/duplicateClass/genericSuperClass.txt index 6e65e2a3acf..3c59aac4748 100644 --- a/compiler/testData/diagnostics/tests/multimodule/duplicateClass/genericSuperClass.txt +++ b/compiler/testData/diagnostics/tests/multimodule/duplicateClass/genericSuperClass.txt @@ -37,7 +37,6 @@ package p { } } - // -- Module: -- package @@ -65,8 +64,8 @@ package p { } } - // -- Module: -- package public fun test(): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/multimodule/duplicateClass/inTheSameModuleWithUsage.txt b/compiler/testData/diagnostics/tests/multimodule/duplicateClass/inTheSameModuleWithUsage.txt index 6c3bb54b64a..7ec079da1b6 100644 --- a/compiler/testData/diagnostics/tests/multimodule/duplicateClass/inTheSameModuleWithUsage.txt +++ b/compiler/testData/diagnostics/tests/multimodule/duplicateClass/inTheSameModuleWithUsage.txt @@ -19,7 +19,6 @@ package p { } } - // -- Module: -- package @@ -34,3 +33,4 @@ package p { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } } + diff --git a/compiler/testData/diagnostics/tests/multimodule/duplicateClass/inTheSameModuleWithUsageNoTypeAnnotation.txt b/compiler/testData/diagnostics/tests/multimodule/duplicateClass/inTheSameModuleWithUsageNoTypeAnnotation.txt index 6c3bb54b64a..7ec079da1b6 100644 --- a/compiler/testData/diagnostics/tests/multimodule/duplicateClass/inTheSameModuleWithUsageNoTypeAnnotation.txt +++ b/compiler/testData/diagnostics/tests/multimodule/duplicateClass/inTheSameModuleWithUsageNoTypeAnnotation.txt @@ -19,7 +19,6 @@ package p { } } - // -- Module: -- package @@ -34,3 +33,4 @@ package p { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } } + diff --git a/compiler/testData/diagnostics/tests/multimodule/duplicateClass/members.txt b/compiler/testData/diagnostics/tests/multimodule/duplicateClass/members.txt index c85023fa316..0092b424d8f 100644 --- a/compiler/testData/diagnostics/tests/multimodule/duplicateClass/members.txt +++ b/compiler/testData/diagnostics/tests/multimodule/duplicateClass/members.txt @@ -20,7 +20,6 @@ package p { } } - // -- Module: -- package @@ -43,8 +42,8 @@ package p { } } - // -- Module: -- package public fun test(/*0*/ a: p.A): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/multimodule/duplicateClass/sameClassNameDifferentPackages.txt b/compiler/testData/diagnostics/tests/multimodule/duplicateClass/sameClassNameDifferentPackages.txt index 9586c2cdd58..181dcfe58af 100644 --- a/compiler/testData/diagnostics/tests/multimodule/duplicateClass/sameClassNameDifferentPackages.txt +++ b/compiler/testData/diagnostics/tests/multimodule/duplicateClass/sameClassNameDifferentPackages.txt @@ -19,7 +19,6 @@ package p { } } - // -- Module: -- package @@ -31,3 +30,4 @@ public final class A { public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } + diff --git a/compiler/testData/diagnostics/tests/multimodule/duplicateClass/sameGenericArguments.txt b/compiler/testData/diagnostics/tests/multimodule/duplicateClass/sameGenericArguments.txt index 245adac56cc..3094057b42c 100644 --- a/compiler/testData/diagnostics/tests/multimodule/duplicateClass/sameGenericArguments.txt +++ b/compiler/testData/diagnostics/tests/multimodule/duplicateClass/sameGenericArguments.txt @@ -19,7 +19,6 @@ package p { } } - // -- Module: -- package @@ -34,8 +33,8 @@ package p { } } - // -- Module: -- package public fun test(): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classGenericsInParams.txt b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classGenericsInParams.txt index 2e5ededd6ec..2934bafb5da 100644 --- a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classGenericsInParams.txt +++ b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classGenericsInParams.txt @@ -11,7 +11,6 @@ package p { } } - // -- Module: -- package @@ -25,7 +24,6 @@ package p { } } - // -- Module: -- package @@ -39,8 +37,8 @@ package p { } } - // -- Module: -- package public fun test(/*0*/ b: p.B?): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classGenericsInParamsBoundMismatch.txt b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classGenericsInParamsBoundMismatch.txt index 17e221a128b..d3eba28f884 100644 --- a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classGenericsInParamsBoundMismatch.txt +++ b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classGenericsInParamsBoundMismatch.txt @@ -11,7 +11,6 @@ package p { } } - // -- Module: -- package @@ -25,7 +24,6 @@ package p { } } - // -- Module: -- package @@ -45,8 +43,8 @@ package p { } } - // -- Module: -- package public fun test(/*0*/ b: p.B?): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classGenericsInParamsIndexMismatch.txt b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classGenericsInParamsIndexMismatch.txt index 06abb324294..3b809132bf8 100644 --- a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classGenericsInParamsIndexMismatch.txt +++ b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classGenericsInParamsIndexMismatch.txt @@ -11,7 +11,6 @@ package p { } } - // -- Module: -- package @@ -25,7 +24,6 @@ package p { } } - // -- Module: -- package @@ -39,8 +37,8 @@ package p { } } - // -- Module: -- package public fun test(/*0*/ b: p.B?): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classGenericsInParamsNameMismatch.txt b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classGenericsInParamsNameMismatch.txt index 763f5b64969..59dc9154700 100644 --- a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classGenericsInParamsNameMismatch.txt +++ b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classGenericsInParamsNameMismatch.txt @@ -11,7 +11,6 @@ package p { } } - // -- Module: -- package @@ -25,7 +24,6 @@ package p { } } - // -- Module: -- package @@ -39,8 +37,8 @@ package p { } } - // -- Module: -- package public fun test(/*0*/ b: p.B?, /*1*/ y: Y): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classGenericsInReturnType.txt b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classGenericsInReturnType.txt index 0919fdebad3..d70ac9ee160 100644 --- a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classGenericsInReturnType.txt +++ b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classGenericsInReturnType.txt @@ -11,7 +11,6 @@ package p { } } - // -- Module: -- package @@ -25,7 +24,6 @@ package p { } } - // -- Module: -- package @@ -39,8 +37,8 @@ package p { } } - // -- Module: -- package public fun test(/*0*/ b: p.B?): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classVsFunctionGenericsInParamsMismatch.fir.kt b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classVsFunctionGenericsInParamsMismatch.fir.kt index a17bb8153f9..1761ad42693 100644 --- a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classVsFunctionGenericsInParamsMismatch.fir.kt +++ b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classVsFunctionGenericsInParamsMismatch.fir.kt @@ -34,4 +34,4 @@ fun test(b: B?, c: C) { if (b is C) { b?.foo(1, 1) } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classVsFunctionGenericsInParamsMismatch.kt b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classVsFunctionGenericsInParamsMismatch.kt index 4015a6f7b91..c0be64d357b 100644 --- a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classVsFunctionGenericsInParamsMismatch.kt +++ b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classVsFunctionGenericsInParamsMismatch.kt @@ -32,6 +32,6 @@ fun test(b: B?, c: C) { b?.foo(1, 1) c.foo(1, 1) if (b is C) { - b?.foo(1, 1) + b?.foo(1, 1) } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classVsFunctionGenericsInParamsMismatch.txt b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classVsFunctionGenericsInParamsMismatch.txt index dc6bf1616d1..94de30d91f8 100644 --- a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classVsFunctionGenericsInParamsMismatch.txt +++ b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classVsFunctionGenericsInParamsMismatch.txt @@ -11,7 +11,6 @@ package p { } } - // -- Module: -- package @@ -25,7 +24,6 @@ package p { } } - // -- Module: -- package @@ -39,8 +37,8 @@ package p { } } - // -- Module: -- package public fun test(/*0*/ b: p.B?, /*1*/ c: p.C): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/covariantReturnTypes.txt b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/covariantReturnTypes.txt index 360c440f5b2..1bacba7366a 100644 --- a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/covariantReturnTypes.txt +++ b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/covariantReturnTypes.txt @@ -11,7 +11,6 @@ package p { } } - // -- Module: -- package @@ -25,7 +24,6 @@ package p { } } - // -- Module: -- package @@ -39,8 +37,8 @@ package p { } } - // -- Module: -- package public fun test(/*0*/ b: p.B?): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/differenceInParamNames.txt b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/differenceInParamNames.txt index db602f386ea..c576ff914a2 100644 --- a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/differenceInParamNames.txt +++ b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/differenceInParamNames.txt @@ -11,7 +11,6 @@ package p { } } - // -- Module: -- package @@ -25,7 +24,6 @@ package p { } } - // -- Module: -- package @@ -39,8 +37,8 @@ package p { } } - // -- Module: -- package public fun test(/*0*/ b: p.B?): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/differentGenericsInParams.txt b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/differentGenericsInParams.txt index dd9bfd77d51..8e1e32797d7 100644 --- a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/differentGenericsInParams.txt +++ b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/differentGenericsInParams.txt @@ -16,7 +16,6 @@ package p { } } - // -- Module: -- package @@ -30,7 +29,6 @@ package p { } } - // -- Module: -- package @@ -44,7 +42,6 @@ package p { } } - // -- Module: -- package @@ -58,8 +55,8 @@ package p { } } - // -- Module: -- package public fun test(/*0*/ b: p.B?): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/differentNumberOfParams.txt b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/differentNumberOfParams.txt index ead8e55e270..c2277135aa7 100644 --- a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/differentNumberOfParams.txt +++ b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/differentNumberOfParams.txt @@ -11,7 +11,6 @@ package p { } } - // -- Module: -- package @@ -25,7 +24,6 @@ package p { } } - // -- Module: -- package @@ -39,8 +37,8 @@ package p { } } - // -- Module: -- package public fun test(/*0*/ b: p.B?): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/differentReturnTypes.txt b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/differentReturnTypes.txt index 419094cbcc2..30903712481 100644 --- a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/differentReturnTypes.txt +++ b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/differentReturnTypes.txt @@ -11,7 +11,6 @@ package p { } } - // -- Module: -- package @@ -25,7 +24,6 @@ package p { } } - // -- Module: -- package @@ -39,8 +37,8 @@ package p { } } - // -- Module: -- package public fun test(/*0*/ b: p.B?): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/extensionMatch.txt b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/extensionMatch.txt index 682114ec31c..e301b994198 100644 --- a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/extensionMatch.txt +++ b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/extensionMatch.txt @@ -11,7 +11,6 @@ package p { } } - // -- Module: -- package @@ -26,7 +25,6 @@ package p { } } - // -- Module: -- package @@ -40,8 +38,8 @@ package p { } } - // -- Module: -- package public fun p.B.test(): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/functionGenericsInParams.txt b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/functionGenericsInParams.txt index 98822761a81..15602c2ba52 100644 --- a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/functionGenericsInParams.txt +++ b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/functionGenericsInParams.txt @@ -11,7 +11,6 @@ package p { } } - // -- Module: -- package @@ -25,7 +24,6 @@ package p { } } - // -- Module: -- package @@ -39,9 +37,9 @@ package p { } } - // -- Module: -- package public fun test(/*0*/ b: p.B?): kotlin.Unit public fun test1(/*0*/ b: p.B?): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/functionGenericsInParamsBoundsMismatch.txt b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/functionGenericsInParamsBoundsMismatch.txt index cf904dd9696..4e23df891c5 100644 --- a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/functionGenericsInParamsBoundsMismatch.txt +++ b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/functionGenericsInParamsBoundsMismatch.txt @@ -11,7 +11,6 @@ package p { } } - // -- Module: -- package @@ -25,7 +24,6 @@ package p { } } - // -- Module: -- package @@ -45,8 +43,8 @@ package p { } } - // -- Module: -- package public fun test(/*0*/ b: p.B?): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/functionGenericsInParamsEqNull.txt b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/functionGenericsInParamsEqNull.txt index 21978d7665c..bb6d3bd9a0e 100644 --- a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/functionGenericsInParamsEqNull.txt +++ b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/functionGenericsInParamsEqNull.txt @@ -11,7 +11,6 @@ package p { } } - // -- Module: -- package @@ -25,7 +24,6 @@ package p { } } - // -- Module: -- package @@ -39,7 +37,6 @@ package p { } } - // -- Module: -- package @@ -47,3 +44,4 @@ public fun test(/*0*/ b: p.B?): kotlin.Unit public fun test1(/*0*/ b: p.B?): kotlin.Unit public fun test2(/*0*/ b: p.B?): kotlin.Unit public fun test3(/*0*/ b: p.B?): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/functionGenericsInParamsNotIs.txt b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/functionGenericsInParamsNotIs.txt index 98822761a81..15602c2ba52 100644 --- a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/functionGenericsInParamsNotIs.txt +++ b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/functionGenericsInParamsNotIs.txt @@ -11,7 +11,6 @@ package p { } } - // -- Module: -- package @@ -25,7 +24,6 @@ package p { } } - // -- Module: -- package @@ -39,9 +37,9 @@ package p { } } - // -- Module: -- package public fun test(/*0*/ b: p.B?): kotlin.Unit public fun test1(/*0*/ b: p.B?): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/functionGenericsInParamsReturnFooT.txt b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/functionGenericsInParamsReturnFooT.txt index 71c83edfaa9..a39c1d782f1 100644 --- a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/functionGenericsInParamsReturnFooT.txt +++ b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/functionGenericsInParamsReturnFooT.txt @@ -17,7 +17,6 @@ package p { } } - // -- Module: -- package @@ -31,7 +30,6 @@ package p { } } - // -- Module: -- package @@ -51,9 +49,9 @@ package p { } } - // -- Module: -- package public fun test(/*0*/ b: p.B?): kotlin.Unit public fun test1(/*0*/ b: p.B?): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/functionGenericsInParamsReturnT.txt b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/functionGenericsInParamsReturnT.txt index 68237b2a1d8..77f677d7929 100644 --- a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/functionGenericsInParamsReturnT.txt +++ b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/functionGenericsInParamsReturnT.txt @@ -11,7 +11,6 @@ package p { } } - // -- Module: -- package @@ -25,7 +24,6 @@ package p { } } - // -- Module: -- package @@ -39,9 +37,9 @@ package p { } } - // -- Module: -- package public fun test(/*0*/ b: p.B?): kotlin.Unit public fun test1(/*0*/ b: p.B?): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/incompleteCodeNoNoneApplicable.txt b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/incompleteCodeNoNoneApplicable.txt index c6f0cc3a9d8..df47de053a5 100644 --- a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/incompleteCodeNoNoneApplicable.txt +++ b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/incompleteCodeNoNoneApplicable.txt @@ -5,7 +5,6 @@ package p { public fun f(/*0*/ s: kotlin.String, /*1*/ t: kotlin.String): kotlin.String } - // -- Module: -- package @@ -13,8 +12,8 @@ package p { public fun f(/*0*/ s: kotlin.String, /*1*/ t: kotlin.String): kotlin.String } - // -- Module: -- package public fun test(): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/noGenericsInParams.txt b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/noGenericsInParams.txt index f0995ad9284..14a3808169a 100644 --- a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/noGenericsInParams.txt +++ b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/noGenericsInParams.txt @@ -11,7 +11,6 @@ package p { } } - // -- Module: -- package @@ -25,7 +24,6 @@ package p { } } - // -- Module: -- package @@ -39,8 +37,8 @@ package p { } } - // -- Module: -- package public fun test(/*0*/ b: p.B?): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/noParams.txt b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/noParams.txt index 0c05d9cfc00..8ed7add7a4f 100644 --- a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/noParams.txt +++ b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/noParams.txt @@ -11,7 +11,6 @@ package p { } } - // -- Module: -- package @@ -26,7 +25,6 @@ package p { } } - // -- Module: -- package @@ -40,8 +38,8 @@ package p { } } - // -- Module: -- package public fun test(/*0*/ b: p.B?): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/sameGenericsInParams.txt b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/sameGenericsInParams.txt index f3623d9097d..11cbc42e710 100644 --- a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/sameGenericsInParams.txt +++ b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/sameGenericsInParams.txt @@ -16,7 +16,6 @@ package p { } } - // -- Module: -- package @@ -30,7 +29,6 @@ package p { } } - // -- Module: -- package @@ -44,7 +42,6 @@ package p { } } - // -- Module: -- package @@ -58,8 +55,8 @@ package p { } } - // -- Module: -- package public fun test(/*0*/ b: p.B?, /*1*/ a: p.G1, /*2*/ b1: p.G2): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/simpleWithInheritance.txt b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/simpleWithInheritance.txt index c40fd69c19f..41316fd54fc 100644 --- a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/simpleWithInheritance.txt +++ b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/simpleWithInheritance.txt @@ -11,7 +11,6 @@ package p { } } - // -- Module: -- package @@ -25,7 +24,6 @@ package p { } } - // -- Module: -- package @@ -46,8 +44,8 @@ package p { } } - // -- Module: -- package public fun test(/*0*/ b: p.B?): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/sinceKotlin.txt b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/sinceKotlin.txt index f74920a9504..37b52f516a1 100644 --- a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/sinceKotlin.txt +++ b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/sinceKotlin.txt @@ -5,7 +5,6 @@ package p1 { @kotlin.SinceKotlin(version = "1.1") public fun foo(/*0*/ s: kotlin.Int): kotlin.String } - // -- Module: -- package @@ -13,9 +12,9 @@ package p2 { public fun foo(/*0*/ s: kotlin.Int): kotlin.Int } - // -- Module: -- package public fun test1(): kotlin.Int public fun test2(): kotlin.Int + diff --git a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/substitutedGenericInParams.txt b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/substitutedGenericInParams.txt index 6840cd203cd..6dd3eb4cf3a 100644 --- a/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/substitutedGenericInParams.txt +++ b/compiler/testData/diagnostics/tests/multimodule/duplicateMethod/substitutedGenericInParams.txt @@ -11,7 +11,6 @@ package p { } } - // -- Module: -- package @@ -25,7 +24,6 @@ package p { } } - // -- Module: -- package @@ -39,8 +37,8 @@ package p { } } - // -- Module: -- package public fun test(/*0*/ b: p.B?): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/multimodule/duplicateSuper/differentSuperTraits.txt b/compiler/testData/diagnostics/tests/multimodule/duplicateSuper/differentSuperTraits.txt index 44854ad1ecd..9f907fc2b8a 100644 --- a/compiler/testData/diagnostics/tests/multimodule/duplicateSuper/differentSuperTraits.txt +++ b/compiler/testData/diagnostics/tests/multimodule/duplicateSuper/differentSuperTraits.txt @@ -25,7 +25,6 @@ package p { } } - // -- Module: -- package @@ -46,7 +45,6 @@ package p { } } - // -- Module: -- package @@ -57,3 +55,4 @@ public final class Foo : p.C, p.B { public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String } + diff --git a/compiler/testData/diagnostics/tests/multimodule/duplicateSuper/sameSuperTrait.txt b/compiler/testData/diagnostics/tests/multimodule/duplicateSuper/sameSuperTrait.txt index c2ecd847cf0..b27f94166ce 100644 --- a/compiler/testData/diagnostics/tests/multimodule/duplicateSuper/sameSuperTrait.txt +++ b/compiler/testData/diagnostics/tests/multimodule/duplicateSuper/sameSuperTrait.txt @@ -18,7 +18,6 @@ package p { } } - // -- Module: -- package @@ -39,7 +38,6 @@ package p { } } - // -- Module: -- package @@ -50,3 +48,4 @@ public final class Foo : p.A, p.B { public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String } + diff --git a/compiler/testData/diagnostics/tests/multimodule/duplicateSuper/sameSuperTraitDifferentBounds.txt b/compiler/testData/diagnostics/tests/multimodule/duplicateSuper/sameSuperTraitDifferentBounds.txt index 7c4bf31fcb5..8d3df4e9e1c 100644 --- a/compiler/testData/diagnostics/tests/multimodule/duplicateSuper/sameSuperTraitDifferentBounds.txt +++ b/compiler/testData/diagnostics/tests/multimodule/duplicateSuper/sameSuperTraitDifferentBounds.txt @@ -18,7 +18,6 @@ package p { } } - // -- Module: -- package @@ -39,7 +38,6 @@ package p { } } - // -- Module: -- package @@ -51,3 +49,4 @@ public final class Foo : p.A, p.B { public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String } + diff --git a/compiler/testData/diagnostics/tests/multimodule/duplicateSuper/sameSuperTraitGenerics.txt b/compiler/testData/diagnostics/tests/multimodule/duplicateSuper/sameSuperTraitGenerics.txt index b58fdd3fcfb..cf0dd0da29c 100644 --- a/compiler/testData/diagnostics/tests/multimodule/duplicateSuper/sameSuperTraitGenerics.txt +++ b/compiler/testData/diagnostics/tests/multimodule/duplicateSuper/sameSuperTraitGenerics.txt @@ -18,7 +18,6 @@ package p { } } - // -- Module: -- package @@ -39,7 +38,6 @@ package p { } } - // -- Module: -- package @@ -50,3 +48,4 @@ public final class Foo : p.A, p.B { public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String } + diff --git a/compiler/testData/diagnostics/tests/multimodule/hiddenClass/deprecatedHiddenImportPriority.txt b/compiler/testData/diagnostics/tests/multimodule/hiddenClass/deprecatedHiddenImportPriority.txt index baa2f7f20e3..f5f5c456f75 100644 --- a/compiler/testData/diagnostics/tests/multimodule/hiddenClass/deprecatedHiddenImportPriority.txt +++ b/compiler/testData/diagnostics/tests/multimodule/hiddenClass/deprecatedHiddenImportPriority.txt @@ -12,7 +12,6 @@ package p1 { } } - // -- Module: -- package @@ -27,9 +26,9 @@ package p2 { } } - // -- Module: -- package public fun test(/*0*/ a: p1.A): kotlin.Unit public fun test(/*0*/ a: p2.A): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/multimodule/hiddenClass/deprecatedHiddenMultipleClasses.txt b/compiler/testData/diagnostics/tests/multimodule/hiddenClass/deprecatedHiddenMultipleClasses.txt index 6f2ee1bbda5..4a92e816676 100644 --- a/compiler/testData/diagnostics/tests/multimodule/hiddenClass/deprecatedHiddenMultipleClasses.txt +++ b/compiler/testData/diagnostics/tests/multimodule/hiddenClass/deprecatedHiddenMultipleClasses.txt @@ -12,7 +12,6 @@ package p1 { } } - // -- Module: -- package @@ -27,7 +26,6 @@ package p2 { } } - // -- Module: -- package @@ -42,9 +40,9 @@ package p3 { } } - // -- Module: -- package public fun test(/*0*/ a: [ERROR : A]): kotlin.Unit public fun test(/*0*/ a: p2.A): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/multimodule/hiddenClass/sinceKotlinImportPriority.txt b/compiler/testData/diagnostics/tests/multimodule/hiddenClass/sinceKotlinImportPriority.txt index 361a4dbcc69..7a9bce19f16 100644 --- a/compiler/testData/diagnostics/tests/multimodule/hiddenClass/sinceKotlinImportPriority.txt +++ b/compiler/testData/diagnostics/tests/multimodule/hiddenClass/sinceKotlinImportPriority.txt @@ -12,7 +12,6 @@ package p1 { } } - // -- Module: -- package @@ -27,9 +26,9 @@ package p2 { } } - // -- Module: -- package public fun test(/*0*/ a: p1.A): kotlin.Unit public fun test(/*0*/ a: p2.A): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/multimodule/hiddenClass/sinceKotlinMultipleClasses.txt b/compiler/testData/diagnostics/tests/multimodule/hiddenClass/sinceKotlinMultipleClasses.txt index f35f3cc8219..25c51bd6b37 100644 --- a/compiler/testData/diagnostics/tests/multimodule/hiddenClass/sinceKotlinMultipleClasses.txt +++ b/compiler/testData/diagnostics/tests/multimodule/hiddenClass/sinceKotlinMultipleClasses.txt @@ -12,7 +12,6 @@ package p1 { } } - // -- Module: -- package @@ -27,7 +26,6 @@ package p2 { } } - // -- Module: -- package @@ -42,9 +40,9 @@ package p3 { } } - // -- Module: -- package public fun test(/*0*/ a: [ERROR : A]): kotlin.Unit public fun test(/*0*/ a: p2.A): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/multimodule/internal.kt b/compiler/testData/diagnostics/tests/multimodule/internal.kt index fa43b40637f..ad42ba38cc4 100644 --- a/compiler/testData/diagnostics/tests/multimodule/internal.kt +++ b/compiler/testData/diagnostics/tests/multimodule/internal.kt @@ -32,4 +32,4 @@ fun test() { val iv = inst.v inst.a() inst.B() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/multimodule/internal.txt b/compiler/testData/diagnostics/tests/multimodule/internal.txt index 456073a4ff5..9bdc85d5e45 100644 --- a/compiler/testData/diagnostics/tests/multimodule/internal.txt +++ b/compiler/testData/diagnostics/tests/multimodule/internal.txt @@ -31,8 +31,8 @@ package p { } } - // -- Module: -- package public fun test(): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/multimodule/kt14249.txt b/compiler/testData/diagnostics/tests/multimodule/kt14249.txt index 4e08cfeb482..25c56c67964 100644 --- a/compiler/testData/diagnostics/tests/multimodule/kt14249.txt +++ b/compiler/testData/diagnostics/tests/multimodule/kt14249.txt @@ -15,21 +15,10 @@ package test { } } - // -- Module: -- package package test { public fun test(): kotlin.Unit - - public/*package*/ open class Foo { - public/*package*/ constructor Foo() - public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int - public/*package*/ open fun takeFoo(/*0*/ f: test.Foo!): kotlin.Unit - public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String - - // Static members - public/*package*/ open fun create(): test.Foo! - } } + diff --git a/compiler/testData/diagnostics/tests/multimodule/packagePrivate.kt b/compiler/testData/diagnostics/tests/multimodule/packagePrivate.kt index ab08f0b9387..99d3f3bd003 100644 --- a/compiler/testData/diagnostics/tests/multimodule/packagePrivate.kt +++ b/compiler/testData/diagnostics/tests/multimodule/packagePrivate.kt @@ -9,11 +9,11 @@ private val a = 1 package p -val b = a // same package, same module +val b = a // same package, same module // MODULE: m2(m1) // FILE: c.kt package p -val c = a // same package, another module +val c = a // same package, another module diff --git a/compiler/testData/diagnostics/tests/multimodule/packagePrivate.txt b/compiler/testData/diagnostics/tests/multimodule/packagePrivate.txt index 25ec2a8304f..0af5fe0c566 100644 --- a/compiler/testData/diagnostics/tests/multimodule/packagePrivate.txt +++ b/compiler/testData/diagnostics/tests/multimodule/packagePrivate.txt @@ -6,10 +6,10 @@ package p { public val b: kotlin.Int = 1 } - // -- Module: -- package package p { public val c: kotlin.Int = 1 } + diff --git a/compiler/testData/diagnostics/tests/multimodule/publishedApiInternal.kt b/compiler/testData/diagnostics/tests/multimodule/publishedApiInternal.kt index 4d0e81ec47f..492edda6b28 100644 --- a/compiler/testData/diagnostics/tests/multimodule/publishedApiInternal.kt +++ b/compiler/testData/diagnostics/tests/multimodule/publishedApiInternal.kt @@ -53,4 +53,4 @@ inline fun testInline() { val iv = inst.v inst.a() inst.B() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/multimodule/publishedApiInternal.txt b/compiler/testData/diagnostics/tests/multimodule/publishedApiInternal.txt index 175747564ce..28b0d53fbe0 100644 --- a/compiler/testData/diagnostics/tests/multimodule/publishedApiInternal.txt +++ b/compiler/testData/diagnostics/tests/multimodule/publishedApiInternal.txt @@ -31,9 +31,9 @@ package p { } } - // -- Module: -- package public fun test(): kotlin.Unit public inline fun testInline(): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/multimodule/redundantElseInWhen.txt b/compiler/testData/diagnostics/tests/multimodule/redundantElseInWhen.txt index c19631cbcf7..f15679a2cab 100644 --- a/compiler/testData/diagnostics/tests/multimodule/redundantElseInWhen.txt +++ b/compiler/testData/diagnostics/tests/multimodule/redundantElseInWhen.txt @@ -37,7 +37,6 @@ package test { } } - // -- Module: -- package @@ -47,3 +46,4 @@ package other { public fun baz(/*0*/ b: kotlin.Boolean?): kotlin.Int public fun foo(/*0*/ e: test.E): kotlin.Int } + diff --git a/compiler/testData/diagnostics/tests/multimodule/varargConflict.txt b/compiler/testData/diagnostics/tests/multimodule/varargConflict.txt index aaced474e55..aa71c1466ce 100644 --- a/compiler/testData/diagnostics/tests/multimodule/varargConflict.txt +++ b/compiler/testData/diagnostics/tests/multimodule/varargConflict.txt @@ -6,7 +6,6 @@ package p { public fun foo(/*0*/ vararg values: kotlin.Int /*kotlin.IntArray*/): kotlin.Unit } - // -- Module: -- package @@ -15,10 +14,10 @@ package p { public fun foo(/*0*/ vararg values: kotlin.Int /*kotlin.IntArray*/): kotlin.Unit } - // -- Module: -- package package m { public fun main(): kotlin.Unit } + diff --git a/compiler/testData/diagnostics/tests/multiplatform/defaultArguments/annotationArgumentEquality.txt b/compiler/testData/diagnostics/tests/multiplatform/defaultArguments/annotationArgumentEquality.txt index 0b451c851ae..88b6e4f3bbe 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/defaultArguments/annotationArgumentEquality.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/defaultArguments/annotationArgumentEquality.txt @@ -79,7 +79,6 @@ public final expect annotation class Primitives : kotlin.Annotation { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package @@ -162,3 +161,4 @@ public final actual annotation class Primitives : kotlin.Annotation { public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } + diff --git a/compiler/testData/diagnostics/tests/multiplatform/defaultArguments/annotations.txt b/compiler/testData/diagnostics/tests/multiplatform/defaultArguments/annotations.txt index ba3815a354f..5ddd0a1c950 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/defaultArguments/annotations.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/defaultArguments/annotations.txt @@ -48,7 +48,6 @@ public final expect annotation class A5 : kotlin.Annotation { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package @@ -98,3 +97,4 @@ public final actual annotation class A5 : kotlin.Annotation { public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } + diff --git a/compiler/testData/diagnostics/tests/multiplatform/defaultArguments/annotationsViaActualTypeAlias.txt b/compiler/testData/diagnostics/tests/multiplatform/defaultArguments/annotationsViaActualTypeAlias.txt index 2ed72355c17..cf1d5e36157 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/defaultArguments/annotationsViaActualTypeAlias.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/defaultArguments/annotationsViaActualTypeAlias.txt @@ -48,7 +48,6 @@ public final expect annotation class A5 : kotlin.Annotation { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package @@ -103,3 +102,4 @@ public actual typealias A2 = J2 public actual typealias A3 = J3 public actual typealias A4 = J4 public actual typealias A5 = J5 + diff --git a/compiler/testData/diagnostics/tests/multiplatform/defaultArguments/annotationsViaActualTypeAlias2.txt b/compiler/testData/diagnostics/tests/multiplatform/defaultArguments/annotationsViaActualTypeAlias2.txt index 1084752c636..f3a0392d5a0 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/defaultArguments/annotationsViaActualTypeAlias2.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/defaultArguments/annotationsViaActualTypeAlias2.txt @@ -63,7 +63,6 @@ public final enum class E : kotlin.Enum { public final /*synthesized*/ fun values(): kotlin.Array } - // -- Module: -- package @@ -131,3 +130,4 @@ public final annotation class Jnno : kotlin.Annotation { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } public actual typealias Anno = Jnno + diff --git a/compiler/testData/diagnostics/tests/multiplatform/defaultArguments/constructor.txt b/compiler/testData/diagnostics/tests/multiplatform/defaultArguments/constructor.txt index 38f39d5c190..b9321ea3f84 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/defaultArguments/constructor.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/defaultArguments/constructor.txt @@ -24,7 +24,6 @@ public final expect class Ok { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package @@ -50,3 +49,4 @@ public final actual class Ok { public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } + diff --git a/compiler/testData/diagnostics/tests/multiplatform/defaultArguments/expectedDeclaresDefaultArguments.txt b/compiler/testData/diagnostics/tests/multiplatform/defaultArguments/expectedDeclaresDefaultArguments.txt index f690612136f..181d8dda6a5 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/defaultArguments/expectedDeclaresDefaultArguments.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/defaultArguments/expectedDeclaresDefaultArguments.txt @@ -15,7 +15,6 @@ public open expect class Foo { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package @@ -33,3 +32,4 @@ public open actual class Foo { public final actual fun ok(/*0*/ x: kotlin.Int, /*1*/ y: kotlin.String): kotlin.Unit public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } + diff --git a/compiler/testData/diagnostics/tests/multiplatform/defaultArguments/expectedInheritsDefaultArguments.txt b/compiler/testData/diagnostics/tests/multiplatform/defaultArguments/expectedInheritsDefaultArguments.txt index ff2fdefea14..8f61ba8fbff 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/defaultArguments/expectedInheritsDefaultArguments.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/defaultArguments/expectedInheritsDefaultArguments.txt @@ -21,7 +21,6 @@ public interface Foo { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package @@ -45,3 +44,4 @@ public interface Foo { public abstract fun ok(/*0*/ x: kotlin.Int, /*1*/ y: kotlin.String = ...): kotlin.Unit public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } + diff --git a/compiler/testData/diagnostics/tests/multiplatform/defaultArguments/expectedVsNonExpectedWithDefaults.txt b/compiler/testData/diagnostics/tests/multiplatform/defaultArguments/expectedVsNonExpectedWithDefaults.txt index 8b641a4f8ae..763dd569a03 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/defaultArguments/expectedVsNonExpectedWithDefaults.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/defaultArguments/expectedVsNonExpectedWithDefaults.txt @@ -3,10 +3,10 @@ package public expect fun ok(/*0*/ x: kotlin.Int, /*1*/ y: kotlin.String = ...): kotlin.Unit - // -- Module: -- package public fun ok(/*0*/ x: kotlin.Int, /*1*/ y: kotlin.Long = ...): kotlin.Unit public actual fun ok(/*0*/ x: kotlin.Int, /*1*/ y: kotlin.String): kotlin.Unit public fun test(): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/multiplatform/deprecated/header.fir.kt b/compiler/testData/diagnostics/tests/multiplatform/deprecated/header.fir.kt index 04c968e8d9e..cd90da17db2 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/deprecated/header.fir.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/deprecated/header.fir.kt @@ -27,4 +27,4 @@ impl object O impl enum class E { FIRST -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/multiplatform/deprecated/header.kt b/compiler/testData/diagnostics/tests/multiplatform/deprecated/header.kt index 98560e4c320..ea0af3b9ba3 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/deprecated/header.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/deprecated/header.kt @@ -2,15 +2,15 @@ // MODULE: m1-common // FILE: common.kt -header class My +header class My -header fun foo(): Int +header fun foo(): Int -header val x: String +header val x: String -header object O +header object O -header enum class E { +header enum class E { FIRST } @@ -27,4 +27,4 @@ impl enum class E { FIRST -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/multiplatform/deprecated/header.txt b/compiler/testData/diagnostics/tests/multiplatform/deprecated/header.txt index 6e9fad39a03..b8c9271a874 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/deprecated/header.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/deprecated/header.txt @@ -32,7 +32,6 @@ public expect object O { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package @@ -71,3 +70,4 @@ public actual object O { public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } + diff --git a/compiler/testData/diagnostics/tests/multiplatform/enum/additionalEntriesInImpl.txt b/compiler/testData/diagnostics/tests/multiplatform/enum/additionalEntriesInImpl.txt index 4cd9ac28660..c0a2400ae4d 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/enum/additionalEntriesInImpl.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/enum/additionalEntriesInImpl.txt @@ -39,7 +39,6 @@ public final expect enum class Foo : kotlin.Enum { public final /*synthesized*/ fun values(): kotlin.Array } - // -- Module: -- package @@ -96,3 +95,4 @@ public final actual enum class Foo : kotlin.Enum { public final /*synthesized*/ fun valueOf(/*0*/ value: kotlin.String): Foo public final /*synthesized*/ fun values(): kotlin.Array } + diff --git a/compiler/testData/diagnostics/tests/multiplatform/enum/differentEntryOrder.txt b/compiler/testData/diagnostics/tests/multiplatform/enum/differentEntryOrder.txt index ed359015ee1..9f7acc0944a 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/enum/differentEntryOrder.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/enum/differentEntryOrder.txt @@ -39,7 +39,6 @@ public final expect enum class Foo : kotlin.Enum { public final /*synthesized*/ fun values(): kotlin.Array } - // -- Module: -- package @@ -86,3 +85,4 @@ public final actual enum class Foo : kotlin.Enum { public final /*synthesized*/ fun valueOf(/*0*/ value: kotlin.String): Foo public final /*synthesized*/ fun values(): kotlin.Array } + diff --git a/compiler/testData/diagnostics/tests/multiplatform/enum/javaEnum.txt b/compiler/testData/diagnostics/tests/multiplatform/enum/javaEnum.txt index a2cb80a759b..ee7517b5845 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/enum/javaEnum.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/enum/javaEnum.txt @@ -31,7 +31,6 @@ public final expect enum class _TimeUnit : kotlin.Enum<_TimeUnit> { public final /*synthesized*/ fun values(): kotlin.Array<_TimeUnit> } - // -- Module: -- package @@ -57,3 +56,4 @@ public final enum class FooImpl : kotlin.Enum { } public actual typealias Foo = FooImpl public actual typealias _TimeUnit = java.util.concurrent.TimeUnit + diff --git a/compiler/testData/diagnostics/tests/multiplatform/enum/simpleEnum.txt b/compiler/testData/diagnostics/tests/multiplatform/enum/simpleEnum.txt index 22a4adc0f28..16f35f3b95a 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/enum/simpleEnum.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/enum/simpleEnum.txt @@ -21,7 +21,6 @@ public final expect enum class Foo : kotlin.Enum { public final /*synthesized*/ fun values(): kotlin.Array } - // -- Module: -- package @@ -48,3 +47,4 @@ public final actual enum class Foo : kotlin.Enum { public final /*synthesized*/ fun valueOf(/*0*/ value: kotlin.String): Foo public final /*synthesized*/ fun values(): kotlin.Array } + diff --git a/compiler/testData/diagnostics/tests/multiplatform/expectInterfaceApplicability.txt b/compiler/testData/diagnostics/tests/multiplatform/expectInterfaceApplicability.txt index 9b270da5a3b..ef99ebfb4f2 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/expectInterfaceApplicability.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/expectInterfaceApplicability.txt @@ -13,7 +13,6 @@ public expect interface My { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package @@ -28,3 +27,4 @@ public actual interface My { public open actual fun openFunPositive(): kotlin.Unit public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } + diff --git a/compiler/testData/diagnostics/tests/multiplatform/generic/functionTypeParameterBounds.txt b/compiler/testData/diagnostics/tests/multiplatform/generic/functionTypeParameterBounds.txt index 3188e209d3e..cd198e2fba5 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/generic/functionTypeParameterBounds.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/generic/functionTypeParameterBounds.txt @@ -3,9 +3,9 @@ package public expect fun > kotlin.Array.sort(): kotlin.Unit - // -- Module: -- package public fun kotlin.Array.sort(): kotlin.Unit public actual fun > kotlin.Array.sort(): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/multiplatform/generic/genericMemberBounds.txt b/compiler/testData/diagnostics/tests/multiplatform/generic/genericMemberBounds.txt index fc175f38e22..cbf2daba488 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/generic/genericMemberBounds.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/generic/genericMemberBounds.txt @@ -9,7 +9,6 @@ public final expect class A { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package @@ -22,3 +21,4 @@ public open class JavaA { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } public actual typealias A = JavaA + diff --git a/compiler/testData/diagnostics/tests/multiplatform/generic/membersInGenericClass.txt b/compiler/testData/diagnostics/tests/multiplatform/generic/membersInGenericClass.txt index 35252a9b711..9878bafbf0b 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/generic/membersInGenericClass.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/generic/membersInGenericClass.txt @@ -10,7 +10,6 @@ public expect interface A { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package @@ -22,3 +21,4 @@ public actual interface A { public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } + diff --git a/compiler/testData/diagnostics/tests/multiplatform/generic/typeParameterBoundsDifferentOrderActualMissing.kt b/compiler/testData/diagnostics/tests/multiplatform/generic/typeParameterBoundsDifferentOrderActualMissing.kt index 8b34494e63b..6b3da1979c5 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/generic/typeParameterBoundsDifferentOrderActualMissing.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/generic/typeParameterBoundsDifferentOrderActualMissing.kt @@ -5,7 +5,7 @@ interface A interface B -expect fun List.foo() where T : A, T : B +expect fun List.foo() where T : A, T : B // MODULE: m2-jvm(m1-common) // FILE: jvm.kt diff --git a/compiler/testData/diagnostics/tests/multiplatform/generic/typeParameterBoundsDifferentOrderActualMissing.txt b/compiler/testData/diagnostics/tests/multiplatform/generic/typeParameterBoundsDifferentOrderActualMissing.txt index fe69e8e0bb0..b2e57731553 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/generic/typeParameterBoundsDifferentOrderActualMissing.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/generic/typeParameterBoundsDifferentOrderActualMissing.txt @@ -15,7 +15,6 @@ public interface B { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package @@ -32,3 +31,4 @@ public interface B { public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } + diff --git a/compiler/testData/diagnostics/tests/multiplatform/headerClass/actualClassWithDefaultValuesInAnnotationViaTypealias.txt b/compiler/testData/diagnostics/tests/multiplatform/headerClass/actualClassWithDefaultValuesInAnnotationViaTypealias.txt index 7514fa24a35..a94819b54fe 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/headerClass/actualClassWithDefaultValuesInAnnotationViaTypealias.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/headerClass/actualClassWithDefaultValuesInAnnotationViaTypealias.txt @@ -49,7 +49,6 @@ public final expect annotation class Foo7 : kotlin.Annotation { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package @@ -107,3 +106,4 @@ public final actual annotation class Foo6 : kotlin.Annotation { public actual typealias Foo1 = Bar1 public actual typealias Foo4 = Bar2 public actual typealias Foo7 = Bar2 + diff --git a/compiler/testData/diagnostics/tests/multiplatform/headerClass/actualClassWithDifferentConstructors.txt b/compiler/testData/diagnostics/tests/multiplatform/headerClass/actualClassWithDifferentConstructors.txt index 6bb6cfa6f0e..ae7e0f17014 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/headerClass/actualClassWithDifferentConstructors.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/headerClass/actualClassWithDifferentConstructors.txt @@ -68,7 +68,6 @@ public final expect class Foo3 { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package @@ -151,3 +150,4 @@ public open class JavaFoo { } public actual typealias Bar3 = JavaBar public actual typealias Foo3 = JavaFoo + diff --git a/compiler/testData/diagnostics/tests/multiplatform/headerClass/actualMissing.txt b/compiler/testData/diagnostics/tests/multiplatform/headerClass/actualMissing.txt index fad757f907b..7460eec3cf5 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/headerClass/actualMissing.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/headerClass/actualMissing.txt @@ -8,7 +8,6 @@ public final expect class A { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package @@ -19,3 +18,4 @@ public final class A { public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } + diff --git a/compiler/testData/diagnostics/tests/multiplatform/headerClass/baseExpectClassWithoutConstructor.fir.kt b/compiler/testData/diagnostics/tests/multiplatform/headerClass/baseExpectClassWithoutConstructor.fir.kt index f461354aa08..1fc42183281 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/headerClass/baseExpectClassWithoutConstructor.fir.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/headerClass/baseExpectClassWithoutConstructor.fir.kt @@ -10,4 +10,4 @@ open class C : A // FILE: jvm.kt actual open class A -actual class B : A() \ No newline at end of file +actual class B : A() diff --git a/compiler/testData/diagnostics/tests/multiplatform/headerClass/baseExpectClassWithoutConstructor.kt b/compiler/testData/diagnostics/tests/multiplatform/headerClass/baseExpectClassWithoutConstructor.kt index 7951a02092f..7eaea54b9d2 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/headerClass/baseExpectClassWithoutConstructor.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/headerClass/baseExpectClassWithoutConstructor.kt @@ -4,10 +4,10 @@ expect open class A expect class B : A -open class C : A +open class C : A // MODULE: m1-jvm(m1-common) // FILE: jvm.kt actual open class A -actual class B : A() \ No newline at end of file +actual class B : A() diff --git a/compiler/testData/diagnostics/tests/multiplatform/headerClass/baseExpectClassWithoutConstructor.txt b/compiler/testData/diagnostics/tests/multiplatform/headerClass/baseExpectClassWithoutConstructor.txt index df558874920..746eb52b110 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/headerClass/baseExpectClassWithoutConstructor.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/headerClass/baseExpectClassWithoutConstructor.txt @@ -20,7 +20,6 @@ public open class C : A { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package @@ -44,3 +43,4 @@ public open class C : A { public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } + diff --git a/compiler/testData/diagnostics/tests/multiplatform/headerClass/classKinds.txt b/compiler/testData/diagnostics/tests/multiplatform/headerClass/classKinds.txt index 7901920cacb..1a1d6a49297 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/headerClass/classKinds.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/headerClass/classKinds.txt @@ -43,7 +43,6 @@ public expect object Object { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package @@ -93,3 +92,4 @@ public actual object Object { public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } + diff --git a/compiler/testData/diagnostics/tests/multiplatform/headerClass/dontOverrideMethodsFromInterfaceInCommonCode.txt b/compiler/testData/diagnostics/tests/multiplatform/headerClass/dontOverrideMethodsFromInterfaceInCommonCode.txt index 21dbb52f53b..2d1d0dd4ec5 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/headerClass/dontOverrideMethodsFromInterfaceInCommonCode.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/headerClass/dontOverrideMethodsFromInterfaceInCommonCode.txt @@ -29,7 +29,6 @@ public final expect class ImplicitFooCheck : Foo { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package @@ -63,3 +62,4 @@ public final actual class ImplicitFooCheck : Foo { public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } + diff --git a/compiler/testData/diagnostics/tests/multiplatform/headerClass/expectClassWithoutConstructor.txt b/compiler/testData/diagnostics/tests/multiplatform/headerClass/expectClassWithoutConstructor.txt index c47a99b50a8..e835bbc64b5 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/headerClass/expectClassWithoutConstructor.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/headerClass/expectClassWithoutConstructor.txt @@ -30,7 +30,6 @@ public final expect class FooBar { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package @@ -63,3 +62,4 @@ public final actual class FooBar { public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } + diff --git a/compiler/testData/diagnostics/tests/multiplatform/headerClass/expectDeclarationWithStrongIncompatibilities.kt b/compiler/testData/diagnostics/tests/multiplatform/headerClass/expectDeclarationWithStrongIncompatibilities.kt index 524dbf95704..2aa48bfe258 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/headerClass/expectDeclarationWithStrongIncompatibilities.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/headerClass/expectDeclarationWithStrongIncompatibilities.kt @@ -4,12 +4,12 @@ // FILE: common.kt expect fun foo1(x: Int) -expect fun foo2(x: Int) +expect fun foo2(x: Int) expect class NoArgConstructor() -expect fun foo3(): Int -expect fun foo4(): Int +expect fun foo3(): Int +expect fun foo4(): Int // MODULE: m2-jvm(m1-common) diff --git a/compiler/testData/diagnostics/tests/multiplatform/headerClass/expectDeclarationWithStrongIncompatibilities.txt b/compiler/testData/diagnostics/tests/multiplatform/headerClass/expectDeclarationWithStrongIncompatibilities.txt index c950dd608b7..98b38a236cb 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/headerClass/expectDeclarationWithStrongIncompatibilities.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/headerClass/expectDeclarationWithStrongIncompatibilities.txt @@ -13,7 +13,6 @@ public final expect class NoArgConstructor { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package @@ -33,3 +32,4 @@ public final actual class NoArgConstructor { public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } + diff --git a/compiler/testData/diagnostics/tests/multiplatform/headerClass/expectDeclarationWithWeakIncompatibilities.kt b/compiler/testData/diagnostics/tests/multiplatform/headerClass/expectDeclarationWithWeakIncompatibilities.kt index 4c99af54746..d7fb8c12dfc 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/headerClass/expectDeclarationWithWeakIncompatibilities.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/headerClass/expectDeclarationWithWeakIncompatibilities.kt @@ -10,7 +10,7 @@ expect fun foo2(): Int expect val s: String -expect open class Foo3 +expect open class Foo3 // MODULE: m2-jvm(m1-common) diff --git a/compiler/testData/diagnostics/tests/multiplatform/headerClass/expectDeclarationWithWeakIncompatibilities.txt b/compiler/testData/diagnostics/tests/multiplatform/headerClass/expectDeclarationWithWeakIncompatibilities.txt index 6f49e7480a5..484d614da1a 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/headerClass/expectDeclarationWithWeakIncompatibilities.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/headerClass/expectDeclarationWithWeakIncompatibilities.txt @@ -22,7 +22,6 @@ public open expect class Foo3 { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package @@ -54,3 +53,4 @@ public final class Foo3 { public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } + diff --git a/compiler/testData/diagnostics/tests/multiplatform/headerClass/expectFinalActualOpen.txt b/compiler/testData/diagnostics/tests/multiplatform/headerClass/expectFinalActualOpen.txt index 2477f74033f..16106c29889 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/headerClass/expectFinalActualOpen.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/headerClass/expectFinalActualOpen.txt @@ -16,7 +16,6 @@ public final expect class Foo { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package @@ -37,3 +36,4 @@ public open class JavaBar { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } public actual typealias Bar = JavaBar + diff --git a/compiler/testData/diagnostics/tests/multiplatform/headerClass/extendExpectedClassWithoutExplicitOverrideOfMethod.txt b/compiler/testData/diagnostics/tests/multiplatform/headerClass/extendExpectedClassWithoutExplicitOverrideOfMethod.txt index 988948c5281..3ad1179cdc6 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/headerClass/extendExpectedClassWithoutExplicitOverrideOfMethod.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/headerClass/extendExpectedClassWithoutExplicitOverrideOfMethod.txt @@ -29,7 +29,6 @@ public final expect class DerivedImplicit : Base { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package @@ -64,3 +63,4 @@ public final actual class DerivedImplicit : Base { public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } + diff --git a/compiler/testData/diagnostics/tests/multiplatform/headerClass/extraHeaderOnMembers.kt b/compiler/testData/diagnostics/tests/multiplatform/headerClass/extraHeaderOnMembers.kt index e2802eb26a2..d1844503c12 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/headerClass/extraHeaderOnMembers.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/headerClass/extraHeaderOnMembers.kt @@ -3,7 +3,7 @@ // FILE: common.kt expect class H { - expect fun foo() + expect fun foo() } // MODULE: m1-jvm(m1-common) diff --git a/compiler/testData/diagnostics/tests/multiplatform/headerClass/extraHeaderOnMembers.txt b/compiler/testData/diagnostics/tests/multiplatform/headerClass/extraHeaderOnMembers.txt index eec55cf2bab..6793409e215 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/headerClass/extraHeaderOnMembers.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/headerClass/extraHeaderOnMembers.txt @@ -8,7 +8,6 @@ public final expect class H { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package @@ -19,3 +18,4 @@ public final actual class H { public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } + diff --git a/compiler/testData/diagnostics/tests/multiplatform/headerClass/functionAndPropertyWithSameName.txt b/compiler/testData/diagnostics/tests/multiplatform/headerClass/functionAndPropertyWithSameName.txt index bbb459d5324..334dd590245 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/headerClass/functionAndPropertyWithSameName.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/headerClass/functionAndPropertyWithSameName.txt @@ -8,7 +8,6 @@ public final expect class Foo { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package @@ -20,3 +19,4 @@ public final actual class Foo { public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } + diff --git a/compiler/testData/diagnostics/tests/multiplatform/headerClass/genericClassImplTypeAlias.txt b/compiler/testData/diagnostics/tests/multiplatform/headerClass/genericClassImplTypeAlias.txt index 56e78558a27..ac6af2833be 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/headerClass/genericClassImplTypeAlias.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/headerClass/genericClassImplTypeAlias.txt @@ -61,7 +61,6 @@ public expect interface C9 { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package @@ -76,3 +75,4 @@ public actual typealias C7 = kotlin.collections.MutableList public actual typealias C8 = kotlin.collections.MutableList<*> public actual typealias C9 = kotlin.collections.MutableList public typealias Tmp = kotlin.collections.MutableList + diff --git a/compiler/testData/diagnostics/tests/multiplatform/headerClass/headerClassMember.txt b/compiler/testData/diagnostics/tests/multiplatform/headerClass/headerClassMember.txt index a49a2fa1ebd..3bc0dbf7112 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/headerClass/headerClassMember.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/headerClass/headerClassMember.txt @@ -9,7 +9,6 @@ public final expect class Foo { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package @@ -22,7 +21,6 @@ public final actual class Foo { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package @@ -34,3 +32,4 @@ public final actual class Foo { public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } + diff --git a/compiler/testData/diagnostics/tests/multiplatform/headerClass/implDataClass.txt b/compiler/testData/diagnostics/tests/multiplatform/headerClass/implDataClass.txt index 1adb731d2b7..b4569b5bdff 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/headerClass/implDataClass.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/headerClass/implDataClass.txt @@ -26,7 +26,6 @@ public final expect class Foo { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package @@ -61,3 +60,4 @@ public final actual data class Foo { public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String } + diff --git a/compiler/testData/diagnostics/tests/multiplatform/headerClass/implOpenClass.txt b/compiler/testData/diagnostics/tests/multiplatform/headerClass/implOpenClass.txt index aa39846925c..0e780206ae9 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/headerClass/implOpenClass.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/headerClass/implOpenClass.txt @@ -10,7 +10,6 @@ public final expect class Foo { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package @@ -30,3 +29,4 @@ public open actual class Foo { public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } + diff --git a/compiler/testData/diagnostics/tests/multiplatform/headerClass/modalityCheckForExplicitAndImplicitOverride.txt b/compiler/testData/diagnostics/tests/multiplatform/headerClass/modalityCheckForExplicitAndImplicitOverride.txt index 1a15d56b7d9..188f8e1814e 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/headerClass/modalityCheckForExplicitAndImplicitOverride.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/headerClass/modalityCheckForExplicitAndImplicitOverride.txt @@ -22,7 +22,6 @@ public final expect class Foo3 { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package @@ -65,3 +64,4 @@ public open class WithFinal { public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } + diff --git a/compiler/testData/diagnostics/tests/multiplatform/headerClass/morePermissiveVisibilityOnActual.txt b/compiler/testData/diagnostics/tests/multiplatform/headerClass/morePermissiveVisibilityOnActual.txt index aad2f344e25..564acd5d019 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/headerClass/morePermissiveVisibilityOnActual.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/headerClass/morePermissiveVisibilityOnActual.txt @@ -16,7 +16,6 @@ public open expect class Container { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package @@ -35,3 +34,4 @@ public open actual class Container { public final actual fun publicFun(): kotlin.Unit public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } + diff --git a/compiler/testData/diagnostics/tests/multiplatform/headerClass/morePermissiveVisibilityOnActualViaTypeAlias.txt b/compiler/testData/diagnostics/tests/multiplatform/headerClass/morePermissiveVisibilityOnActualViaTypeAlias.txt index 37cb28d24fa..01588decb38 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/headerClass/morePermissiveVisibilityOnActualViaTypeAlias.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/headerClass/morePermissiveVisibilityOnActualViaTypeAlias.txt @@ -8,7 +8,6 @@ public open expect class Container { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package @@ -24,3 +23,4 @@ package foo { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } } + diff --git a/compiler/testData/diagnostics/tests/multiplatform/headerClass/nestedClasses.txt b/compiler/testData/diagnostics/tests/multiplatform/headerClass/nestedClasses.txt index 6563d7cac2b..773293a58ac 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/headerClass/nestedClasses.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/headerClass/nestedClasses.txt @@ -65,7 +65,6 @@ public expect object OuterObject { } } - // -- Module: -- package @@ -142,3 +141,4 @@ public actual object OuterObject { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } } + diff --git a/compiler/testData/diagnostics/tests/multiplatform/headerClass/nestedClassesWithErrors.kt b/compiler/testData/diagnostics/tests/multiplatform/headerClass/nestedClassesWithErrors.kt index fed08086bf3..917ce026f49 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/headerClass/nestedClassesWithErrors.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/headerClass/nestedClassesWithErrors.kt @@ -4,15 +4,15 @@ expect class B { class N { - fun body() {} - expect fun extraHeader() + fun body() {} + expect fun extraHeader() } } expect class C { - expect class N - expect enum class E - expect inner class I + expect class N + expect enum class E + expect inner class I } expect class D { diff --git a/compiler/testData/diagnostics/tests/multiplatform/headerClass/nestedClassesWithErrors.txt b/compiler/testData/diagnostics/tests/multiplatform/headerClass/nestedClassesWithErrors.txt index ea60dabe8ca..79fb4c30b7e 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/headerClass/nestedClassesWithErrors.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/headerClass/nestedClassesWithErrors.txt @@ -71,7 +71,6 @@ public final expect class E { } } - // -- Module: -- package @@ -149,3 +148,4 @@ public final actual class E { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } } + diff --git a/compiler/testData/diagnostics/tests/multiplatform/headerClass/noImplKeywordOnMember.txt b/compiler/testData/diagnostics/tests/multiplatform/headerClass/noImplKeywordOnMember.txt index dfd485c4a13..2866e0f02ab 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/headerClass/noImplKeywordOnMember.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/headerClass/noImplKeywordOnMember.txt @@ -8,7 +8,6 @@ public final expect class Foo { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package @@ -19,3 +18,4 @@ public final actual class Foo { public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } + diff --git a/compiler/testData/diagnostics/tests/multiplatform/headerClass/privateMembers.kt b/compiler/testData/diagnostics/tests/multiplatform/headerClass/privateMembers.kt index 09f0c54ca89..0f18a6b5c41 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/headerClass/privateMembers.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/headerClass/privateMembers.kt @@ -3,11 +3,11 @@ // FILE: common.kt expect class A { - private fun foo() - private val bar: String - private fun Int.memExt(): Any + private fun foo() + private val bar: String + private fun Int.memExt(): Any - private class Nested + private class Nested } // MODULE: m1-jvm(m1-common) diff --git a/compiler/testData/diagnostics/tests/multiplatform/headerClass/privateMembers.txt b/compiler/testData/diagnostics/tests/multiplatform/headerClass/privateMembers.txt index 997f90ba950..757cf07da64 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/headerClass/privateMembers.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/headerClass/privateMembers.txt @@ -16,7 +16,6 @@ public final expect class A { } } - // -- Module: -- package @@ -36,3 +35,4 @@ public final actual class A { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } } + diff --git a/compiler/testData/diagnostics/tests/multiplatform/headerClass/simpleHeaderClass.txt b/compiler/testData/diagnostics/tests/multiplatform/headerClass/simpleHeaderClass.txt index 19464093d2e..bbc34c41b28 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/headerClass/simpleHeaderClass.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/headerClass/simpleHeaderClass.txt @@ -7,7 +7,6 @@ public final expect class Foo { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package @@ -18,7 +17,6 @@ public final actual class Foo { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package @@ -28,3 +26,4 @@ public final actual class Foo { public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } + diff --git a/compiler/testData/diagnostics/tests/multiplatform/headerClass/superClass.kt b/compiler/testData/diagnostics/tests/multiplatform/headerClass/superClass.kt index 37707af6feb..bfacd7bbd9b 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/headerClass/superClass.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/headerClass/superClass.kt @@ -8,7 +8,7 @@ interface J expect class Foo : I, C, J -expect class Bar : C() +expect class Bar : C() // MODULE: m2-jvm(m1-common) // FILE: jvm.kt diff --git a/compiler/testData/diagnostics/tests/multiplatform/headerClass/superClass.txt b/compiler/testData/diagnostics/tests/multiplatform/headerClass/superClass.txt index fe0379fe4f1..ced9e92edcb 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/headerClass/superClass.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/headerClass/superClass.txt @@ -32,7 +32,6 @@ public interface J { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package @@ -69,7 +68,6 @@ public interface J { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package @@ -105,3 +103,4 @@ public interface J { public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } + diff --git a/compiler/testData/diagnostics/tests/multiplatform/headerFunInNonHeaderClass.kt b/compiler/testData/diagnostics/tests/multiplatform/headerFunInNonHeaderClass.kt index e2e30547342..f90553efb51 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/headerFunInNonHeaderClass.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/headerFunInNonHeaderClass.kt @@ -3,7 +3,7 @@ // FILE: common.kt class Foo { - expect fun bar(): String + expect fun bar(): String } // MODULE: m1-jvm(m1-common) diff --git a/compiler/testData/diagnostics/tests/multiplatform/headerFunInNonHeaderClass.txt b/compiler/testData/diagnostics/tests/multiplatform/headerFunInNonHeaderClass.txt index 5367b2d1d7c..4e5812a8a3b 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/headerFunInNonHeaderClass.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/headerFunInNonHeaderClass.txt @@ -9,7 +9,6 @@ public final class Foo { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package @@ -20,3 +19,4 @@ public final class Foo { public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } + diff --git a/compiler/testData/diagnostics/tests/multiplatform/implDelegatedMember.txt b/compiler/testData/diagnostics/tests/multiplatform/implDelegatedMember.txt index 5bd03202138..b2598dbf1bd 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/implDelegatedMember.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/implDelegatedMember.txt @@ -8,7 +8,6 @@ public open expect class Foo { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package @@ -28,3 +27,4 @@ public open actual class Foo : Bar { public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } + diff --git a/compiler/testData/diagnostics/tests/multiplatform/implDynamic.txt b/compiler/testData/diagnostics/tests/multiplatform/implDynamic.txt index 8ab6fa62475..0dee352b87c 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/implDynamic.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/implDynamic.txt @@ -11,7 +11,6 @@ public final expect class Foo { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package @@ -24,3 +23,4 @@ public final actual class Foo { public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } + diff --git a/compiler/testData/diagnostics/tests/multiplatform/implFakeOverride.txt b/compiler/testData/diagnostics/tests/multiplatform/implFakeOverride.txt index 2a9c2ad4988..b2fb4a32842 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/implFakeOverride.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/implFakeOverride.txt @@ -8,7 +8,6 @@ public final expect class Foo { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package @@ -27,3 +26,4 @@ public final actual class Foo : Bar { public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } + diff --git a/compiler/testData/diagnostics/tests/multiplatform/inlineClasses/expectActualInlineClass.kt b/compiler/testData/diagnostics/tests/multiplatform/inlineClasses/expectActualInlineClass.kt index db4c08e5a2b..b472ac50468 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/inlineClasses/expectActualInlineClass.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/inlineClasses/expectActualInlineClass.kt @@ -8,7 +8,7 @@ expect inline class Foo1(val x: Int) { expect inline class Foo2(val x: Int) -expect inline class Foo3 +expect inline class Foo3 expect class NonInlineExpect diff --git a/compiler/testData/diagnostics/tests/multiplatform/inlineClasses/expectActualInlineClass.txt b/compiler/testData/diagnostics/tests/multiplatform/inlineClasses/expectActualInlineClass.txt index bdf9167fb9c..41e20224187 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/inlineClasses/expectActualInlineClass.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/inlineClasses/expectActualInlineClass.txt @@ -38,7 +38,6 @@ public final expect class NonInlineExpect { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package @@ -81,3 +80,4 @@ public final actual inline class NonInlineExpect { public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String } + diff --git a/compiler/testData/diagnostics/tests/multiplatform/java/flexibleTypes.txt b/compiler/testData/diagnostics/tests/multiplatform/java/flexibleTypes.txt index 4781dc02f78..64655e639b6 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/java/flexibleTypes.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/java/flexibleTypes.txt @@ -11,7 +11,6 @@ public final expect class Foo { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package @@ -25,3 +24,4 @@ public open class FooImpl { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } public actual typealias Foo = FooImpl + diff --git a/compiler/testData/diagnostics/tests/multiplatform/java/parameterNames.txt b/compiler/testData/diagnostics/tests/multiplatform/java/parameterNames.txt index 8f4bf9cd27c..571562715a4 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/java/parameterNames.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/java/parameterNames.txt @@ -8,7 +8,6 @@ public final expect class Foo { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package @@ -20,3 +19,4 @@ public open class FooImpl { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } public actual typealias Foo = FooImpl + diff --git a/compiler/testData/diagnostics/tests/multiplatform/modifierApplicability.txt b/compiler/testData/diagnostics/tests/multiplatform/modifierApplicability.txt index fb15dfe87ad..4729843e520 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/modifierApplicability.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/modifierApplicability.txt @@ -19,7 +19,6 @@ public final class Outer { } public typealias Foo = kotlin.String - // -- Module: -- package @@ -38,3 +37,4 @@ public final class Outer { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } } + diff --git a/compiler/testData/diagnostics/tests/multiplatform/namedArguments.kt b/compiler/testData/diagnostics/tests/multiplatform/namedArguments.kt index 75d1e4b4dae..67f01d593e8 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/namedArguments.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/namedArguments.kt @@ -12,9 +12,9 @@ expect class Foo(zzz: Int) { expect fun f2(xxx: Int) fun testCommon() { - Foo(zzz = 0) - val f = Foo(aaa = true) - f.f1(xxx = "") + Foo(zzz = 0) + val f = Foo(aaa = true) + f.f1(xxx = "") f2(xxx = 42) } diff --git a/compiler/testData/diagnostics/tests/multiplatform/namedArguments.txt b/compiler/testData/diagnostics/tests/multiplatform/namedArguments.txt index a092f268878..7a500d25e2e 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/namedArguments.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/namedArguments.txt @@ -13,7 +13,6 @@ public final expect class Foo { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package @@ -30,3 +29,4 @@ public final actual class Foo { public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } + diff --git a/compiler/testData/diagnostics/tests/multiplatform/privateTopLevelDeclarations.kt b/compiler/testData/diagnostics/tests/multiplatform/privateTopLevelDeclarations.kt index 4bf271f5c90..ab76e4ec653 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/privateTopLevelDeclarations.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/privateTopLevelDeclarations.kt @@ -2,11 +2,11 @@ // MODULE: m1-common // FILE: common.kt -private expect fun foo() -private expect val bar: String -private expect fun Int.memExt(): Any +private expect fun foo() +private expect val bar: String +private expect fun Int.memExt(): Any -private expect class Foo +private expect class Foo // MODULE: m2-jvm(m1-common) // FILE: jvm.kt diff --git a/compiler/testData/diagnostics/tests/multiplatform/privateTopLevelDeclarations.txt b/compiler/testData/diagnostics/tests/multiplatform/privateTopLevelDeclarations.txt index 9969c86e9f3..317e43b0973 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/privateTopLevelDeclarations.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/privateTopLevelDeclarations.txt @@ -11,7 +11,6 @@ private final expect class Foo { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package @@ -25,3 +24,4 @@ private final actual class Foo { public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } + diff --git a/compiler/testData/diagnostics/tests/multiplatform/sealedTypeAlias.txt b/compiler/testData/diagnostics/tests/multiplatform/sealedTypeAlias.txt index 3b0703e2533..74e8c79ce25 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/sealedTypeAlias.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/sealedTypeAlias.txt @@ -19,7 +19,6 @@ public sealed expect class Presence { } } - // -- Module: -- package @@ -44,3 +43,4 @@ public sealed class P { } } public actual typealias Presence = P + diff --git a/compiler/testData/diagnostics/tests/multiplatform/sealedTypeAliasTopLevel.txt b/compiler/testData/diagnostics/tests/multiplatform/sealedTypeAliasTopLevel.txt index e17aee39f72..8a518d78c8c 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/sealedTypeAliasTopLevel.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/sealedTypeAliasTopLevel.txt @@ -19,7 +19,6 @@ public sealed expect class Presence { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module: -- package @@ -44,3 +43,4 @@ public sealed class P { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } public actual typealias Presence = P + diff --git a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/callHeaderFun.txt b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/callHeaderFun.txt index 3253218cf24..6316aafc26e 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/callHeaderFun.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/callHeaderFun.txt @@ -4,7 +4,6 @@ package public fun callFromCommonCode(/*0*/ x: kotlin.Int): kotlin.Int public expect fun foo(/*0*/ x: kotlin.Int): kotlin.Int - // -- Module: -- package @@ -12,10 +11,10 @@ public fun callFromCommonCode(/*0*/ x: kotlin.Int): kotlin.Int public fun callFromJVM(/*0*/ x: kotlin.Int): kotlin.Int public actual fun foo(/*0*/ x: kotlin.Int): kotlin.Int - // -- Module: -- package public fun callFromCommonCode(/*0*/ x: kotlin.Int): kotlin.Int public fun callFromJS(/*0*/ x: kotlin.Int): kotlin.Int public actual fun foo(/*0*/ x: kotlin.Int): kotlin.Int + diff --git a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/callableReferenceOnExpectFun.kt b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/callableReferenceOnExpectFun.kt index 0c22e4752ef..5c6282fba7f 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/callableReferenceOnExpectFun.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/callableReferenceOnExpectFun.kt @@ -9,7 +9,7 @@ expect fun foo(): String fun g(f: () -> String): String = f() fun test() { - g(::foo) + g(::foo) } // MODULE: m2-jvm(m1-common) diff --git a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/callableReferenceOnExpectFun.txt b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/callableReferenceOnExpectFun.txt index aae2194d48b..a8cff80410d 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/callableReferenceOnExpectFun.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/callableReferenceOnExpectFun.txt @@ -7,7 +7,6 @@ package test { public fun test(): kotlin.Unit } - // -- Module: -- package @@ -16,3 +15,4 @@ package test { public fun g(/*0*/ f: () -> kotlin.String): kotlin.String public fun test(): kotlin.Unit } + diff --git a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/conflictingImplDeclarations.kt b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/conflictingImplDeclarations.kt index fa2813932f8..bef94de7134 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/conflictingImplDeclarations.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/conflictingImplDeclarations.kt @@ -2,7 +2,7 @@ // MODULE: m1-common // FILE: common.kt -expect fun foo() +expect fun foo() // MODULE: m2-jvm(m1-common) // FILE: jvm.kt diff --git a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/conflictingImplDeclarations.txt b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/conflictingImplDeclarations.txt index 71183a4452e..0359b3c5523 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/conflictingImplDeclarations.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/conflictingImplDeclarations.txt @@ -3,16 +3,15 @@ package public expect fun foo(): kotlin.Unit - // -- Module: -- package public actual fun foo(): kotlin.Unit public actual fun foo(): kotlin.Unit - // -- Module: -- package public actual fun foo(): kotlin.Unit public actual fun foo(): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/functionModifiers.txt b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/functionModifiers.txt index e397ad4e8f0..b93a45d806d 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/functionModifiers.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/functionModifiers.txt @@ -7,7 +7,6 @@ public expect fun tailrec(): kotlin.Unit public expect fun kotlin.String.and(/*0*/ other: kotlin.String): kotlin.String public expect fun kotlin.String.unaryMinus(): kotlin.String - // -- Module: -- package @@ -16,3 +15,4 @@ public actual inline fun inline(): kotlin.Unit public actual tailrec fun tailrec(): kotlin.Unit public actual infix fun kotlin.String.and(/*0*/ other: kotlin.String): kotlin.String public actual operator fun kotlin.String.unaryMinus(): kotlin.String + diff --git a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/headerAndImplInDIfferentPackages.kt b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/headerAndImplInDIfferentPackages.kt index 81a5230deb6..b475da2119c 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/headerAndImplInDIfferentPackages.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/headerAndImplInDIfferentPackages.kt @@ -3,7 +3,7 @@ // FILE: common.kt package common -expect fun foo() +expect fun foo() // MODULE: m2-jvm(m1-common) // FILE: jvm.kt diff --git a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/headerAndImplInDIfferentPackages.txt b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/headerAndImplInDIfferentPackages.txt index befbce3ce51..c171d427fa8 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/headerAndImplInDIfferentPackages.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/headerAndImplInDIfferentPackages.txt @@ -5,7 +5,6 @@ package common { public expect fun foo(): kotlin.Unit } - // -- Module: -- package @@ -13,10 +12,10 @@ package jvm { public actual fun foo(): kotlin.Unit } - // -- Module: -- package package js { public actual fun foo(): kotlin.Unit } + diff --git a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/implDeclarationWithoutBody.txt b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/implDeclarationWithoutBody.txt index bfd50ddadbd..e6c754123d9 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/implDeclarationWithoutBody.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/implDeclarationWithoutBody.txt @@ -3,9 +3,9 @@ package public expect fun foo(): kotlin.Unit - // -- Module: -- package public actual fun bar(): kotlin.Unit public actual fun foo(): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/inlineFun.txt b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/inlineFun.txt index 99bdf29fd28..a69333043f5 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/inlineFun.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/inlineFun.txt @@ -4,16 +4,15 @@ package public expect inline fun inlineFun(): kotlin.Unit public expect fun nonInlineFun(): kotlin.Unit - // -- Module: -- package public actual fun inlineFun(): kotlin.Unit public actual fun nonInlineFun(): kotlin.Unit - // -- Module: -- package public actual inline fun inlineFun(): kotlin.Unit public actual inline fun nonInlineFun(): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/simpleHeaderFun.txt b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/simpleHeaderFun.txt index fd7094cdc35..2ddcccf5217 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/simpleHeaderFun.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/simpleHeaderFun.txt @@ -3,14 +3,13 @@ package public expect fun foo(): kotlin.Unit - // -- Module: -- package public actual fun foo(): kotlin.Unit - // -- Module: -- package public actual fun foo(): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/valueParameterModifiers.kt b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/valueParameterModifiers.kt index 42fd68f062d..4193e874d90 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/valueParameterModifiers.kt +++ b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/valueParameterModifiers.kt @@ -11,8 +11,8 @@ expect fun f4(s: () -> String) expect inline fun f5(s: () -> String) expect inline fun f6(crossinline s: () -> String) -expect fun f7(x: Any) -expect fun f8(vararg x: Any) +expect fun f7(x: Any) +expect fun f8(vararg x: Any) // MODULE: m2-jvm(m1-common) // FILE: jvm.kt diff --git a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/valueParameterModifiers.txt b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/valueParameterModifiers.txt index 11eb0f299aa..335fc1e09c1 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/valueParameterModifiers.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/topLevelFun/valueParameterModifiers.txt @@ -10,7 +10,6 @@ public expect inline fun f6(/*0*/ crossinline s: () -> kotlin.String): kotlin.Un public expect fun f7(/*0*/ x: kotlin.Any): kotlin.Unit public expect fun f8(/*0*/ vararg x: kotlin.Any /*kotlin.Array*/): kotlin.Unit - // -- Module: -- package @@ -22,3 +21,4 @@ public actual inline fun f5(/*0*/ crossinline s: () -> kotlin.String): kotlin.Un public actual inline fun f6(/*0*/ s: () -> kotlin.String): kotlin.Unit public actual fun f7(/*0*/ vararg x: kotlin.Any /*kotlin.Array*/): kotlin.Unit public actual fun f8(/*0*/ x: kotlin.Any): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/multiplatform/topLevelProperty/simpleHeaderVar.txt b/compiler/testData/diagnostics/tests/multiplatform/topLevelProperty/simpleHeaderVar.txt index ef55dea0593..ef7bf0917d3 100644 --- a/compiler/testData/diagnostics/tests/multiplatform/topLevelProperty/simpleHeaderVar.txt +++ b/compiler/testData/diagnostics/tests/multiplatform/topLevelProperty/simpleHeaderVar.txt @@ -3,14 +3,13 @@ package public expect var foo: kotlin.String - // -- Module: -- package public actual var foo: kotlin.String - // -- Module: -- package public actual var foo: kotlin.String + diff --git a/compiler/testData/diagnostics/tests/namedArguments/mixedNamedPosition/secondNamed.fir.kt b/compiler/testData/diagnostics/tests/namedArguments/mixedNamedPosition/secondNamed.fir.kt index c46ef743c54..60037b304c0 100644 --- a/compiler/testData/diagnostics/tests/namedArguments/mixedNamedPosition/secondNamed.fir.kt +++ b/compiler/testData/diagnostics/tests/namedArguments/mixedNamedPosition/secondNamed.fir.kt @@ -16,3 +16,4 @@ fun main() { foo(b = "first", a = "a", "second") // prints "a, second" reformat(normalizeCase = "first",str = "","second",false,true, 's' ) } + diff --git a/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/AssertNotNull.fir.kt b/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/AssertNotNull.fir.kt index c86e322fbab..88c1df2e526 100644 --- a/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/AssertNotNull.fir.kt +++ b/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/AssertNotNull.fir.kt @@ -36,4 +36,4 @@ fun main() { val f : String = a!! checkSubtype(a!!) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/AssertNotNull.kt b/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/AssertNotNull.kt index 7da916ddce0..211ce6449e1 100644 --- a/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/AssertNotNull.kt +++ b/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/AssertNotNull.kt @@ -35,5 +35,5 @@ fun main() { } val f : String = a!! - checkSubtype(a!!) -} \ No newline at end of file + checkSubtype(a!!) +} diff --git a/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2216.kt b/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2216.kt index fd169ae4710..4db26fe8a4f 100644 --- a/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2216.kt +++ b/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2216.kt @@ -15,7 +15,7 @@ fun foo() { val y: Int? = 0 val z: Int? = 0 - bar(if (y != null) y else z, y) + bar(if (y != null) y else z, y) y + 2 baz(y, y, if (y == null) return else y, y) baz(y, z!!, z, y) diff --git a/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/nullableReceiverWithOverloadedMethod.kt b/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/nullableReceiverWithOverloadedMethod.kt index 98add7026d6..4fd00ebcb62 100644 --- a/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/nullableReceiverWithOverloadedMethod.kt +++ b/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/nullableReceiverWithOverloadedMethod.kt @@ -26,4 +26,4 @@ class B { 6 }) } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/unstableSmartcastWithOverloadedExtensions.kt b/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/unstableSmartcastWithOverloadedExtensions.kt index 3dd22f00ca3..8a05ee7fba5 100644 --- a/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/unstableSmartcastWithOverloadedExtensions.kt +++ b/compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/unstableSmartcastWithOverloadedExtensions.kt @@ -11,4 +11,4 @@ fun smartCastInterference(b: B) { if (a != null) { a.foo(b) } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/nullableTypes/nullableArgumentToNonNullParameterPlatform.kt b/compiler/testData/diagnostics/tests/nullableTypes/nullableArgumentToNonNullParameterPlatform.kt index bec2e0777e5..718554dae0d 100644 --- a/compiler/testData/diagnostics/tests/nullableTypes/nullableArgumentToNonNullParameterPlatform.kt +++ b/compiler/testData/diagnostics/tests/nullableTypes/nullableArgumentToNonNullParameterPlatform.kt @@ -15,4 +15,4 @@ fun test(j: J, nullStr: String?, nullByte: Byte?, nullDouble: Double?) { j.foo(nullStr) j.foo(nullDouble) j.foo(nullByte) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/nullableTypes/nullableArgumentToNonNullParameterSimple.kt b/compiler/testData/diagnostics/tests/nullableTypes/nullableArgumentToNonNullParameterSimple.kt index 764767b9c16..bf7b67381db 100644 --- a/compiler/testData/diagnostics/tests/nullableTypes/nullableArgumentToNonNullParameterSimple.kt +++ b/compiler/testData/diagnostics/tests/nullableTypes/nullableArgumentToNonNullParameterSimple.kt @@ -10,4 +10,4 @@ fun bar(nullX: Int?, nullY: String?, notNullY: String) { foo(nullX, notNullY) foo(nullX, nullY) foo() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/nullableTypes/safeCallOnTypeWithNullableUpperBound.fir.kt b/compiler/testData/diagnostics/tests/nullableTypes/safeCallOnTypeWithNullableUpperBound.fir.kt index 4cedf9fc624..99e341d1bfa 100644 --- a/compiler/testData/diagnostics/tests/nullableTypes/safeCallOnTypeWithNullableUpperBound.fir.kt +++ b/compiler/testData/diagnostics/tests/nullableTypes/safeCallOnTypeWithNullableUpperBound.fir.kt @@ -11,4 +11,4 @@ fun T.testThis(): String? { return this?.toString() } return this?.toString() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/nullableTypes/safeCallOnTypeWithNullableUpperBound.kt b/compiler/testData/diagnostics/tests/nullableTypes/safeCallOnTypeWithNullableUpperBound.kt index 0476d26f7da..27b11f14094 100644 --- a/compiler/testData/diagnostics/tests/nullableTypes/safeCallOnTypeWithNullableUpperBound.kt +++ b/compiler/testData/diagnostics/tests/nullableTypes/safeCallOnTypeWithNullableUpperBound.kt @@ -10,5 +10,5 @@ fun T.testThis(): String? { if (this != null) { return this?.toString() } - return this?.toString() -} \ No newline at end of file + return this?.toString() +} diff --git a/compiler/testData/diagnostics/tests/numbers/characterIsNotANumber.kt b/compiler/testData/diagnostics/tests/numbers/characterIsNotANumber.kt index c91e751e401..0b478abd11b 100644 --- a/compiler/testData/diagnostics/tests/numbers/characterIsNotANumber.kt +++ b/compiler/testData/diagnostics/tests/numbers/characterIsNotANumber.kt @@ -8,5 +8,5 @@ fun test() { foo(c) val d: Char? = 'd' - foo(d!!) + foo(d!!) } diff --git a/compiler/testData/diagnostics/tests/numbers/doublesInSimpleConstraints.kt b/compiler/testData/diagnostics/tests/numbers/doublesInSimpleConstraints.kt index e17f289ee67..aa00626fded 100644 --- a/compiler/testData/diagnostics/tests/numbers/doublesInSimpleConstraints.kt +++ b/compiler/testData/diagnostics/tests/numbers/doublesInSimpleConstraints.kt @@ -21,5 +21,5 @@ fun test() { val d = either(11, 2.3) checkSubtype(d) - val e: Float = id(1) + val e: Float = id(1) } diff --git a/compiler/testData/diagnostics/tests/numbers/intValuesOutOfRange.kt b/compiler/testData/diagnostics/tests/numbers/intValuesOutOfRange.kt index 2bbe756f018..121c51f3363 100644 --- a/compiler/testData/diagnostics/tests/numbers/intValuesOutOfRange.kt +++ b/compiler/testData/diagnostics/tests/numbers/intValuesOutOfRange.kt @@ -13,5 +13,5 @@ fun main() { //not 'An integer literal does not conform to the expected type Int/Long' val l: Long = 1111111111111117777777777777777 foo(11111111111111177777777777777) - bar(11111111111111177777777777777) + bar(11111111111111177777777777777) } diff --git a/compiler/testData/diagnostics/tests/numbers/numbersInSimpleConstraints.kt b/compiler/testData/diagnostics/tests/numbers/numbersInSimpleConstraints.kt index 4c6fbb91feb..92d54db7d5c 100644 --- a/compiler/testData/diagnostics/tests/numbers/numbersInSimpleConstraints.kt +++ b/compiler/testData/diagnostics/tests/numbers/numbersInSimpleConstraints.kt @@ -17,9 +17,9 @@ fun otherGeneric(l: List) {} fun test() { val a: Byte = id(1) - val b: Byte = id(300) + val b: Byte = id(300) - val c: Int = id(9223372036854775807) + val c: Int = id(9223372036854775807) val d = id(22) checkSubtype(d) @@ -29,14 +29,14 @@ fun test() { val f: Byte = either(1, 2) - val g: Byte = either(1, 300) + val g: Byte = either(1, 300) other(11) - otherGeneric(1) + otherGeneric(1) val r = either(1, "") - r checkType { _() } + r checkType { _() } use(a, b, c, d, e, f, g, r) } @@ -48,7 +48,7 @@ interface Inv fun exactBound(t: T, l: Inv): T = throw Exception("$t $l") fun testExactBound(invS: Inv, invI: Inv, invB: Inv) { - exactBound(1, invS) + exactBound(1, invS) exactBound(1, invI) val b = exactBound(1, invB) @@ -61,7 +61,7 @@ fun lowerBound(t: T, l : Cov): T = throw Exception("$t $l") fun testLowerBound(cov: Cov, covN: Cov) { val r = lowerBound(1, cov) - r checkType { _() } + r checkType { _() } val n = lowerBound(1, covN) n checkType { _() } @@ -72,7 +72,7 @@ interface Contr fun upperBound(t: T, l: Contr): T = throw Exception("$t $l") fun testUpperBound(contrS: Contr, contrB: Contr, contrN: Contr) { - upperBound(1, contrS) + upperBound(1, contrS) val n = upperBound(1, contrN) n checkType { _() } diff --git a/compiler/testData/diagnostics/tests/objects/kt21515/annotationConstructor.kt b/compiler/testData/diagnostics/tests/objects/kt21515/annotationConstructor.kt index 8129714dda7..87312b7a079 100644 --- a/compiler/testData/diagnostics/tests/objects/kt21515/annotationConstructor.kt +++ b/compiler/testData/diagnostics/tests/objects/kt21515/annotationConstructor.kt @@ -10,4 +10,4 @@ class Derived : Base() { @Foo fun foo() = 42 -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesNew.kt b/compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesNew.kt index d062660d407..5ed8eb07fb9 100644 --- a/compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesNew.kt +++ b/compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesNew.kt @@ -139,4 +139,4 @@ class C : O.B() { // DEPRECATED: Classifiers from supertypes of our own companion val r = FromDelta::foo -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesOld.kt b/compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesOld.kt index 70899a07f0e..6aa265ee69d 100644 --- a/compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesOld.kt +++ b/compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesOld.kt @@ -139,4 +139,4 @@ class C : O.B() { // DEPRECATED: Classifiers from supertypes of our own companion val r = FromDelta::foo -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesOldComplexCases.kt b/compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesOldComplexCases.kt index a774f4f746e..bed3061e562 100644 --- a/compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesOldComplexCases.kt +++ b/compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesOldComplexCases.kt @@ -66,4 +66,4 @@ object D { class Derived : Base() { val a = FromBaseCompanion::foo } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedOld.kt b/compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedOld.kt index f7113d0e739..88805b91fd9 100644 --- a/compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedOld.kt +++ b/compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedOld.kt @@ -97,4 +97,4 @@ open class C : O.B() { // DEPRECATED: Classifiers from supertypes of our own companion open class r : FromDelta() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/objects/kt21515/staticsFromJavaOld.kt b/compiler/testData/diagnostics/tests/objects/kt21515/staticsFromJavaOld.kt index 5331d6f75e5..d550d8aa03b 100644 --- a/compiler/testData/diagnostics/tests/objects/kt21515/staticsFromJavaOld.kt +++ b/compiler/testData/diagnostics/tests/objects/kt21515/staticsFromJavaOld.kt @@ -45,4 +45,4 @@ class Derived : Base() { class JavaStaticInSupertypeList : Classifier() { } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorOld.kt b/compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorOld.kt index 47eace1ee00..68cefbafeab 100644 --- a/compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorOld.kt +++ b/compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorOld.kt @@ -96,4 +96,4 @@ class C : O.B() { // DEPRECATED: Classifiers from supertypes of our own companion val r = FromDelta() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/objects/localObjects.kt b/compiler/testData/diagnostics/tests/objects/localObjects.kt index 882e3e0aa53..2b214af97a0 100644 --- a/compiler/testData/diagnostics/tests/objects/localObjects.kt +++ b/compiler/testData/diagnostics/tests/objects/localObjects.kt @@ -12,4 +12,4 @@ fun foo() { val f = { object e {} } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/operatorRem/deprecatedModConvention.kt b/compiler/testData/diagnostics/tests/operatorRem/deprecatedModConvention.kt index d25e4468d83..1a323c3c11c 100644 --- a/compiler/testData/diagnostics/tests/operatorRem/deprecatedModConvention.kt +++ b/compiler/testData/diagnostics/tests/operatorRem/deprecatedModConvention.kt @@ -35,4 +35,4 @@ fun foo() { OldMod.mod(1) ModExtension.mod(1) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/operatorRem/noDeprecatedModConventionWithoutFeature.kt b/compiler/testData/diagnostics/tests/operatorRem/noDeprecatedModConventionWithoutFeature.kt index c8b3a80504f..6bea766e865 100644 --- a/compiler/testData/diagnostics/tests/operatorRem/noDeprecatedModConventionWithoutFeature.kt +++ b/compiler/testData/diagnostics/tests/operatorRem/noDeprecatedModConventionWithoutFeature.kt @@ -35,4 +35,4 @@ fun foo() { OldMod.mod(1) ModExtension.mod(1) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/operatorRem/numberRemConversions.kt b/compiler/testData/diagnostics/tests/operatorRem/numberRemConversions.kt index 8a4f61dc926..468608b6a21 100644 --- a/compiler/testData/diagnostics/tests/operatorRem/numberRemConversions.kt +++ b/compiler/testData/diagnostics/tests/operatorRem/numberRemConversions.kt @@ -12,4 +12,4 @@ fun test() { fooShort(1 % 1) } -public operator fun Int.rem(other: Int): Int = 0 \ No newline at end of file +public operator fun Int.rem(other: Int): Int = 0 diff --git a/compiler/testData/diagnostics/tests/operatorRem/preferRemWithImplicitReceivers.kt b/compiler/testData/diagnostics/tests/operatorRem/preferRemWithImplicitReceivers.kt index cd1b40ce8df..67caa7fb50f 100644 --- a/compiler/testData/diagnostics/tests/operatorRem/preferRemWithImplicitReceivers.kt +++ b/compiler/testData/diagnostics/tests/operatorRem/preferRemWithImplicitReceivers.kt @@ -17,4 +17,4 @@ fun test() { } } -fun takeString(s: String) {} \ No newline at end of file +fun takeString(s: String) {} diff --git a/compiler/testData/diagnostics/tests/operatorsOverloading/kt11300.fir.kt b/compiler/testData/diagnostics/tests/operatorsOverloading/kt11300.fir.kt index 9542129f87d..b09a1166905 100644 --- a/compiler/testData/diagnostics/tests/operatorsOverloading/kt11300.fir.kt +++ b/compiler/testData/diagnostics/tests/operatorsOverloading/kt11300.fir.kt @@ -10,4 +10,4 @@ fun main() { a[1]++ a[1] += 3 a[1] = a[1] + 3 -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/operatorsOverloading/kt11300.kt b/compiler/testData/diagnostics/tests/operatorsOverloading/kt11300.kt index 1c3ba2925e5..fe05453ce05 100644 --- a/compiler/testData/diagnostics/tests/operatorsOverloading/kt11300.kt +++ b/compiler/testData/diagnostics/tests/operatorsOverloading/kt11300.kt @@ -7,7 +7,7 @@ class A { fun main() { val a = A() - a[1]++ - a[1] += 3 + a[1]++ + a[1] += 3 a[1] = a[1] + 3 -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/operatorsOverloading/kt13330.fir.kt b/compiler/testData/diagnostics/tests/operatorsOverloading/kt13330.fir.kt index 13bc8707003..4b6ff721930 100644 --- a/compiler/testData/diagnostics/tests/operatorsOverloading/kt13330.fir.kt +++ b/compiler/testData/diagnostics/tests/operatorsOverloading/kt13330.fir.kt @@ -1,4 +1,4 @@ // !WITH_NEW_INFERENCE //KT-13330 AssertionError: Illegal resolved call to variable with invoke -fun foo(exec: (String.() -> Unit)?) = "".exec() // is test data tag here \ No newline at end of file +fun foo(exec: (String.() -> Unit)?) = "".exec() // is test data tag here diff --git a/compiler/testData/diagnostics/tests/operatorsOverloading/kt13330.kt b/compiler/testData/diagnostics/tests/operatorsOverloading/kt13330.kt index 33795f62314..7d17e513ad6 100644 --- a/compiler/testData/diagnostics/tests/operatorsOverloading/kt13330.kt +++ b/compiler/testData/diagnostics/tests/operatorsOverloading/kt13330.kt @@ -1,4 +1,4 @@ // !WITH_NEW_INFERENCE //KT-13330 AssertionError: Illegal resolved call to variable with invoke -fun foo(exec: (String.() -> Unit)?) = "".exec<caret>() // is test data tag here \ No newline at end of file +fun foo(exec: (String.() -> Unit)?) = "".exec<caret>() // is test data tag here diff --git a/compiler/testData/diagnostics/tests/overload/kt2493.fir.kt b/compiler/testData/diagnostics/tests/overload/kt2493.fir.kt index ccde55d8321..39b45d7b9d6 100644 --- a/compiler/testData/diagnostics/tests/overload/kt2493.fir.kt +++ b/compiler/testData/diagnostics/tests/overload/kt2493.fir.kt @@ -17,4 +17,4 @@ fun main() { AImpl().f() BImpl().f() C().f() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/overload/kt2493.kt b/compiler/testData/diagnostics/tests/overload/kt2493.kt index 27edddd87fa..73424902928 100644 --- a/compiler/testData/diagnostics/tests/overload/kt2493.kt +++ b/compiler/testData/diagnostics/tests/overload/kt2493.kt @@ -16,5 +16,5 @@ class C: A, B fun main() { AImpl().f() BImpl().f() - C().f() -} \ No newline at end of file + C().f() +} diff --git a/compiler/testData/diagnostics/tests/override/AllPrivateFromSuperTypes.kt b/compiler/testData/diagnostics/tests/override/AllPrivateFromSuperTypes.kt index e92b440e116..f78594497fb 100644 --- a/compiler/testData/diagnostics/tests/override/AllPrivateFromSuperTypes.kt +++ b/compiler/testData/diagnostics/tests/override/AllPrivateFromSuperTypes.kt @@ -11,4 +11,4 @@ open class C { class Subject : C(), A { val c = a -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/platformTypes/commonSupertype/withNothing.fir.kt b/compiler/testData/diagnostics/tests/platformTypes/commonSupertype/withNothing.fir.kt index 739c9e166f4..8ca71dcd74b 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/commonSupertype/withNothing.fir.kt +++ b/compiler/testData/diagnostics/tests/platformTypes/commonSupertype/withNothing.fir.kt @@ -1,7 +1,7 @@ // !WITH_NEW_INFERENCE // !DIAGNOSTICS: -UNUSED_PARAMETER // !CHECK_TYPE -// JAVAC_SKIP +// SKIP_JAVAC // NI_EXPECTED_FILE // FILE: p/J.java @@ -24,4 +24,4 @@ fun test(a: Out, b: Out>) { val v = f(a, b, out(J.j())) v checkType { _>() } v checkType { _>() } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/platformTypes/commonSupertype/withNothing.kt b/compiler/testData/diagnostics/tests/platformTypes/commonSupertype/withNothing.kt index 8d520ab13ed..eec363d673e 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/commonSupertype/withNothing.kt +++ b/compiler/testData/diagnostics/tests/platformTypes/commonSupertype/withNothing.kt @@ -1,7 +1,7 @@ // !WITH_NEW_INFERENCE // !DIAGNOSTICS: -UNUSED_PARAMETER // !CHECK_TYPE -// JAVAC_SKIP +// SKIP_JAVAC // NI_EXPECTED_FILE // FILE: p/J.java @@ -23,5 +23,5 @@ fun out(t: T): Out> = null!! fun test(a: Out, b: Out>) { val v = f(a, b, out(J.j())) v checkType { _>() } - v checkType { _>() } -} \ No newline at end of file + v checkType { _>() } +} diff --git a/compiler/testData/diagnostics/tests/platformTypes/methodCall/singleton.fir.kt b/compiler/testData/diagnostics/tests/platformTypes/methodCall/singleton.fir.kt index 395fbdddb07..5cce6cae9c7 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/methodCall/singleton.fir.kt +++ b/compiler/testData/diagnostics/tests/platformTypes/methodCall/singleton.fir.kt @@ -7,4 +7,4 @@ fun test() { var nullable: Foo? = null val foo: Collection = java.util.Collections.singleton(nullable) val foo1: Collection = java.util.Collections.singleton(nullable!!) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/platformTypes/methodCall/singleton.kt b/compiler/testData/diagnostics/tests/platformTypes/methodCall/singleton.kt index 8a6b6df8bcb..4a719283223 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/methodCall/singleton.kt +++ b/compiler/testData/diagnostics/tests/platformTypes/methodCall/singleton.kt @@ -5,6 +5,6 @@ interface Foo fun test() { var nullable: Foo? = null - val foo: Collection = java.util.Collections.singleton(nullable) + val foo: Collection = java.util.Collections.singleton(nullable) val foo1: Collection = java.util.Collections.singleton(nullable!!) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/platformTypes/notNullTypeParameter/methodTypeParameter.kt b/compiler/testData/diagnostics/tests/platformTypes/notNullTypeParameter/methodTypeParameter.kt index 7629ccbec8c..fd07ab11be7 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/notNullTypeParameter/methodTypeParameter.kt +++ b/compiler/testData/diagnostics/tests/platformTypes/notNullTypeParameter/methodTypeParameter.kt @@ -11,9 +11,9 @@ public class A { // FILE: k.kt fun test() { - A.bar(null, "") + A.bar(null, "") A.bar(null, "") A.bar(null, "") - A.bar(null, A.platformString()) + A.bar(null, A.platformString()) } diff --git a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/arithmetic.kt b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/arithmetic.kt index e82ea974494..8f89d89fa9f 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/arithmetic.kt +++ b/compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/arithmetic.kt @@ -52,4 +52,4 @@ fun test() { platformNN += 1 platformN += 1 platformJ += 1 -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/platformTypes/rawTypes/arrays.kt b/compiler/testData/diagnostics/tests/platformTypes/rawTypes/arrays.kt index 5b34f9874cf..b4e216c8712 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/rawTypes/arrays.kt +++ b/compiler/testData/diagnostics/tests/platformTypes/rawTypes/arrays.kt @@ -28,15 +28,15 @@ fun main() { val raw = Test.rawAField raw.charSequences = arrayOf() - raw.charSequences = arrayOf() + raw.charSequences = arrayOf() raw.maps = arrayOf>() raw.maps = arrayOf>() - raw.maps = arrayOf>() + raw.maps = arrayOf>() raw.arraysOfLists = arrayOf>>() - raw.arraysOfLists = arrayOf>() - raw.arraysOfLists = arrayOf>>() + raw.arraysOfLists = arrayOf>() + raw.arraysOfLists = arrayOf>>() raw.arraysOfAny = arrayOf>>() diff --git a/compiler/testData/diagnostics/tests/platformTypes/rawTypes/nonGenericRawMember.kt b/compiler/testData/diagnostics/tests/platformTypes/rawTypes/nonGenericRawMember.kt index 6fe7cdcf74f..6cb93787071 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/rawTypes/nonGenericRawMember.kt +++ b/compiler/testData/diagnostics/tests/platformTypes/rawTypes/nonGenericRawMember.kt @@ -30,5 +30,5 @@ val strList: List = null!! fun main() { val rawB = Test.rawAField.b; // Raw(A).b is not erased because it have no type parameters - var rawInner = rawB.bar(!", "List")!>strList) + var rawInner = rawB.bar(!; List")!>strList) } diff --git a/compiler/testData/diagnostics/tests/platformTypes/rawTypes/samRaw.kt b/compiler/testData/diagnostics/tests/platformTypes/rawTypes/samRaw.kt index 0f43cdde327..cb4a5be6f32 100644 --- a/compiler/testData/diagnostics/tests/platformTypes/rawTypes/samRaw.kt +++ b/compiler/testData/diagnostics/tests/platformTypes/rawTypes/samRaw.kt @@ -21,7 +21,7 @@ class B { fun main() { fun println() {} // All parameters in SAM adapter of `foo` have functional types - B().foo({ println() }, B.bar()) + B().foo({ println() }, B.bar()) // So you should use SAM constructors when you want to use mix lambdas and Java objects B().foo(Runnable { println() }, B.bar()) B().foo({ println() }, { it: Any? -> it == null } ) diff --git a/compiler/testData/diagnostics/tests/privateInFile/visibility.kt b/compiler/testData/diagnostics/tests/privateInFile/visibility.kt index 5c92a64dbed..f61df940fd2 100644 --- a/compiler/testData/diagnostics/tests/privateInFile/visibility.kt +++ b/compiler/testData/diagnostics/tests/privateInFile/visibility.kt @@ -29,21 +29,21 @@ package a fun test() { val y = makeA() - y.bar() - foo() + y.bar() + foo() - val u : A = A() + val u : A = A() - val z = x - x = 30 + val z = x + x = 30 - val po = PO + val po = PO val v = xx - xx = 40 + xx = 40 } -class B : A() {} +class B : A() {} class Q { class W { diff --git a/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/cantBeInferred.kt b/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/cantBeInferred.kt index cea319d6347..686ff76a21d 100644 --- a/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/cantBeInferred.kt +++ b/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/cantBeInferred.kt @@ -1,7 +1,7 @@ // !WITH_NEW_INFERENCE // NI_EXPECTED_FILE -val x get() = foo() -val y get() = bar() +val x get() = foo() +val y get() = bar() fun foo(): E = null!! fun bar(): List = null!! diff --git a/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/objectExpression.kt b/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/objectExpression.kt index 7726b324b40..fed89a4295e 100644 --- a/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/objectExpression.kt +++ b/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/objectExpression.kt @@ -7,7 +7,7 @@ object Outer { get() = 0 override fun get(index: Int): Char { - checkSubtype(x) + checkSubtype(x) return ' ' } diff --git a/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/recursiveGetter.kt b/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/recursiveGetter.kt index fdaa7e1e5c0..86f81277cb9 100644 --- a/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/recursiveGetter.kt +++ b/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/recursiveGetter.kt @@ -2,16 +2,16 @@ // !CHECK_TYPE // NI_EXPECTED_FILE -val x get() = x +val x get() = x class A { - val y get() = y + val y get() = y val a get() = b - val b get() = a + val b get() = a - val z1 get() = id(z1) - val z2 get() = l(z2) + val z1 get() = id(z1) + val z2 get() = l(z2) val u get() = field } diff --git a/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/unsupportedInferenceFromGetters.kt b/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/unsupportedInferenceFromGetters.kt index ebb83e878de..994e836395f 100644 --- a/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/unsupportedInferenceFromGetters.kt +++ b/compiler/testData/diagnostics/tests/properties/inferenceFromGetters/unsupportedInferenceFromGetters.kt @@ -8,8 +8,8 @@ } // cantBeInferred.kt -val x1 get() = foo() -val y1 get() = bar() +val x1 get() = foo() +val y1 get() = bar() fun foo(): E = null!! fun bar(): List = null!! @@ -43,7 +43,7 @@ fun l(x: E): List = null!! } // recursive -val x4 get() = x4 +val x4 get() = x4 // null as nothing val x5 get() = null @@ -68,4 +68,4 @@ object Outer { set(q) { x = q } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/qualifiedExpression/GenericClassVsPackage.txt b/compiler/testData/diagnostics/tests/qualifiedExpression/GenericClassVsPackage.txt index bf0b415c4c8..fa994120836 100644 --- a/compiler/testData/diagnostics/tests/qualifiedExpression/GenericClassVsPackage.txt +++ b/compiler/testData/diagnostics/tests/qualifiedExpression/GenericClassVsPackage.txt @@ -15,7 +15,6 @@ package a { } } - // -- Module: -- package @@ -37,14 +36,12 @@ package a { } } - // -- Module: -- package public fun test(/*0*/ ab_c: a.b.c): kotlin.Unit public fun test2(/*0*/ ab_c: a.b.c): kotlin.Unit - // -- Module: -- package @@ -59,7 +56,6 @@ package a { } } - // -- Module: -- package @@ -79,9 +75,9 @@ public final class a { } } - // -- Module: -- package public fun test(/*0*/ a_b: a.b): kotlin.Unit public fun test2(/*0*/ _ab: a.b): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/qualifiedExpression/PackageVsClass.txt b/compiler/testData/diagnostics/tests/qualifiedExpression/PackageVsClass.txt index 23ce2a51557..d6f69c45ad4 100644 --- a/compiler/testData/diagnostics/tests/qualifiedExpression/PackageVsClass.txt +++ b/compiler/testData/diagnostics/tests/qualifiedExpression/PackageVsClass.txt @@ -1,3 +1,49 @@ +// -- Module: -- +package + +package a { + + package a.b { + + public final class c { + public constructor c() + public final fun ab_c(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } +} + +// -- Module: -- +package + +package a { + public fun a_fun(): kotlin.Unit + + public final class b { + public constructor b() + public final fun a_b(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + + public final class c { + public constructor c() + public final fun a_bc(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + } +} + +// -- Module: -- +package + +public fun test(/*0*/ a_b: a.b): kotlin.Unit +public fun test2(/*0*/ ab_c: a.b.c): kotlin.Unit + // -- Module: <_m1> -- package @@ -24,7 +70,6 @@ package a { } } - // -- Module: <_m2> -- package @@ -48,58 +93,9 @@ package a { } } - // -- Module: <_m3> -- package public fun test(/*0*/ a_b: a.b): kotlin.Unit public fun test2(/*0*/ ab_c: a.b.c): kotlin.Unit - -// -- Module: -- -package - -package a { - - package a.b { - - public final class c { - public constructor c() - public final fun ab_c(): kotlin.Unit - public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int - public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String - } - } -} - - -// -- Module: -- -package - -package a { - public fun a_fun(): kotlin.Unit - - public final class b { - public constructor b() - public final fun a_b(): kotlin.Unit - public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int - public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String - - public final class c { - public constructor c() - public final fun a_bc(): kotlin.Unit - public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int - public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String - } - } -} - - -// -- Module: -- -package - -public fun test(/*0*/ a_b: a.b): kotlin.Unit -public fun test2(/*0*/ ab_c: a.b.c): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/qualifiedExpression/PackageVsClass2.txt b/compiler/testData/diagnostics/tests/qualifiedExpression/PackageVsClass2.txt index 3b7f3ac663c..74b2ba4f0d9 100644 --- a/compiler/testData/diagnostics/tests/qualifiedExpression/PackageVsClass2.txt +++ b/compiler/testData/diagnostics/tests/qualifiedExpression/PackageVsClass2.txt @@ -26,7 +26,6 @@ package a { } } - // -- Module: -- package @@ -41,10 +40,10 @@ package test { } } - // -- Module: -- package package test { public fun foo(/*0*/ i: a.a): kotlin.Unit } + diff --git a/compiler/testData/diagnostics/tests/qualifiedExpression/PackageVsRootClass.txt b/compiler/testData/diagnostics/tests/qualifiedExpression/PackageVsRootClass.txt index 87b9a3cdda2..2de0453918f 100644 --- a/compiler/testData/diagnostics/tests/qualifiedExpression/PackageVsRootClass.txt +++ b/compiler/testData/diagnostics/tests/qualifiedExpression/PackageVsRootClass.txt @@ -12,7 +12,6 @@ package a { } } - // -- Module: -- package @@ -31,7 +30,6 @@ public final class a { } } - // -- Module: -- package @@ -44,3 +42,4 @@ package a { package some { public fun test(/*0*/ a_b: a.b): kotlin.Unit } + diff --git a/compiler/testData/diagnostics/tests/qualifiedExpression/TypeWithError.fir.kt b/compiler/testData/diagnostics/tests/qualifiedExpression/TypeWithError.fir.kt index 2d0f2a637ed..ee8c478f187 100644 --- a/compiler/testData/diagnostics/tests/qualifiedExpression/TypeWithError.fir.kt +++ b/compiler/testData/diagnostics/tests/qualifiedExpression/TypeWithError.fir.kt @@ -29,4 +29,4 @@ fun test4(a: A.B.ee): A.B.ee< fun test5(a: A.ee): A.ee { val aa: A.ee = null!! -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/qualifiedExpression/TypeWithError.kt b/compiler/testData/diagnostics/tests/qualifiedExpression/TypeWithError.kt index 537aacf1120..e6119f16e33 100644 --- a/compiler/testData/diagnostics/tests/qualifiedExpression/TypeWithError.kt +++ b/compiler/testData/diagnostics/tests/qualifiedExpression/TypeWithError.kt @@ -17,16 +17,16 @@ fun test1(a: A.B.): A.B. { fun test2(a: A.e.C): A.e.C { val aa: A.e.C = null!! -} +} fun test3(a: a.A.C): a.A.C { val aa: a.A.C = null!! -} +} fun test4(a: A.B.ee): A.B.ee { val aa: A.B.ee = null!! -} +} fun test5(a: A.ee): A.ee { val aa: A.ee = null!! -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/qualifiedExpression/calleeExpressionAsCallExpression.kt b/compiler/testData/diagnostics/tests/qualifiedExpression/calleeExpressionAsCallExpression.kt index da1ae67a9fc..42784851b6e 100644 --- a/compiler/testData/diagnostics/tests/qualifiedExpression/calleeExpressionAsCallExpression.kt +++ b/compiler/testData/diagnostics/tests/qualifiedExpression/calleeExpressionAsCallExpression.kt @@ -1,2 +1,2 @@ // !WITH_NEW_INFERENCE -val unwrapped = some<sdf()()Any>::unwrap \ No newline at end of file +val unwrapped = some<sdf()()Any>::unwrap diff --git a/compiler/testData/diagnostics/tests/qualifiedExpression/nullCalleeExpression.fir.kt b/compiler/testData/diagnostics/tests/qualifiedExpression/nullCalleeExpression.fir.kt index 73d33cd86cb..1f624d4c7ca 100644 --- a/compiler/testData/diagnostics/tests/qualifiedExpression/nullCalleeExpression.fir.kt +++ b/compiler/testData/diagnostics/tests/qualifiedExpression/nullCalleeExpression.fir.kt @@ -1,4 +1,4 @@ // !WITH_NEW_INFERENCE // NI_EXPECTED_FILE -val unwrapped = some.<cabc$Wrapper<out Any>::unwrap \ No newline at end of file +val unwrapped = some.<cabc$Wrapper<out Any>::unwrap diff --git a/compiler/testData/diagnostics/tests/qualifiedExpression/nullCalleeExpression.kt b/compiler/testData/diagnostics/tests/qualifiedExpression/nullCalleeExpression.kt index f7f31abccbc..18db3c8cb6e 100644 --- a/compiler/testData/diagnostics/tests/qualifiedExpression/nullCalleeExpression.kt +++ b/compiler/testData/diagnostics/tests/qualifiedExpression/nullCalleeExpression.kt @@ -1,4 +1,4 @@ // !WITH_NEW_INFERENCE // NI_EXPECTED_FILE -val unwrapped = some.<cabc$WrapperAny>::unwrap \ No newline at end of file +val unwrapped = some.<cabc$WrapperAny>::unwrap diff --git a/compiler/testData/diagnostics/tests/qualifiedExpression/visibleClassVsQualifiedClass.txt b/compiler/testData/diagnostics/tests/qualifiedExpression/visibleClassVsQualifiedClass.txt index 608b9142060..5656716e414 100644 --- a/compiler/testData/diagnostics/tests/qualifiedExpression/visibleClassVsQualifiedClass.txt +++ b/compiler/testData/diagnostics/tests/qualifiedExpression/visibleClassVsQualifiedClass.txt @@ -12,7 +12,6 @@ package a { } } - // -- Module: -- package @@ -34,7 +33,6 @@ package some { } } - // -- Module: -- package @@ -71,3 +69,4 @@ package other2 { package some { public fun test(/*0*/ _ab: some.a.b): kotlin.Unit } + diff --git a/compiler/testData/diagnostics/tests/recovery/absentLeftHandSide.kt b/compiler/testData/diagnostics/tests/recovery/absentLeftHandSide.kt index 864b2e324e2..d2e695571e1 100644 --- a/compiler/testData/diagnostics/tests/recovery/absentLeftHandSide.kt +++ b/compiler/testData/diagnostics/tests/recovery/absentLeftHandSide.kt @@ -8,9 +8,9 @@ fun composite() { } fun html() { - <html></html> + <html></html> } fun html1() { - <html></html>html -} \ No newline at end of file + <html></html>html +} diff --git a/compiler/testData/diagnostics/tests/recovery/namelessInJava.fir.kt b/compiler/testData/diagnostics/tests/recovery/namelessInJava.fir.kt index 78d2e8f4415..7017eaced2e 100644 --- a/compiler/testData/diagnostics/tests/recovery/namelessInJava.fir.kt +++ b/compiler/testData/diagnostics/tests/recovery/namelessInJava.fir.kt @@ -1,4 +1,4 @@ -// JAVAC_SKIP +// SKIP_JAVAC // FILE: p/Nameless.java package p; @@ -15,4 +15,4 @@ import p.* class K : Nameless() { fun () {} val : Int = 1 -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/recovery/namelessInJava.kt b/compiler/testData/diagnostics/tests/recovery/namelessInJava.kt index cc3d82a94f2..8028e9059db 100644 --- a/compiler/testData/diagnostics/tests/recovery/namelessInJava.kt +++ b/compiler/testData/diagnostics/tests/recovery/namelessInJava.kt @@ -1,4 +1,4 @@ -// JAVAC_SKIP +// SKIP_JAVAC // FILE: p/Nameless.java package p; @@ -15,4 +15,4 @@ import p.* class K : Nameless() { fun () {} val : Int = 1 -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/redeclarations/MultiFilePackageRedeclaration.fir.kt b/compiler/testData/diagnostics/tests/redeclarations/MultiFilePackageRedeclaration.fir.kt index 878e410c051..bf06440ab70 100644 --- a/compiler/testData/diagnostics/tests/redeclarations/MultiFilePackageRedeclaration.fir.kt +++ b/compiler/testData/diagnostics/tests/redeclarations/MultiFilePackageRedeclaration.fir.kt @@ -1,7 +1,7 @@ -// FILE: f.kt +// FILE: a.kt package a class b {} -// FILE: f.kt +// FILE: b.kt +package a.b +// FILE: c.kt package a.b -// FILE: f.kt -package a.b \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/redeclarations/MultiFilePackageRedeclaration.kt b/compiler/testData/diagnostics/tests/redeclarations/MultiFilePackageRedeclaration.kt index b56f906ba85..992ab31ce8a 100644 --- a/compiler/testData/diagnostics/tests/redeclarations/MultiFilePackageRedeclaration.kt +++ b/compiler/testData/diagnostics/tests/redeclarations/MultiFilePackageRedeclaration.kt @@ -1,7 +1,7 @@ -// FILE: f.kt +// FILE: a.kt package a class b {} -// FILE: f.kt +// FILE: b.kt +package a.b +// FILE: c.kt package a.b -// FILE: f.kt -package a.b \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/redeclarations/Redeclarations.fir.kt b/compiler/testData/diagnostics/tests/redeclarations/Redeclarations.fir.kt index 9638c6eaa1c..c4def7ab452 100644 --- a/compiler/testData/diagnostics/tests/redeclarations/Redeclarations.fir.kt +++ b/compiler/testData/diagnostics/tests/redeclarations/Redeclarations.fir.kt @@ -1,4 +1,4 @@ -// FILE: f.kt +// FILE: a.kt package redeclarations object A { val x : Int = 0 @@ -10,6 +10,6 @@ package redeclarations val A = 1 -// FILE: f.kt +// FILE: b.kt package redeclarations.A class A {} diff --git a/compiler/testData/diagnostics/tests/redeclarations/Redeclarations.kt b/compiler/testData/diagnostics/tests/redeclarations/Redeclarations.kt index 23ea9548c8f..59e4d358c13 100644 --- a/compiler/testData/diagnostics/tests/redeclarations/Redeclarations.kt +++ b/compiler/testData/diagnostics/tests/redeclarations/Redeclarations.kt @@ -1,4 +1,4 @@ -// FILE: f.kt +// FILE: a.kt package redeclarations object A { val x : Int = 0 @@ -10,6 +10,6 @@ package redeclarations val A = 1 -// FILE: f.kt +// FILE: b.kt package redeclarations.A class A {} diff --git a/compiler/testData/diagnostics/tests/redeclarations/shadowedExtension/infixExtensionVsNonInfixMember.kt b/compiler/testData/diagnostics/tests/redeclarations/shadowedExtension/infixExtensionVsNonInfixMember.kt index 88e3beff360..8833845fbb2 100644 --- a/compiler/testData/diagnostics/tests/redeclarations/shadowedExtension/infixExtensionVsNonInfixMember.kt +++ b/compiler/testData/diagnostics/tests/redeclarations/shadowedExtension/infixExtensionVsNonInfixMember.kt @@ -4,4 +4,4 @@ interface IFoo { } infix fun IFoo.foo(i: Int) = i -infix fun IFoo.bar(i: Int) = i \ No newline at end of file +infix fun IFoo.bar(i: Int) = i diff --git a/compiler/testData/diagnostics/tests/regressions/Jet81.kt b/compiler/testData/diagnostics/tests/regressions/Jet81.kt index e3965aeeb8c..d557e34dd63 100644 --- a/compiler/testData/diagnostics/tests/regressions/Jet81.kt +++ b/compiler/testData/diagnostics/tests/regressions/Jet81.kt @@ -4,7 +4,7 @@ class Test { private val y = object { - val a = y; + val a = y; } val z = y.a; @@ -18,12 +18,12 @@ object A { class Test2 { private val a = object { init { - b + 1 + b + 1 } val x = b val y = 1 } - val b = a.x + val b = a.x val c = a.y } diff --git a/compiler/testData/diagnostics/tests/regressions/OutProjections.fir.kt b/compiler/testData/diagnostics/tests/regressions/OutProjections.fir.kt index d26f8e694c9..8b50c0fe6b8 100644 --- a/compiler/testData/diagnostics/tests/regressions/OutProjections.fir.kt +++ b/compiler/testData/diagnostics/tests/regressions/OutProjections.fir.kt @@ -19,4 +19,4 @@ fun fout(expression : T) : Out = Out() fun fooout() : Out { val p = Point(); return fout(p); -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/regressions/OutProjections.kt b/compiler/testData/diagnostics/tests/regressions/OutProjections.kt index c35554e7d8c..58386a757be 100644 --- a/compiler/testData/diagnostics/tests/regressions/OutProjections.kt +++ b/compiler/testData/diagnostics/tests/regressions/OutProjections.kt @@ -9,7 +9,7 @@ fun f(expression : T) : G = G() fun foo() : G { val p = Point() - return f(p) + return f(p) } class Out() {} @@ -19,4 +19,4 @@ fun fout(expression : T) : Out< { val p = Point(); return fout(p); -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/regressions/correctResultSubstitutorForErrorCandidate.kt b/compiler/testData/diagnostics/tests/regressions/correctResultSubstitutorForErrorCandidate.kt index 6b103f7e083..acf8d9ad5b4 100644 --- a/compiler/testData/diagnostics/tests/regressions/correctResultSubstitutorForErrorCandidate.kt +++ b/compiler/testData/diagnostics/tests/regressions/correctResultSubstitutorForErrorCandidate.kt @@ -2,7 +2,7 @@ // !DIAGNOSTICS: -UNUSED_PARAMETER fun test(a: Int, b: Boolean) { - bar(a.foo(b)) + bar(a.foo(b)) } fun T.foo(l: (T) -> R): R = TODO() diff --git a/compiler/testData/diagnostics/tests/regressions/ea72837.kt b/compiler/testData/diagnostics/tests/regressions/ea72837.kt index d729cf38ef5..173635e8d04 100644 --- a/compiler/testData/diagnostics/tests/regressions/ea72837.kt +++ b/compiler/testData/diagnostics/tests/regressions/ea72837.kt @@ -4,7 +4,7 @@ fun g(x: T) = 1 fun h(x: () -> Unit) = 1 fun foo() { - f(::) - g(::) + f(::) + g(::) h(::) } diff --git a/compiler/testData/diagnostics/tests/regressions/itselfAsUpperBoundLocal.kt b/compiler/testData/diagnostics/tests/regressions/itselfAsUpperBoundLocal.kt index e4642fcac06..6407878e67b 100644 --- a/compiler/testData/diagnostics/tests/regressions/itselfAsUpperBoundLocal.kt +++ b/compiler/testData/diagnostics/tests/regressions/itselfAsUpperBoundLocal.kt @@ -1,5 +1,5 @@ // !WITH_NEW_INFERENCE fun bar() { fun <T: T?> foo() {} - foo() + foo() } diff --git a/compiler/testData/diagnostics/tests/regressions/kt10243.kt b/compiler/testData/diagnostics/tests/regressions/kt10243.kt index 31914ce925a..0845815e599 100644 --- a/compiler/testData/diagnostics/tests/regressions/kt10243.kt +++ b/compiler/testData/diagnostics/tests/regressions/kt10243.kt @@ -4,9 +4,9 @@ private fun doUpdateRegularTasks() { try { while (f) { val xmlText = getText() - if (xmlText == null) {} + if (xmlText == null) {} else { - xmlText.value = 0 // !!! + xmlText.value = 0 // !!! } } diff --git a/compiler/testData/diagnostics/tests/regressions/kt10843.kt b/compiler/testData/diagnostics/tests/regressions/kt10843.kt index c8960bd58fb..60be57a47a0 100644 --- a/compiler/testData/diagnostics/tests/regressions/kt10843.kt +++ b/compiler/testData/diagnostics/tests/regressions/kt10843.kt @@ -1,8 +1,8 @@ // !WITH_NEW_INFERENCE // NI_EXPECTED_FILE // See EA-76890 / KT-10843: NPE during analysis -fun lambda(x : Int?) = x?.let l { - y -> - if (y > 0) return@l x +fun lambda(x : Int?) = x?.let l { + y -> + if (y > 0) return@l x y }!! diff --git a/compiler/testData/diagnostics/tests/regressions/kt11979.fir.kt b/compiler/testData/diagnostics/tests/regressions/kt11979.fir.kt index 9402f2990e2..ad796b0d6e2 100644 --- a/compiler/testData/diagnostics/tests/regressions/kt11979.fir.kt +++ b/compiler/testData/diagnostics/tests/regressions/kt11979.fir.kt @@ -23,4 +23,4 @@ fun test(foo: Foo<*>, g: Bar<*>) { fun main() { val foo = Foo(BarR()) test(foo, MyBar(2)) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/regressions/kt11979.kt b/compiler/testData/diagnostics/tests/regressions/kt11979.kt index cc51a11a15d..2a9334a113f 100644 --- a/compiler/testData/diagnostics/tests/regressions/kt11979.kt +++ b/compiler/testData/diagnostics/tests/regressions/kt11979.kt @@ -17,10 +17,10 @@ class Foo>(val f: F) fun id(t1: T, t2: T) = t2 fun test(foo: Foo<*>, g: Bar<*>) { - id(foo.f, g).t.t + id(foo.f, g).t.t } fun main() { val foo = Foo(BarR()) test(foo, MyBar(2)) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/regressions/kt12898.fir.kt b/compiler/testData/diagnostics/tests/regressions/kt12898.fir.kt index 47770ff2ace..5272cd34b89 100644 --- a/compiler/testData/diagnostics/tests/regressions/kt12898.fir.kt +++ b/compiler/testData/diagnostics/tests/regressions/kt12898.fir.kt @@ -17,4 +17,4 @@ fun f(b: B<*, Any>) { fun main() { f(C("hello")) f(C(null)) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/regressions/kt12898.kt b/compiler/testData/diagnostics/tests/regressions/kt12898.kt index e573d011812..c974e06e263 100644 --- a/compiler/testData/diagnostics/tests/regressions/kt12898.kt +++ b/compiler/testData/diagnostics/tests/regressions/kt12898.kt @@ -8,13 +8,13 @@ interface B { class C(override val t: Any?) : B fun f(b: B<*, Any>) { - val y = b.t - if (y is String?) { - y.length + val y = b.t + if (y is String?) { + y.length } } fun main() { f(C("hello")) f(C(null)) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/regressions/kt13685.kt b/compiler/testData/diagnostics/tests/regressions/kt13685.kt index 71d427dede6..bc5d8303712 100644 --- a/compiler/testData/diagnostics/tests/regressions/kt13685.kt +++ b/compiler/testData/diagnostics/tests/regressions/kt13685.kt @@ -2,6 +2,6 @@ // !DIAGNOSTICS: -UNREACHABLE_CODE fun foo() { - val text: List = null!! - text.map Any?::toString + val text: List = null!! + text.map Any?::toString } diff --git a/compiler/testData/diagnostics/tests/regressions/kt1489_1728.kt b/compiler/testData/diagnostics/tests/regressions/kt1489_1728.kt index 4d5835e75ac..e8a38553320 100644 --- a/compiler/testData/diagnostics/tests/regressions/kt1489_1728.kt +++ b/compiler/testData/diagnostics/tests/regressions/kt1489_1728.kt @@ -19,7 +19,7 @@ class C { fun p() : Resource? = null fun bar() { - foo(p()) { + foo(p()) { } } diff --git a/compiler/testData/diagnostics/tests/regressions/kt24488.fir.kt b/compiler/testData/diagnostics/tests/regressions/kt24488.fir.kt index f454a2de1b0..b4eb7957a51 100644 --- a/compiler/testData/diagnostics/tests/regressions/kt24488.fir.kt +++ b/compiler/testData/diagnostics/tests/regressions/kt24488.fir.kt @@ -12,4 +12,4 @@ fun Array.asIterable(): Iterable = TODO() fun testFrontend() { val bar = Bar() foo(bar) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/regressions/kt24488.kt b/compiler/testData/diagnostics/tests/regressions/kt24488.kt index 1574cb8d248..03710b2c651 100644 --- a/compiler/testData/diagnostics/tests/regressions/kt24488.kt +++ b/compiler/testData/diagnostics/tests/regressions/kt24488.kt @@ -5,11 +5,11 @@ class Bar { val a: Array? = null } -fun foo(bar: Bar) = bar.a?.asIterable() ?: emptyArray() +fun foo(bar: Bar) = bar.a?.asIterable() ?: emptyArray() fun Array.asIterable(): Iterable = TODO() fun testFrontend() { val bar = Bar() foo(bar) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/regressions/kt251.kt b/compiler/testData/diagnostics/tests/regressions/kt251.kt index fb980b2f916..d176a2ec39b 100644 --- a/compiler/testData/diagnostics/tests/regressions/kt251.kt +++ b/compiler/testData/diagnostics/tests/regressions/kt251.kt @@ -6,7 +6,7 @@ class A() { field = value } val y: Int - get(): String = "s" + get(): String = "s" val z: Int get() { return "s" diff --git a/compiler/testData/diagnostics/tests/regressions/kt312.fir.kt b/compiler/testData/diagnostics/tests/regressions/kt312.fir.kt index be907b58530..acc1f575bea 100644 --- a/compiler/testData/diagnostics/tests/regressions/kt312.fir.kt +++ b/compiler/testData/diagnostics/tests/regressions/kt312.fir.kt @@ -7,4 +7,4 @@ fun Array.safeGet(index : Int) : T? { val args : Array = Array(1, {""}) val name : String = args.safeGet(0) // No error, must be type mismatch -val name1 : String? = args.safeGet(0) \ No newline at end of file +val name1 : String? = args.safeGet(0) diff --git a/compiler/testData/diagnostics/tests/regressions/kt312.kt b/compiler/testData/diagnostics/tests/regressions/kt312.kt index 8985a69a3a6..3a9d5e87cc1 100644 --- a/compiler/testData/diagnostics/tests/regressions/kt312.kt +++ b/compiler/testData/diagnostics/tests/regressions/kt312.kt @@ -6,5 +6,5 @@ fun Array.safeGet(index : Int) : T? { } val args : Array = Array(1, {""}) -val name : String = args.safeGet(0) // No error, must be type mismatch -val name1 : String? = args.safeGet(0) \ No newline at end of file +val name : String = args.safeGet(0) // No error, must be type mismatch +val name1 : String? = args.safeGet(0) diff --git a/compiler/testData/diagnostics/tests/regressions/kt328.kt b/compiler/testData/diagnostics/tests/regressions/kt328.kt index e9bbf3d1671..dd94b10c7a0 100644 --- a/compiler/testData/diagnostics/tests/regressions/kt328.kt +++ b/compiler/testData/diagnostics/tests/regressions/kt328.kt @@ -12,14 +12,14 @@ fun bar2() = { //properties //in a class class A() { - val x = { x } + val x = { x } } //in a package -val x = { x } +val x = { x } //KT-787 AssertionError on code 'val x = x' -val z = z +val z = z //KT-329 Assertion failure on local function fun block(f : () -> Unit) = f() diff --git a/compiler/testData/diagnostics/tests/regressions/kt353.kt b/compiler/testData/diagnostics/tests/regressions/kt353.kt index df1c7cf517e..efe7adee74e 100644 --- a/compiler/testData/diagnostics/tests/regressions/kt353.kt +++ b/compiler/testData/diagnostics/tests/regressions/kt353.kt @@ -13,7 +13,7 @@ fun foo(a: A) { val u: Unit = a.gen() // Unit should be inferred if (true) { - a.gen() // Shouldn't work: no info for inference + a.gen() // Shouldn't work: no info for inference } val b : () -> Unit = { @@ -29,5 +29,5 @@ fun foo(a: A) { a.gen() //type mismatch, but Int can be derived } - a.gen() // Shouldn't work: no info for inference + a.gen() // Shouldn't work: no info for inference } diff --git a/compiler/testData/diagnostics/tests/regressions/kt36222.fir.kt b/compiler/testData/diagnostics/tests/regressions/kt36222.fir.kt index d7a23988aaa..1b411a21a07 100644 --- a/compiler/testData/diagnostics/tests/regressions/kt36222.fir.kt +++ b/compiler/testData/diagnostics/tests/regressions/kt36222.fir.kt @@ -7,3 +7,4 @@ fun select(x: K, y: K): K = x fun test() { foo { select("non-null", null) } // inferred String? but String is expected } + diff --git a/compiler/testData/diagnostics/tests/regressions/kt557.kt b/compiler/testData/diagnostics/tests/regressions/kt557.kt index fcfcb202f2a..69c28808b02 100644 --- a/compiler/testData/diagnostics/tests/regressions/kt557.kt +++ b/compiler/testData/diagnostics/tests/regressions/kt557.kt @@ -8,5 +8,5 @@ fun Array.length() : Int { } fun test(array : Array?) { - array?.sure>().length() + array?.sure>().length() } diff --git a/compiler/testData/diagnostics/tests/regressions/kt701.kt b/compiler/testData/diagnostics/tests/regressions/kt701.kt index 5be7b22e089..544a64a28b6 100644 --- a/compiler/testData/diagnostics/tests/regressions/kt701.kt +++ b/compiler/testData/diagnostics/tests/regressions/kt701.kt @@ -14,4 +14,4 @@ public class Throwables() { propagateIfInstanceOf(throwable, getJavaClass()) // Type inference failed: Mismatch while expanding constraints } } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/regressions/kt9682.kt b/compiler/testData/diagnostics/tests/regressions/kt9682.kt index db72922dbd8..8fd48d9de46 100644 --- a/compiler/testData/diagnostics/tests/regressions/kt9682.kt +++ b/compiler/testData/diagnostics/tests/regressions/kt9682.kt @@ -25,4 +25,4 @@ interface IFoo2 { fun test2(foo: Foo) { foo as IFoo2 foo.bar() // should be ambiguity -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/resolve/constructorVsCompanion.kt b/compiler/testData/diagnostics/tests/resolve/constructorVsCompanion.kt index d371da9c931..781679f47e6 100644 --- a/compiler/testData/diagnostics/tests/resolve/constructorVsCompanion.kt +++ b/compiler/testData/diagnostics/tests/resolve/constructorVsCompanion.kt @@ -20,4 +20,4 @@ val a = A val b = B val c = C val d = D -val e = E(42) \ No newline at end of file +val e = E(42) diff --git a/compiler/testData/diagnostics/tests/resolve/dslMarker/dslMarkerWithTypealiasRecursion.kt b/compiler/testData/diagnostics/tests/resolve/dslMarker/dslMarkerWithTypealiasRecursion.kt index 84b73ab44fd..5336f397ce8 100644 --- a/compiler/testData/diagnostics/tests/resolve/dslMarker/dslMarkerWithTypealiasRecursion.kt +++ b/compiler/testData/diagnostics/tests/resolve/dslMarker/dslMarkerWithTypealiasRecursion.kt @@ -13,12 +13,12 @@ typealias YBar = ZBar typealias ZBar = YBar fun Foo.foo(body: Foo.() -> Unit) = body() -fun Foo.zbar(body: ZBar.() -> Unit) = Bar().body() +fun Foo.zbar(body: ZBar.() -> Unit) = Bar().body() fun test() { Foo().foo { zbar { - foo {} + foo {} } } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/resolve/invoke/errors/ambiguityForInvoke.kt b/compiler/testData/diagnostics/tests/resolve/invoke/errors/ambiguityForInvoke.kt index df4f3e17450..3b22fe99ffa 100644 --- a/compiler/testData/diagnostics/tests/resolve/invoke/errors/ambiguityForInvoke.kt +++ b/compiler/testData/diagnostics/tests/resolve/invoke/errors/ambiguityForInvoke.kt @@ -5,7 +5,7 @@ fun Int.invoke(i: Int, a: Any) {} fun Int.invoke(a: Any, i: Int) {} fun foo(i: Int) { - i(1, 1) + i(1, 1) - 5(1, 2) + 5(1, 2) } diff --git a/compiler/testData/diagnostics/tests/resolve/invoke/errors/typeInferenceErrorForInvoke.kt b/compiler/testData/diagnostics/tests/resolve/invoke/errors/typeInferenceErrorForInvoke.kt index 131f0c14783..4896965ae74 100644 --- a/compiler/testData/diagnostics/tests/resolve/invoke/errors/typeInferenceErrorForInvoke.kt +++ b/compiler/testData/diagnostics/tests/resolve/invoke/errors/typeInferenceErrorForInvoke.kt @@ -8,7 +8,7 @@ operator fun T.invoke(a: A) {} fun foo(s: String, ai: A) { 1(ai) - s(ai) + s(ai) - ""(ai) + ""(ai) } diff --git a/compiler/testData/diagnostics/tests/resolve/invoke/errors/unsafeCallWithInvoke.kt b/compiler/testData/diagnostics/tests/resolve/invoke/errors/unsafeCallWithInvoke.kt index 14a26805e52..6ebc3151730 100644 --- a/compiler/testData/diagnostics/tests/resolve/invoke/errors/unsafeCallWithInvoke.kt +++ b/compiler/testData/diagnostics/tests/resolve/invoke/errors/unsafeCallWithInvoke.kt @@ -6,5 +6,5 @@ operator fun String.invoke(i: Int) {} fun foo(s: String?) { s(1) - (s ?: null)(1) + (s ?: null)(1) } diff --git a/compiler/testData/diagnostics/tests/resolve/invoke/errors/wrongReceiverForInvokeOnExpression.fir.kt b/compiler/testData/diagnostics/tests/resolve/invoke/errors/wrongReceiverForInvokeOnExpression.fir.kt index 8aea96e9043..85b8d534ef0 100644 --- a/compiler/testData/diagnostics/tests/resolve/invoke/errors/wrongReceiverForInvokeOnExpression.fir.kt +++ b/compiler/testData/diagnostics/tests/resolve/invoke/errors/wrongReceiverForInvokeOnExpression.fir.kt @@ -14,4 +14,4 @@ fun test3() { fun foo(): String.(Int) -> Unit = {} 1.(foo())(1) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/resolve/invoke/errors/wrongReceiverForInvokeOnExpression.kt b/compiler/testData/diagnostics/tests/resolve/invoke/errors/wrongReceiverForInvokeOnExpression.kt index af96d5c2b83..46c92d47f0c 100644 --- a/compiler/testData/diagnostics/tests/resolve/invoke/errors/wrongReceiverForInvokeOnExpression.kt +++ b/compiler/testData/diagnostics/tests/resolve/invoke/errors/wrongReceiverForInvokeOnExpression.kt @@ -1,17 +1,17 @@ // !WITH_NEW_INFERENCE fun test1() { - 1. (fun String.(i: Int) = i )(1) - 1.(label@ fun String.(i: Int) = i )(1) + 1. (fun String.(i: Int) = i )(1) + 1.(label@ fun String.(i: Int) = i )(1) } fun test2(f: String.(Int) -> Unit) { - 11.(f)(1) - 11.(f)() + 11.(f)(1) + 11.(f)() } fun test3() { fun foo(): String.(Int) -> Unit = {} - 1.(foo())(1) -} \ No newline at end of file + 1.(foo())(1) +} diff --git a/compiler/testData/diagnostics/tests/resolve/invoke/extensionValueAsNonExtension.fir.kt b/compiler/testData/diagnostics/tests/resolve/invoke/extensionValueAsNonExtension.fir.kt index ce28c42c796..8e0ac8d2ca4 100644 --- a/compiler/testData/diagnostics/tests/resolve/invoke/extensionValueAsNonExtension.fir.kt +++ b/compiler/testData/diagnostics/tests/resolve/invoke/extensionValueAsNonExtension.fir.kt @@ -20,4 +20,4 @@ fun foo(): A.() -> Int { val c: Int = (foo())(A()) return null!! -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/resolve/invoke/extensionValueAsNonExtension.kt b/compiler/testData/diagnostics/tests/resolve/invoke/extensionValueAsNonExtension.kt index e7dc0ec67ae..14ba82c59c0 100644 --- a/compiler/testData/diagnostics/tests/resolve/invoke/extensionValueAsNonExtension.kt +++ b/compiler/testData/diagnostics/tests/resolve/invoke/extensionValueAsNonExtension.kt @@ -19,5 +19,5 @@ fun foo(): A.() -> Int { val b: Int = foo()(A()) val c: Int = (foo())(A()) - return null!! -} \ No newline at end of file + return null!! +} diff --git a/compiler/testData/diagnostics/tests/resolve/invoke/functionExpectedWhenSeveralInvokesExist.kt b/compiler/testData/diagnostics/tests/resolve/invoke/functionExpectedWhenSeveralInvokesExist.kt index 03dcf869e74..cdcac34ffd7 100644 --- a/compiler/testData/diagnostics/tests/resolve/invoke/functionExpectedWhenSeveralInvokesExist.kt +++ b/compiler/testData/diagnostics/tests/resolve/invoke/functionExpectedWhenSeveralInvokesExist.kt @@ -7,8 +7,8 @@ fun Int.invoke(a: Int, b: Int) {} class SomeClass fun test(identifier: SomeClass, fn: String.() -> Unit) { - identifier() + identifier() identifier(123) identifier(1, 2) 1.fn() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/resolve/invoke/invokeOnVariableWithExtensionFunctionType.fir.kt b/compiler/testData/diagnostics/tests/resolve/invoke/invokeOnVariableWithExtensionFunctionType.fir.kt index 2ba657f428d..52919c92464 100644 --- a/compiler/testData/diagnostics/tests/resolve/invoke/invokeOnVariableWithExtensionFunctionType.fir.kt +++ b/compiler/testData/diagnostics/tests/resolve/invoke/invokeOnVariableWithExtensionFunctionType.fir.kt @@ -41,7 +41,7 @@ fun test(a: A, b: B) { } } -// FILE: 1.kt +// FILE: 2.kt package fooIsMember class A { diff --git a/compiler/testData/diagnostics/tests/resolve/invoke/invokeOnVariableWithExtensionFunctionType.kt b/compiler/testData/diagnostics/tests/resolve/invoke/invokeOnVariableWithExtensionFunctionType.kt index 2d80c60b1a8..68269dfac25 100644 --- a/compiler/testData/diagnostics/tests/resolve/invoke/invokeOnVariableWithExtensionFunctionType.kt +++ b/compiler/testData/diagnostics/tests/resolve/invoke/invokeOnVariableWithExtensionFunctionType.kt @@ -41,7 +41,7 @@ fun test(a: A, b: B) { } } -// FILE: 1.kt +// FILE: 2.kt package fooIsMember class A { diff --git a/compiler/testData/diagnostics/tests/resolve/invoke/reportFunctionExpectedWhenOneInvokeExist.fir.kt b/compiler/testData/diagnostics/tests/resolve/invoke/reportFunctionExpectedWhenOneInvokeExist.fir.kt index 47c99beab08..9ba5b306186 100644 --- a/compiler/testData/diagnostics/tests/resolve/invoke/reportFunctionExpectedWhenOneInvokeExist.fir.kt +++ b/compiler/testData/diagnostics/tests/resolve/invoke/reportFunctionExpectedWhenOneInvokeExist.fir.kt @@ -10,4 +10,4 @@ fun test(identifier: SomeClass, fn: String.() -> Unit) { identifier(123) identifier(1, 2) 1.fn() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/resolve/invoke/reportFunctionExpectedWhenOneInvokeExist.kt b/compiler/testData/diagnostics/tests/resolve/invoke/reportFunctionExpectedWhenOneInvokeExist.kt index f7b82eb131c..fccb7472ec7 100644 --- a/compiler/testData/diagnostics/tests/resolve/invoke/reportFunctionExpectedWhenOneInvokeExist.kt +++ b/compiler/testData/diagnostics/tests/resolve/invoke/reportFunctionExpectedWhenOneInvokeExist.kt @@ -6,8 +6,8 @@ fun Int.invoke() {} class SomeClass fun test(identifier: SomeClass, fn: String.() -> Unit) { - identifier() + identifier() identifier(123) identifier(1, 2) 1.fn() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/resolve/kt36264.kt b/compiler/testData/diagnostics/tests/resolve/kt36264.kt index fe0d372a3c3..065737f95a8 100644 --- a/compiler/testData/diagnostics/tests/resolve/kt36264.kt +++ b/compiler/testData/diagnostics/tests/resolve/kt36264.kt @@ -12,7 +12,7 @@ class Cls { fun test(s: String) { if (s.ext is B) - take(s.ext) + take(s.ext) } } diff --git a/compiler/testData/diagnostics/tests/resolve/nestedCalls/completeTypeInferenceForNestedInNoneApplicable.kt b/compiler/testData/diagnostics/tests/resolve/nestedCalls/completeTypeInferenceForNestedInNoneApplicable.kt index 7a12450e8c8..b9c4e349144 100644 --- a/compiler/testData/diagnostics/tests/resolve/nestedCalls/completeTypeInferenceForNestedInNoneApplicable.kt +++ b/compiler/testData/diagnostics/tests/resolve/nestedCalls/completeTypeInferenceForNestedInNoneApplicable.kt @@ -5,7 +5,7 @@ fun foo(i: Int) = i fun foo(s: String) = s fun test() { - foo(emptyList()) + foo(emptyList()) } -fun emptyList(): List {throw Exception()} \ No newline at end of file +fun emptyList(): List {throw Exception()} diff --git a/compiler/testData/diagnostics/tests/resolve/nestedCalls/twoTypeParameters.fir.kt b/compiler/testData/diagnostics/tests/resolve/nestedCalls/twoTypeParameters.fir.kt index d7b16cc0eb8..3e04edb2149 100644 --- a/compiler/testData/diagnostics/tests/resolve/nestedCalls/twoTypeParameters.fir.kt +++ b/compiler/testData/diagnostics/tests/resolve/nestedCalls/twoTypeParameters.fir.kt @@ -14,4 +14,4 @@ public class ResolutionTaskHolder { tasks.bar(ResolutionTask(candidate)) tasks.add(ResolutionTask(candidate)) } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/resolve/nestedCalls/twoTypeParameters.kt b/compiler/testData/diagnostics/tests/resolve/nestedCalls/twoTypeParameters.kt index 65668e6d6d0..a97dcea49d9 100644 --- a/compiler/testData/diagnostics/tests/resolve/nestedCalls/twoTypeParameters.kt +++ b/compiler/testData/diagnostics/tests/resolve/nestedCalls/twoTypeParameters.kt @@ -11,7 +11,7 @@ public class ResolutionTaskHolder { tasks.add(ResolutionTask(candidate)) //todo the problem is the type of ResolutionTask is inferred as ResolutionTask too early - tasks.bar(ResolutionTask(candidate)) + tasks.bar(ResolutionTask(candidate)) tasks.add(ResolutionTask(candidate)) } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/resolve/newLineLambda.kt b/compiler/testData/diagnostics/tests/resolve/newLineLambda.kt index 128ee9d30a5..a556a086751 100644 --- a/compiler/testData/diagnostics/tests/resolve/newLineLambda.kt +++ b/compiler/testData/diagnostics/tests/resolve/newLineLambda.kt @@ -100,8 +100,8 @@ fun testTwoLambdas() { {} {} - return if (true) { - twoLambdaArgs({}) + return if (true) { + twoLambdaArgs({}) {} {} } else { @@ -112,7 +112,7 @@ fun testTwoLambdas() { fun f1(): (() -> Unit) -> (() -> Unit) -> Unit { return { l1 -> - l1() - { l2 -> l2() } + l1() + { l2 -> l2() } } } diff --git a/compiler/testData/diagnostics/tests/resolve/noCandidates/resolvedToClassifier.kt b/compiler/testData/diagnostics/tests/resolve/noCandidates/resolvedToClassifier.kt index ffe03215465..3890a2547ca 100644 --- a/compiler/testData/diagnostics/tests/resolve/noCandidates/resolvedToClassifier.kt +++ b/compiler/testData/diagnostics/tests/resolve/noCandidates/resolvedToClassifier.kt @@ -16,4 +16,4 @@ fun test() { fun bar() { val typeParameter_as_val = T val typeParameter_as_fun = T() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/resolve/noCandidates/resolvedToClassifierWithReceiver.kt b/compiler/testData/diagnostics/tests/resolve/noCandidates/resolvedToClassifierWithReceiver.kt index 138ca4f7441..f4baeb19090 100644 --- a/compiler/testData/diagnostics/tests/resolve/noCandidates/resolvedToClassifierWithReceiver.kt +++ b/compiler/testData/diagnostics/tests/resolve/noCandidates/resolvedToClassifierWithReceiver.kt @@ -36,4 +36,4 @@ fun test(x: X) { val object_as_fun = x.B() val class_as_val = x.C -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/resolve/overloadConflicts/allLambdas.fir.kt b/compiler/testData/diagnostics/tests/resolve/overloadConflicts/allLambdas.fir.kt index fbfedb7bc2a..0806faef8dc 100644 --- a/compiler/testData/diagnostics/tests/resolve/overloadConflicts/allLambdas.fir.kt +++ b/compiler/testData/diagnostics/tests/resolve/overloadConflicts/allLambdas.fir.kt @@ -7,4 +7,4 @@ object X2 fun foo(x: T1, f: (T1) -> T1) = X1 fun foo(xf: () -> T2, f: (T2) -> T2) = X2 -val test: X2 = foo({ 0 }, { it -> it + 1 }) \ No newline at end of file +val test: X2 = foo({ 0 }, { it -> it + 1 }) diff --git a/compiler/testData/diagnostics/tests/resolve/overloadConflicts/allLambdas.kt b/compiler/testData/diagnostics/tests/resolve/overloadConflicts/allLambdas.kt index e04a1fff003..730b30478cd 100644 --- a/compiler/testData/diagnostics/tests/resolve/overloadConflicts/allLambdas.kt +++ b/compiler/testData/diagnostics/tests/resolve/overloadConflicts/allLambdas.kt @@ -7,4 +7,4 @@ object X2 fun foo(x: T1, f: (T1) -> T1) = X1 fun foo(xf: () -> T2, f: (T2) -> T2) = X2 -val test: X2 = foo({ 0 }, { it -> it + 1 }) \ No newline at end of file +val test: X2 = foo({ 0 }, { it -> it + 1 }) diff --git a/compiler/testData/diagnostics/tests/resolve/overloadConflicts/genericClash.kt b/compiler/testData/diagnostics/tests/resolve/overloadConflicts/genericClash.kt index 0b5472a913a..d79b377d9d7 100644 --- a/compiler/testData/diagnostics/tests/resolve/overloadConflicts/genericClash.kt +++ b/compiler/testData/diagnostics/tests/resolve/overloadConflicts/genericClash.kt @@ -15,6 +15,6 @@ fun baz(x: String, y: E) {} fun bar(x: A) { x.foo("") - x.baz("", "") - baz("", "") + x.baz("", "") + baz("", "") } diff --git a/compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt10640.fir.kt b/compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt10640.fir.kt index 1fd5e880bc4..16482cbb981 100644 --- a/compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt10640.fir.kt +++ b/compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt10640.fir.kt @@ -7,4 +7,4 @@ fun T2.myUse(f: (T2) -> R2): R2 = f(this) fun test1(x: Closeable) = x.myUse { 42 } fun test2(x: Closeable) = x.myUse { 42 } -fun test3(x: Closeable) = x.myUse { 42 } // TODO KT-10681 \ No newline at end of file +fun test3(x: Closeable) = x.myUse { 42 } // TODO KT-10681 diff --git a/compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt10640.kt b/compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt10640.kt index 4300405a011..d11483dff2a 100644 --- a/compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt10640.kt +++ b/compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt10640.kt @@ -7,4 +7,4 @@ fun T2.myUse(f: (T2) -> R2): R2 = f(this) fun test1(x: Closeable) = x.myUse { 42 } fun test2(x: Closeable) = x.myUse { 42 } -fun test3(x: Closeable) = x.myUse<AutoCloseable, Int> { 42 } // TODO KT-10681 \ No newline at end of file +fun test3(x: Closeable) = x.myUse<AutoCloseable, Int> { 42 } // TODO KT-10681 diff --git a/compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt31670.fir.kt b/compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt31670.fir.kt index 6a5f32372ed..7f17a2117c0 100644 --- a/compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt31670.fir.kt +++ b/compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt31670.fir.kt @@ -13,4 +13,4 @@ fun B.foo(block: (T) -> Unit) { fun main() { B("string").foo { } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt31670.kt b/compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt31670.kt index 2ac53c3ca76..2737c6b7d8a 100644 --- a/compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt31670.kt +++ b/compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt31670.kt @@ -12,5 +12,5 @@ fun B.foo(block: (T) -> Unit) { } fun main() { - B("string").foo { } -} \ No newline at end of file + B("string").foo { } +} diff --git a/compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt31758.fir.kt b/compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt31758.fir.kt index 3a67bfa5323..468039157a6 100644 --- a/compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt31758.fir.kt +++ b/compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt31758.fir.kt @@ -23,4 +23,4 @@ import b.* fun test() { foo { } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt31758.kt b/compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt31758.kt index f36b2217a25..38cf41b468d 100644 --- a/compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt31758.kt +++ b/compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt31758.kt @@ -22,5 +22,5 @@ import a.* import b.* fun test() { - foo { } -} \ No newline at end of file + foo { } +} diff --git a/compiler/testData/diagnostics/tests/resolve/overloadConflicts/overloadResolutionOnNullableContravariantParameter.fir.kt b/compiler/testData/diagnostics/tests/resolve/overloadConflicts/overloadResolutionOnNullableContravariantParameter.fir.kt index dbbc7e4e962..a757322ceaf 100644 --- a/compiler/testData/diagnostics/tests/resolve/overloadConflicts/overloadResolutionOnNullableContravariantParameter.fir.kt +++ b/compiler/testData/diagnostics/tests/resolve/overloadConflicts/overloadResolutionOnNullableContravariantParameter.fir.kt @@ -21,4 +21,4 @@ import b.* fun main() { foo { } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/resolve/overloadConflicts/overloadResolutionOnNullableContravariantParameter.kt b/compiler/testData/diagnostics/tests/resolve/overloadConflicts/overloadResolutionOnNullableContravariantParameter.kt index 6b3d3afc83f..32ff8d7df0b 100644 --- a/compiler/testData/diagnostics/tests/resolve/overloadConflicts/overloadResolutionOnNullableContravariantParameter.kt +++ b/compiler/testData/diagnostics/tests/resolve/overloadConflicts/overloadResolutionOnNullableContravariantParameter.kt @@ -20,5 +20,5 @@ import a.* import b.* fun main() { - foo { } -} \ No newline at end of file + foo { } +} diff --git a/compiler/testData/diagnostics/tests/resolve/overloadConflicts/varargsMixed.kt b/compiler/testData/diagnostics/tests/resolve/overloadConflicts/varargsMixed.kt index 39b6f98be7b..6a86023dfc4 100644 --- a/compiler/testData/diagnostics/tests/resolve/overloadConflicts/varargsMixed.kt +++ b/compiler/testData/diagnostics/tests/resolve/overloadConflicts/varargsMixed.kt @@ -10,4 +10,4 @@ fun overloadedFun5(s: String, vararg ss: String) = X2 val test1 = overloadedFun5("") val test2 = overloadedFun5("", "") val test3: X2 = overloadedFun5(s = "", ss = "") -val test4: X1 = overloadedFun5(ss = "") \ No newline at end of file +val test4: X1 = overloadedFun5(ss = "") diff --git a/compiler/testData/diagnostics/tests/resolve/overloadConflicts/withVariance.fir.kt b/compiler/testData/diagnostics/tests/resolve/overloadConflicts/withVariance.fir.kt index a0203b1cbcf..9a0af8f0569 100644 --- a/compiler/testData/diagnostics/tests/resolve/overloadConflicts/withVariance.fir.kt +++ b/compiler/testData/diagnostics/tests/resolve/overloadConflicts/withVariance.fir.kt @@ -7,4 +7,4 @@ class A fun A.foo() = X1 fun A.foo() = X2 -fun A.test() = foo() // TODO fix constraint system \ No newline at end of file +fun A.test() = foo() // TODO fix constraint system diff --git a/compiler/testData/diagnostics/tests/resolve/overloadConflicts/withVariance.kt b/compiler/testData/diagnostics/tests/resolve/overloadConflicts/withVariance.kt index f45d71818a0..f73fc338e57 100644 --- a/compiler/testData/diagnostics/tests/resolve/overloadConflicts/withVariance.kt +++ b/compiler/testData/diagnostics/tests/resolve/overloadConflicts/withVariance.kt @@ -7,4 +7,4 @@ class A fun A.foo() = X1 fun A.foo() = X2 -fun A.test() = foo() // TODO fix constraint system \ No newline at end of file +fun A.test() = foo() // TODO fix constraint system diff --git a/compiler/testData/diagnostics/tests/resolve/specialConstructions/constantsInIf.fir.kt b/compiler/testData/diagnostics/tests/resolve/specialConstructions/constantsInIf.fir.kt index 052ad1c675f..e675a31a9f8 100644 --- a/compiler/testData/diagnostics/tests/resolve/specialConstructions/constantsInIf.fir.kt +++ b/compiler/testData/diagnostics/tests/resolve/specialConstructions/constantsInIf.fir.kt @@ -11,4 +11,4 @@ fun test() { bar(1 ?: 2) } -fun bar(s: String) = s \ No newline at end of file +fun bar(s: String) = s diff --git a/compiler/testData/diagnostics/tests/resolve/specialConstructions/constantsInIf.kt b/compiler/testData/diagnostics/tests/resolve/specialConstructions/constantsInIf.kt index 91feabb9dc3..ce19ae7b491 100644 --- a/compiler/testData/diagnostics/tests/resolve/specialConstructions/constantsInIf.kt +++ b/compiler/testData/diagnostics/tests/resolve/specialConstructions/constantsInIf.kt @@ -2,13 +2,13 @@ // !DIAGNOSTICS: -USELESS_ELVIS fun test() { - bar(if (true) { - 1 + bar(if (true) { + 1 } else { - 2 + 2 }) - bar(1 ?: 2) + bar(1 ?: 2) } -fun bar(s: String) = s \ No newline at end of file +fun bar(s: String) = s diff --git a/compiler/testData/diagnostics/tests/resolve/specialConstructions/elvisAsCall.kt b/compiler/testData/diagnostics/tests/resolve/specialConstructions/elvisAsCall.kt index 3abec5dfeab..6860fc3c516 100644 --- a/compiler/testData/diagnostics/tests/resolve/specialConstructions/elvisAsCall.kt +++ b/compiler/testData/diagnostics/tests/resolve/specialConstructions/elvisAsCall.kt @@ -14,7 +14,7 @@ fun testElvis(a: Int?, b: Int?) { if (a != null) { doInt(b ?: a) } - doList(getList() ?: emptyListOfA()) //should be an error + doList(getList() ?: emptyListOfA()) //should be an error doList(getList() ?: strangeList { doInt(it) }) //lambda was not analyzed } @@ -33,5 +33,5 @@ fun testDataFlowInfo2(a: Int?, b: Int?) { } fun testTypeMismatch(a: String?, b: Any) { - doInt(a ?: b) -} \ No newline at end of file + doInt(a ?: b) +} diff --git a/compiler/testData/diagnostics/tests/resolve/specialConstructions/exclExclAsCall.fir.kt b/compiler/testData/diagnostics/tests/resolve/specialConstructions/exclExclAsCall.fir.kt index b4f44a1b4e9..50e7fc4e026 100644 --- a/compiler/testData/diagnostics/tests/resolve/specialConstructions/exclExclAsCall.fir.kt +++ b/compiler/testData/diagnostics/tests/resolve/specialConstructions/exclExclAsCall.fir.kt @@ -26,4 +26,4 @@ fun testDataFlowInfoAfterExclExcl(a: Int?) { fun testUnnecessaryExclExcl(a: Int) { doInt(a!!) //should be warning -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/resolve/specialConstructions/exclExclAsCall.kt b/compiler/testData/diagnostics/tests/resolve/specialConstructions/exclExclAsCall.kt index d13c5392542..63f6dc53415 100644 --- a/compiler/testData/diagnostics/tests/resolve/specialConstructions/exclExclAsCall.kt +++ b/compiler/testData/diagnostics/tests/resolve/specialConstructions/exclExclAsCall.kt @@ -13,8 +13,8 @@ fun emptyNullableListOfA(): List? = null //------------------------------- fun testExclExcl() { - doList(emptyNullableListOfA()!!) //should be an error here - val l: List = id(emptyNullableListOfA()!!) + doList(emptyNullableListOfA()!!) //should be an error here + val l: List = id(emptyNullableListOfA()!!) doList(strangeNullableList { doInt(it) }!!) //lambda should be analyzed (at completion phase) } @@ -26,4 +26,4 @@ fun testDataFlowInfoAfterExclExcl(a: Int?) { fun testUnnecessaryExclExcl(a: Int) { doInt(a!!) //should be warning -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/resolve/specialConstructions/multipleSuperClasses.fir.kt b/compiler/testData/diagnostics/tests/resolve/specialConstructions/multipleSuperClasses.fir.kt index 3df6767a807..c3fb5a6fcac 100644 --- a/compiler/testData/diagnostics/tests/resolve/specialConstructions/multipleSuperClasses.fir.kt +++ b/compiler/testData/diagnostics/tests/resolve/specialConstructions/multipleSuperClasses.fir.kt @@ -26,4 +26,4 @@ fun foo(c: C?, d: D?, e: E?) { 2 -> d else -> e } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/resolve/specialConstructions/multipleSuperClasses.kt b/compiler/testData/diagnostics/tests/resolve/specialConstructions/multipleSuperClasses.kt index c5cfc432cb5..6462bff9bcd 100644 --- a/compiler/testData/diagnostics/tests/resolve/specialConstructions/multipleSuperClasses.kt +++ b/compiler/testData/diagnostics/tests/resolve/specialConstructions/multipleSuperClasses.kt @@ -9,7 +9,7 @@ interface D: A, B interface E: A, B fun foo(c: C?, d: D?, e: E?) { - val test1: A? = c ?: d ?: e + val test1: A? = c ?: d ?: e val test2: B? = if (false) if (true) c else d else e @@ -26,4 +26,4 @@ fun foo(c: C?, d: D?, e: E?) { 2 -> d else -> e } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/resolve/specialConstructions/reportTypeMismatchDeeplyOnBranches.kt b/compiler/testData/diagnostics/tests/resolve/specialConstructions/reportTypeMismatchDeeplyOnBranches.kt index dc507807c72..9fecfc44b98 100644 --- a/compiler/testData/diagnostics/tests/resolve/specialConstructions/reportTypeMismatchDeeplyOnBranches.kt +++ b/compiler/testData/diagnostics/tests/resolve/specialConstructions/reportTypeMismatchDeeplyOnBranches.kt @@ -4,25 +4,25 @@ package b fun bar(i: Int) = i fun test(a: Int?, b: Int?) { - bar(if (a == null) return else b) + bar(if (a == null) return else b) } fun test(a: Int?, b: Int?, c: Int?) { - bar(if (a == null) return else if (b == null) return else c) + bar(if (a == null) return else if (b == null) return else c) } fun test(a: Any?, b: Any?, c: Int?) { - bar(if (a == null) if (b == null) c else return else return) + bar(if (a == null) if (b == null) c else return else return) } fun test(a: Int?, b: Any?, c: Int?) { - bar(if (a == null) { + bar(if (a == null) { return } else { if (b == null) { return } else { - c + c } }) } diff --git a/compiler/testData/diagnostics/tests/resolve/wrongNumberOfTypeArguments.fir.kt b/compiler/testData/diagnostics/tests/resolve/wrongNumberOfTypeArguments.fir.kt index 07fc8b72572..1e3a572e7c2 100644 --- a/compiler/testData/diagnostics/tests/resolve/wrongNumberOfTypeArguments.fir.kt +++ b/compiler/testData/diagnostics/tests/resolve/wrongNumberOfTypeArguments.fir.kt @@ -12,4 +12,4 @@ fun bar(t: T, r: R) {} fun test2() { bar("", "") -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/resolve/wrongNumberOfTypeArguments.kt b/compiler/testData/diagnostics/tests/resolve/wrongNumberOfTypeArguments.kt index f2399e13102..9e73278a30e 100644 --- a/compiler/testData/diagnostics/tests/resolve/wrongNumberOfTypeArguments.kt +++ b/compiler/testData/diagnostics/tests/resolve/wrongNumberOfTypeArguments.kt @@ -4,12 +4,12 @@ fun foo(t: T) = t fun test1() { - foo("") + foo("") } fun bar(t: T, r: R) {} fun test2() { - bar("", "") -} \ No newline at end of file + bar("", "") +} diff --git a/compiler/testData/diagnostics/tests/samConversions/OverloadPriority.kt b/compiler/testData/diagnostics/tests/samConversions/OverloadPriority.kt index f108ab528f9..102142cdcfb 100644 --- a/compiler/testData/diagnostics/tests/samConversions/OverloadPriority.kt +++ b/compiler/testData/diagnostics/tests/samConversions/OverloadPriority.kt @@ -28,4 +28,4 @@ fun test(j: J) { // NI: TODO j.bar { it checkType { _() }; "" } checkType { _() } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/samConversions/OverloadPriorityKT.kt b/compiler/testData/diagnostics/tests/samConversions/OverloadPriorityKT.kt index e6153c5b49d..024b6f0ad55 100644 --- a/compiler/testData/diagnostics/tests/samConversions/OverloadPriorityKT.kt +++ b/compiler/testData/diagnostics/tests/samConversions/OverloadPriorityKT.kt @@ -27,4 +27,4 @@ fun test(k: K) { // NI: TODO k.bar { it checkType { _() }; "" } checkType { _() } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/samConversions/arrayAsVarargAfterSamArgumentProhibited.kt b/compiler/testData/diagnostics/tests/samConversions/arrayAsVarargAfterSamArgumentProhibited.kt index 17c8186f00b..61f1ca77387 100644 --- a/compiler/testData/diagnostics/tests/samConversions/arrayAsVarargAfterSamArgumentProhibited.kt +++ b/compiler/testData/diagnostics/tests/samConversions/arrayAsVarargAfterSamArgumentProhibited.kt @@ -51,4 +51,4 @@ fun main(x2: Runnable) { i2.foo2({}, {}, *x3) i2.foo2({}, x2, x3) i2.foo2(x2, {}, *arrayOf("")) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/samConversions/arrayAsVarargAfterSamArgumentWithoutSamConversionsPerArgument.kt b/compiler/testData/diagnostics/tests/samConversions/arrayAsVarargAfterSamArgumentWithoutSamConversionsPerArgument.kt index b19433357fd..367682d7cdb 100644 --- a/compiler/testData/diagnostics/tests/samConversions/arrayAsVarargAfterSamArgumentWithoutSamConversionsPerArgument.kt +++ b/compiler/testData/diagnostics/tests/samConversions/arrayAsVarargAfterSamArgumentWithoutSamConversionsPerArgument.kt @@ -51,4 +51,4 @@ fun main(x2: Runnable) { i1.foo2({}, {}, *x3) i1.foo2({}, x2, x3) i1.foo2(x2, {}, *arrayOf("")) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/samConversions/javaMemberAgainstExtension.kt b/compiler/testData/diagnostics/tests/samConversions/javaMemberAgainstExtension.kt index 993a3815092..68dfcbfccb0 100644 --- a/compiler/testData/diagnostics/tests/samConversions/javaMemberAgainstExtension.kt +++ b/compiler/testData/diagnostics/tests/samConversions/javaMemberAgainstExtension.kt @@ -28,3 +28,4 @@ fun test2(r: Runnable, o: Observer, l: LiveData) { val c = l.observe({}) {} // conversion for all arguments c } + diff --git a/compiler/testData/diagnostics/tests/scopes/VisibilityInClassObject.kt b/compiler/testData/diagnostics/tests/scopes/VisibilityInClassObject.kt index 41591ef908c..3be7ad04e94 100644 --- a/compiler/testData/diagnostics/tests/scopes/VisibilityInClassObject.kt +++ b/compiler/testData/diagnostics/tests/scopes/VisibilityInClassObject.kt @@ -30,4 +30,4 @@ class B: A() { devNull(A.private_val) devNull(A.protected_val) } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/scopes/VisibilityInheritModifier.kt b/compiler/testData/diagnostics/tests/scopes/VisibilityInheritModifier.kt index 4f0097fbeb8..b6885dfb852 100644 --- a/compiler/testData/diagnostics/tests/scopes/VisibilityInheritModifier.kt +++ b/compiler/testData/diagnostics/tests/scopes/VisibilityInheritModifier.kt @@ -82,4 +82,4 @@ interface Q : R { class S : P, Q { internal override fun foo() {} -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/companionObject.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/companionObject.kt index efd791f306f..77148da35ae 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/companionObject.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/companionObject.kt @@ -38,4 +38,4 @@ class C: B(), A { B.Companion.B_() C.B_() } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/companionObjectAfterJava.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/companionObjectAfterJava.kt index e298d612d22..c23589d5cc6 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/companionObjectAfterJava.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/companionObjectAfterJava.kt @@ -49,4 +49,4 @@ class D: C() { C.B_() D.B_() } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClass.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClass.kt index f2bd8f0c5d0..ce2b9501c08 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClass.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClass.kt @@ -36,4 +36,4 @@ class C: A() { B() } } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClassVsNested.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClassVsNested.kt index 4824f34ff71..06f87294f86 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClassVsNested.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClassVsNested.kt @@ -92,4 +92,4 @@ class C: A() { Z().C_C_Z() Z().A_C_Z() } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClassVsNestedJava.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClassVsNestedJava.kt index d682b0f9f4a..5505b72e294 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClassVsNestedJava.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClassVsNestedJava.kt @@ -44,4 +44,4 @@ class Y: C() { Z().A_C_Z() } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/nestedVsToplevelClass.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/nestedVsToplevelClass.kt index 81ae00acaa4..ff9a4fff2c5 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/nestedVsToplevelClass.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/nestedVsToplevelClass.kt @@ -35,4 +35,4 @@ class B: A() { Y().A_C_Y() Y().T_Y() } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/kjk.kt b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/kjk.kt index 3d6e11b5d29..ca061a2e03f 100644 --- a/compiler/testData/diagnostics/tests/scopes/inheritance/statics/kjk.kt +++ b/compiler/testData/diagnostics/tests/scopes/inheritance/statics/kjk.kt @@ -14,7 +14,7 @@ class D extends K { static void bar() {} } -// FILE: K.kt +// FILE: K2.kt class K2 { companion object { diff --git a/compiler/testData/diagnostics/tests/scopes/kt1080.kt b/compiler/testData/diagnostics/tests/scopes/kt1080.kt index 4c36bcd2dd8..4ee1a598e90 100644 --- a/compiler/testData/diagnostics/tests/scopes/kt1080.kt +++ b/compiler/testData/diagnostics/tests/scopes/kt1080.kt @@ -16,4 +16,4 @@ class Some: Test() package b.d -public open class Test \ No newline at end of file +public open class Test diff --git a/compiler/testData/diagnostics/tests/scopes/kt1244.kt b/compiler/testData/diagnostics/tests/scopes/kt1244.kt index ce2fa037917..cf03bb828c4 100644 --- a/compiler/testData/diagnostics/tests/scopes/kt1244.kt +++ b/compiler/testData/diagnostics/tests/scopes/kt1244.kt @@ -10,4 +10,4 @@ class B() { init { A().a = "Hello" } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/scopes/kt151.kt b/compiler/testData/diagnostics/tests/scopes/kt151.kt index 1e0e07db876..a4d34a24b6a 100644 --- a/compiler/testData/diagnostics/tests/scopes/kt151.kt +++ b/compiler/testData/diagnostics/tests/scopes/kt151.kt @@ -37,4 +37,4 @@ class F : C(), T { class G : C(), T { public override fun foo() {} -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/scopes/kt1738.kt b/compiler/testData/diagnostics/tests/scopes/kt1738.kt index 3ad2f15a121..ab8358c3aba 100644 --- a/compiler/testData/diagnostics/tests/scopes/kt1738.kt +++ b/compiler/testData/diagnostics/tests/scopes/kt1738.kt @@ -8,4 +8,4 @@ class A(private var i: Int, var j: Int) { fun test(a: A) { a.i++ a.j++ -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/scopes/kt1805.kt b/compiler/testData/diagnostics/tests/scopes/kt1805.kt index ae88a9f6f6f..1c4e591d50f 100644 --- a/compiler/testData/diagnostics/tests/scopes/kt1805.kt +++ b/compiler/testData/diagnostics/tests/scopes/kt1805.kt @@ -17,4 +17,4 @@ fun test() { val s1 = SomeSubclass() s1.privateField // 3. Unresolved reference -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/scopes/kt1806.kt b/compiler/testData/diagnostics/tests/scopes/kt1806.kt index a91c7a33a43..d131315f949 100644 --- a/compiler/testData/diagnostics/tests/scopes/kt1806.kt +++ b/compiler/testData/diagnostics/tests/scopes/kt1806.kt @@ -21,4 +21,4 @@ class Test { } } -fun doSmth(s: String) = s \ No newline at end of file +fun doSmth(s: String) = s diff --git a/compiler/testData/diagnostics/tests/scopes/kt37.kt b/compiler/testData/diagnostics/tests/scopes/kt37.kt index 761a6fa6085..4154c41f8cb 100644 --- a/compiler/testData/diagnostics/tests/scopes/kt37.kt +++ b/compiler/testData/diagnostics/tests/scopes/kt37.kt @@ -13,4 +13,4 @@ fun box(): String { val c = C() if (c.f != 610) return "fail" return "OK" -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/scopes/kt9430.kt b/compiler/testData/diagnostics/tests/scopes/kt9430.kt index cb743b1d27d..5c5004d4283 100644 --- a/compiler/testData/diagnostics/tests/scopes/kt9430.kt +++ b/compiler/testData/diagnostics/tests/scopes/kt9430.kt @@ -13,4 +13,4 @@ class C: A() { class D { fun qux() { B().foo() } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/scopes/protectedVisibility/syntheticSAMExtensions.kt b/compiler/testData/diagnostics/tests/scopes/protectedVisibility/syntheticSAMExtensions.kt index 308acfa0c82..11b9330481e 100644 --- a/compiler/testData/diagnostics/tests/scopes/protectedVisibility/syntheticSAMExtensions.kt +++ b/compiler/testData/diagnostics/tests/scopes/protectedVisibility/syntheticSAMExtensions.kt @@ -21,7 +21,7 @@ class B : A() { } if (d.x is B) { - d.x.foo {} + d.x.foo {} } } } diff --git a/compiler/testData/diagnostics/tests/scopes/protectedVisibility/unstableSmartCast.kt b/compiler/testData/diagnostics/tests/scopes/protectedVisibility/unstableSmartCast.kt index 1f5b6865394..b16e095a26a 100644 --- a/compiler/testData/diagnostics/tests/scopes/protectedVisibility/unstableSmartCast.kt +++ b/compiler/testData/diagnostics/tests/scopes/protectedVisibility/unstableSmartCast.kt @@ -13,7 +13,7 @@ class Derived : BaseOuter() { fun test(foo: Foo) { if (foo.base is Derived) { foo.base.foo() checkType { _() } // Resolved to extension - foo.base.bar() + foo.base.bar() } } } diff --git a/compiler/testData/diagnostics/tests/scopes/visibility.kt b/compiler/testData/diagnostics/tests/scopes/visibility.kt index db0a3e723cc..dfb38302288 100644 --- a/compiler/testData/diagnostics/tests/scopes/visibility.kt +++ b/compiler/testData/diagnostics/tests/scopes/visibility.kt @@ -40,8 +40,8 @@ class B { } fun test3(a: A) { - a.v //todo .bMethod() - a.f(0, 1) //todo .bMethod() + a.v //todo .bMethod() + a.f(0, 1) //todo .bMethod() } interface T @@ -54,7 +54,7 @@ open class C : T { } fun test4(c: C) { - c.i++ + c.i++ } class D : C() { @@ -78,7 +78,7 @@ class F : C() { class G : T { fun test8(c: C) { - doSmth(c.i) + doSmth(c.i) } } @@ -91,5 +91,5 @@ import test_visibility.* fun test() { internal_fun() - private_fun() + private_fun() } diff --git a/compiler/testData/diagnostics/tests/scopes/visibility2.kt b/compiler/testData/diagnostics/tests/scopes/visibility2.kt index c3fee556f45..85d0603543c 100644 --- a/compiler/testData/diagnostics/tests/scopes/visibility2.kt +++ b/compiler/testData/diagnostics/tests/scopes/visibility2.kt @@ -17,23 +17,23 @@ private object PO {} //+JDK package b -import a.A -import a.foo +import a.A +import a.foo import a.makeA -import a.PO +import a.PO fun test() { val y = makeA() - y.bar() - foo() + y.bar() + foo() - val u : A = A() - val a : java.util.Arrays.ArrayList; + val u : A = A() + val a : java.util.Arrays.ArrayList; - val po = PO + val po = PO } -class B : A() {} +class B : A() {} class Q { class W { diff --git a/compiler/testData/diagnostics/tests/scopes/visibility3.kt b/compiler/testData/diagnostics/tests/scopes/visibility3.kt index 215e9171f0a..5d17a443b5f 100644 --- a/compiler/testData/diagnostics/tests/scopes/visibility3.kt +++ b/compiler/testData/diagnostics/tests/scopes/visibility3.kt @@ -25,18 +25,18 @@ package a fun test() { val y = makeA() - y.bar() - foo() + y.bar() + foo() - val u : A = A() + val u : A = A() - val z = x - x = 30 + val z = x + x = 30 - val po = PO + val po = PO } -class B : A() {} +class B : A() {} class Q { class W { diff --git a/compiler/testData/diagnostics/tests/script/NestedInnerClass.kts b/compiler/testData/diagnostics/tests/script/NestedInnerClass.kts index a23519483ed..74ea7ce82e8 100644 --- a/compiler/testData/diagnostics/tests/script/NestedInnerClass.kts +++ b/compiler/testData/diagnostics/tests/script/NestedInnerClass.kts @@ -5,8 +5,8 @@ fun function() = 42 val property = "" class Nested { - fun f() = function() - fun g() = property + fun f() = function() + fun g() = property } @@ -22,4 +22,4 @@ inner class Inner { fun h() = this@Inner.innerFun() fun i() = this@Inner.innerProp } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/sealed/inheritorInDifferentModule.txt b/compiler/testData/diagnostics/tests/sealed/inheritorInDifferentModule.txt index f6c493cc02d..334e5f75c20 100644 --- a/compiler/testData/diagnostics/tests/sealed/inheritorInDifferentModule.txt +++ b/compiler/testData/diagnostics/tests/sealed/inheritorInDifferentModule.txt @@ -18,7 +18,6 @@ package a { } } - // -- Module: -- package @@ -31,3 +30,4 @@ package a { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } } + diff --git a/compiler/testData/diagnostics/tests/sealed/interfaces/inheritorInDifferentModule.txt b/compiler/testData/diagnostics/tests/sealed/interfaces/inheritorInDifferentModule.txt index 8d6d9f86841..9707ac807d7 100644 --- a/compiler/testData/diagnostics/tests/sealed/interfaces/inheritorInDifferentModule.txt +++ b/compiler/testData/diagnostics/tests/sealed/interfaces/inheritorInDifferentModule.txt @@ -16,7 +16,6 @@ package a { } } - // -- Module: -- package @@ -28,3 +27,4 @@ package a { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } } + diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/constructorCallType.kt b/compiler/testData/diagnostics/tests/secondaryConstructors/constructorCallType.kt index 013f49da8be..b364924b1de 100644 --- a/compiler/testData/diagnostics/tests/secondaryConstructors/constructorCallType.kt +++ b/compiler/testData/diagnostics/tests/secondaryConstructors/constructorCallType.kt @@ -21,8 +21,8 @@ val y4: B = B("") val y5: B = B(1) val y6: B = B("") -val y7: B = B(1) +val y7: B = B(1) val y8: B = B("") val y9 = B(1) -val y10 = B("") +val y10 = B("") diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/ctrsAnnotationResolve.kt b/compiler/testData/diagnostics/tests/secondaryConstructors/ctrsAnnotationResolve.kt index 9e77c08483a..556f65048e7 100644 --- a/compiler/testData/diagnostics/tests/secondaryConstructors/ctrsAnnotationResolve.kt +++ b/compiler/testData/diagnostics/tests/secondaryConstructors/ctrsAnnotationResolve.kt @@ -9,4 +9,4 @@ class A { constructor(x1: Int) @Ann2(2) constructor(x1: Int, x2: Int) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/errorsOnEmptyDelegationCall.kt b/compiler/testData/diagnostics/tests/secondaryConstructors/errorsOnEmptyDelegationCall.kt index 3736ef1a2a5..e8fc8dad909 100644 --- a/compiler/testData/diagnostics/tests/secondaryConstructors/errorsOnEmptyDelegationCall.kt +++ b/compiler/testData/diagnostics/tests/secondaryConstructors/errorsOnEmptyDelegationCall.kt @@ -39,4 +39,4 @@ open class B3 { class A3 : B3 { constructor() constructor(x: Int) : super() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/generics2.kt b/compiler/testData/diagnostics/tests/secondaryConstructors/generics2.kt index 9619dfce57d..aaa496a9499 100644 --- a/compiler/testData/diagnostics/tests/secondaryConstructors/generics2.kt +++ b/compiler/testData/diagnostics/tests/secondaryConstructors/generics2.kt @@ -14,14 +14,14 @@ class A0 { class A1 : B { constructor(x: T1, y: T2): super(x, y) - constructor(x: T1, y: Int): super(x, y) - constructor(x: T1, y: T1, z: T1): super(x, y) + constructor(x: T1, y: Int): super(x, y) + constructor(x: T1, y: T1, z: T1): super(x, y) } class A2 : B { - constructor(x: T1, y: T2): super(x, y) + constructor(x: T1, y: T2): super(x, y) constructor(x: T1, y: Int): super(x, y) - constructor(x: T1, y: T1, z: T1): super(x, y) - constructor(x: T1, y: T2, z: String): super(y, 1) + constructor(x: T1, y: T1, z: T1): super(x, y) + constructor(x: T1, y: T2, z: String): super(y, 1) } diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/kt6993.kt b/compiler/testData/diagnostics/tests/secondaryConstructors/kt6993.kt index 736edb67a42..868a5611a31 100644 --- a/compiler/testData/diagnostics/tests/secondaryConstructors/kt6993.kt +++ b/compiler/testData/diagnostics/tests/secondaryConstructors/kt6993.kt @@ -2,4 +2,4 @@ // !WITH_NEW_INFERENCE class X(val t: T) { constructor(t: T, i: Int) : this(i) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/redeclarations.kt b/compiler/testData/diagnostics/tests/secondaryConstructors/redeclarations.kt index 0391ad88b2a..9b3c8f4164c 100644 --- a/compiler/testData/diagnostics/tests/secondaryConstructors/redeclarations.kt +++ b/compiler/testData/diagnostics/tests/secondaryConstructors/redeclarations.kt @@ -24,4 +24,4 @@ class Outer { } fun B(x: Int) {} -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/smartCasts/afterBinaryExpr.kt b/compiler/testData/diagnostics/tests/smartCasts/afterBinaryExpr.kt index 71aea3b88f6..2cc12b56400 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/afterBinaryExpr.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/afterBinaryExpr.kt @@ -11,4 +11,4 @@ class B { fun test(a: A, b: B?) { a foo b!! b.bar() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/smartCasts/alwaysNull.fir.kt b/compiler/testData/diagnostics/tests/smartCasts/alwaysNull.fir.kt index 92202f02d93..29fc541bfce 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/alwaysNull.fir.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/alwaysNull.fir.kt @@ -20,4 +20,4 @@ fun bar(s: String?) { s as? String s as String? s as String -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/smartCasts/alwaysNull.kt b/compiler/testData/diagnostics/tests/smartCasts/alwaysNull.kt index 8c8584c556b..9e1d6a96f66 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/alwaysNull.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/alwaysNull.kt @@ -3,12 +3,12 @@ fun foo(): String { var s: String? s = null s?.length - s.length + s.length if (s == null) return s!! var t: String? = "y" if (t == null) t = "x" var x: Int? = null - if (x == null) x += null + if (x == null) x += null return t + s } @@ -16,8 +16,8 @@ fun String?.gav() {} fun bar(s: String?) { if (s != null) return - s.gav() + s.gav() s as? String s as String? s as String -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/smartCasts/alwaysNullWithJava.kt b/compiler/testData/diagnostics/tests/smartCasts/alwaysNullWithJava.kt index bfa431a3c11..6c6fd41b8cf 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/alwaysNullWithJava.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/alwaysNullWithJava.kt @@ -11,7 +11,7 @@ public class My { fun test() { val my = My.create() if (my == null) { - my.foo() + my.foo() } } diff --git a/compiler/testData/diagnostics/tests/smartCasts/castchecks/variables.fir.kt b/compiler/testData/diagnostics/tests/smartCasts/castchecks/variables.fir.kt index 254fdd6b891..63997330a6c 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/castchecks/variables.fir.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/castchecks/variables.fir.kt @@ -65,4 +65,4 @@ fun f(a: SomeClass?) { c.hashCode() c.foo } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/smartCasts/castchecks/variables.kt b/compiler/testData/diagnostics/tests/smartCasts/castchecks/variables.kt index b3d4d488fd4..b9e005b3ca9 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/castchecks/variables.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/castchecks/variables.kt @@ -41,7 +41,7 @@ fun f(a: SomeClass?) { if (aa as? SomeSubClass != null) { aa = null // 'aa' cannot be cast to SomeSubClass - aa.hashCode() + aa.hashCode() aa.foo (aa as? SomeSubClass).foo (aa as SomeSubClass).foo @@ -50,7 +50,7 @@ fun f(a: SomeClass?) { aa = null if (b != null) { // 'aa' cannot be cast to SomeSubClass - aa.hashCode() + aa.hashCode() aa.foo (aa as? SomeSubClass).foo (aa as SomeSubClass).foo @@ -65,4 +65,4 @@ fun f(a: SomeClass?) { c.hashCode() c.foo } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/smartCasts/comparisonUnderAnd.fir.kt b/compiler/testData/diagnostics/tests/smartCasts/comparisonUnderAnd.fir.kt index d6f6a2b8607..62ba2cb3653 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/comparisonUnderAnd.fir.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/comparisonUnderAnd.fir.kt @@ -36,4 +36,4 @@ fun foo(x : String?, y : String?) { x.length y.length } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/smartCasts/comparisonUnderAnd.kt b/compiler/testData/diagnostics/tests/smartCasts/comparisonUnderAnd.kt index d41ce7f675a..3f386d860d5 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/comparisonUnderAnd.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/comparisonUnderAnd.kt @@ -16,12 +16,12 @@ fun foo(x : String?, y : String?) { else { // y == null but x != y x.length - y.length + y.length } if (y == null && x != y) { // y == null but x != y x.length - y.length + y.length } else { x.length @@ -36,4 +36,4 @@ fun foo(x : String?, y : String?) { x.length y.length } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/smartCasts/complexComparison.fir.kt b/compiler/testData/diagnostics/tests/smartCasts/complexComparison.fir.kt index 2165f847e7e..5ba47dc28b8 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/complexComparison.fir.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/complexComparison.fir.kt @@ -20,4 +20,4 @@ fun foo(x: String?, y: String?, z: String?, w: String?) { y.length else y.length -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/smartCasts/complexComparison.kt b/compiler/testData/diagnostics/tests/smartCasts/complexComparison.kt index 6b5aaad4310..bed56cb0280 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/complexComparison.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/complexComparison.kt @@ -7,7 +7,7 @@ fun foo(x: String?, y: String?, z: String?, w: String?) { if (x != null || y != null || (x != z && y != z)) z.length else - z.length + z.length if (x == null || y == null || (x != z && y != z)) z.length else @@ -20,4 +20,4 @@ fun foo(x: String?, y: String?, z: String?, w: String?) { y.length else y.length -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/smartCasts/elvis/impossible.kt b/compiler/testData/diagnostics/tests/smartCasts/elvis/impossible.kt index 8174bd0da67..788f7950c63 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/elvis/impossible.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/elvis/impossible.kt @@ -18,7 +18,7 @@ fun foo(list: StringList, arg: Unstable) { list.remove(arg.first) if (arg.first?.isEmpty() ?: false) { // Should be still resolved to extension, without smart cast or smart cast impossible - list.remove(arg.first) + list.remove(arg.first) } } @@ -36,6 +36,6 @@ fun bar(list: BooleanList, arg: UnstableBoolean) { list.remove(arg.first) if (arg.first ?: false) { // Should be still resolved to extension, without smart cast or smart cast impossible - list.remove(arg.first) + list.remove(arg.first) } } diff --git a/compiler/testData/diagnostics/tests/smartCasts/inference/intersectionTypes.kt b/compiler/testData/diagnostics/tests/smartCasts/inference/intersectionTypes.kt index 3a1268c199a..be7f514adc3 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/inference/intersectionTypes.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/inference/intersectionTypes.kt @@ -17,7 +17,7 @@ interface C: A fun test(a: A, b: B, c: C) { if (a is B && a is C) { - val d: C = id(a) + val d: C = id(a) val e: Any = id(a) val f = id(a) checkSubtype(f) @@ -31,7 +31,7 @@ fun test(a: A, b: B, c: C) { val k = three(a, b, c) checkSubtype(k) checkSubtype(k) - val l: Int = three(a, b, c) + val l: Int = three(a, b, c) use(d, e, f, g, h, k, l) } @@ -41,11 +41,11 @@ fun foo(t: T, l: MutableList): T = t fun testErrorMessages(a: A, ml: MutableList) { if (a is B && a is C) { - foo(a, ml) + foo(a, ml) } if(a is C) { - foo(a, ml) + foo(a, ml) } } diff --git a/compiler/testData/diagnostics/tests/smartCasts/inference/kt29767.fir.kt b/compiler/testData/diagnostics/tests/smartCasts/inference/kt29767.fir.kt index e2b74b41c29..ea2aa47e601 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/inference/kt29767.fir.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/inference/kt29767.fir.kt @@ -8,4 +8,4 @@ fun test(a: MutableList?) { b.inc() } } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/smartCasts/inference/kt29767.kt b/compiler/testData/diagnostics/tests/smartCasts/inference/kt29767.kt index 46f081df69c..ccf8d6892a2 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/inference/kt29767.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/inference/kt29767.kt @@ -3,9 +3,9 @@ fun test(a: MutableList?) { if (a != null) { - val b = a[0] // no SMARTCAST diagnostic + val b = a[0] // no SMARTCAST diagnostic if (b != null) { b.inc() } } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/smartCasts/inference/kt39010.kt b/compiler/testData/diagnostics/tests/smartCasts/inference/kt39010.kt index 6ab66160644..79b4b03581d 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/inference/kt39010.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/inference/kt39010.kt @@ -8,4 +8,4 @@ class B(var a: A<*>?) { a.foo() } } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/smartCasts/intersectionScope/flexibleTypes.kt b/compiler/testData/diagnostics/tests/smartCasts/intersectionScope/flexibleTypes.kt index 7f5faa5ea60..cc13a0c6bc4 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/intersectionScope/flexibleTypes.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/intersectionScope/flexibleTypes.kt @@ -17,37 +17,37 @@ interface C { fun foo(x: Any?) { if (x is A && x is B) { - x.foo().checkType { _() } + x.foo().checkType { _() } x.foo().checkType { _() } } if (x is B && x is A) { - x.foo().checkType { _() } + x.foo().checkType { _() } x.foo().checkType { _() } } if (x is A && x is C) { x.foo().checkType { _() } - x.foo().checkType { _() } + x.foo().checkType { _() } } if (x is C && x is A) { x.foo().checkType { _() } - x.foo().checkType { _() } + x.foo().checkType { _() } } if (x is A && x is B && x is C) { x.foo().checkType { _() } - x.foo().checkType { _() } + x.foo().checkType { _() } } if (x is B && x is A && x is C) { x.foo().checkType { _() } - x.foo().checkType { _() } + x.foo().checkType { _() } } if (x is B && x is C && x is A) { x.foo().checkType { _() } - x.foo().checkType { _() } + x.foo().checkType { _() } } } diff --git a/compiler/testData/diagnostics/tests/smartCasts/kt10444.kt b/compiler/testData/diagnostics/tests/smartCasts/kt10444.kt index 62cefffb4b7..bf336d36415 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/kt10444.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/kt10444.kt @@ -10,7 +10,7 @@ class Qwe(val a: T?) { fun test1(obj: Qwe<*>) { obj as Qwe - check(obj.a) + check(obj.a) } fun check(a: T?) { diff --git a/compiler/testData/diagnostics/tests/smartCasts/kt2865.fir.kt b/compiler/testData/diagnostics/tests/smartCasts/kt2865.fir.kt index fe9fae8146d..fe257d907eb 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/kt2865.fir.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/kt2865.fir.kt @@ -9,4 +9,4 @@ fun foo(a: MutableMap, x: String?) { fun foo1(a: MutableMap, x: String?) { a[x] = x!! a[x!!] = x -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/smartCasts/kt2865.kt b/compiler/testData/diagnostics/tests/smartCasts/kt2865.kt index a44ddf5de2d..adbf52f7c6b 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/kt2865.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/kt2865.kt @@ -7,6 +7,6 @@ fun foo(a: MutableMap, x: String?) { } fun foo1(a: MutableMap, x: String?) { - a[x] = x!! + a[x] = x!! a[x!!] = x -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/smartCasts/kt30927.fir.kt b/compiler/testData/diagnostics/tests/smartCasts/kt30927.fir.kt index c696612aea0..c6d8c192664 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/kt30927.fir.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/kt30927.fir.kt @@ -48,4 +48,4 @@ fun case_3(z: Any?) { y checkType { _() } y checkType { _() } // y is inferred to String -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/smartCasts/kt30927.kt b/compiler/testData/diagnostics/tests/smartCasts/kt30927.kt index 9e68572e8f4..6d6c6e044c2 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/kt30927.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/kt30927.kt @@ -6,22 +6,22 @@ fun case_0() { val z: Any? = 10 val y = z.run { this as Int - this // error in NI: required Int, found Any?; just inferred to Any? in OI + this // error in NI: required Int, found Any?; just inferred to Any? in OI } - y checkType { _() } - y checkType { _() } + y checkType { _() } + y checkType { _() } } fun case_1(z: Any?) { val y = z.run { when (this) { - is String -> return@run this // type mismatch in the new inference (required String, found Any?) + is String -> return@run this // type mismatch in the new inference (required String, found Any?) is Float -> "" else -> return@run "" } } - y checkType { _() } - y checkType { _() } + y checkType { _() } + y checkType { _() } // y is inferred to Any? } @@ -40,12 +40,12 @@ fun case_2(z: Any?) { fun case_3(z: Any?) { val y = z.let { when (it) { - is String -> return@let it + is String -> return@let it is Float -> "" else -> return@let "" } } - y checkType { _() } - y checkType { _() } + y checkType { _() } + y checkType { _() } // y is inferred to String -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/smartCasts/lambdaArgumentWithBoundWithoutType.kt b/compiler/testData/diagnostics/tests/smartCasts/lambdaArgumentWithBoundWithoutType.kt index 2a1a6f3b5b2..e11188b6bdf 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/lambdaArgumentWithBoundWithoutType.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/lambdaArgumentWithBoundWithoutType.kt @@ -13,14 +13,14 @@ val foo: Foo = run { x } -val foofoo: Foo = run { +val foofoo: Foo = run { val x = foo() if (x == null) throw Exception() - x + x } -val bar: Bar = run { +val bar: Bar = run { val x = foo() if (x == null) throw Exception() - x + x } diff --git a/compiler/testData/diagnostics/tests/smartCasts/localFunChanges.kt b/compiler/testData/diagnostics/tests/smartCasts/localFunChanges.kt index d7d642e66fc..11537043f3f 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/localFunChanges.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/localFunChanges.kt @@ -9,7 +9,7 @@ fun foo() { return true } i.hashCode() - trans(i, ::can) + trans(i, ::can) i.hashCode() } } diff --git a/compiler/testData/diagnostics/tests/smartCasts/objectLiterals/captured.kt b/compiler/testData/diagnostics/tests/smartCasts/objectLiterals/captured.kt index 4edee8fe60c..158b6c22d25 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/objectLiterals/captured.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/objectLiterals/captured.kt @@ -17,7 +17,7 @@ fun foo(): Int { k.run() val d: Int = c // a is captured so smart cast is not possible - return d + a + return d + a } else return -1 } diff --git a/compiler/testData/diagnostics/tests/smartCasts/publicVals/otherModule.txt b/compiler/testData/diagnostics/tests/smartCasts/publicVals/otherModule.txt index 636370392ef..4c7db673204 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/publicVals/otherModule.txt +++ b/compiler/testData/diagnostics/tests/smartCasts/publicVals/otherModule.txt @@ -12,7 +12,6 @@ package a { } } - // -- Module: -- package @@ -23,3 +22,4 @@ package a { package b { public fun a.X.gav(): kotlin.Int } + diff --git a/compiler/testData/diagnostics/tests/smartCasts/safecalls/nullableReceiver.kt b/compiler/testData/diagnostics/tests/smartCasts/safecalls/nullableReceiver.kt index 94ce4126471..647485c1a2c 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/safecalls/nullableReceiver.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/safecalls/nullableReceiver.kt @@ -10,4 +10,4 @@ fun test(foo: Foo?) { // Correct foo?.bar?.length } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/smartCasts/safecalls/safeAccessReceiverNotNull.kt b/compiler/testData/diagnostics/tests/smartCasts/safecalls/safeAccessReceiverNotNull.kt index 3ae438cc7ce..139653e644f 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/safecalls/safeAccessReceiverNotNull.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/safecalls/safeAccessReceiverNotNull.kt @@ -132,4 +132,4 @@ fun checkInvokable(ip: InvokableProperty?) { if (ip?.i() == "Hello") { ip.hashCode() } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/smartCasts/smartcastOnSameFieldOfDifferentInstances.kt b/compiler/testData/diagnostics/tests/smartCasts/smartcastOnSameFieldOfDifferentInstances.kt index 68f01c6bdbf..b28bd82c100 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/smartcastOnSameFieldOfDifferentInstances.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/smartcastOnSameFieldOfDifferentInstances.kt @@ -8,4 +8,4 @@ class A(val x: String?) { x.length > 0 -> "2" } } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/smartCasts/variables/ifNullAssignment.fir.kt b/compiler/testData/diagnostics/tests/smartCasts/variables/ifNullAssignment.fir.kt index 04df688e9a4..6cf1fc73b07 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/variables/ifNullAssignment.fir.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/variables/ifNullAssignment.fir.kt @@ -70,4 +70,4 @@ fun gau(flag: Boolean, arg: String?) { } x.hashCode() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/smartCasts/variables/ifNullAssignment.kt b/compiler/testData/diagnostics/tests/smartCasts/variables/ifNullAssignment.kt index b4c09df476a..0f0bd5b8dbf 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/variables/ifNullAssignment.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/variables/ifNullAssignment.kt @@ -69,5 +69,5 @@ fun gau(flag: Boolean, arg: String?) { } } - x.hashCode() -} \ No newline at end of file + x.hashCode() +} diff --git a/compiler/testData/diagnostics/tests/smartCasts/variables/lambdaBetweenArguments.fir.kt b/compiler/testData/diagnostics/tests/smartCasts/variables/lambdaBetweenArguments.fir.kt index ac221151837..d7c52abd0f1 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/variables/lambdaBetweenArguments.fir.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/variables/lambdaBetweenArguments.fir.kt @@ -7,4 +7,4 @@ fun bar() { var x: Int? x = 4 foo(x, { x = null; x.hashCode() }, x) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/smartCasts/variables/lambdaBetweenArguments.kt b/compiler/testData/diagnostics/tests/smartCasts/variables/lambdaBetweenArguments.kt index 29b21ad80dc..67884b2c8da 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/variables/lambdaBetweenArguments.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/variables/lambdaBetweenArguments.kt @@ -6,5 +6,5 @@ fun foo(x: Int, f: () -> Unit, y: Int) {} fun bar() { var x: Int? x = 4 - foo(x, { x = null; x.hashCode() }, x) -} \ No newline at end of file + foo(x, { x = null; x.hashCode() }, x) +} diff --git a/compiler/testData/diagnostics/tests/smartCasts/variables/property.fir.kt b/compiler/testData/diagnostics/tests/smartCasts/variables/property.fir.kt index 8951d31bf6f..b12b92d08c8 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/variables/property.fir.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/variables/property.fir.kt @@ -8,4 +8,4 @@ fun bar(s: String): Int { fun foo(m: MyClass): Int { m.p = "xyz" return bar(m.p) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/smartCasts/variables/property.kt b/compiler/testData/diagnostics/tests/smartCasts/variables/property.kt index ff09a6cf1c2..c6af27d8ad7 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/variables/property.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/variables/property.kt @@ -7,5 +7,5 @@ fun bar(s: String): Int { fun foo(m: MyClass): Int { m.p = "xyz" - return bar(m.p) -} \ No newline at end of file + return bar(m.p) +} diff --git a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/assignment.fir.kt b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/assignment.fir.kt index 853571a14f0..0dce64de076 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/assignment.fir.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/assignment.fir.kt @@ -8,4 +8,4 @@ fun foo() { v.length v = "abc" v.length -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/assignment.kt b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/assignment.kt index f899cf84aa2..c3ee5db2cc0 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/assignment.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/assignment.kt @@ -5,7 +5,7 @@ fun foo() { v = "abc" v.length v = null - v.length + v.length v = "abc" v.length -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/boundInitializerWrong.kt b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/boundInitializerWrong.kt index af728f2c7a3..49b7e95df7f 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/boundInitializerWrong.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/boundInitializerWrong.kt @@ -6,7 +6,7 @@ fun foo() { val y = x x = null if (y != null) { - x.hashCode() + x.hashCode() } } @@ -23,7 +23,7 @@ fun bar(s: String?) { val hashCode = ss?.hashCode() ss = null if (hashCode != null) { - ss.hashCode() + ss.hashCode() } } diff --git a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/initInTryReturnInCatch.kt b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/initInTryReturnInCatch.kt index 6890bdaf128..c1248f74030 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/initInTryReturnInCatch.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/initInTryReturnInCatch.kt @@ -76,5 +76,5 @@ fun test6() { finally { a = null } - a.hashCode() // a is null here + a.hashCode() // a is null here } diff --git a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/initialization.fir.kt b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/initialization.fir.kt index a5f4d31c26c..430868a8b0c 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/initialization.fir.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/initialization.fir.kt @@ -5,4 +5,4 @@ fun foo() { v.length v = null v.length -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/initialization.kt b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/initialization.kt index c19833c4ce2..3bf5394913e 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/initialization.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/initialization.kt @@ -4,5 +4,5 @@ fun foo() { // It is possible in principle to provide smart cast here v.length v = null - v.length -} \ No newline at end of file + v.length +} diff --git a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/plusplusMinusminus.kt b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/plusplusMinusminus.kt index 08ec280670c..cac789a2e71 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/plusplusMinusminus.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/plusplusMinusminus.kt @@ -12,10 +12,10 @@ operator fun Long?.inc() = this?.let { it + 1 } fun bar(arg: Long?): Long { var i = arg if (i++ == 5L) { - return i-- + i + return i-- + i } if (i++ == 7L) { return i++ + i } return 0L -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/postfixNotnullClassIncrement.fir.kt b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/postfixNotnullClassIncrement.fir.kt index f596b8eb5ec..b7520e5f0b1 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/postfixNotnullClassIncrement.fir.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/postfixNotnullClassIncrement.fir.kt @@ -10,4 +10,4 @@ public fun box() : MyClass? { var j = i++ j.hashCode() return i -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/postfixNotnullClassIncrement.kt b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/postfixNotnullClassIncrement.kt index a8af60b0b89..b23cf17ff87 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/postfixNotnullClassIncrement.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/postfixNotnullClassIncrement.kt @@ -1,7 +1,7 @@ // !WITH_NEW_INFERENCE class MyClass -operator fun MyClass.inc(): MyClass { return null!! } +operator fun MyClass.inc(): MyClass { return null!! } public fun box() : MyClass? { var i : MyClass? @@ -10,4 +10,4 @@ public fun box() : MyClass? { var j = i++ j.hashCode() return i -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/prefixNotnullClassIncrement.fir.kt b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/prefixNotnullClassIncrement.fir.kt index b6221b848ba..9193fee27ef 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/prefixNotnullClassIncrement.fir.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/prefixNotnullClassIncrement.fir.kt @@ -10,4 +10,4 @@ public fun box() { var j = ++i // j is null so call is unsafe j.hashCode() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/prefixNotnullClassIncrement.kt b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/prefixNotnullClassIncrement.kt index bc4f25b85b7..f31b9849399 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/prefixNotnullClassIncrement.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/prefixNotnullClassIncrement.kt @@ -1,7 +1,7 @@ // !WITH_NEW_INFERENCE class MyClass -operator fun MyClass.inc(): MyClass { return null!! } +operator fun MyClass.inc(): MyClass { return null!! } public fun box() { var i : MyClass? @@ -10,4 +10,4 @@ public fun box() { var j = ++i // j is null so call is unsafe j.hashCode() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/unnecessaryWithMap.kt b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/unnecessaryWithMap.kt index 3eca82fa791..696a1d23866 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/unnecessaryWithMap.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/unnecessaryWithMap.kt @@ -15,7 +15,7 @@ class MyClass { m = create() // See KT-7428 for ((k, v) in m) - res += (k.length + v.length) + res += (k.length + v.length) return res } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/varCapturedInInlineClosure.fir.kt b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/varCapturedInInlineClosure.fir.kt index 508d7330612..009054c8de9 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/varCapturedInInlineClosure.fir.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/varCapturedInInlineClosure.fir.kt @@ -13,4 +13,4 @@ fun max(a: IntArray): Int? { maxI = i } return maxI -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/varCapturedInInlineClosure.kt b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/varCapturedInInlineClosure.kt index 290f8b6f5c9..a5ef4b3718a 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/varCapturedInInlineClosure.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/varCapturedInInlineClosure.kt @@ -9,8 +9,8 @@ fun IntArray.forEachIndexed( op: (i: Int, value: Int) -> Unit) { fun max(a: IntArray): Int? { var maxI: Int? = null a.forEachIndexed { i, value -> - if (maxI == null || value >= a[maxI]) + if (maxI == null || value >= a[maxI]) maxI = i } return maxI -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/varIntNull.kt b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/varIntNull.kt index ad110456f2f..a23c1b027c9 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/varIntNull.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/varIntNull.kt @@ -2,5 +2,5 @@ fun foo(): Int { var i: Int? = 42 i = null - return i + 1 -} \ No newline at end of file + return i + 1 +} diff --git a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/varNull.fir.kt b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/varNull.fir.kt index ffc12c87ecd..e70c299a0d1 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/varNull.fir.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/varNull.fir.kt @@ -3,4 +3,4 @@ fun foo(): Int { var s: String? = "abc" s = null return s.length -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/varNull.kt b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/varNull.kt index da0e7ad3353..91ed7e8410d 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/varNull.kt +++ b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/varNull.kt @@ -2,5 +2,5 @@ fun foo(): Int { var s: String? = "abc" s = null - return s.length -} \ No newline at end of file + return s.length +} diff --git a/compiler/testData/diagnostics/tests/substitutions/starProjections.kt b/compiler/testData/diagnostics/tests/substitutions/starProjections.kt index 2ce4d7b1316..185071aec6e 100644 --- a/compiler/testData/diagnostics/tests/substitutions/starProjections.kt +++ b/compiler/testData/diagnostics/tests/substitutions/starProjections.kt @@ -17,9 +17,9 @@ interface B, T>> { } fun testB(b: B<*, *>) { - b.r().checkType { _() } - b.t().checkType { _, *>>() } + b.r().checkType { _() } + b.t().checkType { _, *>>() } - b.t().r().size + b.t().r().size } diff --git a/compiler/testData/diagnostics/tests/substitutions/upperBoundsSubstitutionForOverloadResolutionWithAmbiguity.fir.kt b/compiler/testData/diagnostics/tests/substitutions/upperBoundsSubstitutionForOverloadResolutionWithAmbiguity.fir.kt index fb10e0b812c..5df68887ee8 100644 --- a/compiler/testData/diagnostics/tests/substitutions/upperBoundsSubstitutionForOverloadResolutionWithAmbiguity.fir.kt +++ b/compiler/testData/diagnostics/tests/substitutions/upperBoundsSubstitutionForOverloadResolutionWithAmbiguity.fir.kt @@ -16,4 +16,4 @@ import bar.* fun test(l: List) { f(l) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/substitutions/upperBoundsSubstitutionForOverloadResolutionWithAmbiguity.kt b/compiler/testData/diagnostics/tests/substitutions/upperBoundsSubstitutionForOverloadResolutionWithAmbiguity.kt index 02675574551..13b20d49921 100644 --- a/compiler/testData/diagnostics/tests/substitutions/upperBoundsSubstitutionForOverloadResolutionWithAmbiguity.kt +++ b/compiler/testData/diagnostics/tests/substitutions/upperBoundsSubstitutionForOverloadResolutionWithAmbiguity.kt @@ -15,5 +15,5 @@ import foo.* import bar.* fun test(l: List) { - f(l) -} \ No newline at end of file + f(l) +} diff --git a/compiler/testData/diagnostics/tests/substitutions/upperBoundsSubstitutionForOverloadResolutionWithErrorTypes.fir.kt b/compiler/testData/diagnostics/tests/substitutions/upperBoundsSubstitutionForOverloadResolutionWithErrorTypes.fir.kt index 6516feb3311..92fd0a5ef67 100644 --- a/compiler/testData/diagnostics/tests/substitutions/upperBoundsSubstitutionForOverloadResolutionWithErrorTypes.fir.kt +++ b/compiler/testData/diagnostics/tests/substitutions/upperBoundsSubstitutionForOverloadResolutionWithErrorTypes.fir.kt @@ -6,4 +6,4 @@ fun f1(c: Collection): T{throw Exception()} fun test(l: List) { f1(l) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/substitutions/upperBoundsSubstitutionForOverloadResolutionWithErrorTypes.kt b/compiler/testData/diagnostics/tests/substitutions/upperBoundsSubstitutionForOverloadResolutionWithErrorTypes.kt index 7881086dbfb..b4462ae3337 100644 --- a/compiler/testData/diagnostics/tests/substitutions/upperBoundsSubstitutionForOverloadResolutionWithErrorTypes.kt +++ b/compiler/testData/diagnostics/tests/substitutions/upperBoundsSubstitutionForOverloadResolutionWithErrorTypes.kt @@ -5,5 +5,5 @@ fun f1(l: List2): T {throw Exception()} // ERR fun f1(c: Collection): T{throw Exception()} fun test(l: List) { - f1(l) -} \ No newline at end of file + f1(l) +} diff --git a/compiler/testData/diagnostics/tests/suspendConversion/chainedFunSuspendConversionForSimpleExpression.kt b/compiler/testData/diagnostics/tests/suspendConversion/chainedFunSuspendConversionForSimpleExpression.kt index 17f0bf5e12f..9c19df99408 100644 --- a/compiler/testData/diagnostics/tests/suspendConversion/chainedFunSuspendConversionForSimpleExpression.kt +++ b/compiler/testData/diagnostics/tests/suspendConversion/chainedFunSuspendConversionForSimpleExpression.kt @@ -11,3 +11,4 @@ fun test(f: () -> Unit) { foo { } foo(f) } + diff --git a/compiler/testData/diagnostics/tests/suspendConversion/suspendAndFunConversionInDisabledMode.kt b/compiler/testData/diagnostics/tests/suspendConversion/suspendAndFunConversionInDisabledMode.kt index 1437e84447d..f7fffebc507 100644 --- a/compiler/testData/diagnostics/tests/suspendConversion/suspendAndFunConversionInDisabledMode.kt +++ b/compiler/testData/diagnostics/tests/suspendConversion/suspendAndFunConversionInDisabledMode.kt @@ -28,3 +28,4 @@ object Test2 { } } } + diff --git a/compiler/testData/diagnostics/tests/suspendConversion/suspendConversionCompatibility.kt b/compiler/testData/diagnostics/tests/suspendConversion/suspendConversionCompatibility.kt index 2d83b8a378c..90c564f0e13 100644 --- a/compiler/testData/diagnostics/tests/suspendConversion/suspendConversionCompatibility.kt +++ b/compiler/testData/diagnostics/tests/suspendConversion/suspendConversionCompatibility.kt @@ -40,4 +40,4 @@ object Test3 { result } } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/Bases.kt b/compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/Bases.kt index 2ea41e308b1..9eb9f40821b 100644 --- a/compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/Bases.kt +++ b/compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/Bases.kt @@ -28,4 +28,4 @@ public class JavaClass1 { // FILE: JavaClass2.java public class JavaClass2 extends KotlinClass1 { public int getSomething2() { return 1; } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/Getter.kt b/compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/Getter.kt index 314f895def1..56f9bd2f56e 100644 --- a/compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/Getter.kt +++ b/compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/Getter.kt @@ -17,4 +17,4 @@ fun useInt(i: Int) {} // FILE: JavaClass.java public class JavaClass { public int getSomething() { return 1; } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/OnlyPublic.kt b/compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/OnlyPublic.kt index 7164afb1eb6..5e057186469 100644 --- a/compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/OnlyPublic.kt +++ b/compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/OnlyPublic.kt @@ -19,4 +19,4 @@ public class JavaClass { int getSomethingPackage() { return 1; } protected void setSomethingPublic(int value) {} -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/SetterHasHigherAccess.kt b/compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/SetterHasHigherAccess.kt index ddb4ee89226..d0d8de0a565 100644 --- a/compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/SetterHasHigherAccess.kt +++ b/compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/SetterHasHigherAccess.kt @@ -13,4 +13,4 @@ fun foo(javaClass: JavaClass) { public class JavaClass { protected int getSomething() { return 1; } public void setSomething(int value) {} -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericMethod.kt b/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericMethod.kt index ab0f7d86bb2..ffa5c54f4e0 100644 --- a/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericMethod.kt +++ b/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericMethod.kt @@ -11,4 +11,4 @@ public class JavaClass { interface I { T run(T t); -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericMethodInGenericClass.kt b/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericMethodInGenericClass.kt index b1a3772167e..f715eebf393 100644 --- a/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericMethodInGenericClass.kt +++ b/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericMethodInGenericClass.kt @@ -13,4 +13,4 @@ public class JavaClass { interface I { T run(T t); -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/InnerClassInGeneric.kt b/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/InnerClassInGeneric.kt index 680412ce5dd..9577f65917d 100644 --- a/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/InnerClassInGeneric.kt +++ b/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/InnerClassInGeneric.kt @@ -2,7 +2,7 @@ // FILE: KotlinFile.kt fun foo(javaClass: JavaClass): Int { val inner = javaClass.createInner() - return inner.doSomething(1, "") { } + return inner.doSomething(1, "") { } } // FILE: JavaClass.java diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/PackageLocal.kt b/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/PackageLocal.kt index 55819311328..185dcc0ca49 100644 --- a/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/PackageLocal.kt +++ b/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/PackageLocal.kt @@ -15,4 +15,4 @@ fun foo(javaClass: JavaClass) { // FILE: JavaClass.java public class JavaClass { void doSomething(Runnable runnable) { runnable.run(); } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/Private.kt b/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/Private.kt index 044299fd325..9de8a5382e9 100644 --- a/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/Private.kt +++ b/compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/Private.kt @@ -1,10 +1,10 @@ // !WITH_NEW_INFERENCE // FILE: KotlinFile.kt fun foo(javaClass: JavaClass) { - javaClass.doSomething { } + javaClass.doSomething { } } // FILE: JavaClass.java public class JavaClass { private void doSomething(Runnable runnable) { runnable.run(); } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/ambiguousSuperWithGenerics.kt b/compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/ambiguousSuperWithGenerics.kt index 4efde3e90e0..1843a358cba 100644 --- a/compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/ambiguousSuperWithGenerics.kt +++ b/compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/ambiguousSuperWithGenerics.kt @@ -14,7 +14,7 @@ class GenericDerivedClass : GenericBaseClass(), GenericBaseInterface { override fun bar(x: T): T = super.bar(x) override fun ambiguous(x: T): T = - super.ambiguous(x) + super.ambiguous(x) } class SpecializedDerivedClass : GenericBaseClass(), GenericBaseInterface { @@ -22,9 +22,9 @@ class SpecializedDerivedClass : GenericBaseCl override fun bar(x: String): String = super.bar(x) override fun ambiguous(x: String): String = - super.ambiguous(x) + super.ambiguous(x) override fun ambiguous(x: Int): Int = - super.ambiguous(x) + super.ambiguous(x) } class MixedDerivedClass : GenericBaseClass(), GenericBaseInterface { @@ -32,7 +32,7 @@ class MixedDerivedClass : GenericBaseClass override fun bar(x: T): T = super.bar(x) override fun ambiguous(x: Int): Int = - super.ambiguous(x) + super.ambiguous(x) override fun ambiguous(x: T): T = - super.ambiguous(x) -} \ No newline at end of file + super.ambiguous(x) +} diff --git a/compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/unqualifiedSuperWithCallableProperty.kt b/compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/unqualifiedSuperWithCallableProperty.kt index 6d682b6de24..39b17224993 100644 --- a/compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/unqualifiedSuperWithCallableProperty.kt +++ b/compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/unqualifiedSuperWithCallableProperty.kt @@ -14,8 +14,8 @@ interface InterfaceWithFun { class DerivedUsingFun : BaseWithCallableProp(), InterfaceWithFun { fun foo(): String = - super.fn() + super.fn() override fun bar(): String = super.bar() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/typeParameters/implicitNothingInReturnPosition.kt b/compiler/testData/diagnostics/tests/typeParameters/implicitNothingInReturnPosition.kt index c9b3c768423..a29b5460edd 100644 --- a/compiler/testData/diagnostics/tests/typeParameters/implicitNothingInReturnPosition.kt +++ b/compiler/testData/diagnostics/tests/typeParameters/implicitNothingInReturnPosition.kt @@ -40,7 +40,7 @@ class Context fun Any.decodeIn(typeFrom: Context): T = something() fun Any?.decodeOut1(typeFrom: Context): T { - return this?.decodeIn(typeFrom) ?: kotlin.Unit + return this?.decodeIn(typeFrom) ?: kotlin.Unit } fun Any.decodeOut2(typeFrom: Context): T { diff --git a/compiler/testData/diagnostics/tests/typealias/boundViolationInTypeAliasConstructor.kt b/compiler/testData/diagnostics/tests/typealias/boundViolationInTypeAliasConstructor.kt index 2a4864084e6..ac96526df5b 100644 --- a/compiler/testData/diagnostics/tests/typealias/boundViolationInTypeAliasConstructor.kt +++ b/compiler/testData/diagnostics/tests/typealias/boundViolationInTypeAliasConstructor.kt @@ -13,6 +13,6 @@ class TColl> typealias TC = TColl typealias TC2 = TC -val y1 = TCollAny>() -val y2 = TCAny>() -val y3 = TC2Any>() +val y1 = TCollAny>() +val y2 = TCAny>() +val y3 = TC2Any>() diff --git a/compiler/testData/diagnostics/tests/typealias/boundsViolationInTypeAliasExpansion.kt b/compiler/testData/diagnostics/tests/typealias/boundsViolationInTypeAliasExpansion.kt index 5a111b724b6..66998fd9bfe 100644 --- a/compiler/testData/diagnostics/tests/typealias/boundsViolationInTypeAliasExpansion.kt +++ b/compiler/testData/diagnostics/tests/typealias/boundsViolationInTypeAliasExpansion.kt @@ -18,8 +18,8 @@ fun test4(x: NL) {} val test5 = NA() val test6 = NA<Any>() val test7 = NL() -val test8 = MMMM<Int>() -val test9dwd = NL() +val test8 = MMMM<Int>() +val test9dwd = NL() fun test9(x: TC>) {} fun test10(x: TC>) {} diff --git a/compiler/testData/diagnostics/tests/typealias/importMemberFromJavaViaAlias.fir.kt b/compiler/testData/diagnostics/tests/typealias/importMemberFromJavaViaAlias.fir.kt deleted file mode 100644 index c07a996b728..00000000000 --- a/compiler/testData/diagnostics/tests/typealias/importMemberFromJavaViaAlias.fir.kt +++ /dev/null @@ -1,28 +0,0 @@ -// !DIAGNOSTICS: -UNUSED_PARAMETER -// SKIP_JAVAC - -// FILE: test/jv/JavaSample.java - -package test.jv; - -public class JavaSample { - public static void member() {} -} - -// FILE: foo.kt - -package test.kot - -typealias JavaAlias = test.jv.JavaSample - -// FILE: test.kt - -import test.kot.JavaAlias -import test.kot.JavaAlias.member - -fun foo( - sample: JavaSample, - alias: JavaAlias -) { - member() -} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/typealias/importMemberFromJavaViaAlias.kt b/compiler/testData/diagnostics/tests/typealias/importMemberFromJavaViaAlias.kt index 07cedb5ffff..8c4115c85b5 100644 --- a/compiler/testData/diagnostics/tests/typealias/importMemberFromJavaViaAlias.kt +++ b/compiler/testData/diagnostics/tests/typealias/importMemberFromJavaViaAlias.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // !DIAGNOSTICS: -UNUSED_PARAMETER // SKIP_JAVAC @@ -25,4 +26,4 @@ fun foo( alias: JavaAlias ) { member() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/typealias/innerClassTypeAliasConstructor.fir.kt b/compiler/testData/diagnostics/tests/typealias/innerClassTypeAliasConstructor.fir.kt index 33217c3fb62..3fd7f4dd2ba 100644 --- a/compiler/testData/diagnostics/tests/typealias/innerClassTypeAliasConstructor.fir.kt +++ b/compiler/testData/diagnostics/tests/typealias/innerClassTypeAliasConstructor.fir.kt @@ -21,4 +21,4 @@ fun test2(x: Generic) = x.GI() fun test3(x: Generic) = x.GI() fun test4(x: Generic>) = x.GI() fun test5(x: Generic) = x.GIntI() -fun Generic.test6() = GIntI() \ No newline at end of file +fun Generic.test6() = GIntI() diff --git a/compiler/testData/diagnostics/tests/typealias/innerClassTypeAliasConstructor.kt b/compiler/testData/diagnostics/tests/typealias/innerClassTypeAliasConstructor.kt index a5f98675826..3a8bc36da99 100644 --- a/compiler/testData/diagnostics/tests/typealias/innerClassTypeAliasConstructor.kt +++ b/compiler/testData/diagnostics/tests/typealias/innerClassTypeAliasConstructor.kt @@ -20,5 +20,5 @@ typealias GIntI = Generic.Inner fun test2(x: Generic) = x.GI() fun test3(x: Generic) = x.GI() fun test4(x: Generic>) = x.GI() -fun test5(x: Generic) = x.GIntI() -fun Generic.test6() = GIntI() \ No newline at end of file +fun test5(x: Generic) = x.GIntI() +fun Generic.test6() = GIntI() diff --git a/compiler/testData/diagnostics/tests/typealias/innerClassTypeAliasConstructorInSupertypes.kt b/compiler/testData/diagnostics/tests/typealias/innerClassTypeAliasConstructorInSupertypes.kt index 78e5b9fc8de..dc9e4b2b674 100644 --- a/compiler/testData/diagnostics/tests/typealias/innerClassTypeAliasConstructorInSupertypes.kt +++ b/compiler/testData/diagnostics/tests/typealias/innerClassTypeAliasConstructorInSupertypes.kt @@ -22,16 +22,16 @@ class Generic { open inner class Generic inner class Test1 : GI() - inner class Test2 : GIInt() + inner class Test2 : GIInt() inner class Test3 : GIStar() inner class Test3a : test.Generic<*>.Inner() inner class Test4 : GG() inner class Test5 : GG() - inner class Test6 : GG() - inner class Test7 : GG() - inner class Test8 : GIntG() - inner class Test9 : GGInt() + inner class Test6 : GG() + inner class Test7 : GG() + inner class Test8 : GIntG() + inner class Test9 : GGInt() inner class Test10 : GGInt() inner class Test11 : GG { diff --git a/compiler/testData/diagnostics/tests/typealias/innerTypeAliasConstructor.kt b/compiler/testData/diagnostics/tests/typealias/innerTypeAliasConstructor.kt index 7132d68b6e5..9aec6936a4f 100644 --- a/compiler/testData/diagnostics/tests/typealias/innerTypeAliasConstructor.kt +++ b/compiler/testData/diagnostics/tests/typealias/innerTypeAliasConstructor.kt @@ -20,5 +20,5 @@ val test4 = C.P2(1, // C.P() syntax could work if we add captured type parameters as type variables in a constraint system for corresponding call. // However, this should be consistent with inner classes capturing type parameters. val test5 = C.P(1, 1) -val test6 = C.P1("", 1) -val test7 = C.P2(1, "") +val test6 = C.P1("", 1) +val test7 = C.P2(1, "") diff --git a/compiler/testData/diagnostics/tests/typealias/noApproximationInTypeAliasArgumentSubstitution.kt b/compiler/testData/diagnostics/tests/typealias/noApproximationInTypeAliasArgumentSubstitution.kt index 00d8fc5e873..b8651e1dfaf 100644 --- a/compiler/testData/diagnostics/tests/typealias/noApproximationInTypeAliasArgumentSubstitution.kt +++ b/compiler/testData/diagnostics/tests/typealias/noApproximationInTypeAliasArgumentSubstitution.kt @@ -6,7 +6,7 @@ typealias Array2D = Array> fun foo1(a: Array2D) = a fun bar1(a: Array2D) = - foo1( /* = Array> */", "Array2D /* = Array> */")!>a) + foo1( /* = Array> */; Array2D /* = Array> */")!>a) typealias TMap = Map @@ -14,4 +14,4 @@ typealias TMap = Map fun foo2(m: TMap) = m fun bar2(m: TMap<*>) = - foo2(m) + foo2(m) diff --git a/compiler/testData/diagnostics/tests/typealias/noRHS.kt b/compiler/testData/diagnostics/tests/typealias/noRHS.kt index 6cb972210ab..646828f1dbe 100644 --- a/compiler/testData/diagnostics/tests/typealias/noRHS.kt +++ b/compiler/testData/diagnostics/tests/typealias/noRHS.kt @@ -4,4 +4,4 @@ typealias typealias A1 typealias A2 = - \ No newline at end of file + diff --git a/compiler/testData/diagnostics/tests/typealias/privateInFile.kt b/compiler/testData/diagnostics/tests/typealias/privateInFile.kt index ab48482a624..3b72ee3c5b0 100644 --- a/compiler/testData/diagnostics/tests/typealias/privateInFile.kt +++ b/compiler/testData/diagnostics/tests/typealias/privateInFile.kt @@ -19,4 +19,4 @@ private val test2: TA = TA() private val test2co = TA private class C -private typealias TA = Int \ No newline at end of file +private typealias TA = Int diff --git a/compiler/testData/diagnostics/tests/typealias/recursive.kt b/compiler/testData/diagnostics/tests/typealias/recursive.kt index 485491f1dac..3522e2dbf12 100644 --- a/compiler/testData/diagnostics/tests/typealias/recursive.kt +++ b/compiler/testData/diagnostics/tests/typealias/recursive.kt @@ -8,4 +8,4 @@ typealias B = A typealias F1 = (Int) -> F2 typealias F2 = (F1) -> Int -val x: A = TODO() \ No newline at end of file +val x: A = TODO() diff --git a/compiler/testData/diagnostics/tests/typealias/starImportOnTypeAlias.fir.kt b/compiler/testData/diagnostics/tests/typealias/starImportOnTypeAlias.fir.kt index 373869f845c..ea3d6ab50cc 100644 --- a/compiler/testData/diagnostics/tests/typealias/starImportOnTypeAlias.fir.kt +++ b/compiler/testData/diagnostics/tests/typealias/starImportOnTypeAlias.fir.kt @@ -1,7 +1,5 @@ // FILE: foo.kt -// FILE: foo.kt - package test typealias ClassAlias = ClassSample @@ -27,4 +25,4 @@ import test.EnumAlias fun bar() { Entry EnumAlias.Entry -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/typealias/starImportOnTypeAlias.kt b/compiler/testData/diagnostics/tests/typealias/starImportOnTypeAlias.kt index d1e6dcbfc52..02ae714f6e2 100644 --- a/compiler/testData/diagnostics/tests/typealias/starImportOnTypeAlias.kt +++ b/compiler/testData/diagnostics/tests/typealias/starImportOnTypeAlias.kt @@ -1,7 +1,5 @@ // FILE: foo.kt -// FILE: foo.kt - package test typealias ClassAlias = ClassSample @@ -27,4 +25,4 @@ import test.EnumAlias fun bar() { Entry EnumAlias.Entry -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/typealias/starProjection.fir.kt b/compiler/testData/diagnostics/tests/typealias/starProjection.fir.kt index c30441b6756..a760eb31598 100644 --- a/compiler/testData/diagnostics/tests/typealias/starProjection.fir.kt +++ b/compiler/testData/diagnostics/tests/typealias/starProjection.fir.kt @@ -12,4 +12,4 @@ fun test3(x: Map) = check(x).size fun test4(x: Map) = check(x)["42"] -fun test5(x: Map) = check(x)[42] \ No newline at end of file +fun test5(x: Map) = check(x)[42] diff --git a/compiler/testData/diagnostics/tests/typealias/starProjection.kt b/compiler/testData/diagnostics/tests/typealias/starProjection.kt index 1c88d728d2f..0d651e014e8 100644 --- a/compiler/testData/diagnostics/tests/typealias/starProjection.kt +++ b/compiler/testData/diagnostics/tests/typealias/starProjection.kt @@ -10,6 +10,6 @@ fun test2(x: Map) = check(x) fun test3(x: Map) = check(x).size -fun test4(x: Map) = check(x)["42"] +fun test4(x: Map) = check(x)["42"] -fun test5(x: Map) = check(x)[42] \ No newline at end of file +fun test5(x: Map) = check(x)[42] diff --git a/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorCrazyProjections.fir.kt b/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorCrazyProjections.fir.kt index c2b8b12cbf2..23887da1590 100644 --- a/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorCrazyProjections.fir.kt +++ b/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorCrazyProjections.fir.kt @@ -13,4 +13,4 @@ fun listOf(): List = null!! // since it has 'out' type projection in 'in' position. val test1 = BOutIn(listOf(), null!!) -val test2 = BInIn(listOf(), null!!) \ No newline at end of file +val test2 = BInIn(listOf(), null!!) diff --git a/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorCrazyProjections.kt b/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorCrazyProjections.kt index fd3e6ec9b20..516e50eea4b 100644 --- a/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorCrazyProjections.kt +++ b/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorCrazyProjections.kt @@ -11,6 +11,6 @@ fun listOf(): List = null!! // Unresolved reference is ok here: // we can't create a substituted signature for type alias constructor // since it has 'out' type projection in 'in' position. -val test1 = BOutIn(listOf(), null!!) +val test1 = BOutIn(listOf(), null!!) -val test2 = BInIn(listOf(), null!!) \ No newline at end of file +val test2 = BInIn(listOf(), null!!) diff --git a/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorForProjection.fir.kt b/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorForProjection.fir.kt index a163bc1498c..4218c8cbba6 100644 --- a/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorForProjection.fir.kt +++ b/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorForProjection.fir.kt @@ -12,4 +12,4 @@ val test1 = CStar() val test2 = CIn() val test3 = COut() val test4 = CT<*>() -val test5 = CT>() \ No newline at end of file +val test5 = CT>() diff --git a/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorForProjection.kt b/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorForProjection.kt index 46bbc07fa6a..9f37e11bee7 100644 --- a/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorForProjection.kt +++ b/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorForProjection.kt @@ -8,8 +8,8 @@ typealias CIn = C typealias COut = C typealias CT = C -val test1 = CStar() -val test2 = CIn() -val test3 = COut() -val test4 = CT<*>() -val test5 = CT>() \ No newline at end of file +val test1 = CStar() +val test2 = CIn() +val test3 = COut() +val test4 = CT<*>() +val test5 = CT>() diff --git a/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorForProjectionInSupertypes.kt b/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorForProjectionInSupertypes.kt index dcef82eff8a..0084edb6950 100644 --- a/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorForProjectionInSupertypes.kt +++ b/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorForProjectionInSupertypes.kt @@ -6,12 +6,12 @@ typealias CIn = C typealias COut = C typealias CT = C -class Test1 : CStar() -class Test2 : CIn() -class Test3 : COut() +class Test1 : CStar() +class Test2 : CIn() +class Test3 : COut() class Test4 : CStar { - constructor() : super() + constructor() : super() } class Test5 : CT<*>() diff --git a/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorInSuperCall.kt b/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorInSuperCall.kt index 72b7900f92d..5ea5d5b070d 100644 --- a/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorInSuperCall.kt +++ b/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorInSuperCall.kt @@ -11,4 +11,4 @@ class MyDerived2a : MyBase(null) class MyDerived3 : MyAlias { constructor(x: Nothing?) : super(x) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorInferenceInSupertypesList.kt b/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorInferenceInSupertypesList.kt index 93d7d7740be..955d07623f5 100644 --- a/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorInferenceInSupertypesList.kt +++ b/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorInferenceInSupertypesList.kt @@ -4,4 +4,4 @@ typealias R = Ref // Type inference SHOULD NOT work for type alias constructor in supertypes list class Test1 : R(0) -class Test2 : R(0) \ No newline at end of file +class Test2 : R(0) diff --git a/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInference.kt b/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInference.kt index 268e740ef69..3b9fb834740 100644 --- a/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInference.kt +++ b/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInference.kt @@ -5,15 +5,15 @@ class Num(val x: Tn) typealias N = Num val test0 = N(1) -val test1 = N("1") +val test1 = N("1") class Cons(val head: T, val tail: Cons?) typealias C = Cons typealias CC = C> -val test2 = C(1, 2) -val test3 = CC(1, 2) +val test2 = C(1, 2) +val test3 = CC(1, 2) val test4 = CC(C(1, null), null) @@ -21,13 +21,13 @@ class Pair(val x: X, val y: Y) typealias PL = Pair> typealias PN = Pair> -val test5 = PL(1, null) +val test5 = PL(1, null) class Foo(val p: Pair) typealias F = Foo -fun testProjections1(x: Pair) = F(x) -fun testProjections2(x: Pair) = F(x) -fun testProjections3(x: Pair) = F(x) -fun testProjections4(x: Pair) = F(x) \ No newline at end of file +fun testProjections1(x: Pair) = F(x) +fun testProjections2(x: Pair) = F(x) +fun testProjections3(x: Pair) = F(x) +fun testProjections4(x: Pair) = F(x) diff --git a/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInferenceWithNestedCalls.kt b/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInferenceWithNestedCalls.kt index b7a04efa96a..75f5863535f 100644 --- a/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInferenceWithNestedCalls.kt +++ b/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInferenceWithNestedCalls.kt @@ -5,4 +5,4 @@ class Cons(val head: T, val tail: Cons?) typealias C = Cons val test1 = C(1, C(2, null)) -val test2 = C(1, C("", null)) +val test2 = C(1, C("", null)) diff --git a/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInferenceWithNestedCalls2.fir.kt b/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInferenceWithNestedCalls2.fir.kt index 52045873554..f2b5bafefc9 100644 --- a/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInferenceWithNestedCalls2.fir.kt +++ b/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInferenceWithNestedCalls2.fir.kt @@ -38,4 +38,4 @@ fun test() { r2a.x = r2a.x r3.x = r3.x r3a.x = r3a.x -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInferenceWithNestedCalls2.kt b/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInferenceWithNestedCalls2.kt index d18d7e9772b..4525dcbbad5 100644 --- a/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInferenceWithNestedCalls2.kt +++ b/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInferenceWithNestedCalls2.kt @@ -32,10 +32,10 @@ val r3 = LateInitNumRef(1) val r3a = LateNR(1) fun test() { - r1.x = r1.x - r1a.x = r1a.x + r1.x = r1.x + r1a.x = r1a.x r2.x = r2.x r2a.x = r2a.x r3.x = r3.x r3a.x = r3a.x -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInferenceWithPhantomTypes.kt b/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInferenceWithPhantomTypes.kt index 8f234c87673..b7e1a1389a5 100644 --- a/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInferenceWithPhantomTypes.kt +++ b/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInferenceWithPhantomTypes.kt @@ -9,9 +9,9 @@ class Hr(val a: A, val b: B) typealias Test = Hr, Bar> val test1 = Test(1, "") -val test2 = Test(1, 2) +val test2 = Test(1, 2) typealias Bas = Hr, Bar> -val test3 = Bas(1, 1) +val test3 = Bas(1, 1) diff --git a/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorWrongVisibility.kt b/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorWrongVisibility.kt index e0deed70027..d70ce56fb86 100644 --- a/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorWrongVisibility.kt +++ b/compiler/testData/diagnostics/tests/typealias/typeAliasConstructorWrongVisibility.kt @@ -26,4 +26,4 @@ class MyDerived : MyClass(1.0) { val test5a = MyClass("") val test6 = MyAlias(1.0) val test6a = MyClass(1.0) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/typealias/typeAliasesInQualifiers.kt b/compiler/testData/diagnostics/tests/typealias/typeAliasesInQualifiers.kt index 057e762c472..2d6d5d0e538 100644 --- a/compiler/testData/diagnostics/tests/typealias/typeAliasesInQualifiers.kt +++ b/compiler/testData/diagnostics/tests/typealias/typeAliasesInQualifiers.kt @@ -72,4 +72,4 @@ fun foo( test.EnumSample.Nested::func test.EnumAlias.Nested::func -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/typealias/wrongNumberOfArgumentsInTypeAliasConstructor.kt b/compiler/testData/diagnostics/tests/typealias/wrongNumberOfArgumentsInTypeAliasConstructor.kt index be6aff68aab..969cd7036c7 100644 --- a/compiler/testData/diagnostics/tests/typealias/wrongNumberOfArgumentsInTypeAliasConstructor.kt +++ b/compiler/testData/diagnostics/tests/typealias/wrongNumberOfArgumentsInTypeAliasConstructor.kt @@ -21,15 +21,15 @@ val test2p2 = P2(1, 1) val test3p2 = P2(1, 1) val test0pr = PR(1, "") -val test1pr = PR(1, "") +val test1pr = PR(1, "") val test2pr = PR(1, "") val test2pra = PR(1, "") -val test3pr = P2(1, "") +val test3pr = P2(1, "") class Num(val x: T) typealias N = Num -val testN0 = N("") +val testN0 = N("") val testN1 = N(1) val testN1a = N<String>("") val testN2 = N(1) @@ -38,5 +38,5 @@ class MyPair(val string: T1, val number: T2) typealias MP = MyPair val testMP0 = MP("", 1) -val testMP1 = MP(1, "") -val testMP2 = MP<String>("", "") \ No newline at end of file +val testMP1 = MP(1, "") +val testMP2 = MP<String>("", "") diff --git a/compiler/testData/diagnostics/tests/unitConversion/chainedFunSuspendUnitConversion.kt b/compiler/testData/diagnostics/tests/unitConversion/chainedFunSuspendUnitConversion.kt index 4a3c38869ae..6815b33cf66 100644 --- a/compiler/testData/diagnostics/tests/unitConversion/chainedFunSuspendUnitConversion.kt +++ b/compiler/testData/diagnostics/tests/unitConversion/chainedFunSuspendUnitConversion.kt @@ -15,4 +15,4 @@ fun test(f: () -> String, s: SubInt) { foo(f) foo(s) foo(::bar) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/unitConversion/chainedUnitSuspendConversion.kt b/compiler/testData/diagnostics/tests/unitConversion/chainedUnitSuspendConversion.kt index ad5611f7a73..b0979e6a33f 100644 --- a/compiler/testData/diagnostics/tests/unitConversion/chainedUnitSuspendConversion.kt +++ b/compiler/testData/diagnostics/tests/unitConversion/chainedUnitSuspendConversion.kt @@ -11,4 +11,4 @@ fun test(g: () -> Double, s: SubInt) { foo(::bar) foo(g) foo(s) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/unitConversion/unitConversionForAllKinds.kt b/compiler/testData/diagnostics/tests/unitConversion/unitConversionForAllKinds.kt index 38681e94c2d..3049912bb4c 100644 --- a/compiler/testData/diagnostics/tests/unitConversion/unitConversionForAllKinds.kt +++ b/compiler/testData/diagnostics/tests/unitConversion/unitConversionForAllKinds.kt @@ -13,4 +13,4 @@ fun test(g: () -> String, h: (Float) -> String) { foo(g) fooGeneric(h) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/valueClasses/presenceOfInitializerBlockInsideValueClass.kt b/compiler/testData/diagnostics/tests/valueClasses/presenceOfInitializerBlockInsideValueClass.kt index 06e24914753..72b125b8752 100644 --- a/compiler/testData/diagnostics/tests/valueClasses/presenceOfInitializerBlockInsideValueClass.kt +++ b/compiler/testData/diagnostics/tests/valueClasses/presenceOfInitializerBlockInsideValueClass.kt @@ -1,6 +1,6 @@ +// FIR_IDENTICAL // !LANGUAGE: +InlineClasses // !DIAGNOSTICS: -UNUSED_VARIABLE -// FIR_IDENTICAL package kotlin.jvm diff --git a/compiler/testData/diagnostics/tests/valueClasses/presenceOfPublicPrimaryConstructorForValueClass.kt b/compiler/testData/diagnostics/tests/valueClasses/presenceOfPublicPrimaryConstructorForValueClass.kt index f5ffb217cda..2e5603bb3a3 100644 --- a/compiler/testData/diagnostics/tests/valueClasses/presenceOfPublicPrimaryConstructorForValueClass.kt +++ b/compiler/testData/diagnostics/tests/valueClasses/presenceOfPublicPrimaryConstructorForValueClass.kt @@ -1,5 +1,5 @@ -// !LANGUAGE: +InlineClasses // FIR_IDENTICAL +// !LANGUAGE: +InlineClasses package kotlin.jvm diff --git a/compiler/testData/diagnostics/tests/varargs/NullableTypeForVarargArgument.fir.kt b/compiler/testData/diagnostics/tests/varargs/NullableTypeForVarargArgument.fir.kt index af729da9c91..037cf7fa0fd 100644 --- a/compiler/testData/diagnostics/tests/varargs/NullableTypeForVarargArgument.fir.kt +++ b/compiler/testData/diagnostics/tests/varargs/NullableTypeForVarargArgument.fir.kt @@ -63,4 +63,4 @@ fun invokeTest(goodArgs: Array) { J.staticFun(*goodArgs) J.staticFun(*args) J.staticFun(*args ?: null) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/varargs/NullableTypeForVarargArgument.kt b/compiler/testData/diagnostics/tests/varargs/NullableTypeForVarargArgument.kt index dc44796bbce..405e452a716 100644 --- a/compiler/testData/diagnostics/tests/varargs/NullableTypeForVarargArgument.kt +++ b/compiler/testData/diagnostics/tests/varargs/NullableTypeForVarargArgument.kt @@ -32,13 +32,13 @@ fun getArr(): Array? = null fun f() { A().foo(1, *args) bar(2, *args) - baz(*args) + baz(*args) } fun g(args: Array?) { if (args != null) { - A().foo(1, *args) + A().foo(1, *args) } A().foo(1, *A.ar) } @@ -49,18 +49,18 @@ class B { fun h(b: B) { if (b.args != null) { - A().foo(1, *b.args) + A().foo(1, *b.args) } } fun k() { A().foo(1, *getArr()) bar(2, *getArr()) - baz(*getArr()) + baz(*getArr()) } fun invokeTest(goodArgs: Array) { J.staticFun(*goodArgs) J.staticFun(*args) J.staticFun(*args ?: null) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/varargs/assignArrayToVararagInNamedForm_1_3.kt b/compiler/testData/diagnostics/tests/varargs/assignArrayToVararagInNamedForm_1_3.kt index af94f1b47ce..59b89bb4c96 100644 --- a/compiler/testData/diagnostics/tests/varargs/assignArrayToVararagInNamedForm_1_3.kt +++ b/compiler/testData/diagnostics/tests/varargs/assignArrayToVararagInNamedForm_1_3.kt @@ -20,7 +20,7 @@ fun test_fun(s: String, arr: Array) { } fun test_ann(s: String, arr: Array) { - @Ann([""], x = 1) + @Ann([""], x = 1) foo() @Ann(*[""], x = 1) foo() @@ -31,6 +31,6 @@ fun test_ann(s: String, arr: Array) { @Ann("", x = 1) foo() - @Ann(s = "", x = 1) + @Ann(s = "", x = 1) foo() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/varargs/assignArrayToVararagInNamedForm_1_4.kt b/compiler/testData/diagnostics/tests/varargs/assignArrayToVararagInNamedForm_1_4.kt index d74bf038a54..2d25dc50f1c 100644 --- a/compiler/testData/diagnostics/tests/varargs/assignArrayToVararagInNamedForm_1_4.kt +++ b/compiler/testData/diagnostics/tests/varargs/assignArrayToVararagInNamedForm_1_4.kt @@ -16,11 +16,11 @@ fun test_fun(s: String, arr: Array) { withVararg(s = *arr) // Warning withVararg(s) // OK - withVararg(s = s) // Error + withVararg(s = s) // Error } fun test_ann(s: String, arr: Array) { - @Ann([""], x = 1) + @Ann([""], x = 1) foo() @Ann(*[""], x = 1) foo() @@ -31,6 +31,6 @@ fun test_ann(s: String, arr: Array) { @Ann("", x = 1) foo() - @Ann(s = "", x = 1) + @Ann(s = "", x = 1) foo() } diff --git a/compiler/testData/diagnostics/tests/varargs/assigningArraysToVarargsInAnnotations.kt b/compiler/testData/diagnostics/tests/varargs/assigningArraysToVarargsInAnnotations.kt index e830c54b743..c74b302baae 100644 --- a/compiler/testData/diagnostics/tests/varargs/assigningArraysToVarargsInAnnotations.kt +++ b/compiler/testData/diagnostics/tests/varargs/assigningArraysToVarargsInAnnotations.kt @@ -18,7 +18,7 @@ fun test1() {} @Ann(s = intArrayOf()) fun test2() {} -@Ann(s = arrayOf(1)) +@Ann(s = arrayOf(1)) fun test3() {} @Ann("value1", "value2") @@ -43,4 +43,4 @@ annotation class IntAnn(vararg val i: Int) fun foo1() {} @IntAnn(i = intArrayOf(0)) -fun foo2() {} \ No newline at end of file +fun foo2() {} diff --git a/compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormAnnDeprecation_after.kt b/compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormAnnDeprecation_after.kt index 6f3a0c756fd..1a65bf35926 100644 --- a/compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormAnnDeprecation_after.kt +++ b/compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormAnnDeprecation_after.kt @@ -27,4 +27,4 @@ fun test4() {} fun test5() {} @JavaAnn("value", path = ["path"]) -fun test6() {} \ No newline at end of file +fun test6() {} diff --git a/compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormAnnDeprecation_before.kt b/compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormAnnDeprecation_before.kt index 56e78abbebc..b4738e722b2 100644 --- a/compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormAnnDeprecation_before.kt +++ b/compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormAnnDeprecation_before.kt @@ -27,4 +27,4 @@ fun test4() {} fun test5() {} @JavaAnn("value", path = ["path"]) -fun test6() {} \ No newline at end of file +fun test6() {} diff --git a/compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormFunDeprecation_after.kt b/compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormFunDeprecation_after.kt index f6edfe187fe..6fe42670ea9 100644 --- a/compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormFunDeprecation_after.kt +++ b/compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormFunDeprecation_after.kt @@ -53,8 +53,8 @@ fun testMany(a: Any) { manyFoo(s = "") manyFoo(a) - manyFoo(v = a) - manyFoo(s = a) + manyFoo(v = a) + manyFoo(s = a) manyFoo(v = a as Int) manyFoo(s = a as String) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormFunDeprecation_before.kt b/compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormFunDeprecation_before.kt index 279279f695e..19e64a41598 100644 --- a/compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormFunDeprecation_before.kt +++ b/compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormFunDeprecation_before.kt @@ -53,8 +53,8 @@ fun testMany(a: Any) { manyFoo(s = "") manyFoo(a) - manyFoo(v = a) - manyFoo(s = a) + manyFoo(v = a) + manyFoo(s = a) manyFoo(v = a as Int) manyFoo(s = a as String) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/varargs/noAssigningArraysToVarargsFeature.kt b/compiler/testData/diagnostics/tests/varargs/noAssigningArraysToVarargsFeature.kt index 203747e07d8..65fec28db67 100644 --- a/compiler/testData/diagnostics/tests/varargs/noAssigningArraysToVarargsFeature.kt +++ b/compiler/testData/diagnostics/tests/varargs/noAssigningArraysToVarargsFeature.kt @@ -12,30 +12,30 @@ annotation class Ann(vararg val s: String) -@Ann(s = arrayOf()) +@Ann(s = arrayOf()) fun test1() {} @Ann(s = intArrayOf()) fun test2() {} -@Ann(s = arrayOf(1)) +@Ann(s = arrayOf(1)) fun test3() {} -@Ann(s = ["value"]) +@Ann(s = ["value"]) fun test5() {} -@JavaAnn(value = arrayOf("value")) +@JavaAnn(value = arrayOf("value")) fun jTest1() {} -@JavaAnn(value = ["value"]) +@JavaAnn(value = ["value"]) fun jTest2() {} -@JavaAnn(value = ["value"], path = ["path"]) +@JavaAnn(value = ["value"], path = ["path"]) fun jTest3() {} annotation class IntAnn(vararg val i: Int) -@IntAnn(i = [1, 2]) +@IntAnn(i = [1, 2]) fun foo1() {} @IntAnn(i = intArrayOf(0)) @@ -46,4 +46,4 @@ fun foo(vararg i: Int) {} @Ann(s = "value") fun dep1() { foo(i = 1) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/varargs/varargViewedAsArray.kt b/compiler/testData/diagnostics/tests/varargs/varargViewedAsArray.kt index b9d02d090bf..5a1fc141b2b 100644 --- a/compiler/testData/diagnostics/tests/varargs/varargViewedAsArray.kt +++ b/compiler/testData/diagnostics/tests/varargs/varargViewedAsArray.kt @@ -21,9 +21,9 @@ fun test() { useStringArray(::stringVararg) useIntArray(::numberVararg) usePrimitiveIntArray(::intVararg) - useIntArray() -> Unit", "KFunction1")!>::intVararg) - useMixedStringArgs1() -> Unit", "KFunction1, Unit>")!>::stringVararg) - useMixedStringArgs2(, String) -> Unit", "KFunction1, Unit>")!>::stringVararg) - useMixedStringArgs3(, String) -> Unit", "KFunction1, Unit>")!>::stringVararg) - useTwoStringArrays(, Array) -> Unit", "KFunction1, Unit>")!>::stringVararg) + useIntArray() -> Unit; KFunction1")!>::intVararg) + useMixedStringArgs1() -> Unit; KFunction1, Unit>")!>::stringVararg) + useMixedStringArgs2(, String) -> Unit; KFunction1, Unit>")!>::stringVararg) + useMixedStringArgs3(, String) -> Unit; KFunction1, Unit>")!>::stringVararg) + useTwoStringArrays(, Array) -> Unit; KFunction1, Unit>")!>::stringVararg) } diff --git a/compiler/testData/diagnostics/tests/variance/Class.fir.kt b/compiler/testData/diagnostics/tests/variance/Class.fir.kt index 3993b556f6f..09ebdfe5ea5 100644 --- a/compiler/testData/diagnostics/tests/variance/Class.fir.kt +++ b/compiler/testData/diagnostics/tests/variance/Class.fir.kt @@ -20,4 +20,4 @@ class SubClass3 : Out

class SubClass4 : In class SubClass5 : In class SubClass6 : Inv -class SubClass7 : Inv \ No newline at end of file +class SubClass7 : Inv diff --git a/compiler/testData/diagnostics/tests/variance/Class.kt b/compiler/testData/diagnostics/tests/variance/Class.kt index bbc7c8044c7..a4148f9ac16 100644 --- a/compiler/testData/diagnostics/tests/variance/Class.kt +++ b/compiler/testData/diagnostics/tests/variance/Class.kt @@ -2,22 +2,22 @@ interface In interface Out interface Inv -interface TypeBounds1I> +interface TypeBounds1I> interface TypeBounds2 interface TypeBounds3 interface TypeBounds4> -interface TypeBounds5")!>O>> +interface TypeBounds5")!>O>> -interface WhereTypeBounds1 where X : I +interface WhereTypeBounds1 where X : I interface WhereTypeBounds2 where X : O interface WhereTypeBounds3 where X : P interface WhereTypeBounds4 where X : In -interface WhereTypeBounds5 where X : In<")!>O> +interface WhereTypeBounds5 where X : In<")!>O> -class SubClass1 : Out<")!>I> +class SubClass1 : Out<")!>I> class SubClass2 : Out class SubClass3 : Out

class SubClass4 : In -class SubClass5 : In<")!>O> -class SubClass6 : Inv<")!>O> -class SubClass7 : Inv<")!>I> \ No newline at end of file +class SubClass5 : In<")!>O> +class SubClass6 : Inv<")!>O> +class SubClass7 : Inv<")!>I> diff --git a/compiler/testData/diagnostics/tests/variance/Function.fir.kt b/compiler/testData/diagnostics/tests/variance/Function.fir.kt index f405959daeb..a85f51153d0 100644 --- a/compiler/testData/diagnostics/tests/variance/Function.fir.kt +++ b/compiler/testData/diagnostics/tests/variance/Function.fir.kt @@ -31,4 +31,4 @@ interface Test { fun typeParameter3() fun > typeParameter4() fun > typeParameter5() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/variance/Function.kt b/compiler/testData/diagnostics/tests/variance/Function.kt index 9f58506d52e..1f2ed9ca1e6 100644 --- a/compiler/testData/diagnostics/tests/variance/Function.kt +++ b/compiler/testData/diagnostics/tests/variance/Function.kt @@ -4,31 +4,31 @@ interface Inv fun getT(): T = null!! interface Test { - fun parameters1(i: I, o: O, p: P) - fun parameters2(i: In<")!>I>) + fun parameters1(i: I, o: O, p: P) + fun parameters2(i: In<")!>I>) fun parameters3(i: In) - fun explicitReturnType1() : I + fun explicitReturnType1() : I fun explicitReturnType2() : O fun explicitReturnType3() : P fun explicitReturnType4() : In - fun explicitReturnType5() : In<")!>O> + fun explicitReturnType5() : In<")!>O> - fun imlicitReturnType1() = getT() + fun imlicitReturnType1() = getT() fun imlicitReturnType2() = getT() fun imlicitReturnType3() = getT

() fun imlicitReturnType4() = getT>() - ")!>fun imlicitReturnType5() = getT>() + ")!>fun imlicitReturnType5() = getT>() fun I.receiver1() - fun O.receiver2() + fun O.receiver2() fun P.receiver3() - fun In<")!>I>.receiver4() + fun In<")!>I>.receiver4() fun In.receiver5() fun typeParameter1() - fun O> typeParameter2() + fun O> typeParameter2() fun typeParameter3() - fun ")!>I>> typeParameter4() + fun ")!>I>> typeParameter4() fun > typeParameter5() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/variance/InPosition.fir.kt b/compiler/testData/diagnostics/tests/variance/InPosition.fir.kt index 78d0051f8d3..8a8b8171ec3 100644 --- a/compiler/testData/diagnostics/tests/variance/InPosition.fir.kt +++ b/compiler/testData/diagnostics/tests/variance/InPosition.fir.kt @@ -47,4 +47,4 @@ interface Test { fun neOk33(i: Inv<>) fun neOk34(i: Inv) fun neOk35(i: Inv) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/variance/InPosition.kt b/compiler/testData/diagnostics/tests/variance/InPosition.kt index b5b8e51a7bc..d10054e83b8 100644 --- a/compiler/testData/diagnostics/tests/variance/InPosition.kt +++ b/compiler/testData/diagnostics/tests/variance/InPosition.kt @@ -27,24 +27,24 @@ interface Test { fun Ok22(i: Inv) fun Ok23(i: Inv) - fun neOk1(i: O) - fun neOk2(i: In<")!>I>) - fun neOk3(i: In>")!>O>>) - fun neOk4(i: Inv<")!>I>) - fun neOk5(i: Inv<")!>O>) - fun neOk6(i: In>")!>O>>) - fun neOk7(i: Pair, O>")!>I>, , O>")!>O>) - fun neOk8(i: Inv")!>O>) + fun neOk1(i: O) + fun neOk2(i: In<")!>I>) + fun neOk3(i: In>")!>O>>) + fun neOk4(i: Inv<")!>I>) + fun neOk5(i: Inv<")!>O>) + fun neOk6(i: In>")!>O>>) + fun neOk7(i: Pair, O>")!>I>, , O>")!>O>) + fun neOk8(i: Inv")!>O>) fun neOk9(i: In<out P>) - fun neOk10(i: Out<")!>O>) + fun neOk10(i: Out<")!>O>) - fun neOk11(i: Inv")!>I>) - fun neOk12(i: Inv")!>O>) + fun neOk11(i: Inv")!>I>) + fun neOk12(i: Inv")!>O>) fun neOk30(i: Pair, >) - fun neOk31(i: Pair<")!>O, Inv>) + fun neOk31(i: Pair<")!>O, Inv>) fun neOk32(i: Inv) fun neOk33(i: Inv<>) fun neOk34(i: Inv<C>) fun neOk35(i: Inv) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/variance/InvariantPosition.fir.kt b/compiler/testData/diagnostics/tests/variance/InvariantPosition.fir.kt index 31f2c5717d5..4b0754eeb12 100644 --- a/compiler/testData/diagnostics/tests/variance/InvariantPosition.fir.kt +++ b/compiler/testData/diagnostics/tests/variance/InvariantPosition.fir.kt @@ -44,4 +44,4 @@ interface Test { var neOk33: Inv<> var neOk34: Inv var neOk35: Inv -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/variance/InvariantPosition.kt b/compiler/testData/diagnostics/tests/variance/InvariantPosition.kt index 008381f6084..e6ce71c676c 100644 --- a/compiler/testData/diagnostics/tests/variance/InvariantPosition.kt +++ b/compiler/testData/diagnostics/tests/variance/InvariantPosition.kt @@ -14,34 +14,34 @@ interface Test { var ok6: Inv var ok7: Inv - var neOk1: O - var neOk2: In<")!>I> - var neOk3: In>")!>O>> - var neOk4: Inv<")!>I> - var neOk5: Inv<")!>O> - var neOk6: In>")!>O>> - var neOk7: Pair, O>")!>I>, , O>")!>O> - var neOk8: Inv")!>O> - var neOk9: Inv")!>I> + var neOk1: O + var neOk2: In<")!>I> + var neOk3: In>")!>O>> + var neOk4: Inv<")!>I> + var neOk5: Inv<")!>O> + var neOk6: In>")!>O>> + var neOk7: Pair, O>")!>I>, , O>")!>O> + var neOk8: Inv")!>O> + var neOk9: Inv")!>I> var neOk10: In<out I> - var neOk11: I - var neOk12: In<")!>O> - var neOk13: In>")!>I>> - var neOk14: Out<")!>I> - var neOk15: Out>")!>I>> - var neOk16: Out>")!>O>> - var neOk17: Pair, I>")!>O>, , I>")!>I> + var neOk11: I + var neOk12: In<")!>O> + var neOk13: In>")!>I>> + var neOk14: Out<")!>I> + var neOk15: Out>")!>I>> + var neOk16: Out>")!>O>> + var neOk17: Pair, I>")!>O>, , I>")!>I> - var neOk20: Inv")!>O> - var neOk21: Inv")!>I> - var neOk22: Inv")!>O> - var neOk23: Inv")!>I> + var neOk20: Inv")!>O> + var neOk21: Inv")!>I> + var neOk22: Inv")!>O> + var neOk23: Inv")!>I> var neOk30: Pair, > - var neOk31: Pair<")!>I, Inv> + var neOk31: Pair<")!>I, Inv> var neOk32: Inv var neOk33: Inv<> var neOk34: Inv<C> var neOk35: Inv -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/variance/NullableTypes.fir.kt b/compiler/testData/diagnostics/tests/variance/NullableTypes.fir.kt index 66626173ee0..9f3b7b7913d 100644 --- a/compiler/testData/diagnostics/tests/variance/NullableTypes.fir.kt +++ b/compiler/testData/diagnostics/tests/variance/NullableTypes.fir.kt @@ -13,4 +13,4 @@ interface Test { fun neOk(i: Out?) : In? fun neOk3(i: Inv) fun neOk4() = getT?>() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/variance/NullableTypes.kt b/compiler/testData/diagnostics/tests/variance/NullableTypes.kt index d5fc03917cf..089729b268f 100644 --- a/compiler/testData/diagnostics/tests/variance/NullableTypes.kt +++ b/compiler/testData/diagnostics/tests/variance/NullableTypes.kt @@ -9,8 +9,8 @@ interface Test { fun ok2(i: In?) : Out? fun ok3(i: Inv) = getT>() - fun neOk1(i: O?) : I? - fun neOk(i: Out<?")!>O?>?) : In<?")!>O?>? - fun neOk3(i: Inv")!>I?>) - ?")!>fun neOk4() = getT?>() -} \ No newline at end of file + fun neOk1(i: O?) : I? + fun neOk(i: Out<?")!>O?>?) : In<?")!>O?>? + fun neOk3(i: Inv")!>I?>) + ?")!>fun neOk4() = getT?>() +} diff --git a/compiler/testData/diagnostics/tests/variance/OutPosition.fir.kt b/compiler/testData/diagnostics/tests/variance/OutPosition.fir.kt index 3e048d33525..7fa171d1429 100644 --- a/compiler/testData/diagnostics/tests/variance/OutPosition.fir.kt +++ b/compiler/testData/diagnostics/tests/variance/OutPosition.fir.kt @@ -39,4 +39,4 @@ interface Test { fun neOk33(): Inv<> fun neOk34(): Inv fun neOk35(): Inv -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/variance/OutPosition.kt b/compiler/testData/diagnostics/tests/variance/OutPosition.kt index 274e5a7e2e8..f1d567f2766 100644 --- a/compiler/testData/diagnostics/tests/variance/OutPosition.kt +++ b/compiler/testData/diagnostics/tests/variance/OutPosition.kt @@ -21,22 +21,22 @@ interface Test { fun ok12(): Inv fun ok13(): Inv - fun neOk1(): I - fun neOk2(): In<")!>O> - fun neOk3(): In>")!>I>> - fun neOk4(): Inv<")!>I> - fun neOk5(): Inv<")!>O> - fun neOk6(): Pair, I>")!>O>, , I>")!>I> - fun neOk7(): Inv")!>O> + fun neOk1(): I + fun neOk2(): In<")!>O> + fun neOk3(): In>")!>I>> + fun neOk4(): Inv<")!>I> + fun neOk5(): Inv<")!>O> + fun neOk6(): Pair, I>")!>O>, , I>")!>I> + fun neOk7(): Inv")!>O> fun neOk8(): Out<in I> - fun neOk10(): Inv")!>O> - fun neOk11(): Inv")!>I> + fun neOk10(): Inv")!>O> + fun neOk11(): Inv")!>I> fun neOk30(): Pair, > - fun neOk31(): Pair<")!>I, Inv> + fun neOk31(): Pair<")!>I, Inv> fun neOk32(): Inv fun neOk33(): Inv<> fun neOk34(): Inv<C> fun neOk35(): Inv -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/variance/PrimaryConstructor.fir.kt b/compiler/testData/diagnostics/tests/variance/PrimaryConstructor.fir.kt index c97cf42397c..d0fa36fb22d 100644 --- a/compiler/testData/diagnostics/tests/variance/PrimaryConstructor.fir.kt +++ b/compiler/testData/diagnostics/tests/variance/PrimaryConstructor.fir.kt @@ -22,4 +22,4 @@ class Test( type13: P, type14: In, type15: In -) \ No newline at end of file +) diff --git a/compiler/testData/diagnostics/tests/variance/PrimaryConstructor.kt b/compiler/testData/diagnostics/tests/variance/PrimaryConstructor.kt index 2d36e579433..7338a1f618e 100644 --- a/compiler/testData/diagnostics/tests/variance/PrimaryConstructor.kt +++ b/compiler/testData/diagnostics/tests/variance/PrimaryConstructor.kt @@ -5,21 +5,21 @@ interface Inv fun getT(): T = null!! class Test( - val type1: I, + val type1: I, val type2: O, val type3: P, val type4: In, - val type5: In<")!>O>, + val type5: In<")!>O>, - var type6: I, - var type7: O, + var type6: I, + var type7: O, var type8: P, - var type9: In<")!>I>, - var type0: In<")!>O>, + var type9: In<")!>I>, + var type0: In<")!>O>, type11: I, type12: O, type13: P, type14: In, type15: In -) \ No newline at end of file +) diff --git a/compiler/testData/diagnostics/tests/variance/ValProperty.kt b/compiler/testData/diagnostics/tests/variance/ValProperty.kt index 69e7e33fc16..94ab374cd21 100644 --- a/compiler/testData/diagnostics/tests/variance/ValProperty.kt +++ b/compiler/testData/diagnostics/tests/variance/ValProperty.kt @@ -12,39 +12,39 @@ class Delegate { fun getT(): T = null!! abstract class Test { - abstract val type1: I + abstract val type1: I abstract val type2: O abstract val type3: P abstract val type4: In - abstract val type5: In<")!>O> + abstract val type5: In<")!>O> - val implicitType1 = getT() + val implicitType1 = getT() val implicitType2 = getT() val implicitType3 = getT

() val implicitType4 = getT>() - ")!>val implicitType5 = getT>() + ")!>val implicitType5 = getT>() - val delegateType1 by Delegate() + val delegateType1 by Delegate() val delegateType2 by Delegate() val delegateType3 by Delegate

() val delegateType4 by Delegate>() - ")!>val delegateType5 by Delegate>() + ")!>val delegateType5 by Delegate>() abstract val I.receiver1: Int - abstract val O.receiver2: Int + abstract val O.receiver2: Int abstract val P.receiver3: Int - abstract val In<")!>I>.receiver4: Int + abstract val In<")!>I>.receiver4: Int abstract val In.receiver5: Int val X.typeParameter1: Int get() = 0 - val O> X.typeParameter2: Int get() = 0 + val O> X.typeParameter2: Int get() = 0 val X.typeParameter3: Int get() = 0 - val ")!>I>> X.typeParameter4: Int get() = 0 + val ")!>I>> X.typeParameter4: Int get() = 0 val > X.typeParameter5: Int get() = 0 val X.typeParameter6: Int where X : I get() = 0 - val X.typeParameter7: Int where X : O get() = 0 + val X.typeParameter7: Int where X : O get() = 0 val X.typeParameter8: Int where X : P get() = 0 - val X.typeParameter9: Int where X : In<")!>I> get() = 0 + val X.typeParameter9: Int where X : In<")!>I> get() = 0 val X.typeParameter0: Int where X : In get() = 0 } diff --git a/compiler/testData/diagnostics/tests/variance/VarProperty.kt b/compiler/testData/diagnostics/tests/variance/VarProperty.kt index 31d3b348e1a..38dd3ff7f02 100644 --- a/compiler/testData/diagnostics/tests/variance/VarProperty.kt +++ b/compiler/testData/diagnostics/tests/variance/VarProperty.kt @@ -12,39 +12,39 @@ class Delegate { fun getT(): T = null!! abstract class Test { - abstract var type1: I - abstract var type2: O + abstract var type1: I + abstract var type2: O abstract var type3: P - abstract var type4: In<")!>I> - abstract var type5: In<")!>O> + abstract var type4: In<")!>I> + abstract var type5: In<")!>O> - var implicitType1 = getT() - var implicitType2 = getT() + var implicitType1 = getT() + var implicitType2 = getT() var implicitType3 = getT

() - ")!>var implicitType4 = getT>() - ")!>var implicitType5 = getT>() + ")!>var implicitType4 = getT>() + ")!>var implicitType5 = getT>() - var delegateType1 by Delegate() - var delegateType2 by Delegate() + var delegateType1 by Delegate() + var delegateType2 by Delegate() var delegateType3 by Delegate

() - ")!>var delegateType4 by Delegate>() - ")!>var delegateType5 by Delegate>() + ")!>var delegateType4 by Delegate>() + ")!>var delegateType5 by Delegate>() abstract var I.receiver1: Int - abstract var O.receiver2: Int + abstract var O.receiver2: Int abstract var P.receiver3: Int - abstract var In<")!>I>.receiver4: Int + abstract var In<")!>I>.receiver4: Int abstract var In.receiver5: Int var X.typeParameter1: Int get() = 0; set(i) {} - var O> X.typeParameter2: Int get() = 0; set(i) {} + var O> X.typeParameter2: Int get() = 0; set(i) {} var X.typeParameter3: Int get() = 0; set(i) {} - var ")!>I>> X.typeParameter4: Int get() = 0; set(i) {} + var ")!>I>> X.typeParameter4: Int get() = 0; set(i) {} var > X.typeParameter5: Int get() = 0; set(i) {} var X.typeParameter6: Int where X : I get() = 0; set(i) {} - var X.typeParameter7: Int where X : O get() = 0; set(i) {} + var X.typeParameter7: Int where X : O get() = 0; set(i) {} var X.typeParameter8: Int where X : P get() = 0; set(i) {} - var X.typeParameter9: Int where X : In<")!>I> get() = 0; set(i) {} + var X.typeParameter9: Int where X : In<")!>I> get() = 0; set(i) {} var X.typeParameter0: Int where X : In get() = 0; set(i) {} } diff --git a/compiler/testData/diagnostics/tests/variance/privateToThis/FunctionCall.kt b/compiler/testData/diagnostics/tests/variance/privateToThis/FunctionCall.kt index 438996b8560..9fe7c3e6a9a 100644 --- a/compiler/testData/diagnostics/tests/variance/privateToThis/FunctionCall.kt +++ b/compiler/testData/diagnostics/tests/variance/privateToThis/FunctionCall.kt @@ -15,23 +15,23 @@ class Test { apply(this.foo()) with(Test()) { apply(foo()) // resolved to this@Test.foo - apply(this.foo()) - apply(this@with.foo()) + apply(this.foo()) + apply(this@with.foo()) apply(this@Test.foo()) } } fun test(t: Test) { - t.apply(t.foo()) + t.apply(t.foo()) } companion object { fun test(t: Test) { - t.apply(t.foo()) + t.apply(t.foo()) } } } fun test(t: Test) { - t.apply(t.foo()) + t.apply(t.foo()) } diff --git a/compiler/testData/diagnostics/tests/variance/privateToThis/GetVal.kt b/compiler/testData/diagnostics/tests/variance/privateToThis/GetVal.kt index b63854a2012..b05426a7dc5 100644 --- a/compiler/testData/diagnostics/tests/variance/privateToThis/GetVal.kt +++ b/compiler/testData/diagnostics/tests/variance/privateToThis/GetVal.kt @@ -15,23 +15,23 @@ class Test { apply(this.i) with(Test()) { apply(i) // resolved to this@Test.i - apply(this.i) - apply(this@with.i) + apply(this.i) + apply(this@with.i) apply(this@Test.i) } } fun test(t: Test) { - t.apply(t.i) + t.apply(t.i) } companion object { fun test(t: Test) { - t.apply(t.i) + t.apply(t.i) } } } fun test(t: Test) { - t.apply(t.i) + t.apply(t.i) } diff --git a/compiler/testData/diagnostics/tests/variance/privateToThis/SetVar.kt b/compiler/testData/diagnostics/tests/variance/privateToThis/SetVar.kt index 66d588b6f3d..35a199d2403 100644 --- a/compiler/testData/diagnostics/tests/variance/privateToThis/SetVar.kt +++ b/compiler/testData/diagnostics/tests/variance/privateToThis/SetVar.kt @@ -15,23 +15,23 @@ class Test { this.i = getT() with(Test()) { i = getT() // resolved to this@Test.i - this.i = getT() - this@with.i = getT() + this.i = getT() + this@with.i = getT() this@Test.i = getT() } } fun test(t: Test) { - t.i = getT() + t.i = getT() } companion object { fun test(t: Test) { - t.i = getT() + t.i = getT() } } } fun test(t: Test) { - t.i = getT() + t.i = getT() } diff --git a/compiler/testData/diagnostics/tests/visibility/abstractInvisibleMemberFromKotlin.txt b/compiler/testData/diagnostics/tests/visibility/abstractInvisibleMemberFromKotlin.txt index cd709d494b4..86b166f70c3 100644 --- a/compiler/testData/diagnostics/tests/visibility/abstractInvisibleMemberFromKotlin.txt +++ b/compiler/testData/diagnostics/tests/visibility/abstractInvisibleMemberFromKotlin.txt @@ -22,6 +22,20 @@ package base { } } +// -- Module: -- +package + +package intermediate { + + public abstract class Intermediate : base.Base { + public constructor Intermediate() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public final override /*1*/ /*fake_override*/ fun foo(): kotlin.String + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + invisible_fake abstract override /*1*/ /*fake_override*/ fun internalFoo(): kotlin.String + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} // -- Module: -- package @@ -75,18 +89,3 @@ package impl { } } - -// -- Module: -- -package - -package intermediate { - - public abstract class Intermediate : base.Base { - public constructor Intermediate() - public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - public final override /*1*/ /*fake_override*/ fun foo(): kotlin.String - public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int - invisible_fake abstract override /*1*/ /*fake_override*/ fun internalFoo(): kotlin.String - public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String - } -} diff --git a/compiler/testData/diagnostics/tests/visibility/abstractInvisibleMemberFromKotlinWarning.txt b/compiler/testData/diagnostics/tests/visibility/abstractInvisibleMemberFromKotlinWarning.txt index 4ead4cb08c7..bf0d5a3ad31 100644 --- a/compiler/testData/diagnostics/tests/visibility/abstractInvisibleMemberFromKotlinWarning.txt +++ b/compiler/testData/diagnostics/tests/visibility/abstractInvisibleMemberFromKotlinWarning.txt @@ -13,7 +13,6 @@ package base { } } - // -- Module: -- package @@ -29,3 +28,4 @@ package impl { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } } + diff --git a/compiler/testData/diagnostics/tests/when/BranchBypassVal.fir.kt b/compiler/testData/diagnostics/tests/when/BranchBypassVal.fir.kt index 1fc11675ec2..cda408221da 100644 --- a/compiler/testData/diagnostics/tests/when/BranchBypassVal.fir.kt +++ b/compiler/testData/diagnostics/tests/when/BranchBypassVal.fir.kt @@ -1,4 +1,14 @@ // !WITH_NEW_INFERENCE +/* + * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE) + * + * SPEC VERSION: 0.1-313 + * PRIMARY LINKS: expressions, when-expression, exhaustive-when-expressions -> paragraph 1 -> sentence 1 + * expressions, when-expression -> paragraph 6 -> sentence 1 + * expressions, when-expression -> paragraph 5 -> sentence 1 + * type-inference, smart-casts, smart-cast-types -> paragraph 9 -> sentence 1 + * type-inference, smart-casts, smart-cast-types -> paragraph 9 -> sentence 6 + */ class A fun test(a: Any): String { diff --git a/compiler/testData/diagnostics/tests/when/BranchBypassVar.fir.kt b/compiler/testData/diagnostics/tests/when/BranchBypassVar.fir.kt index 7a8e4484cca..90053fe80f2 100644 --- a/compiler/testData/diagnostics/tests/when/BranchBypassVar.fir.kt +++ b/compiler/testData/diagnostics/tests/when/BranchBypassVar.fir.kt @@ -1,4 +1,14 @@ // !WITH_NEW_INFERENCE +/* + * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE) + * + * SPEC VERSION: 0.1-313 + * PRIMARY LINKS: expressions, when-expression, exhaustive-when-expressions -> paragraph 1 -> sentence 1 + * expressions, when-expression -> paragraph 6 -> sentence 1 + * expressions, when-expression -> paragraph 5 -> sentence 1 + * type-inference, smart-casts, smart-cast-types -> paragraph 9 -> sentence 1 + * type-inference, smart-casts, smart-cast-types -> paragraph 9 -> sentence 8 + */ class A fun test(a: Any) { diff --git a/compiler/testData/diagnostics/tests/when/BranchFalseBypass.fir.kt b/compiler/testData/diagnostics/tests/when/BranchFalseBypass.fir.kt index 1b406849f6e..5c0f881fe1a 100644 --- a/compiler/testData/diagnostics/tests/when/BranchFalseBypass.fir.kt +++ b/compiler/testData/diagnostics/tests/when/BranchFalseBypass.fir.kt @@ -1,3 +1,13 @@ +/* + * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE) + * + * SPEC VERSION: 0.1-313 + * PRIMARY LINKS: expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 9 + * expressions, when-expression -> paragraph 6 -> sentence 1 + * expressions, when-expression -> paragraph 5 -> sentence 1 + * type-inference, smart-casts, smart-cast-types -> paragraph 9 -> sentence 1 + * type-inference, smart-casts, smart-cast-types -> paragraph 9 -> sentence 8 + */ enum class My { A, B } fun test(a: My): String { diff --git a/compiler/testData/diagnostics/tests/when/BranchFalseBypassElse.fir.kt b/compiler/testData/diagnostics/tests/when/BranchFalseBypassElse.fir.kt index c66f5e955aa..1ae41ddd45c 100644 --- a/compiler/testData/diagnostics/tests/when/BranchFalseBypassElse.fir.kt +++ b/compiler/testData/diagnostics/tests/when/BranchFalseBypassElse.fir.kt @@ -1,3 +1,13 @@ +/* + * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE) + * + * SPEC VERSION: 0.1-313 + * PRIMARY LINKS: expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 1 + * expressions, when-expression -> paragraph 6 -> sentence 1 + * expressions, when-expression -> paragraph 5 -> sentence 1 + * type-inference, smart-casts, smart-cast-types -> paragraph 9 -> sentence 1 + * type-inference, smart-casts, smart-cast-types -> paragraph 9 -> sentence 8 + */ class A fun test(a: Any): String { diff --git a/compiler/testData/diagnostics/tests/when/CommaInWhenConditionWithoutArgument.fir.kt b/compiler/testData/diagnostics/tests/when/CommaInWhenConditionWithoutArgument.fir.kt index da4a6d4c2a7..67d01c6de6a 100644 --- a/compiler/testData/diagnostics/tests/when/CommaInWhenConditionWithoutArgument.fir.kt +++ b/compiler/testData/diagnostics/tests/when/CommaInWhenConditionWithoutArgument.fir.kt @@ -1,3 +1,10 @@ +/* + * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE) + * + * SPEC VERSION: 0.1-313 + * PRIMARY LINKS: expressions, when-expression -> paragraph 2 -> sentence 1 + * expressions, when-expression -> paragraph 5 -> sentence 1 + */ fun foo(x: Int, y: Int): Int = when { x > 0, y > 0,, x < 0 -> 1 @@ -8,4 +15,4 @@ fun bar(x: Int): Int = when (x) { 0 -> 0 else -> 1 - } \ No newline at end of file + } diff --git a/compiler/testData/diagnostics/tests/when/CommaInWhenConditionWithoutArgument.kt b/compiler/testData/diagnostics/tests/when/CommaInWhenConditionWithoutArgument.kt index 447cf794d78..a666f056153 100644 --- a/compiler/testData/diagnostics/tests/when/CommaInWhenConditionWithoutArgument.kt +++ b/compiler/testData/diagnostics/tests/when/CommaInWhenConditionWithoutArgument.kt @@ -15,4 +15,4 @@ fun bar(x: Int): Int = when (x) { 0 -> 0 else -> 1 - } \ No newline at end of file + } diff --git a/compiler/testData/diagnostics/tests/when/DuplicatedLabels.fir.kt b/compiler/testData/diagnostics/tests/when/DuplicatedLabels.fir.kt index 72d12360fa9..1d9dc3ced95 100644 --- a/compiler/testData/diagnostics/tests/when/DuplicatedLabels.fir.kt +++ b/compiler/testData/diagnostics/tests/when/DuplicatedLabels.fir.kt @@ -1,3 +1,13 @@ +/* + * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE) + * + * SPEC VERSION: 0.1-313 + * PRIMARY LINKS: expressions, when-expression -> paragraph 5 -> sentence 1 + * expressions, when-expression -> paragraph 9 -> sentence 1 + * expressions, when-expression -> paragraph 2 -> sentence 4 + * expressions, when-expression -> paragraph 2 -> sentence 5 + */ + package test const val four = 4 diff --git a/compiler/testData/diagnostics/tests/when/ElseOnNullableEnum.fir.kt b/compiler/testData/diagnostics/tests/when/ElseOnNullableEnum.fir.kt index 049871ff6bb..31da011183f 100644 --- a/compiler/testData/diagnostics/tests/when/ElseOnNullableEnum.fir.kt +++ b/compiler/testData/diagnostics/tests/when/ElseOnNullableEnum.fir.kt @@ -1,4 +1,12 @@ // KT-2902 Check for null should be required when match nullable enum element +/* + * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE) + * + * SPEC VERSION: 0.1-313 + * PRIMARY LINKS: expressions, when-expression -> paragraph 5 -> sentence 1 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 9 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 10 + */ // FILE: 1.kt diff --git a/compiler/testData/diagnostics/tests/when/ElseOnNullableEnumWithSmartCast.fir.kt b/compiler/testData/diagnostics/tests/when/ElseOnNullableEnumWithSmartCast.fir.kt index f0f8219837f..5c9fb47e6d2 100644 --- a/compiler/testData/diagnostics/tests/when/ElseOnNullableEnumWithSmartCast.fir.kt +++ b/compiler/testData/diagnostics/tests/when/ElseOnNullableEnumWithSmartCast.fir.kt @@ -1,3 +1,12 @@ +/* + * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE) + * + * SPEC VERSION: 0.1-313 + * PRIMARY LINKS: expressions, when-expression -> paragraph 5 -> sentence 1 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 9 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 10 + */ + enum class E { A, B } fun foo(e: E, something: Any?): Int { diff --git a/compiler/testData/diagnostics/tests/when/ExhaustiveBreakContinue.fir.kt b/compiler/testData/diagnostics/tests/when/ExhaustiveBreakContinue.fir.kt index 8a4910d7564..35760e6cd2c 100644 --- a/compiler/testData/diagnostics/tests/when/ExhaustiveBreakContinue.fir.kt +++ b/compiler/testData/diagnostics/tests/when/ExhaustiveBreakContinue.fir.kt @@ -1,3 +1,14 @@ +/* + * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE) + * + * SPEC VERSION: 0.1-313 + * PRIMARY LINKS: expressions, when-expression -> paragraph 5 -> sentence 1 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 9 + * control--and-data-flow-analysis, control-flow-graph, expressions-1, conditional-expressions -> paragraph 2 -> sentence 1 + * control--and-data-flow-analysis, control-flow-graph, expressions-1, boolean-operators -> paragraph 0 -> sentence 0 + * control--and-data-flow-analysis, control-flow-graph, statements-1 -> paragraph 0 -> sentence 0 + */ + enum class Color { RED, GREEN, BLUE } fun foo(arr: Array): Color { @@ -11,4 +22,4 @@ fun foo(arr: Array): Color { return Color.BLUE } return Color.GREEN -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/ExhaustiveBreakContinue.kt b/compiler/testData/diagnostics/tests/when/ExhaustiveBreakContinue.kt index d0db24cde50..239615121b0 100644 --- a/compiler/testData/diagnostics/tests/when/ExhaustiveBreakContinue.kt +++ b/compiler/testData/diagnostics/tests/when/ExhaustiveBreakContinue.kt @@ -22,4 +22,4 @@ fun foo(arr: Array): Color { return Color.BLUE } return Color.GREEN -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/ExhaustiveEnumIs.fir.kt b/compiler/testData/diagnostics/tests/when/ExhaustiveEnumIs.fir.kt index fe9a153a267..278ee04bced 100644 --- a/compiler/testData/diagnostics/tests/when/ExhaustiveEnumIs.fir.kt +++ b/compiler/testData/diagnostics/tests/when/ExhaustiveEnumIs.fir.kt @@ -1,3 +1,12 @@ +/* + * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE) + * + * SPEC VERSION: 0.1-313 + * PRIMARY LINKS: expressions, when-expression -> paragraph 5 -> sentence 1 + * expressions, when-expression -> paragraph 6 -> sentence 1 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 9 + */ + enum class MyEnum { A, B, C } @@ -8,4 +17,4 @@ fun foo(x: MyEnum): Int { is MyEnum.B -> 2 is MyEnum.C -> 3 } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/ExhaustiveEnumIs.kt b/compiler/testData/diagnostics/tests/when/ExhaustiveEnumIs.kt index db917e778c0..11ed0d1520a 100644 --- a/compiler/testData/diagnostics/tests/when/ExhaustiveEnumIs.kt +++ b/compiler/testData/diagnostics/tests/when/ExhaustiveEnumIs.kt @@ -17,4 +17,4 @@ fun foo(x: MyEnum): Int { is MyEnum.B -> 2 is MyEnum.C -> 3 } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/ExhaustiveEnumMixed.fir.kt b/compiler/testData/diagnostics/tests/when/ExhaustiveEnumMixed.fir.kt index cceb426abbf..481970e4455 100644 --- a/compiler/testData/diagnostics/tests/when/ExhaustiveEnumMixed.fir.kt +++ b/compiler/testData/diagnostics/tests/when/ExhaustiveEnumMixed.fir.kt @@ -1,3 +1,13 @@ +/* + * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE) + * + * SPEC VERSION: 0.1-313 + * PRIMARY LINKS: expressions, when-expression -> paragraph 5 -> sentence 1 + * expressions, when-expression -> paragraph 6 -> sentence 1 + * expressions, when-expression -> paragraph 6 -> sentence 5 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 9 + */ + enum class MyEnum { A, B, C } @@ -8,4 +18,4 @@ fun foo(x: MyEnum): Int { is MyEnum.B -> 2 is MyEnum.C -> 3 } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/ExhaustiveEnumMixed.kt b/compiler/testData/diagnostics/tests/when/ExhaustiveEnumMixed.kt index 9864e2eb57a..468d5dc5bb3 100644 --- a/compiler/testData/diagnostics/tests/when/ExhaustiveEnumMixed.kt +++ b/compiler/testData/diagnostics/tests/when/ExhaustiveEnumMixed.kt @@ -18,4 +18,4 @@ fun foo(x: MyEnum): Int { is MyEnum.B -> 2 is MyEnum.C -> 3 } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/ExhaustiveInitialization.fir.kt b/compiler/testData/diagnostics/tests/when/ExhaustiveInitialization.fir.kt index 0e15e5efb3d..39f8824c742 100644 --- a/compiler/testData/diagnostics/tests/when/ExhaustiveInitialization.fir.kt +++ b/compiler/testData/diagnostics/tests/when/ExhaustiveInitialization.fir.kt @@ -1,3 +1,14 @@ +/* + * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE) + * + * SPEC VERSION: 0.1-313 + * PRIMARY LINKS: expressions, when-expression -> paragraph 5 -> sentence 1 + * expressions, when-expression -> paragraph 6 -> sentence 5 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 9 + * control--and-data-flow-analysis, performing-analysis-on-the-control-flow-graph, variable-initialization-analysis -> paragraph 2 -> sentence 1 + * control--and-data-flow-analysis, performing-analysis-on-the-control-flow-graph, variable-initialization-analysis -> paragraph 2 -> sentence 3 + */ + enum class Direction { NORTH, SOUTH, WEST, EAST } @@ -12,4 +23,4 @@ fun foo(dir: Direction): Int { Direction.EAST -> res = 4 } return res -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/ExhaustiveNoInitialization.fir.kt b/compiler/testData/diagnostics/tests/when/ExhaustiveNoInitialization.fir.kt index b7f68238504..99bffa09a59 100644 --- a/compiler/testData/diagnostics/tests/when/ExhaustiveNoInitialization.fir.kt +++ b/compiler/testData/diagnostics/tests/when/ExhaustiveNoInitialization.fir.kt @@ -1,3 +1,15 @@ +/* + * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE) + * + * SPEC VERSION: 0.1-313 + * PRIMARY LINKS: expressions, when-expression -> paragraph 5 -> sentence 1 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 3 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 4 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 5 + * control--and-data-flow-analysis, performing-analysis-on-the-control-flow-graph, variable-initialization-analysis -> paragraph 2 -> sentence 1 + * control--and-data-flow-analysis, performing-analysis-on-the-control-flow-graph, variable-initialization-analysis -> paragraph 2 -> sentence 3 + */ + fun foo(b: Boolean): Int { val x: Int val y: Int @@ -8,4 +20,4 @@ fun foo(b: Boolean): Int { // x is initialized here x = 3 return x + y -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/ExhaustiveNoInitialization.kt b/compiler/testData/diagnostics/tests/when/ExhaustiveNoInitialization.kt index 25e23ad8b76..2511cf26411 100644 --- a/compiler/testData/diagnostics/tests/when/ExhaustiveNoInitialization.kt +++ b/compiler/testData/diagnostics/tests/when/ExhaustiveNoInitialization.kt @@ -20,4 +20,4 @@ fun foo(b: Boolean): Int { // x is initialized here x = 3 return x + y -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/ExhaustiveNullable.fir.kt b/compiler/testData/diagnostics/tests/when/ExhaustiveNullable.fir.kt index 19edb89d8fd..0229225035d 100644 --- a/compiler/testData/diagnostics/tests/when/ExhaustiveNullable.fir.kt +++ b/compiler/testData/diagnostics/tests/when/ExhaustiveNullable.fir.kt @@ -1,3 +1,14 @@ +/* + * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE) + * + * SPEC VERSION: 0.1-313 + * PRIMARY LINKS: expressions, when-expression -> paragraph 5 -> sentence 1 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 9 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 10 + * control--and-data-flow-analysis, performing-analysis-on-the-control-flow-graph, variable-initialization-analysis -> paragraph 2 -> sentence 1 + * control--and-data-flow-analysis, performing-analysis-on-the-control-flow-graph, variable-initialization-analysis -> paragraph 2 -> sentence 3 + */ + enum class MyEnum { A, B } @@ -11,4 +22,4 @@ fun foo(x: MyEnum?): Int { null -> y = 0 } return y -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/ExhaustiveNullable.kt b/compiler/testData/diagnostics/tests/when/ExhaustiveNullable.kt index 2d4e0543a55..eb1c3a6b23a 100644 --- a/compiler/testData/diagnostics/tests/when/ExhaustiveNullable.kt +++ b/compiler/testData/diagnostics/tests/when/ExhaustiveNullable.kt @@ -22,4 +22,4 @@ fun foo(x: MyEnum?): Int { null -> y = 0 } return y -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/ExhaustivePlatformEnum.fir.kt b/compiler/testData/diagnostics/tests/when/ExhaustivePlatformEnum.fir.kt index 2a97dd3827c..bde25dbecb6 100644 --- a/compiler/testData/diagnostics/tests/when/ExhaustivePlatformEnum.fir.kt +++ b/compiler/testData/diagnostics/tests/when/ExhaustivePlatformEnum.fir.kt @@ -1,3 +1,11 @@ +/* + * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE) + * + * SPEC VERSION: 0.1-313 + * PRIMARY LINKS: expressions, when-expression -> paragraph 5 -> sentence 1 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 9 + */ + // See KT-6399: exhaustive whens on platform enums // FILE: J.java diff --git a/compiler/testData/diagnostics/tests/when/ExhaustivePlatformEnumStatement.fir.kt b/compiler/testData/diagnostics/tests/when/ExhaustivePlatformEnumStatement.fir.kt index a51fda0cbdd..2f70bcdc05b 100644 --- a/compiler/testData/diagnostics/tests/when/ExhaustivePlatformEnumStatement.fir.kt +++ b/compiler/testData/diagnostics/tests/when/ExhaustivePlatformEnumStatement.fir.kt @@ -1,3 +1,12 @@ +/* + * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE) + * + * SPEC VERSION: 0.1-152 + * PRIMARY LINKS: expressions, when-expression -> paragraph 5 -> sentence 1 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 9 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 923 + */ + // See KT-6399: exhaustive whens on platform enums // FILE: J.java diff --git a/compiler/testData/diagnostics/tests/when/ExhaustiveReturn.fir.kt b/compiler/testData/diagnostics/tests/when/ExhaustiveReturn.fir.kt index 11c764c8ccd..6990583e18e 100644 --- a/compiler/testData/diagnostics/tests/when/ExhaustiveReturn.fir.kt +++ b/compiler/testData/diagnostics/tests/when/ExhaustiveReturn.fir.kt @@ -1,3 +1,13 @@ +/* + * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE) + * + * SPEC VERSION: 0.1-152 + * PRIMARY LINKS: expressions, when-expression -> paragraph 5 -> sentence 1 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 9 + * control--and-data-flow-analysis, control-flow-graph, expressions-1, conditional-expressions -> paragraph 2 -> sentence 1 + * control--and-data-flow-analysis, control-flow-graph, expressions-1, boolean-operators -> paragraph 0 -> sentence 0 + */ + enum class Direction { NORTH, SOUTH, WEST, EAST } @@ -10,4 +20,4 @@ fun foo(dir: Direction): Int { Direction.EAST -> return 4 } // See KT-1882: no return is needed at the end -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/ExhaustiveReturn.kt b/compiler/testData/diagnostics/tests/when/ExhaustiveReturn.kt index 8eb102e1655..b261e3419c4 100644 --- a/compiler/testData/diagnostics/tests/when/ExhaustiveReturn.kt +++ b/compiler/testData/diagnostics/tests/when/ExhaustiveReturn.kt @@ -20,4 +20,4 @@ fun foo(dir: Direction): Int { Direction.EAST -> return 4 } // See KT-1882: no return is needed at the end -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/ExhaustiveReturnThrow.fir.kt b/compiler/testData/diagnostics/tests/when/ExhaustiveReturnThrow.fir.kt index b6bafbb0de4..90780a78450 100644 --- a/compiler/testData/diagnostics/tests/when/ExhaustiveReturnThrow.fir.kt +++ b/compiler/testData/diagnostics/tests/when/ExhaustiveReturnThrow.fir.kt @@ -1,3 +1,13 @@ +/* + * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE) + * + * SPEC VERSION: 0.1-152 + * PRIMARY LINKS: expressions, when-expression -> paragraph 5 -> sentence 1 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 9 + * control--and-data-flow-analysis, control-flow-graph, expressions-1, conditional-expressions -> paragraph 2 -> sentence 1 + * control--and-data-flow-analysis, control-flow-graph, expressions-1, boolean-operators -> paragraph 0 -> sentence 0 + */ + enum class Direction { NORTH, SOUTH, WEST, EAST } @@ -11,4 +21,4 @@ fun foo(dir: Direction): Int { } // Error: Unreachable code. Return is not required. if (dir == Direction.SOUTH) return 2 -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/ExhaustiveReturnThrow.kt b/compiler/testData/diagnostics/tests/when/ExhaustiveReturnThrow.kt index 684de364469..59d43058120 100644 --- a/compiler/testData/diagnostics/tests/when/ExhaustiveReturnThrow.kt +++ b/compiler/testData/diagnostics/tests/when/ExhaustiveReturnThrow.kt @@ -21,4 +21,4 @@ fun foo(dir: Direction): Int { } // Error: Unreachable code. Return is not required. if (dir == Direction.SOUTH) return 2 -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/ExhaustiveValOverConditionalInit.fir.kt b/compiler/testData/diagnostics/tests/when/ExhaustiveValOverConditionalInit.fir.kt index 27e53b8833c..314fffa5bc6 100644 --- a/compiler/testData/diagnostics/tests/when/ExhaustiveValOverConditionalInit.fir.kt +++ b/compiler/testData/diagnostics/tests/when/ExhaustiveValOverConditionalInit.fir.kt @@ -1,3 +1,15 @@ +/* + * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE) + * + * SPEC VERSION: 0.1-152 + * PRIMARY LINKS: expressions, when-expression -> paragraph 5 -> sentence 1 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 3 + * control--and-data-flow-analysis, performing-analysis-on-the-control-flow-graph, variable-initialization-analysis -> paragraph 2 -> sentence 1 + * control--and-data-flow-analysis, performing-analysis-on-the-control-flow-graph, variable-initialization-analysis -> paragraph 2 -> sentence 3 + * control--and-data-flow-analysis, performing-analysis-on-the-control-flow-graph, variable-initialization-analysis -> paragraph 3 -> sentence 2 + * control--and-data-flow-analysis, performing-analysis-on-the-control-flow-graph, variable-initialization-analysis -> paragraph 3 -> sentence 3 + */ + fun foo(a: Boolean, b: Boolean): Int { val x: Int if (a) { @@ -19,4 +31,4 @@ fun bar(a: Boolean, b: Boolean): Int { false -> x = 3 } return x -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/ExhaustiveValOverConditionalInit.kt b/compiler/testData/diagnostics/tests/when/ExhaustiveValOverConditionalInit.kt index c5dd4ef380b..2d9cb6ed869 100644 --- a/compiler/testData/diagnostics/tests/when/ExhaustiveValOverConditionalInit.kt +++ b/compiler/testData/diagnostics/tests/when/ExhaustiveValOverConditionalInit.kt @@ -31,4 +31,4 @@ fun bar(a: Boolean, b: Boolean): Int { false -> x = 3 } return x -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/ExhaustiveVarOverConditionalInit.fir.kt b/compiler/testData/diagnostics/tests/when/ExhaustiveVarOverConditionalInit.fir.kt index 50d1442f1cf..be1be855c35 100644 --- a/compiler/testData/diagnostics/tests/when/ExhaustiveVarOverConditionalInit.fir.kt +++ b/compiler/testData/diagnostics/tests/when/ExhaustiveVarOverConditionalInit.fir.kt @@ -1,3 +1,14 @@ +/* + * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE) + * + * SPEC VERSION: 0.1-152 + * PRIMARY LINKS: expressions, when-expression -> paragraph 5 -> sentence 1 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 3 + * control--and-data-flow-analysis, performing-analysis-on-the-control-flow-graph, variable-initialization-analysis -> paragraph 2 -> sentence 1 + * control--and-data-flow-analysis, performing-analysis-on-the-control-flow-graph, variable-initialization-analysis -> paragraph 2 -> sentence 3 + * control--and-data-flow-analysis, performing-analysis-on-the-control-flow-graph, variable-initialization-analysis -> paragraph 3 -> sentence 2 + */ + fun foo(a: Boolean, b: Boolean): Int { var x: Int if (a) { @@ -19,4 +30,4 @@ fun bar(a: Boolean, b: Boolean): Int { false -> x = 3 } return x -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/ExhaustiveVarOverConditionalInit.kt b/compiler/testData/diagnostics/tests/when/ExhaustiveVarOverConditionalInit.kt index ebf6e94a18a..4ad5438cfa0 100644 --- a/compiler/testData/diagnostics/tests/when/ExhaustiveVarOverConditionalInit.kt +++ b/compiler/testData/diagnostics/tests/when/ExhaustiveVarOverConditionalInit.kt @@ -30,4 +30,4 @@ fun bar(a: Boolean, b: Boolean): Int { false -> x = 3 } return x -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/ExhaustiveWithNullabilityCheck.fir.kt b/compiler/testData/diagnostics/tests/when/ExhaustiveWithNullabilityCheck.fir.kt index 86925b7212a..4f42f7fc9c9 100644 --- a/compiler/testData/diagnostics/tests/when/ExhaustiveWithNullabilityCheck.fir.kt +++ b/compiler/testData/diagnostics/tests/when/ExhaustiveWithNullabilityCheck.fir.kt @@ -1,3 +1,12 @@ +/* + * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE) + * + * SPEC VERSION: 0.1-152 + * PRIMARY LINKS: expressions, when-expression -> paragraph 5 -> sentence 1 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 9 + * type-inference, smart-casts, smart-cast-types -> paragraph 9 -> sentence 1 + */ + // KT-7857: when exhaustiveness does not take previous nullability checks into account enum class X { A, B } fun foo(arg: X?): Int { @@ -11,4 +20,4 @@ fun foo(arg: X?): Int { else { return 0 } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/ExhaustiveWithNullabilityCheck.kt b/compiler/testData/diagnostics/tests/when/ExhaustiveWithNullabilityCheck.kt index 22ccf26e884..f69d29641d9 100644 --- a/compiler/testData/diagnostics/tests/when/ExhaustiveWithNullabilityCheck.kt +++ b/compiler/testData/diagnostics/tests/when/ExhaustiveWithNullabilityCheck.kt @@ -20,4 +20,4 @@ fun foo(arg: X?): Int { else { return 0 } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/ExhaustiveWithNullabilityCheckBefore.fir.kt b/compiler/testData/diagnostics/tests/when/ExhaustiveWithNullabilityCheckBefore.fir.kt index 41d97447c03..bf200671e98 100644 --- a/compiler/testData/diagnostics/tests/when/ExhaustiveWithNullabilityCheckBefore.fir.kt +++ b/compiler/testData/diagnostics/tests/when/ExhaustiveWithNullabilityCheckBefore.fir.kt @@ -1,3 +1,14 @@ +/* + * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE) + * + * SPEC VERSION: 0.1-152 + * PRIMARY LINKS: expressions, when-expression -> paragraph 5 -> sentence 1 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 9 + * type-inference, smart-casts, smart-cast-types -> paragraph 9 -> sentence 1 + * control--and-data-flow-analysis, control-flow-graph, expressions-1, conditional-expressions -> paragraph 1 -> sentence 1 + * control--and-data-flow-analysis, control-flow-graph, expressions-1, boolean-operators -> paragraph 0 -> sentence 0 + */ + // KT-7857: when exhaustiveness does not take previous nullability checks into account enum class X { A, B } fun foo(arg: X?): Int { @@ -9,4 +20,4 @@ fun foo(arg: X?): Int { X.B -> 2 // else or null branch should not be required here! } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/ExhaustiveWithNullabilityCheckBefore.kt b/compiler/testData/diagnostics/tests/when/ExhaustiveWithNullabilityCheckBefore.kt index 1e9a81fcc3d..569fe558f63 100644 --- a/compiler/testData/diagnostics/tests/when/ExhaustiveWithNullabilityCheckBefore.kt +++ b/compiler/testData/diagnostics/tests/when/ExhaustiveWithNullabilityCheckBefore.kt @@ -20,4 +20,4 @@ fun foo(arg: X?): Int { X.B -> 2 // else or null branch should not be required here! } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/ExhaustiveWithNullabilityCheckBoolean.fir.kt b/compiler/testData/diagnostics/tests/when/ExhaustiveWithNullabilityCheckBoolean.fir.kt index 67e7e269297..6949dcc30b8 100644 --- a/compiler/testData/diagnostics/tests/when/ExhaustiveWithNullabilityCheckBoolean.fir.kt +++ b/compiler/testData/diagnostics/tests/when/ExhaustiveWithNullabilityCheckBoolean.fir.kt @@ -1,3 +1,14 @@ +/* + * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE) + * + * SPEC VERSION: 0.1-152 + * PRIMARY LINKS: expressions, when-expression -> paragraph 5 -> sentence 1 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 3 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 4 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 5 + * type-inference, smart-casts, smart-cast-types -> paragraph 9 -> sentence 1 + */ + // KT-7857: when exhaustiveness does not take previous nullability checks into account fun foo(arg: Boolean?): Int { if (arg != null) { @@ -10,4 +21,4 @@ fun foo(arg: Boolean?): Int { else { return -1 } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/ExhaustiveWithNullabilityCheckBoolean.kt b/compiler/testData/diagnostics/tests/when/ExhaustiveWithNullabilityCheckBoolean.kt index 7061a5e8d27..c1d3710359e 100644 --- a/compiler/testData/diagnostics/tests/when/ExhaustiveWithNullabilityCheckBoolean.kt +++ b/compiler/testData/diagnostics/tests/when/ExhaustiveWithNullabilityCheckBoolean.kt @@ -21,4 +21,4 @@ fun foo(arg: Boolean?): Int { else { return -1 } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/ExhaustiveWithNullabilityCheckElse.fir.kt b/compiler/testData/diagnostics/tests/when/ExhaustiveWithNullabilityCheckElse.fir.kt index 3b315600ab8..bad9021aa46 100644 --- a/compiler/testData/diagnostics/tests/when/ExhaustiveWithNullabilityCheckElse.fir.kt +++ b/compiler/testData/diagnostics/tests/when/ExhaustiveWithNullabilityCheckElse.fir.kt @@ -1,3 +1,14 @@ +/* + * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE) + * + * SPEC VERSION: 0.1-152 + * PRIMARY LINKS: expressions, when-expression -> paragraph 5 -> sentence 1 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 9 + * type-inference, smart-casts, smart-cast-types -> paragraph 9 -> sentence 1 + * control--and-data-flow-analysis, control-flow-graph, expressions-1, conditional-expressions -> paragraph 1 -> sentence 1 + * control--and-data-flow-analysis, control-flow-graph, expressions-1, boolean-operators -> paragraph 0 -> sentence 0 + */ + // KT-7857: when exhaustiveness does not take previous nullability checks into account enum class X { A, B } fun foo(arg: X?): Int { @@ -11,4 +22,4 @@ fun foo(arg: X?): Int { // else or null branch should not be required here! } } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/ExhaustiveWithNullabilityCheckElse.kt b/compiler/testData/diagnostics/tests/when/ExhaustiveWithNullabilityCheckElse.kt index 3259ceaf08b..5ee29c145da 100644 --- a/compiler/testData/diagnostics/tests/when/ExhaustiveWithNullabilityCheckElse.kt +++ b/compiler/testData/diagnostics/tests/when/ExhaustiveWithNullabilityCheckElse.kt @@ -22,4 +22,4 @@ fun foo(arg: X?): Int { // else or null branch should not be required here! } } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/NoElseExpectedUnit.fir.kt b/compiler/testData/diagnostics/tests/when/NoElseExpectedUnit.fir.kt index 4b240e601c9..382c03583e0 100644 --- a/compiler/testData/diagnostics/tests/when/NoElseExpectedUnit.fir.kt +++ b/compiler/testData/diagnostics/tests/when/NoElseExpectedUnit.fir.kt @@ -1,7 +1,16 @@ +/* + * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE) + * + * SPEC VERSION: 0.1-152 + * PRIMARY LINKS: expressions, when-expression -> paragraph 5 -> sentence 1 + * expressions, when-expression -> paragraph 9 -> sentence 2 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 1 -> sentence 1 + */ + fun foo(x: Int) { val y: Unit = when (x) { 2 -> {} 3 -> {} } return y -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/NoElseExpectedUnit.kt b/compiler/testData/diagnostics/tests/when/NoElseExpectedUnit.kt index 9cd15b14552..d08e040bc97 100644 --- a/compiler/testData/diagnostics/tests/when/NoElseExpectedUnit.kt +++ b/compiler/testData/diagnostics/tests/when/NoElseExpectedUnit.kt @@ -13,4 +13,4 @@ fun foo(x: Int) { 3 -> {} } return y -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/NoElseNoExpectedType.fir.kt b/compiler/testData/diagnostics/tests/when/NoElseNoExpectedType.fir.kt index c625fff796e..81081046fa7 100644 --- a/compiler/testData/diagnostics/tests/when/NoElseNoExpectedType.fir.kt +++ b/compiler/testData/diagnostics/tests/when/NoElseNoExpectedType.fir.kt @@ -1,6 +1,15 @@ +/* + * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE) + * + * SPEC VERSION: 0.1-152 + * PRIMARY LINKS: expressions, when-expression -> paragraph 5 -> sentence 1 + * expressions, when-expression -> paragraph 9 -> sentence 2 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 1 -> sentence 1 + */ + fun foo(x: Int): Any { val v = when (x) { 2 -> 0 } return v -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/NoElseNoExpectedType.kt b/compiler/testData/diagnostics/tests/when/NoElseNoExpectedType.kt index 53a35c30195..5cc1a2be78f 100644 --- a/compiler/testData/diagnostics/tests/when/NoElseNoExpectedType.kt +++ b/compiler/testData/diagnostics/tests/when/NoElseNoExpectedType.kt @@ -12,4 +12,4 @@ fun foo(x: Int): Any { 2 -> 0 } return v -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/NoElseReturnedCoercionToUnit.fir.kt b/compiler/testData/diagnostics/tests/when/NoElseReturnedCoercionToUnit.fir.kt index 695f64ab91c..cfdaa269fe4 100644 --- a/compiler/testData/diagnostics/tests/when/NoElseReturnedCoercionToUnit.fir.kt +++ b/compiler/testData/diagnostics/tests/when/NoElseReturnedCoercionToUnit.fir.kt @@ -1,3 +1,13 @@ +/* + * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE) + * + * SPEC VERSION: 0.1-152 + * PRIMARY LINKS: expressions, when-expression -> paragraph 5 -> sentence 1 + * expressions, when-expression -> paragraph 9 -> sentence 2 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 1 -> sentence 1 + * expressions, function-literals, lambda-literals -> paragraph 10 -> sentence 1 + */ + fun foo(x: Int) { r { when (x) { @@ -8,4 +18,4 @@ fun foo(x: Int) { fun r(f: () -> Unit) { f() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/NoElseReturnedCoercionToUnit.kt b/compiler/testData/diagnostics/tests/when/NoElseReturnedCoercionToUnit.kt index 791a254b8e0..230a1fefe70 100644 --- a/compiler/testData/diagnostics/tests/when/NoElseReturnedCoercionToUnit.kt +++ b/compiler/testData/diagnostics/tests/when/NoElseReturnedCoercionToUnit.kt @@ -18,4 +18,4 @@ fun foo(x: Int) { fun r(f: () -> Unit) { f() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/NoElseReturnedFromLambdaExpectedInt.fir.kt b/compiler/testData/diagnostics/tests/when/NoElseReturnedFromLambdaExpectedInt.fir.kt index 4dfb9c7dbcf..3a452e87291 100644 --- a/compiler/testData/diagnostics/tests/when/NoElseReturnedFromLambdaExpectedInt.fir.kt +++ b/compiler/testData/diagnostics/tests/when/NoElseReturnedFromLambdaExpectedInt.fir.kt @@ -1,3 +1,14 @@ +/* + * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE) + * + * SPEC VERSION: 0.1-152 + * PRIMARY LINKS: expressions, when-expression -> paragraph 5 -> sentence 1 + * expressions, when-expression -> paragraph 9 -> sentence 2 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 1 -> sentence 1 + * expressions, function-literals, lambda-literals -> paragraph 10 -> sentence 1 + * overload-resolution, determining-function-applicability-for-a-specific-call, description -> paragraph 3 -> sentence 3 + */ + fun foo(x: Int) { r { when (x) { @@ -8,4 +19,4 @@ fun foo(x: Int) { fun r(f: () -> Int) { f() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/NoElseReturnedFromLambdaExpectedInt.kt b/compiler/testData/diagnostics/tests/when/NoElseReturnedFromLambdaExpectedInt.kt index f6b22498c82..e57636611b9 100644 --- a/compiler/testData/diagnostics/tests/when/NoElseReturnedFromLambdaExpectedInt.kt +++ b/compiler/testData/diagnostics/tests/when/NoElseReturnedFromLambdaExpectedInt.kt @@ -19,4 +19,4 @@ fun foo(x: Int) { fun r(f: () -> Int) { f() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/NoElseReturnedNonUnit.fir.kt b/compiler/testData/diagnostics/tests/when/NoElseReturnedNonUnit.fir.kt index 1ba2b607982..69423511de3 100644 --- a/compiler/testData/diagnostics/tests/when/NoElseReturnedNonUnit.fir.kt +++ b/compiler/testData/diagnostics/tests/when/NoElseReturnedNonUnit.fir.kt @@ -1,5 +1,14 @@ +/* + * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE) + * + * SPEC VERSION: 0.1-152 + * PRIMARY LINKS: expressions, when-expression -> paragraph 5 -> sentence 1 + * expressions, when-expression -> paragraph 9 -> sentence 2 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 1 -> sentence 1 + */ + fun foo(x: Int): Any { return when (x) { 2 -> 0 } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/NoElseReturnedNonUnit.kt b/compiler/testData/diagnostics/tests/when/NoElseReturnedNonUnit.kt index 4dc63a2739a..6822f03a47a 100644 --- a/compiler/testData/diagnostics/tests/when/NoElseReturnedNonUnit.kt +++ b/compiler/testData/diagnostics/tests/when/NoElseReturnedNonUnit.kt @@ -11,4 +11,4 @@ fun foo(x: Int): Any { return when (x) { 2 -> 0 } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/NoElseReturnedUnit.fir.kt b/compiler/testData/diagnostics/tests/when/NoElseReturnedUnit.fir.kt index 606fe43e816..94b8f840ec2 100644 --- a/compiler/testData/diagnostics/tests/when/NoElseReturnedUnit.fir.kt +++ b/compiler/testData/diagnostics/tests/when/NoElseReturnedUnit.fir.kt @@ -1,6 +1,16 @@ +/* + * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE) + * + * SPEC VERSION: 0.1-152 + * PRIMARY LINKS: expressions, when-expression -> paragraph 5 -> sentence 1 + * expressions, when-expression -> paragraph 9 -> sentence 2 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 1 -> sentence 1 + */ + + fun foo(x: Int) { return when (x) { 2 -> {} 3 -> {} } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/NoElseReturnedUnit.kt b/compiler/testData/diagnostics/tests/when/NoElseReturnedUnit.kt index 833c96c7602..4a5dbe3116a 100644 --- a/compiler/testData/diagnostics/tests/when/NoElseReturnedUnit.kt +++ b/compiler/testData/diagnostics/tests/when/NoElseReturnedUnit.kt @@ -13,4 +13,4 @@ fun foo(x: Int) { 2 -> {} 3 -> {} } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/NonExhaustiveBooleanNullable.fir.kt b/compiler/testData/diagnostics/tests/when/NonExhaustiveBooleanNullable.fir.kt index a1b0cf6478c..0a39652a6fd 100644 --- a/compiler/testData/diagnostics/tests/when/NonExhaustiveBooleanNullable.fir.kt +++ b/compiler/testData/diagnostics/tests/when/NonExhaustiveBooleanNullable.fir.kt @@ -1,3 +1,13 @@ +/* + * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE) + * + * SPEC VERSION: 0.1-152 + * PRIMARY LINKS: expressions, when-expression -> paragraph 5 -> sentence 1 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 1 -> sentence 1 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 3 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 10 + */ + // See also: KT-3743 fun foo(arg: Boolean?): String { // Must be NOT exhaustive diff --git a/compiler/testData/diagnostics/tests/when/NonExhaustivePlatformEnum.fir.kt b/compiler/testData/diagnostics/tests/when/NonExhaustivePlatformEnum.fir.kt index f88086ef62a..c3014d5ef6f 100644 --- a/compiler/testData/diagnostics/tests/when/NonExhaustivePlatformEnum.fir.kt +++ b/compiler/testData/diagnostics/tests/when/NonExhaustivePlatformEnum.fir.kt @@ -1,3 +1,12 @@ +/* + * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE) + * + * SPEC VERSION: 0.1-152 + * PRIMARY LINKS: expressions, when-expression -> paragraph 5 -> sentence 1 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 1 -> sentence 1 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 9 + */ + // See KT-6399: exhaustive whens on platform enums // FILE: J.java @@ -17,4 +26,4 @@ fun foo(): Int { return when (J.create()) { J.A -> 1 } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/NonExhaustivePlatformEnum.kt b/compiler/testData/diagnostics/tests/when/NonExhaustivePlatformEnum.kt index e07e7975845..b9480bf6cc4 100644 --- a/compiler/testData/diagnostics/tests/when/NonExhaustivePlatformEnum.kt +++ b/compiler/testData/diagnostics/tests/when/NonExhaustivePlatformEnum.kt @@ -26,4 +26,4 @@ fun foo(): Int { return when (J.create()) { J.A -> 1 } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/NonExhaustiveWarning.fir.kt b/compiler/testData/diagnostics/tests/when/NonExhaustiveWarning.fir.kt index 311b12aae32..4786062e25d 100644 --- a/compiler/testData/diagnostics/tests/when/NonExhaustiveWarning.fir.kt +++ b/compiler/testData/diagnostics/tests/when/NonExhaustiveWarning.fir.kt @@ -1,3 +1,15 @@ +/* + * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE) + * + * SPEC VERSION: 0.1-152 + * PRIMARY LINKS: expressions, when-expression -> paragraph 5 -> sentence 1 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 1 -> sentence 1 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 9 + * expressions, when-expression -> paragraph 9 -> sentence 2 + * control--and-data-flow-analysis, performing-analysis-on-the-control-flow-graph, variable-initialization-analysis -> paragraph 2 -> sentence 1 + * control--and-data-flow-analysis, performing-analysis-on-the-control-flow-graph, variable-initialization-analysis -> paragraph 2 -> sentence 3 + */ + // Base for KT-6227 enum class X { A, B, C, D } @@ -8,4 +20,4 @@ fun foo(arg: X): String { X.B -> res = "B" } return res -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/NonExhaustiveWarning.kt b/compiler/testData/diagnostics/tests/when/NonExhaustiveWarning.kt index a0cbfd75119..5e6ef130882 100644 --- a/compiler/testData/diagnostics/tests/when/NonExhaustiveWarning.kt +++ b/compiler/testData/diagnostics/tests/when/NonExhaustiveWarning.kt @@ -20,4 +20,4 @@ fun foo(arg: X): String { X.B -> res = "B" } return res -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/NonExhaustiveWarningFalse.fir.kt b/compiler/testData/diagnostics/tests/when/NonExhaustiveWarningFalse.fir.kt index c78080fd833..cd256cdf297 100644 --- a/compiler/testData/diagnostics/tests/when/NonExhaustiveWarningFalse.fir.kt +++ b/compiler/testData/diagnostics/tests/when/NonExhaustiveWarningFalse.fir.kt @@ -1,3 +1,14 @@ +/* + * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE) + * + * SPEC VERSION: 0.1-152 + * PRIMARY LINKS: expressions, when-expression -> paragraph 5 -> sentence 1 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 9 + * control--and-data-flow-analysis, performing-analysis-on-the-control-flow-graph, variable-initialization-analysis -> paragraph 2 -> sentence 1 + * control--and-data-flow-analysis, performing-analysis-on-the-control-flow-graph, variable-initialization-analysis -> paragraph 2 -> sentence 3 + * control--and-data-flow-analysis, performing-analysis-on-the-control-flow-graph, variable-initialization-analysis -> paragraph 3 -> sentence 2 + */ + // Base for KT-6227 enum class X { A, B, C, D } @@ -10,4 +21,4 @@ fun foo(arg: X): String { X.D -> res = "D" } return res -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/NonExhaustiveWarningFalse.kt b/compiler/testData/diagnostics/tests/when/NonExhaustiveWarningFalse.kt index 16d6c63b033..12ebb10b332 100644 --- a/compiler/testData/diagnostics/tests/when/NonExhaustiveWarningFalse.kt +++ b/compiler/testData/diagnostics/tests/when/NonExhaustiveWarningFalse.kt @@ -21,4 +21,4 @@ fun foo(arg: X): String { X.D -> res = "D" } return res -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/NonExhaustiveWarningForSealedClass.fir.kt b/compiler/testData/diagnostics/tests/when/NonExhaustiveWarningForSealedClass.fir.kt index 36e760226ea..02c0d4d56b0 100644 --- a/compiler/testData/diagnostics/tests/when/NonExhaustiveWarningForSealedClass.fir.kt +++ b/compiler/testData/diagnostics/tests/when/NonExhaustiveWarningForSealedClass.fir.kt @@ -1,3 +1,16 @@ +/* + * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE) + * + * SPEC VERSION: 0.1-152 + * PRIMARY LINKS: expressions, when-expression -> paragraph 5 -> sentence 1 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 1 -> sentence 1 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 6 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 7 + * expressions, when-expression -> paragraph 9 -> sentence 2 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 3 -> sentence 1 + * type-inference, smart-casts, smart-cast-types -> paragraph 9 -> sentence 1 + */ + sealed class S object First : S() @@ -13,4 +26,4 @@ fun foo(s: S) { First -> {} is Derived -> use(s.s) } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/NonExhaustiveWarningForSealedClass.kt b/compiler/testData/diagnostics/tests/when/NonExhaustiveWarningForSealedClass.kt index 2b3f3e3070a..845ba67b987 100644 --- a/compiler/testData/diagnostics/tests/when/NonExhaustiveWarningForSealedClass.kt +++ b/compiler/testData/diagnostics/tests/when/NonExhaustiveWarningForSealedClass.kt @@ -26,4 +26,4 @@ fun foo(s: S) { First -> {} is Derived -> use(s.s) } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/NonExhaustiveWithNullabilityCheck.fir.kt b/compiler/testData/diagnostics/tests/when/NonExhaustiveWithNullabilityCheck.fir.kt index 97cb1995804..e0bcb365303 100644 --- a/compiler/testData/diagnostics/tests/when/NonExhaustiveWithNullabilityCheck.fir.kt +++ b/compiler/testData/diagnostics/tests/when/NonExhaustiveWithNullabilityCheck.fir.kt @@ -1,3 +1,14 @@ +/* + * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE) + * + * SPEC VERSION: 0.1-152 + * PRIMARY LINKS: expressions, when-expression -> paragraph 5 -> sentence 1 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 1 -> sentence 1 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 9 + * expressions, when-expression -> paragraph 9 -> sentence 2 + * type-inference, smart-casts, smart-cast-types -> paragraph 9 -> sentence 1 + */ + // KT-7857: when exhaustiveness does not take previous nullability checks into account enum class X { A, B } fun foo(arg: X?): Int { @@ -9,4 +20,4 @@ fun foo(arg: X?): Int { else { return 0 } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/NonExhaustiveWithNullabilityCheck.kt b/compiler/testData/diagnostics/tests/when/NonExhaustiveWithNullabilityCheck.kt index 34ba7eced8d..baec7c29eea 100644 --- a/compiler/testData/diagnostics/tests/when/NonExhaustiveWithNullabilityCheck.kt +++ b/compiler/testData/diagnostics/tests/when/NonExhaustiveWithNullabilityCheck.kt @@ -20,4 +20,4 @@ fun foo(arg: X?): Int { else { return 0 } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/PropertyNotInitialized.fir.kt b/compiler/testData/diagnostics/tests/when/PropertyNotInitialized.fir.kt index c286b1e93c3..5f48f19aa9a 100644 --- a/compiler/testData/diagnostics/tests/when/PropertyNotInitialized.fir.kt +++ b/compiler/testData/diagnostics/tests/when/PropertyNotInitialized.fir.kt @@ -1,3 +1,15 @@ +/* + * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE) + * + * SPEC VERSION: 0.1-152 + * PRIMARY LINKS: expressions, when-expression -> paragraph 5 -> sentence 1 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 9 + * control--and-data-flow-analysis, performing-analysis-on-the-control-flow-graph, variable-initialization-analysis -> paragraph 2 -> sentence 1 + * control--and-data-flow-analysis, performing-analysis-on-the-control-flow-graph, variable-initialization-analysis -> paragraph 2 -> sentence 3 + * control--and-data-flow-analysis, performing-analysis-on-the-control-flow-graph, variable-initialization-analysis -> paragraph 3 -> sentence 2 + * declarations, classifier-declaration, classifier-initialization -> paragraph 6 -> sentence 4 + */ + // See KT-5113 enum class E { A, @@ -13,4 +25,4 @@ class Outer(e: E) { E.B -> prop = 2 } } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/PropertyNotInitialized.kt b/compiler/testData/diagnostics/tests/when/PropertyNotInitialized.kt index 649173b7a64..5561c8066ed 100644 --- a/compiler/testData/diagnostics/tests/when/PropertyNotInitialized.kt +++ b/compiler/testData/diagnostics/tests/when/PropertyNotInitialized.kt @@ -25,4 +25,4 @@ class Outer(e: E) { E.B -> prop = 2 } } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/RedundantElse.fir.kt b/compiler/testData/diagnostics/tests/when/RedundantElse.fir.kt index 88d76554d03..829fb30787e 100644 --- a/compiler/testData/diagnostics/tests/when/RedundantElse.fir.kt +++ b/compiler/testData/diagnostics/tests/when/RedundantElse.fir.kt @@ -1,3 +1,15 @@ +/* + * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE) + * + * SPEC VERSION: 0.1-152 + * PRIMARY LINKS: expressions, when-expression -> paragraph 5 -> sentence 1 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 3 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 6 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 9 + * expressions, when-expression -> paragraph 6 -> sentence 10 + * expressions, when-expression -> paragraph 6 -> sentence 11 + */ + // FILE: MyEnum.java public enum MyEnum { SINGLE; @@ -65,4 +77,4 @@ fun useJava(): String { MyEnum.SINGLE -> "OK" else -> "FAIL" // no warning } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/RedundantElse.kt b/compiler/testData/diagnostics/tests/when/RedundantElse.kt index a82f36e3435..88e3c40c2fd 100644 --- a/compiler/testData/diagnostics/tests/when/RedundantElse.kt +++ b/compiler/testData/diagnostics/tests/when/RedundantElse.kt @@ -77,4 +77,4 @@ fun useJava(): String { MyEnum.SINGLE -> "OK" else -> "FAIL" // no warning } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/ReservedExhaustiveWhen.fir.kt b/compiler/testData/diagnostics/tests/when/ReservedExhaustiveWhen.fir.kt index 768ca9e343d..35d56121810 100644 --- a/compiler/testData/diagnostics/tests/when/ReservedExhaustiveWhen.fir.kt +++ b/compiler/testData/diagnostics/tests/when/ReservedExhaustiveWhen.fir.kt @@ -1,3 +1,12 @@ +/* + * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE) + * + * SPEC VERSION: 0.1-152 + * PRIMARY LINKS: expressions, when-expression -> paragraph 2 -> sentence 1 + * expressions, when-expression -> paragraph 5 -> sentence 1 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 1 + */ + // !DIAGNOSTICS: -UNUSED_PARAMETER infix fun Any.sealed(a: Any?) {} @@ -34,4 +43,4 @@ fun foo() { when { else -> {} } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/ReservedExhaustiveWhen.kt b/compiler/testData/diagnostics/tests/when/ReservedExhaustiveWhen.kt index 6989da12de5..dce46c0d290 100644 --- a/compiler/testData/diagnostics/tests/when/ReservedExhaustiveWhen.kt +++ b/compiler/testData/diagnostics/tests/when/ReservedExhaustiveWhen.kt @@ -43,4 +43,4 @@ fun foo() { when { else -> {} } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/TopLevelSealed.fir.kt b/compiler/testData/diagnostics/tests/when/TopLevelSealed.fir.kt index 51371115be4..b7577c720de 100644 --- a/compiler/testData/diagnostics/tests/when/TopLevelSealed.fir.kt +++ b/compiler/testData/diagnostics/tests/when/TopLevelSealed.fir.kt @@ -1,4 +1,14 @@ // !DIAGNOSTICS: -UNUSED_VARIABLE +/* + * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE) + * + * SPEC VERSION: 0.1-152 + * PRIMARY LINKS: expressions, when-expression -> paragraph 5 -> sentence 1 + * expressions, when-expression -> paragraph 6 -> sentence 1 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 6 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 7 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 8 + */ sealed class A { class B: A() { @@ -19,4 +29,4 @@ fun test(a: A) { is A.B.C -> "C" is D -> "D" } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/TopLevelSealed.kt b/compiler/testData/diagnostics/tests/when/TopLevelSealed.kt index 9ea59cd85d8..14d6fd04291 100644 --- a/compiler/testData/diagnostics/tests/when/TopLevelSealed.kt +++ b/compiler/testData/diagnostics/tests/when/TopLevelSealed.kt @@ -29,4 +29,4 @@ fun test(a: A) { is A.B.C -> "C" is D -> "D" } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/When.fir.kt b/compiler/testData/diagnostics/tests/when/When.fir.kt index 7a7be97f158..f292d20fbd8 100644 --- a/compiler/testData/diagnostics/tests/when/When.fir.kt +++ b/compiler/testData/diagnostics/tests/when/When.fir.kt @@ -1,4 +1,17 @@ // !WITH_NEW_INFERENCE +/* + * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE) + * + * SPEC VERSION: 0.1-152 + * PRIMARY LINKS: expressions, when-expression -> paragraph 2 -> sentence 5 + * expressions, when-expression -> paragraph 5 -> sentence 1 + * expressions, when-expression -> paragraph 6 -> sentence 1 + * expressions, when-expression -> paragraph 6 -> sentence 3 + * expressions, when-expression -> paragraph 6 -> sentence 5 + * expressions, when-expression -> paragraph 6 -> sentence 9 + * expressions, when-expression -> paragraph 6 -> sentence 10 + * expressions, when-expression -> paragraph 6 -> sentence 11 + */ fun Int.foo() : Boolean = true @@ -44,4 +57,4 @@ fun test() { when (z) { else -> 1 } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/When.kt b/compiler/testData/diagnostics/tests/when/When.kt index e657da1d321..a8a475024e9 100644 --- a/compiler/testData/diagnostics/tests/when/When.kt +++ b/compiler/testData/diagnostics/tests/when/When.kt @@ -57,4 +57,4 @@ fun test() { when (z) { else -> 1 } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/WhenTypeDisjunctions.fir.kt b/compiler/testData/diagnostics/tests/when/WhenTypeDisjunctions.fir.kt index 61f82a393b6..7233c101745 100644 --- a/compiler/testData/diagnostics/tests/when/WhenTypeDisjunctions.fir.kt +++ b/compiler/testData/diagnostics/tests/when/WhenTypeDisjunctions.fir.kt @@ -1,3 +1,15 @@ +/* + * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE) + * + * SPEC VERSION: 0.1-152 + * PRIMARY LINKS: expressions, when-expression -> paragraph 5 -> sentence 1 + * type-inference, smart-casts, smart-cast-types -> paragraph 9 -> sentence 1 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 1 + * expressions, when-expression -> paragraph 6 -> sentence 1 + * control--and-data-flow-analysis, control-flow-graph, expressions-1, conditional-expressions -> paragraph 2 -> sentence 1 + * control--and-data-flow-analysis, control-flow-graph, expressions-1, boolean-operators -> paragraph 0 -> sentence 0 + */ + fun foo(s: Any): String { val x = when (s) { is String -> s @@ -18,4 +30,4 @@ fun bar(s: Any): String { val y: String = x // no error return y -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/WhenTypeDisjunctions.kt b/compiler/testData/diagnostics/tests/when/WhenTypeDisjunctions.kt index fe6a807d59b..94ebf7b8880 100644 --- a/compiler/testData/diagnostics/tests/when/WhenTypeDisjunctions.kt +++ b/compiler/testData/diagnostics/tests/when/WhenTypeDisjunctions.kt @@ -30,4 +30,4 @@ fun bar(s: Any): String { val y: String = x // no error return y -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/kt10439.fir.kt b/compiler/testData/diagnostics/tests/when/kt10439.fir.kt index 72d49f53481..c30fc705cc3 100644 --- a/compiler/testData/diagnostics/tests/when/kt10439.fir.kt +++ b/compiler/testData/diagnostics/tests/when/kt10439.fir.kt @@ -1,4 +1,15 @@ // !WITH_NEW_INFERENCE +/* + * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE) + * + * SPEC VERSION: 0.1-152 + * PRIMARY LINKS: expressions, when-expression -> paragraph 5 -> sentence 1 + * expressions, when-expression -> paragraph 9 -> sentence 1 + * expressions, conditional-expression -> paragraph 4 -> sentence 1 + * expressions, conditional-expression -> paragraph 5 -> sentence 1 + * overload-resolution, determining-function-applicability-for-a-specific-call, rationale -> paragraph 1 -> sentence 1 + * overload-resolution, determining-function-applicability-for-a-specific-call, description -> paragraph 3 -> sentence 1 + */ fun foo(x: Int) = x diff --git a/compiler/testData/diagnostics/tests/when/kt10439.kt b/compiler/testData/diagnostics/tests/when/kt10439.kt index 4f419505dc2..45ee0a3a834 100644 --- a/compiler/testData/diagnostics/tests/when/kt10439.kt +++ b/compiler/testData/diagnostics/tests/when/kt10439.kt @@ -14,12 +14,12 @@ fun foo(x: Int) = x fun test0(flag: Boolean) { - foo(if (flag) true else "") + foo(if (flag) true else "") } fun test1(flag: Boolean) { - foo(when (flag) { - true -> true - else -> "" + foo(when (flag) { + true -> true + else -> "" }) } diff --git a/compiler/testData/diagnostics/tests/when/kt10809.fir.kt b/compiler/testData/diagnostics/tests/when/kt10809.fir.kt index 3ccd6260110..6765d688134 100644 --- a/compiler/testData/diagnostics/tests/when/kt10809.fir.kt +++ b/compiler/testData/diagnostics/tests/when/kt10809.fir.kt @@ -1,6 +1,22 @@ // !WITH_NEW_INFERENCE // !DIAGNOSTICS: -UNUSED_PARAMETER -DEBUG_INFO_SMARTCAST // NI_EXPECTED_FILE +/* + * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE) + * + * SPEC VERSION: 0.1-152 + * PRIMARY LINKS: expressions, when-expression -> paragraph 5 -> sentence 1 + * expressions, when-expression -> paragraph 6 -> sentence 1 + * expressions, when-expression -> paragraph 2 -> sentence 1 + * expressions, when-expression -> paragraph 9 -> sentence 1 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 1 + * expressions, conditional-expression -> paragraph 4 -> sentence 1 + * declarations, function-declaration -> paragraph 7 -> sentence 1 + * type-inference, smart-casts, smart-cast-types -> paragraph 9 -> sentence 1 + * type-system, type-kinds, type-parameters -> paragraph 4 -> sentence 1 + * type-inference, local-type-inference -> paragraph 8 -> sentence 1 + * type-inference, local-type-inference -> paragraph 2 -> sentence 1 + */ interface Data interface Item diff --git a/compiler/testData/diagnostics/tests/when/kt10809.kt b/compiler/testData/diagnostics/tests/when/kt10809.kt index fd4baa81a4a..d7ae441fdfb 100644 --- a/compiler/testData/diagnostics/tests/when/kt10809.kt +++ b/compiler/testData/diagnostics/tests/when/kt10809.kt @@ -25,7 +25,7 @@ class ListData(val list: List) : Data fun listOf(vararg items: T): List = null!! -fun test1(o: Any) = when (o) { +fun test1(o: Any) = when (o) { is List<*> -> ListData(listOf()) is Int -> when { @@ -52,7 +52,7 @@ fun test1x(o: Any): Data? = when (o) { } fun test2() = - if (true) + if (true) ListData(listOf()) else FlagData(true) diff --git a/compiler/testData/diagnostics/tests/when/kt4434.fir.kt b/compiler/testData/diagnostics/tests/when/kt4434.fir.kt index 2d2809f0b0b..46abd84179d 100644 --- a/compiler/testData/diagnostics/tests/when/kt4434.fir.kt +++ b/compiler/testData/diagnostics/tests/when/kt4434.fir.kt @@ -1,3 +1,13 @@ +/* + * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE) + * + * SPEC VERSION: 0.1-152 + * PRIMARY LINKS: expressions, when-expression -> paragraph 5 -> sentence 1 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 1 -> sentence 1 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 1 + * expressions, when-expression -> paragraph 6 -> sentence 5 + */ + // KT-4434 Missed diagnostic about else branch in when package test diff --git a/compiler/testData/diagnostics/tests/when/kt9929.fir.kt b/compiler/testData/diagnostics/tests/when/kt9929.fir.kt index bdcef146df4..99e8a97adf9 100644 --- a/compiler/testData/diagnostics/tests/when/kt9929.fir.kt +++ b/compiler/testData/diagnostics/tests/when/kt9929.fir.kt @@ -7,4 +7,4 @@ val test: Int = if (true) { } else { 2 -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/kt9929.kt b/compiler/testData/diagnostics/tests/when/kt9929.kt index e70a58c428e..5ca2059e1ee 100644 --- a/compiler/testData/diagnostics/tests/when/kt9929.kt +++ b/compiler/testData/diagnostics/tests/when/kt9929.kt @@ -1,10 +1,10 @@ // !WITH_NEW_INFERENCE -val test: Int = if (true) { +val test: Int = if (true) { when (2) { 1 -> 1 - else -> null + else -> null } } else { 2 -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/kt9972.fir.kt b/compiler/testData/diagnostics/tests/when/kt9972.fir.kt index 4db13805be5..779a4c0b0ab 100644 --- a/compiler/testData/diagnostics/tests/when/kt9972.fir.kt +++ b/compiler/testData/diagnostics/tests/when/kt9972.fir.kt @@ -1,4 +1,14 @@ // !WITH_NEW_INFERENCE +/* + * KOTLIN DIAGNOSTICS SPEC TEST (POSITIVE) + * + * SPEC VERSION: 0.1-152 + * PRIMARY LINKS: expressions, when-expression -> paragraph 2 -> sentence 1 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 1 + * expressions, when-expression -> paragraph 9 -> sentence 1 + * expressions, conditional-expression -> paragraph 4 -> sentence 1 + * expressions, conditional-expression -> paragraph 5 -> sentence 1 + */ fun test1(): Int { val x: String = if (true) { @@ -16,4 +26,4 @@ fun test2(): Int { else -> null } ?: return 0 return x.hashCode() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/kt9972.kt b/compiler/testData/diagnostics/tests/when/kt9972.kt index 529f2cf3f6b..591722f3354 100644 --- a/compiler/testData/diagnostics/tests/when/kt9972.kt +++ b/compiler/testData/diagnostics/tests/when/kt9972.kt @@ -11,19 +11,19 @@ */ fun test1(): Int { - val x: String = if (true) { + val x: String = if (true) { when { - true -> Any() - else -> null + true -> Any() + else -> null } } else "" return x.hashCode() } fun test2(): Int { - val x: String = when { - true -> Any() + val x: String = when { + true -> Any() else -> null } ?: return 0 return x.hashCode() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/whenAndLambdaWithExpectedType.fir.kt b/compiler/testData/diagnostics/tests/when/whenAndLambdaWithExpectedType.fir.kt index 8f793c6fb58..ce5df31b6d7 100644 --- a/compiler/testData/diagnostics/tests/when/whenAndLambdaWithExpectedType.fir.kt +++ b/compiler/testData/diagnostics/tests/when/whenAndLambdaWithExpectedType.fir.kt @@ -1,4 +1,14 @@ // !WITH_NEW_INFERENCE +/* + * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE) + * + * SPEC VERSION: 0.1-152 + * PRIMARY LINKS: expressions, when-expression -> paragraph 2 -> sentence 1 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 1 + * type-system, subtyping, subtyping-rules -> paragraph 2 -> sentence 1 + * type-inference, local-type-inference -> paragraph 2 -> sentence 1 + * overload-resolution, determining-function-applicability-for-a-specific-call, description -> paragraph 3 -> sentence 3 + */ val test1: (String) -> Boolean = when { diff --git a/compiler/testData/diagnostics/tests/when/whenAndLambdaWithExpectedType.kt b/compiler/testData/diagnostics/tests/when/whenAndLambdaWithExpectedType.kt index 3fe94eaf418..7642b53335d 100644 --- a/compiler/testData/diagnostics/tests/when/whenAndLambdaWithExpectedType.kt +++ b/compiler/testData/diagnostics/tests/when/whenAndLambdaWithExpectedType.kt @@ -30,7 +30,7 @@ val test3: (String) -> Boolean = val test4: (String) -> Boolean = when { - true -> { s1, s2 -> true } + true -> { s1, s2 -> true } else -> null!! } diff --git a/compiler/testData/diagnostics/tests/when/whenWithNothingAndLambdas.fir.kt b/compiler/testData/diagnostics/tests/when/whenWithNothingAndLambdas.fir.kt index 22c7a8247c6..f48235d51ab 100644 --- a/compiler/testData/diagnostics/tests/when/whenWithNothingAndLambdas.fir.kt +++ b/compiler/testData/diagnostics/tests/when/whenWithNothingAndLambdas.fir.kt @@ -1,5 +1,16 @@ // !WITH_NEW_INFERENCE // NI_EXPECTED_FILE +/* + * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE) + * + * SPEC VERSION: 0.1-152 + * PRIMARY LINKS: expressions, when-expression -> paragraph 2 -> sentence 1 + * expressions, when-expression, exhaustive-when-expressions -> paragraph 2 -> sentence 1 + * declarations, function-declaration -> paragraph 7 -> sentence 1 + * declarations, function-declaration -> paragraph 7 -> sentence 2 + * declarations, function-declaration -> paragraph 8 -> sentence 1 + * overload-resolution, determining-function-applicability-for-a-specific-call, description -> paragraph 1 -> sentence 3 + */ val test1 = when { true -> { { true } } @@ -37,4 +48,4 @@ val test3a: () -> Boolean = when { true -> { { true } } true -> { { true } } else -> TODO() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/when/whenWithNothingAndLambdas.kt b/compiler/testData/diagnostics/tests/when/whenWithNothingAndLambdas.kt index 4874ca7bc58..3c96278cbf4 100644 --- a/compiler/testData/diagnostics/tests/when/whenWithNothingAndLambdas.kt +++ b/compiler/testData/diagnostics/tests/when/whenWithNothingAndLambdas.kt @@ -12,8 +12,8 @@ * overload-resolution, determining-function-applicability-for-a-specific-call, description -> paragraph 1 -> sentence 3 */ -val test1 = when { - true -> { { true } } +val test1 = when { + true -> { { true } } else -> TODO() } @@ -22,10 +22,10 @@ val test1a: () -> Boolean = when { else -> TODO() } -val test2 = when { - true -> { { true } } +val test2 = when { + true -> { { true } } else -> when { - true -> { { true } } + true -> { { true } } else -> TODO() } } @@ -33,14 +33,14 @@ val test2 = when { val test2a: () -> Boolean = when { true -> { { true } } else -> when { - true -> { { true } } // TODO + true -> { { true } } // TODO else -> TODO() } } -val test3 = when { - true -> { { true } } - true -> { { true } } +val test3 = when { + true -> { { true } } + true -> { { true } } else -> TODO() } @@ -48,4 +48,4 @@ val test3a: () -> Boolean = when { true -> { { true } } true -> { { true } } else -> TODO() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/addAllProjection.kt b/compiler/testData/diagnostics/testsWithStdLib/addAllProjection.kt index 0d47fae1499..b84f5e7c54e 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/addAllProjection.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/addAllProjection.kt @@ -1,14 +1,14 @@ // !WITH_NEW_INFERENCE fun test(mc: MutableCollection) { - mc.addAll(mc) + mc.addAll(mc) - mc.addAll(arrayListOf()) + mc.addAll(arrayListOf()) mc.addAll(arrayListOf()) - mc.addAll(listOf("")) - mc.addAll(listOf("")) - mc.addAll(listOf("")) + mc.addAll(listOf("")) + mc.addAll(listOf("")) + mc.addAll(listOf("")) mc.addAll(emptyList()) mc.addAll(emptyList()) diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability/jvmNameOnMangledNames.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability/jvmNameOnMangledNames.fir.kt index aaf1391ee81..c936aeb4b86 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability/jvmNameOnMangledNames.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability/jvmNameOnMangledNames.fir.kt @@ -27,4 +27,4 @@ class C { } @JvmName("extensionFun") -fun Foo.extensionFun() {} \ No newline at end of file +fun Foo.extensionFun() {} diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability/suppressOnFunctionReference.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability/suppressOnFunctionReference.fir.kt index eebe8baba18..a5d2bdf8807 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability/suppressOnFunctionReference.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability/suppressOnFunctionReference.fir.kt @@ -1,4 +1,4 @@ // !WITH_NEW_INFERENCE // See KT-15839 -val x = "1".let(@Suppress("DEPRECATION") Integer::parseInt) \ No newline at end of file +val x = "1".let(@Suppress("DEPRECATION") Integer::parseInt) diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability/suppressOnFunctionReference.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability/suppressOnFunctionReference.kt index 8f2a2593ab0..5a5c919edf5 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability/suppressOnFunctionReference.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability/suppressOnFunctionReference.kt @@ -1,4 +1,4 @@ // !WITH_NEW_INFERENCE // See KT-15839 -val x = "1".let(@Suppress("DEPRECATION") Integer::parseInt) \ No newline at end of file +val x = "1".let(@Suppress("DEPRECATION") Integer::parseInt) diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter/javaAnnotationWithVarargArgument.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter/javaAnnotationWithVarargArgument.kt index a4fbc2da293..ae79a26a374 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter/javaAnnotationWithVarargArgument.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter/javaAnnotationWithVarargArgument.kt @@ -6,6 +6,6 @@ public @interface A { } // FILE: b.kt -@A(*arrayOf(1, "b")) +@A(*arrayOf(1, "b")) fun test() { } diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter/kotlinAnnotationWithVarargArgument.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter/kotlinAnnotationWithVarargArgument.kt index f19fe4b86e5..b6c06233464 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter/kotlinAnnotationWithVarargArgument.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter/kotlinAnnotationWithVarargArgument.kt @@ -2,6 +2,6 @@ annotation class B(vararg val args: String) -@B(*arrayOf(1, "b")) +@B(*arrayOf(1, "b")) fun test() { } diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/superCall.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/superCall.kt index 28b7b07b3fb..25304cc7a88 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/superCall.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/superCall.kt @@ -59,4 +59,4 @@ class ManySupers2: Foo2(), C { super.test() super.test() } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsInVariance.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsInVariance.kt index 3d45621274f..a5d59fbb61a 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsInVariance.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsInVariance.kt @@ -14,7 +14,7 @@ class MyClass1 @Ann1(arrayOf(Any::class)) class MyClass1a -@Ann1(arrayOf(B1::class)) +@Ann1(arrayOf(B1::class)) class MyClass2 annotation class Ann2(val arg: Array>) @@ -25,5 +25,5 @@ class MyClass3 @Ann2(arrayOf(B1::class)) class MyClass4 -@Ann2(arrayOf(B2::class)) +@Ann2(arrayOf(B2::class)) class MyClass5 diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsOutVariance.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsOutVariance.kt index b0f09ecd02e..50c73321702 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsOutVariance.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsOutVariance.kt @@ -11,7 +11,7 @@ annotation class Ann1(val arg: Array>) @Ann1(arrayOf(A::class)) class MyClass1 -@Ann1(arrayOf(Any::class)) +@Ann1(arrayOf(Any::class)) class MyClass1a @Ann1(arrayOf(B1::class)) @@ -19,11 +19,11 @@ class MyClass2 annotation class Ann2(val arg: Array>) -@Ann2(arrayOf(A::class)) +@Ann2(arrayOf(A::class)) class MyClass3 @Ann2(arrayOf(B1::class)) class MyClass4 -@Ann2(arrayOf(B2::class)) +@Ann2(arrayOf(B2::class)) class MyClass5 diff --git a/compiler/testData/diagnostics/testsWithStdLib/assert/cast.kt b/compiler/testData/diagnostics/testsWithStdLib/assert/cast.kt index 55e2e594208..5210167b086 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/assert/cast.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/assert/cast.kt @@ -11,11 +11,11 @@ class B: A { fun test1(a: A) { assert((a as B).bool()) - a.bool() + a.bool() } fun test2() { val a: A? = null; assert((a as B).bool()) - a?.bool() + a?.bool() } diff --git a/compiler/testData/diagnostics/testsWithStdLib/assert/safeCall.kt b/compiler/testData/diagnostics/testsWithStdLib/assert/safeCall.kt index e66f96c8efd..eca2c5f8a5d 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/assert/safeCall.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/assert/safeCall.kt @@ -5,34 +5,34 @@ fun test1(s: String?) { assert(s!!.isEmpty()) - s?.length + s?.length } fun test2(s: String?) { assert(s!!.isEmpty()) - s!!.length + s!!.length } fun test3(s: String?) { assert(s!!.isEmpty()) - s.length + s.length } fun test4() { val s: String? = null; assert(s!!.isEmpty()) - s?.length + s?.length } fun test5() { val s: String? = null; assert(s!!.isEmpty()) - s!!.length + s!!.length } fun test6() { val s: String? = null; assert(s!!.isEmpty()) - s.length + s.length } diff --git a/compiler/testData/diagnostics/testsWithStdLib/commonCollections.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/commonCollections.fir.kt index 0e42f2f16b9..905eb9f1aa8 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/commonCollections.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/commonCollections.fir.kt @@ -28,4 +28,4 @@ fun foo() { hm[""] hm.remove("") -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/commonCollections.kt b/compiler/testData/diagnostics/testsWithStdLib/commonCollections.kt index c5ae9f45219..361426dc751 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/commonCollections.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/commonCollections.kt @@ -5,7 +5,7 @@ import java.util.* fun foo() { val al = ArrayList() al.size - al.contains(1) + al.contains(1) al.contains("") al.remove("") @@ -13,7 +13,7 @@ fun foo() { val hs = HashSet() hs.size - hs.contains(1) + hs.contains(1) hs.contains("") hs.remove("") @@ -21,11 +21,11 @@ fun foo() { val hm = HashMap() hm.size - hm.containsKey(1) + hm.containsKey(1) hm.containsKey("") - hm[1] + hm[1] hm[""] hm.remove("") -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining/nestedTryCatchs.kt b/compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining/nestedTryCatchs.kt index 429e24dd162..5896a2a50a7 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining/nestedTryCatchs.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining/nestedTryCatchs.kt @@ -44,4 +44,4 @@ fun innerTryCatchInitializes() { } // Here x=I because outer try-catch either exited normally (x=I) or catched exception (x=I, with reassingment, though) x.inc() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining/throwIfNotCalled.kt b/compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining/throwIfNotCalled.kt index 33907cea37c..b015db64a14 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining/throwIfNotCalled.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining/throwIfNotCalled.kt @@ -45,4 +45,4 @@ fun catchThrowIfNotCalled() { // x *isn't* initialized here! println(x) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/extensionReceiver.kt b/compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/extensionReceiver.kt index c4af95ceeab..3ea7f80c23d 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/extensionReceiver.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/extensionReceiver.kt @@ -35,4 +35,4 @@ fun mixedReceiver(s: String?) { length } } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/extensionReceiver_after.kt b/compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/extensionReceiver_after.kt index 3e0213fe764..9e6713cb635 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/extensionReceiver_after.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/extensionReceiver_after.kt @@ -35,4 +35,4 @@ fun mixedReceiver(s: String?) { length } } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/externalArguments.kt b/compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/externalArguments.kt index 29b5a273c70..81a0eccec94 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/externalArguments.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/externalArguments.kt @@ -6,7 +6,7 @@ import kotlin.reflect.KProperty fun testLambdaArgumentSmartCast(foo: Int?) { val v = run { if (foo != null) - return@run foo + return@run foo 15 } } diff --git a/compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/intersectionTypes.kt b/compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/intersectionTypes.kt index 36e561b161c..72a7ff346dd 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/intersectionTypes.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/intersectionTypes.kt @@ -42,4 +42,4 @@ fun testDeMorgan2(x: Any?) { x.length x.inc() } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/nullabilitySmartcastWhenNullability.kt b/compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/nullabilitySmartcastWhenNullability.kt index 3aad95c869b..247bcf9074c 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/nullabilitySmartcastWhenNullability.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/nullabilitySmartcastWhenNullability.kt @@ -54,4 +54,4 @@ fun testNotNullWhenNotNull (x: Int?) { } x.dec() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/operatorsTests/andOperator.kt b/compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/operatorsTests/andOperator.kt index 1cc38efdac6..38ba78827b5 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/operatorsTests/andOperator.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/operatorsTests/andOperator.kt @@ -78,4 +78,4 @@ fun falsefalse(x: Any?) { x.length x.inc() } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/operatorsTests/orOperator.kt b/compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/operatorsTests/orOperator.kt index c9b7b2d305c..42ea9a96433 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/operatorsTests/orOperator.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/operatorsTests/orOperator.kt @@ -75,4 +75,4 @@ fun falsefalse(x: Any?) { x.length x.inc() } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/applyInsideCoroutine.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/applyInsideCoroutine.fir.kt index 9aacb4b796b..93bc5b88964 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/applyInsideCoroutine.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/applyInsideCoroutine.fir.kt @@ -34,4 +34,4 @@ val test3 = generate { interface A object B : A -object C : A \ No newline at end of file +object C : A diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/applyInsideCoroutine.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/applyInsideCoroutine.kt index c19433676f1..8aee3020c07 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/applyInsideCoroutine.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/applyInsideCoroutine.kt @@ -9,21 +9,21 @@ class Controller { fun generate(g: suspend Controller.() -> Unit): S = TODO() -val test1 = generate { +val test1 = generate { apply { yield(4) } } -val test2 = generate { +val test2 = generate { yield(B) apply { yield(C) } } -val test3 = generate { - this.let { +val test3 = generate { + this.let { yield(B) } @@ -34,4 +34,4 @@ val test3 = ::bar) test1(::bar) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/extensionWithNonValuableConstraints.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/extensionWithNonValuableConstraints.fir.kt index d8915915fa1..da066ee810a 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/extensionWithNonValuableConstraints.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/extensionWithNonValuableConstraints.fir.kt @@ -59,4 +59,4 @@ val test7 = generate { val test8 = generate { safeExtension() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/extensionWithNonValuableConstraints.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/extensionWithNonValuableConstraints.kt index 492567df776..ffdda40308c 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/extensionWithNonValuableConstraints.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/extensionWithNonValuableConstraints.kt @@ -29,7 +29,7 @@ val test1 = generate { baseExtension() } -val test2 = generate { +val test2 = generate { baseExtension() } @@ -38,25 +38,25 @@ val test3 = generate { outNullableAnyExtension() } -val test4 = generate { +val test4 = generate { outNullableAnyExtension() } -val test5 = generate { +val test5 = generate { yield(42) outAnyExtension() } -val test6 = generate { +val test6 = generate { yield("bar") invNullableAnyExtension() } -val test7 = generate { - yield("baz") +val test7 = generate { + yield("baz") genericExtension() } val test8 = generate { safeExtension() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/extensionsWithNonValuableConstraintsGenericBase.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/extensionsWithNonValuableConstraintsGenericBase.fir.kt index d81a3c85025..7811e1ce8ef 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/extensionsWithNonValuableConstraintsGenericBase.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/extensionsWithNonValuableConstraintsGenericBase.fir.kt @@ -49,4 +49,4 @@ val test5 = generateSpecific { val test6 = generateSpecific { stringBase() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/extensionsWithNonValuableConstraintsGenericBase.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/extensionsWithNonValuableConstraintsGenericBase.kt index dbab0a5e154..0b971c8be82 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/extensionsWithNonValuableConstraintsGenericBase.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/extensionsWithNonValuableConstraintsGenericBase.kt @@ -28,11 +28,11 @@ val test1 = generate { yield("foo") } -val test2 = generate { +val test2 = generate { starBase() } -val test3 = generate { +val test3 = generate { yield("bar") stringBase() } @@ -47,6 +47,6 @@ val test5 = generateSpecific { stringBase() } -val test6 = generateSpecific { +val test6 = generateSpecific { stringBase() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/incorrectCalls.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/incorrectCalls.fir.kt index cf1b8c54790..955a0c766fd 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/incorrectCalls.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/incorrectCalls.fir.kt @@ -33,4 +33,4 @@ val test3 = generate { val test4 = generate { yield(3) barReturnType() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/incorrectCalls.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/incorrectCalls.kt index 867437b8ba7..befdfa9876a 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/incorrectCalls.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/incorrectCalls.kt @@ -25,12 +25,12 @@ val test2 = generate { notYield(3) } -val test3 = generate { +val test3 = generate { yield(3) yieldBarReturnType(3) } -val test4 = generate { +val test4 = generate { yield(3) barReturnType() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/inferCoroutineTypeInOldVersion.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/inferCoroutineTypeInOldVersion.kt index 6b0fbee7b15..37c751dc857 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/inferCoroutineTypeInOldVersion.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/inferCoroutineTypeInOldVersion.kt @@ -17,11 +17,11 @@ val member = build { add(42) } -val memberWithoutAnn = wrongBuild { +val memberWithoutAnn = wrongBuild { add(42) } -val extension = build { +val extension = build { extensionAdd("foo") } diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt35684.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt35684.fir.kt index f55f52aba1a..a6573fc2c0f 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt35684.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt35684.fir.kt @@ -32,4 +32,4 @@ interface Inv { fun yield(element: T) } -fun materialize(): Inv = TODO() \ No newline at end of file +fun materialize(): Inv = TODO() diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt36220.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt36220.fir.kt index bd5060ad377..08380daa150 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt36220.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt36220.fir.kt @@ -17,4 +17,4 @@ fun main() { parse { it.toInt() } serialize { it.toString() } } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt36220.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt36220.kt index c8ed5d607a5..f6cf08db1ce 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt36220.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt36220.kt @@ -13,8 +13,8 @@ class TypeDefinition { fun defineType(@BuilderInference definition: TypeDefinition.() -> Unit): Unit = TODO() fun main() { - defineType { + defineType { parse { it.toInt() } - serialize { it.toString() } + serialize { it.toString() } } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt41308.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt41308.fir.kt index 14e081cacc7..f31747fa9b1 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt41308.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt41308.fir.kt @@ -4,6 +4,6 @@ fun main() { sequence { val list: List? = null val outputList = ")!>list ?: listOf() - yieldAll(outputList) + yieldAll(outputList) } } diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/recursiveGenerators2.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/recursiveGenerators2.fir.kt index c2f11e09f17..ad6c02c3c56 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/recursiveGenerators2.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/recursiveGenerators2.fir.kt @@ -21,4 +21,4 @@ val test1 = generate { yieldGenerate { yield(4) } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/recursiveGenerators2.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/recursiveGenerators2.kt index 7be80eb1d6e..343ff7160d9 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/recursiveGenerators2.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/recursiveGenerators2.kt @@ -18,7 +18,7 @@ suspend fun GenericController>.yieldGenerate(g: suspend GenericContr val test1 = generate { // TODO: KT-15185 - yieldGenerate { + yieldGenerate { yield(4) } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/resolveUsualCallWithBuilderInference.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/resolveUsualCallWithBuilderInference.kt index e79f2c2119c..1a8fad0022b 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/resolveUsualCallWithBuilderInference.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/resolveUsualCallWithBuilderInference.kt @@ -24,11 +24,11 @@ val member = build { add(42) } -val memberWithoutAnn = wrongBuild { +val memberWithoutAnn = wrongBuild { add(42) } -val extension = build { +val extension = build { extensionAdd("foo") } diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/suspendCallsWithErrors.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/suspendCallsWithErrors.fir.kt index 32d9df49a67..7da1401ab2a 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/suspendCallsWithErrors.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/suspendCallsWithErrors.fir.kt @@ -21,4 +21,4 @@ val test1 = generate { val test2: Int = generate { yield(A()) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/suspendCallsWithErrors.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/suspendCallsWithErrors.kt index 006b57f0ff3..e55c7eb1b07 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/suspendCallsWithErrors.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/suspendCallsWithErrors.kt @@ -15,10 +15,10 @@ fun generate(@BuilderInference g: suspend Controller.() -> Unit): S = TOD class A -val test1 = generate { +val test1 = generate { yield(A) } -val test2: Int = generate { - yield(A()) -} \ No newline at end of file +val test2: Int = generate { + yield(A()) +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/suspendCallsWrongUpperBound.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/suspendCallsWrongUpperBound.fir.kt index 7a585a63ab7..5cb3cc89a30 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/suspendCallsWrongUpperBound.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/suspendCallsWrongUpperBound.fir.kt @@ -10,4 +10,4 @@ fun generate(g: suspend Controller.() -> Unit): S = TODO() val test = generate { yield("foo") -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/suspendCallsWrongUpperBound.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/suspendCallsWrongUpperBound.kt index 78b722505fc..cef8b8759be 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/suspendCallsWrongUpperBound.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/suspendCallsWrongUpperBound.kt @@ -8,6 +8,6 @@ class Controller { fun generate(g: suspend Controller.() -> Unit): S = TODO() -val test = generate { +val test = generate { yield("foo") -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/useInferenceInformationFromExtension.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/useInferenceInformationFromExtension.fir.kt index db4efb8fc5d..897aceff9c5 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/useInferenceInformationFromExtension.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/useInferenceInformationFromExtension.fir.kt @@ -30,4 +30,4 @@ val extension = generate { val safeExtension = generate { safeExtensionYield("foo") -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/useInferenceInformationFromExtension.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/useInferenceInformationFromExtension.kt index bc2077c95d0..ed52208c740 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/useInferenceInformationFromExtension.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/useInferenceInformationFromExtension.kt @@ -24,10 +24,10 @@ val normal = generate { yield(42) } -val extension = generate { +val extension = generate { extensionYield("foo") } val safeExtension = generate { safeExtensionYield("foo") -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/withUninferredParameter.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/withUninferredParameter.kt index d085841f48e..ccd4f6cae80 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/withUninferredParameter.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/withUninferredParameter.kt @@ -8,7 +8,7 @@ class GenericController { fun generate(g: suspend GenericController.(S) -> Unit): S = TODO() -val test1 = generate { +val test1 = generate { yield(4) } diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/kt18292.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/kt18292.fir.kt index 8061049251e..f0ee16f3589 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/kt18292.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/kt18292.fir.kt @@ -16,4 +16,4 @@ suspend fun fib(n: Long) = n < 2 -> n else -> fib(n - 1).await() + fib(n - 2).await() } - } \ No newline at end of file + } diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/kt18292.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/kt18292.kt index 893ff1442e1..508c6b911a0 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/kt18292.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/kt18292.kt @@ -14,6 +14,6 @@ suspend fun fib(n: Long) = async { when { n < 2 -> n - else -> fib(n - 1).await() + fib(n - 2).await() + else -> fib(n - 1).await() + fib(n - 2).await() } - } \ No newline at end of file + } diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/lambdaExpectedType.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/lambdaExpectedType.kt index bfa44b2e1eb..91441f5f00d 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/lambdaExpectedType.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/lambdaExpectedType.kt @@ -21,7 +21,7 @@ fun foo() { builder { 1 } val x = { 1 } - builder(x) + builder(x) builder({1} as (suspend () -> Int)) var i: Int = 1 @@ -29,10 +29,10 @@ fun foo() { i = genericBuilder { 1 } genericBuilder { 1 } genericBuilder { 1 } - genericBuilder { "" } + genericBuilder { "" } val y = { 1 } - genericBuilder(y) + genericBuilder(y) unitBuilder {} unitBuilder { 1 } @@ -44,7 +44,7 @@ fun foo() { val s: String = manyArgumentsBuilder({}, { "" }) { 1 } manyArgumentsBuilder({}, { "" }, { 1 }) - manyArgumentsBuilder({}, { 1 }, { 2 }) + manyArgumentsBuilder({}, { 1 }, { 2 }) severalParamsInLambda { x, y -> x checkType { _() } diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendCoroutineOrReturn.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendCoroutineOrReturn.kt index 17d3cb1ef20..39228ce35c4 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendCoroutineOrReturn.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendCoroutineOrReturn.kt @@ -19,7 +19,7 @@ class Controller { suspend fun yieldString(value: String) = suspendCoroutineUninterceptedOrReturn { it.resume(1) it checkType { _>() } - it.resume("") + it.resume("") // We can return anything here, 'suspendCoroutineUninterceptedOrReturn' is not very type-safe // Also we can call resume and then return the value too, but it's still just our problem diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendCoroutineOrReturn_1_2.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendCoroutineOrReturn_1_2.kt index 3ca0e0a7f13..35cb9f5f308 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendCoroutineOrReturn_1_2.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendCoroutineOrReturn_1_2.kt @@ -20,7 +20,7 @@ class Controller { suspend fun yieldString(value: String) = suspendCoroutineUninterceptedOrReturn { it.resume(1) it checkType { _>() } - it.resume("") + it.resume("") // We can return anything here, 'suspendCoroutineUninterceptedOrReturn' is not very type-safe // Also we can call resume and then return the value too, but it's still just our problem diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendExternalFunctions.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendExternalFunctions.kt index 480695aa678..b804a66d71b 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendExternalFunctions.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendExternalFunctions.kt @@ -36,7 +36,7 @@ fun test() { severalParams("", 89) checkType { _() } // TODO: should we allow somehow to call with passing continuation explicitly? - severalParams("", 89, 6.9) checkType { _() } + severalParams("", 89, 6.9) checkType { _() } "".stringReceiver(1) Any().anyReceiver(1) diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/suspendFunctionN.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/suspendFunctionN.fir.kt index 7a39863d161..d0379d3dd47 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/suspendFunctionN.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/suspendFunctionN.fir.kt @@ -1,4 +1,4 @@ -// JAVAC_SKIP +// SKIP_JAVAC typealias Test1 = SuspendFunction0 typealias Test2 = kotlin.SuspendFunction0 -typealias Test3 = kotlin.coroutines.SuspendFunction0 \ No newline at end of file +typealias Test3 = kotlin.coroutines.SuspendFunction0 diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/suspendFunctionN.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/suspendFunctionN.kt index 0ca30dc5602..59bd0c5fce7 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/suspendFunctionN.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/suspendFunctionN.kt @@ -1,4 +1,4 @@ -// JAVAC_SKIP +// SKIP_JAVAC typealias Test1 = SuspendFunction0 typealias Test2 = kotlin.SuspendFunction0 -typealias Test3 = kotlin.coroutines.SuspendFunction0 \ No newline at end of file +typealias Test3 = kotlin.coroutines.SuspendFunction0 diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctions.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctions.kt index 86402fb4a75..4b5b776aa61 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctions.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctions.kt @@ -37,7 +37,7 @@ fun test() { severalParams("", 89) checkType { _() } // TODO: should we allow somehow to call with passing continuation explicitly? - severalParams("", 89, 6.9) checkType { _() } - severalParams("", 89, this as Continuation) checkType { _() } + severalParams("", 89, 6.9) checkType { _() } + severalParams("", 89, this as Continuation) checkType { _() } } } diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/tryCatchLambda.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/tryCatchLambda.kt index cdbc394658d..4e92e90e6b1 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/tryCatchLambda.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/coroutines/tryCatchLambda.kt @@ -8,10 +8,10 @@ fun genericBuilder(c: suspend () -> T): T = null!! fun foo() { var result = "" genericBuilder { - try { + try { await("") } catch(e: Exception) { - result = "fail" + result = "fail" } } } diff --git a/compiler/testData/diagnostics/testsWithStdLib/elvisOnJavaList.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/elvisOnJavaList.fir.kt index 9c95f9f8929..646570072b9 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/elvisOnJavaList.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/elvisOnJavaList.fir.kt @@ -16,4 +16,4 @@ public class P { fun foo(c: P): MutableList { // Error should be here: see KT-8168 Typechecker fails for platform collection type return c.getList() ?: listOf() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/elvisOnJavaList.kt b/compiler/testData/diagnostics/testsWithStdLib/elvisOnJavaList.kt index 5a339692f2f..8fcea40f606 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/elvisOnJavaList.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/elvisOnJavaList.kt @@ -15,5 +15,5 @@ public class P { fun foo(c: P): MutableList { // Error should be here: see KT-8168 Typechecker fails for platform collection type - return c.getList() ?: listOf() -} \ No newline at end of file + return c.getList() ?: listOf() +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/experimental/experimentalOnWholeModule.txt b/compiler/testData/diagnostics/testsWithStdLib/experimental/experimentalOnWholeModule.txt index 0a986b5f95c..5c2ed887dd5 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/experimental/experimentalOnWholeModule.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/experimental/experimentalOnWholeModule.txt @@ -12,10 +12,10 @@ package api { } } - // -- Module: -- package package usage { public fun use(): kotlin.Unit } + diff --git a/compiler/testData/diagnostics/testsWithStdLib/experimental/useExperimentalOnWholeModule.txt b/compiler/testData/diagnostics/testsWithStdLib/experimental/useExperimentalOnWholeModule.txt index f3f4d5ae8c3..a9e0900d491 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/experimental/useExperimentalOnWholeModule.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/experimental/useExperimentalOnWholeModule.txt @@ -12,10 +12,10 @@ package api { } } - // -- Module: -- package package usage { public fun use(): kotlin.Unit } + diff --git a/compiler/testData/diagnostics/testsWithStdLib/factoryPattern/overloadByLambdaReturnType_disabled.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/factoryPattern/overloadByLambdaReturnType_disabled.fir.kt index c24133ec13b..51f9e0c49da 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/factoryPattern/overloadByLambdaReturnType_disabled.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/factoryPattern/overloadByLambdaReturnType_disabled.fir.kt @@ -20,17 +20,17 @@ fun takeString(s: String) {} fun takeInt(s: Int) {} fun test_1() { - val x = create { "" } + val x = create { "" } takeString(x) } fun test_2() { - val x = create { 1 } + val x = create { 1 } takeInt(x) } fun test_3() { - val x = create { 1.0 } + val x = create { 1.0 } } @OverloadResolutionByLambdaReturnType @@ -38,11 +38,11 @@ fun create(x: K, f: (K) -> Int): Int = 1 fun create(x: T, f: (T) -> String): String = "" fun test_4() { - val x = create("") { "" } + val x = create("") { "" } takeString(x) } fun test_5() { - val x = create("") { 1 } + val x = create("") { 1 } takeInt(x) } diff --git a/compiler/testData/diagnostics/testsWithStdLib/factoryPattern/overloadByLambdaReturnType_disabled.kt b/compiler/testData/diagnostics/testsWithStdLib/factoryPattern/overloadByLambdaReturnType_disabled.kt index 2e15db0c30b..aa9d33be560 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/factoryPattern/overloadByLambdaReturnType_disabled.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/factoryPattern/overloadByLambdaReturnType_disabled.kt @@ -45,4 +45,4 @@ fun test_4() { fun test_5() { val x = create("") { 1 } takeInt(x) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/implicitCastToAny.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/implicitCastToAny.fir.kt index 71bd847a1a7..86f3ab3c156 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/implicitCastToAny.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/implicitCastToAny.fir.kt @@ -31,4 +31,4 @@ fun test3(word: String) = else { System.out?.println(word) // Unit? } - } \ No newline at end of file + } diff --git a/compiler/testData/diagnostics/testsWithStdLib/implicitCastToAny.kt b/compiler/testData/diagnostics/testsWithStdLib/implicitCastToAny.kt index 4354adc0bc2..ac420b4dd63 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/implicitCastToAny.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/implicitCastToAny.kt @@ -6,20 +6,20 @@ val smallWords = hashSetOf() fun test1(word: String) = run { if (word.length > 4) { - longWords++ + longWords++ } else { - smallWords.add(word) + smallWords.add(word) } } fun test2(word: String) = run { if (word.length > 4) { - if (word.startsWith("a")) longWords++ + if (word.startsWith("a")) longWords++ } else { - smallWords.add(word) + smallWords.add(word) } } @@ -31,4 +31,4 @@ fun test3(word: String) = else { System.out?.println(word) // Unit? } - } \ No newline at end of file + } diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/exactAnnotation.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/exactAnnotation.fir.kt index 8f28742410d..ea3d533660e 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/exactAnnotation.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/exactAnnotation.fir.kt @@ -9,4 +9,4 @@ fun test1(l: List) { val i: Int = l.firstTyped() val s: String = l.firstTyped() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/exactAnnotation.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/exactAnnotation.kt index 9d67807de36..613f83cb9cd 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/exactAnnotation.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/exactAnnotation.kt @@ -8,5 +8,5 @@ fun test1(l: List) { val i: Int = l.firstTyped() - val s: String = l.firstTyped() -} \ No newline at end of file + val s: String = l.firstTyped() +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/exactAnnotationWithUpperBoundConstraint.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/exactAnnotationWithUpperBoundConstraint.kt index 3a37dabbd40..032a420dbde 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/exactAnnotationWithUpperBoundConstraint.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/exactAnnotationWithUpperBoundConstraint.kt @@ -14,4 +14,4 @@ fun test() { r2 map.getOrDefault_Exact("y", "string") -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/kt26698.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/kt26698.kt index 12be925638c..3412d85ca5e 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/kt26698.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/kt26698.kt @@ -18,6 +18,6 @@ fun <@kotlin.internal.OnlyInputTypes T : Base> fooB(a: T, b: T) {} fun usage(x: CX, y: CY) { foo(x, y) // expected err, got err - fooA(x, y) // expected err, got ok - fooB(x, y) // expected err, got ok -} \ No newline at end of file + fooA(x, y) // expected err, got ok + fooB(x, y) // expected err, got ok +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/kt29307.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/kt29307.fir.kt index 9e4250b2230..e9c32749674 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/kt29307.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/kt29307.fir.kt @@ -29,4 +29,4 @@ fun test_5(map: Map, a: A) { fun test_6(map: Map, b: B) { map.get(b) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/kt29307.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/kt29307.kt index 35efb85fc5b..d95d4862396 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/kt29307.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/kt29307.kt @@ -4,7 +4,7 @@ // ISSUE: KT-29307 fun test_1(map: Map) { - val x = map[42] // OK + val x = map[42] // OK } open class A @@ -12,7 +12,7 @@ open class A class B : A() fun test_2(map: Map) { - val x = map[42] + val x = map[42] } fun test_3(m: Map<*, String>) { @@ -29,4 +29,4 @@ fun test_5(map: Map, a: A) { fun test_6(map: Map, b: B) { map.get(b) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/noInferAndLowPriority.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/noInferAndLowPriority.kt index 81f5d829ff4..2a1a51baed4 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/noInferAndLowPriority.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/noInferAndLowPriority.kt @@ -11,6 +11,6 @@ public fun Iterable.contains1(element: @kotlin.internal.NoInfer T): Boole fun test() { - val a: Boolean = listOf(1).contains1("") + val a: Boolean = listOf(1).contains1("") val b: Boolean = listOf(1).contains1(1) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/noInferAnnotation.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/noInferAnnotation.fir.kt index dc5e2fb9d17..e1de728cd58 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/noInferAnnotation.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/noInferAnnotation.fir.kt @@ -30,4 +30,4 @@ fun assertEquals1(e1: T, e2: @kotlin.internal.NoInfer T): Boolean = true fun test(s: String) { assertEquals1(s, 11) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/noInferAnnotation.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/noInferAnnotation.kt index b46a6e56057..1b52856d113 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/noInferAnnotation.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/noInferAnnotation.kt @@ -11,23 +11,23 @@ fun @kotlin.internal.NoInfer T.test2(t1: T): T = t1 fun test3(t1: @kotlin.internal.NoInfer T): T = t1 fun usage() { - test1(1, "312") - 1.test2("") - test3("") + test1(1, "312") + 1.test2("") + test3("") } @Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE") fun List.contains1(e: @kotlin.internal.NoInfer T): Boolean = true fun test(i: Int?, a: Any, l: List) { - l.contains1(a) - l.contains1("") - l.contains1(i) + l.contains1(a) + l.contains1("") + l.contains1(i) } @Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE") fun assertEquals1(e1: T, e2: @kotlin.internal.NoInfer T): Boolean = true fun test(s: String) { - assertEquals1(s, 11) -} \ No newline at end of file + assertEquals1(s, 11) +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesAndLowPriority.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesAndLowPriority.kt index 9a539acbe0e..b7ca949ae29 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesAndLowPriority.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesAndLowPriority.kt @@ -19,9 +19,9 @@ public fun Map.get1(key: Any?): Int = null!! public fun <@kotlin.internal.OnlyInputTypes K, V> Map.get1(key: K): V? = null!! fun test(map: Map) { - val a: Int = listOf(1).contains1("") + val a: Int = listOf(1).contains1("") val b: Boolean = listOf(1).contains1(1) val c: String? = map.get1("") val d: String? = map.get1(1) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesAndTopLevelCapturedTypes.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesAndTopLevelCapturedTypes.kt index 9805dbd380a..9ac814dd9ad 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesAndTopLevelCapturedTypes.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesAndTopLevelCapturedTypes.kt @@ -22,12 +22,12 @@ fun test( invOut.onlyOut(42) invOut.onlyOut(1L) - invOut.onlyOutUB("str") - invStar.onlyOutUB(0) + invOut.onlyOutUB("str") + invStar.onlyOutUB(0) invOut.onlyOutUB(42) invOut.onlyOutUB(1L) - invIn.onlyIn("str") + invIn.onlyIn("str") invIn.onlyIn(42) invIn.onlyIn(1L) } @@ -67,8 +67,8 @@ class Test5 { set(value) { if (value != null) { val a = a - require(a != null && value in a.children) + require(a != null && value in a.children) } field = value } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesCaptured.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesCaptured.kt index b6b5677fcae..497171ac320 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesCaptured.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesCaptured.kt @@ -18,7 +18,7 @@ class Out // ------------------------------------------------------- fun test_0(x: Inv2, list: List>) { - list.foo(x) + list.foo(x) } // ------------------------- Inv ------------------------- @@ -36,11 +36,11 @@ fun test_3(x: Inv, list: List>) { } fun test_4(x: Inv, list: List>) { - list.contains1(x) + list.contains1(x) } fun test_5(x: Inv, list: List>) { - list.contains1(x) + list.contains1(x) } fun test_6(x: Inv, list: List>) { diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesUpperBound.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesUpperBound.kt index fab6066598d..4a26d8b6ebe 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesUpperBound.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesUpperBound.kt @@ -7,7 +7,7 @@ class Inv class Out fun foo(i: Inv, o: Out) { - bar(i, o) + bar(i, o) } fun <@kotlin.internal.OnlyInputTypes K> bar(r: Inv, o: Out): K = TODO() diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/resolveWithOnlyInputTypesAnnotation.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/resolveWithOnlyInputTypesAnnotation.kt index a8324c8a917..a66f670aeb8 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/resolveWithOnlyInputTypesAnnotation.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/resolveWithOnlyInputTypesAnnotation.kt @@ -23,4 +23,4 @@ public fun <@kotlin.internal.OnlyInputTypes T> expect1(expected: T, block: () -> fun test() { expect1(2) { byteArrayOf(1, 2, 3).indexOf(3) } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/callableReferenceOnParameter.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/callableReferenceOnParameter.kt index ae0f37a8578..55504722547 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/inference/callableReferenceOnParameter.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/inference/callableReferenceOnParameter.kt @@ -5,4 +5,4 @@ internal class Z { inline fun compute(key: String, producer: () -> String): String { return map.getOrPut(key, ::producer) } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/complexInterdependentInputOutputTypes.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/complexInterdependentInputOutputTypes.fir.kt index f7f948f907a..c997fe35ed9 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/complexInterdependentInputOutputTypes.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/complexInterdependentInputOutputTypes.fir.kt @@ -38,4 +38,4 @@ private fun containsNullable( pairs, { option, key -> option.withParameterObjectNullable(createGetParameterObject(plant, key)) }, assertionCreator -) \ No newline at end of file +) diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/fixIndependentVariables.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/fixIndependentVariables.fir.kt index 404707f49d8..333ac05e169 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/fixIndependentVariables.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/fixIndependentVariables.fir.kt @@ -8,4 +8,4 @@ fun materialize(): T = null as T fun main(x: List?) { foo(x?.map { Foo(it) } ?: listOf(materialize>())) {} -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/kt11266.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/kt11266.kt index ba3299f2b20..27ada61349a 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/inference/kt11266.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/inference/kt11266.kt @@ -1,4 +1,4 @@ // !WITH_NEW_INFERENCE // NI_EXPECTED_FILE -fun foo(first: Array, second: Array) = Pair(first.toCollection(), second.toCollection()) \ No newline at end of file +fun foo(first: Array, second: Array) = Pair(first.toCollection(), second.toCollection()) diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/kt27772.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/kt27772.fir.kt index 12ae9041270..702005d9ff0 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/inference/kt27772.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/inference/kt27772.fir.kt @@ -6,4 +6,4 @@ fun foo(resources: List) { fun bar(resources: List) { resources.map { runCatching { it } }.mapNotNull { it.getOrNull() } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/kt27772.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/kt27772.kt index 3eb12f63243..dcbcf3013bf 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/inference/kt27772.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/inference/kt27772.kt @@ -1,9 +1,9 @@ // !WITH_NEW_INFERENCE fun foo(resources: List) { - resources.map { runCatching { it } }.mapNotNull { it.getOrNull() } + resources.map { runCatching { it } }.mapNotNull { it.getOrNull() } } fun bar(resources: List) { resources.map { runCatching { it } }.mapNotNull { it.getOrNull() } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/kt36249.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/kt36249.fir.kt index 933682a0710..1ed52d5f5e2 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/inference/kt36249.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/inference/kt36249.fir.kt @@ -1,4 +1,4 @@ -// !DIAGNOSTICS: -UNUSED_PARAMETER UNUSED_VARIABLE -UNUSED_EXPRESSION +// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE -UNUSED_EXPRESSION import kotlin.reflect.KClass fun select(vararg classes: KClass): T? { diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/kt36249.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/kt36249.kt index 67227acfb08..c26d666b6e5 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/inference/kt36249.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/inference/kt36249.kt @@ -1,4 +1,4 @@ -// !DIAGNOSTICS: -UNUSED_PARAMETER UNUSED_VARIABLE -UNUSED_EXPRESSION +// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE -UNUSED_EXPRESSION import kotlin.reflect.KClass fun select(vararg classes: KClass): T? { diff --git a/compiler/testData/diagnostics/testsWithStdLib/java/concurrentHashMapContains.kt b/compiler/testData/diagnostics/testsWithStdLib/java/concurrentHashMapContains.kt index 0e7c47ae0f1..899ce6b966b 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/java/concurrentHashMapContains.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/java/concurrentHashMapContains.kt @@ -29,8 +29,8 @@ fun main() { "" in (hm as Map) "" !in (hm as Map) - 1 in (hm as Map) - 1 !in (hm as Map) + 1 in (hm as Map) + 1 !in (hm as Map) val a = A() "" in a @@ -45,8 +45,8 @@ fun main() { "" in (a as Map) "" !in (a as Map) - 1 in (a as Map) - 1 !in (a as Map) + 1 in (a as Map) + 1 !in (a as Map) val b = B() "" in b @@ -59,8 +59,8 @@ fun main() { "" in (b as Map) "" !in (b as Map) - 1 in (b as Map) - 1 !in (b as Map) + 1 in (b as Map) + 1 !in (b as Map) // Actually, we could've allow calls here because the owner explicitly declared as operator, but semantics is still weird val c = C() @@ -74,7 +74,7 @@ fun main() { "" in (c as Map) "" !in (c as Map) - 1 in (c as Map) - 1 !in (c as Map) + 1 in (c as Map) + 1 !in (c as Map) } diff --git a/compiler/testData/diagnostics/testsWithStdLib/java/concurrentHashMapContainsError.kt b/compiler/testData/diagnostics/testsWithStdLib/java/concurrentHashMapContainsError.kt index 6eb609301a1..112a5b35d2c 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/java/concurrentHashMapContainsError.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/java/concurrentHashMapContainsError.kt @@ -29,8 +29,8 @@ fun main() { "" in (hm as Map) "" !in (hm as Map) - 1 in (hm as Map) - 1 !in (hm as Map) + 1 in (hm as Map) + 1 !in (hm as Map) val a = A() "" in a @@ -45,8 +45,8 @@ fun main() { "" in (a as Map) "" !in (a as Map) - 1 in (a as Map) - 1 !in (a as Map) + 1 in (a as Map) + 1 !in (a as Map) val b = B() "" in b @@ -59,8 +59,8 @@ fun main() { "" in (b as Map) "" !in (b as Map) - 1 in (b as Map) - 1 !in (b as Map) + 1 in (b as Map) + 1 !in (b as Map) // Actually, we could've allow calls here because the owner explicitly declared as operator, but semantics is still weird val c = C() @@ -74,7 +74,7 @@ fun main() { "" in (c as Map) "" !in (c as Map) - 1 in (c as Map) - 1 !in (c as Map) + 1 in (c as Map) + 1 !in (c as Map) } diff --git a/compiler/testData/diagnostics/testsWithStdLib/kt7585/delegate.fir.fail b/compiler/testData/diagnostics/testsWithStdLib/kt7585/delegate.fir.fail deleted file mode 100644 index b1cc486f92a..00000000000 --- a/compiler/testData/diagnostics/testsWithStdLib/kt7585/delegate.fir.fail +++ /dev/null @@ -1,17 +0,0 @@ -Failures detected in FirImplicitTypeBodyResolveTransformerAdapter, file: /My.kt -Cause: java.lang.RuntimeException: While resolving call Q|Properties|.R?C|/Properties.calcVal|( = calcVal@fun .(): { - lval y: = x#.plus#(IntegerLiteral(1)) - when () { - CMP(>, y#.compareTo#(IntegerLiteral(0))) -> { - MyBase#.derivedWrapper#() - } - CMP(<, x#.compareTo#(IntegerLiteral(0))) -> { - MyBase#.exoticWrapper#(x#) - } - else -> { - throw java#.lang#.NullPointerException#(String()) - } - } - -} -) diff --git a/compiler/testData/diagnostics/testsWithStdLib/kt7585/delegate.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/kt7585/delegate.fir.kt deleted file mode 100644 index 557e9ba6a6b..00000000000 --- a/compiler/testData/diagnostics/testsWithStdLib/kt7585/delegate.fir.kt +++ /dev/null @@ -1,76 +0,0 @@ -// !WITH_NEW_INFERENCE -// NI_EXPECTED_FILE -// JAVAC_EXPECTED_FILE -// FILE: Base.java - -public interface Base {} - -// FILE: Other.java - -public interface Other {} - -// FILE: Derived.java - -public final class Derived implements Base, Other {} - -// FILE: Exotic.java - -public final class Exotic implements Base, Other { - - int x; - - Exotic(int x) { - this.x = x; - } -} - -// FILE: Properties.java - -import kotlin.jvm.functions.Function0; - -class Val { - - Function0 initializer; - - Val(Function0 initializer) { - this.initializer = initializer; - } - - T getValue(Object instance, Object metadata) { - return initializer.invoke(); - } -} - -class Properties { - static Val calcVal(Function0 initializer) { - return new Val(initializer); - } -} - -// FILE: My.kt - -open class Wrapper(val v: T) - -class DerivedWrapper(v: Derived<*>): Wrapper>(v) - -class ExoticWrapper(v: Exotic): Wrapper(v) - -object MyBase { - - fun derived() = Derived() - fun exotic(x: Int) = Exotic(x) - - fun derivedWrapper() = DerivedWrapper(derived()) - fun exoticWrapper(x: Int) = ExoticWrapper(exotic(x)) -} - -class My(val x: Int) { - val wrapper/*: Wrapper<*>*/ by Properties.calcVal { - val y = x + 1 - when { - y > 0 -> MyBase.derivedWrapper() - x < 0 -> MyBase.exoticWrapper(x) - else -> throw java.lang.NullPointerException("") - } - } -} diff --git a/compiler/testData/diagnostics/testsWithStdLib/kt7585/delegate.kt b/compiler/testData/diagnostics/testsWithStdLib/kt7585/delegate.kt index 557e9ba6a6b..352dc1bbce9 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/kt7585/delegate.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/kt7585/delegate.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // !WITH_NEW_INFERENCE // NI_EXPECTED_FILE // JAVAC_EXPECTED_FILE @@ -28,7 +29,17 @@ public final class Exotic implements Base, Other { import kotlin.jvm.functions.Function0; -class Val { +public class Properties { + static Val calcVal(Function0 initializer) { + return new Val(initializer); + } +} + +// FILE: Val.java + +import kotlin.jvm.functions.Function0; + +public class Val { Function0 initializer; @@ -41,12 +52,6 @@ class Val { } } -class Properties { - static Val calcVal(Function0 initializer) { - return new Val(initializer); - } -} - // FILE: My.kt open class Wrapper(val v: T) diff --git a/compiler/testData/diagnostics/testsWithStdLib/kt7585/delegate.ni.txt b/compiler/testData/diagnostics/testsWithStdLib/kt7585/delegate.ni.txt index 96957778aa1..62354258430 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/kt7585/delegate.ni.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/kt7585/delegate.ni.txt @@ -63,8 +63,8 @@ public interface Other { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -public/*package*/ open class Properties { - public/*package*/ constructor Properties() +public open class Properties { + public constructor Properties() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String @@ -73,6 +73,15 @@ public/*package*/ open class Properties { public/*package*/ open fun calcVal(/*0*/ initializer: (() -> T!)!): Val! } +public open class Val { + public/*package*/ constructor Val(/*0*/ initializer: (() -> T!)!) + public/*package*/ final var initializer: (() -> T!)! + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public/*package*/ open operator fun getValue(/*0*/ instance: kotlin.Any!, /*1*/ metadata: kotlin.Any!): T! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + public open class Wrapper { public constructor Wrapper(/*0*/ v: T) public final val v: T @@ -80,3 +89,4 @@ public open class Wrapper { public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } + diff --git a/compiler/testData/diagnostics/testsWithStdLib/multiplatform/jvmOverloads.txt b/compiler/testData/diagnostics/testsWithStdLib/multiplatform/jvmOverloads.txt index 2aa5ad3d363..d2a4258c3a5 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/multiplatform/jvmOverloads.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/multiplatform/jvmOverloads.txt @@ -3,8 +3,8 @@ package public expect fun foo(/*0*/ x: kotlin.String, /*1*/ y: kotlin.Int = ...): kotlin.Unit - // -- Module: -- package @kotlin.jvm.JvmOverloads public actual fun foo(/*0*/ x: kotlin.String, /*1*/ y: kotlin.Int): kotlin.Unit + diff --git a/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/maps.kt b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/maps.kt index 62f5d79fb7e..332d36329dd 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/maps.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/maps.kt @@ -15,9 +15,9 @@ fun hashMapTest() { x.put(bar(), 1) x.put("", 1) - x[null] = 1 - x[bar()] = 1 - x[""] = nullableInt + x[null] = 1 + x[bar()] = 1 + x[""] = nullableInt x[""] = 1 val b1: MutableMap = x @@ -39,9 +39,9 @@ fun treeMapTest() { x.put(bar(), 1) x.put("", 1) - x[null] = 1 - x[bar()] = 1 - x[""] = nullableInt + x[null] = 1 + x[bar()] = 1 + x[""] = nullableInt x[""] = 1 val b1: MutableMap = x @@ -63,9 +63,9 @@ fun concurrentHashMapTest() { x.put(bar(), 1) x.put("", 1) - x[null] = 1 - x[bar()] = 1 - x[""] = nullableInt + x[null] = 1 + x[bar()] = 1 + x[""] = nullableInt x[""] = 1 val b1: MutableMap = x diff --git a/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/mapsWithNullableKey.kt b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/mapsWithNullableKey.kt index 9fe410d83bd..c64c10ab4f8 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/mapsWithNullableKey.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/mapsWithNullableKey.kt @@ -16,7 +16,7 @@ fun hashMapTest() { x[null] = 1 x[bar()] = 1 - x[""] = nullableInt + x[""] = nullableInt x[""] = 1 val b1: MutableMap = x @@ -41,7 +41,7 @@ fun treeMapTest() { x[null] = 1 x[bar()] = 1 - x[""] = nullableInt + x[""] = nullableInt x[""] = 1 val b1: MutableMap = x diff --git a/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/mapsWithNullableValues.kt b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/mapsWithNullableValues.kt index a2e5ea18187..7f2232822de 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/mapsWithNullableValues.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/mapsWithNullableValues.kt @@ -14,8 +14,8 @@ fun hashMapTest() { x.put(bar(), 1) x.put("", 1) - x[null] = 1 - x[bar()] = 1 + x[null] = 1 + x[bar()] = 1 x[""] = nullableInt x[""] = 1 @@ -38,8 +38,8 @@ fun treeMapTest() { x.put(bar(), 1) x.put("", 1) - x[null] = 1 - x[bar()] = 1 + x[null] = 1 + x[bar()] = 1 x[""] = nullableInt x[""] = 1 diff --git a/compiler/testData/diagnostics/testsWithStdLib/regression/kt-37497.kt b/compiler/testData/diagnostics/testsWithStdLib/regression/kt-37497.kt index e893f7af98c..8b56a5d0cbc 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/regression/kt-37497.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/regression/kt-37497.kt @@ -1,5 +1,5 @@ // FIR_IDENTICAL -// FULL_JDK +// FULL_JDK // Issue: KT-37497 import java.util.* diff --git a/compiler/testData/diagnostics/testsWithStdLib/regression/kt9820_javaFunctionTypeInheritor.kt b/compiler/testData/diagnostics/testsWithStdLib/regression/kt9820_javaFunctionTypeInheritor.kt index acd58d9790b..3c5fa188739 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/regression/kt9820_javaFunctionTypeInheritor.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/regression/kt9820_javaFunctionTypeInheritor.kt @@ -14,5 +14,5 @@ fun useJ(j: J) { } fun jj() { - useJ({}) + useJ({}) } diff --git a/compiler/testData/diagnostics/testsWithStdLib/resolve/hidesMembers2.kt b/compiler/testData/diagnostics/testsWithStdLib/resolve/hidesMembers2.kt index 0781d51bab5..4280141441d 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/resolve/hidesMembers2.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/resolve/hidesMembers2.kt @@ -41,4 +41,4 @@ fun test2(a: A) { forEach() checkType { _() } forEach(1) } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/resolve/javaStaticMembers.kt b/compiler/testData/diagnostics/testsWithStdLib/resolve/javaStaticMembers.kt index b5e670dd9a5..f1532277731 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/resolve/javaStaticMembers.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/resolve/javaStaticMembers.kt @@ -9,4 +9,4 @@ fun ff() { val b = Test?.FOO System.out.println(a + b) System?.out.println(a + b) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/resolve/kt4711.kt b/compiler/testData/diagnostics/testsWithStdLib/resolve/kt4711.kt index d57a6ff4c60..0c9e380f3ab 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/resolve/kt4711.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/resolve/kt4711.kt @@ -7,15 +7,15 @@ fun main() { val startTimeNanos = System.nanoTime() // the problem sits on the next line: - val pi = 4.0.toDouble() * delta * (1..n).reduce( + val pi = 4.0.toDouble() * delta * (1..n).reduce( {t, i -> val x = (i - 0.5) * delta - t + 1.0 / (1.0 + x * x) + t + 1.0 / (1.0 + x * x) }) // !!! pi has error type here val elapseTime = (System.nanoTime() - startTimeNanos) / 1e9 - println("pi_sequential_reduce $pi $n $elapseTime") + println("pi_sequential_reduce $pi $n $elapseTime") } diff --git a/compiler/testData/diagnostics/testsWithStdLib/resolve/samAgainstFunctionalType.kt b/compiler/testData/diagnostics/testsWithStdLib/resolve/samAgainstFunctionalType.kt index 07800865910..46db0309bb9 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/resolve/samAgainstFunctionalType.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/resolve/samAgainstFunctionalType.kt @@ -27,4 +27,4 @@ fun test() { StaticOverrides.A.foo {} checkType { _() } StaticOverrides.B.foo {} checkType { _() } StaticOverrides.C.foo {} checkType { _() } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/resolve/samOverloadsWithGenerics.kt b/compiler/testData/diagnostics/testsWithStdLib/resolve/samOverloadsWithGenerics.kt index 91d34f27ca1..d322cc0befb 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/resolve/samOverloadsWithGenerics.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/resolve/samOverloadsWithGenerics.kt @@ -22,4 +22,4 @@ class Foo { fun test() { Foo().foo {} checkType { _() } Foo().bar {} checkType { _() } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/resolve/samOverloadsWithGenericsWithoutRefinedSams.kt b/compiler/testData/diagnostics/testsWithStdLib/resolve/samOverloadsWithGenericsWithoutRefinedSams.kt index 3ec7ab2247e..1570fa4336c 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/resolve/samOverloadsWithGenericsWithoutRefinedSams.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/resolve/samOverloadsWithGenericsWithoutRefinedSams.kt @@ -23,4 +23,4 @@ class Foo { fun test() { Foo().foo {} checkType { _() } Foo().bar {} checkType { _() } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/resolve/samOverloadsWithKtFunction.kt b/compiler/testData/diagnostics/testsWithStdLib/resolve/samOverloadsWithKtFunction.kt index 59d45e72309..f0ecaba389c 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/resolve/samOverloadsWithKtFunction.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/resolve/samOverloadsWithKtFunction.kt @@ -17,4 +17,4 @@ public class Foo { // FILE: 1.kt fun bar() { Foo().test {} checkType { _() } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/resolve/samOverloadsWithKtFunctionWithoutRefinedSams.kt b/compiler/testData/diagnostics/testsWithStdLib/resolve/samOverloadsWithKtFunctionWithoutRefinedSams.kt index cb05faaaac3..b012f4cfda0 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/resolve/samOverloadsWithKtFunctionWithoutRefinedSams.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/resolve/samOverloadsWithKtFunctionWithoutRefinedSams.kt @@ -19,4 +19,4 @@ public class Foo { // FILE: 1.kt fun bar() { Foo().test {} checkType { _() } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/smartcasts/forEachSafe.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/smartcasts/forEachSafe.fir.kt index 3eb045d61d2..623169cc967 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/smartcasts/forEachSafe.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/smartcasts/forEachSafe.fir.kt @@ -9,4 +9,4 @@ fun indexOfMax(a: IntArray): Int? { } } return maxI -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/smartcasts/forEachSafe.kt b/compiler/testData/diagnostics/testsWithStdLib/smartcasts/forEachSafe.kt index ecd067eed3b..7a349d7e040 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/smartcasts/forEachSafe.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/smartcasts/forEachSafe.kt @@ -4,9 +4,9 @@ fun indexOfMax(a: IntArray): Int? { var maxI: Int? = null a.forEachIndexed { i, value -> - if (maxI == null || value >= a[maxI]) { + if (maxI == null || value >= a[maxI]) { maxI = i } } return maxI -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/smartcasts/forEachUnsafe.kt b/compiler/testData/diagnostics/testsWithStdLib/smartcasts/forEachUnsafe.kt index 779a06a60e5..6b97b352a1b 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/smartcasts/forEachUnsafe.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/smartcasts/forEachUnsafe.kt @@ -11,4 +11,4 @@ fun indexOfMax(a: IntArray): Int? { } } return maxI -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/targetedBuiltIns/unsupportedFeature.kt b/compiler/testData/diagnostics/testsWithStdLib/targetedBuiltIns/unsupportedFeature.kt index 3b81ee3d9ce..ab99897f682 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/targetedBuiltIns/unsupportedFeature.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/targetedBuiltIns/unsupportedFeature.kt @@ -28,7 +28,7 @@ interface A2 : List { override fun stream(): java.util.stream.Stream = null!! } -class B : Throwable("", null, false, false) +class B : Throwable("", null, false, false) class B1 : RuntimeException() { override fun fillInStackTrace(): Throwable { // 'override' keyword must be prohibited, as it was in 1.0.x diff --git a/compiler/testData/diagnostics/testsWithStdLib/tryCatch/assignTry.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/tryCatch/assignTry.fir.kt index abf739ca63f..beee087680e 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/tryCatch/assignTry.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/tryCatch/assignTry.fir.kt @@ -108,4 +108,4 @@ fun test10() { 42 } x.length -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/tryCatch/assignTry.kt b/compiler/testData/diagnostics/testsWithStdLib/tryCatch/assignTry.kt index faf1a1e9a44..c9ebce89b95 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/tryCatch/assignTry.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/tryCatch/assignTry.kt @@ -12,8 +12,8 @@ fun test2() { catch (e: ExcA) { null } - catch (e: ExcB) { - 10 + catch (e: ExcB) { + 10 } s.length } @@ -108,4 +108,4 @@ fun test10() { 42 } x.length -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/tryCatch/falseNegativeSmartcasts_after.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/tryCatch/falseNegativeSmartcasts_after.fir.kt index 511efb38d57..cf7cd637230 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/tryCatch/falseNegativeSmartcasts_after.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/tryCatch/falseNegativeSmartcasts_after.fir.kt @@ -17,4 +17,4 @@ fun test1(s1: String?) { s.length } s.length -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/tryCatch/falseNegativeSmartcasts_after.kt b/compiler/testData/diagnostics/testsWithStdLib/tryCatch/falseNegativeSmartcasts_after.kt index f516d803a08..c251e9505ca 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/tryCatch/falseNegativeSmartcasts_after.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/tryCatch/falseNegativeSmartcasts_after.kt @@ -14,7 +14,7 @@ fun test1(s1: String?) { return } finally { - s.length + s.length } s.length -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/tryCatch/falsePositiveSmartcasts_after.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/tryCatch/falsePositiveSmartcasts_after.fir.kt index 0e40b596a63..98aad3f98f6 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/tryCatch/falsePositiveSmartcasts_after.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/tryCatch/falsePositiveSmartcasts_after.fir.kt @@ -105,4 +105,4 @@ fun test6(s1: String?, s2: String?) { s.length s1.length s2.length -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/tryCatch/falsePositiveSmartcasts_after.kt b/compiler/testData/diagnostics/testsWithStdLib/tryCatch/falsePositiveSmartcasts_after.kt index 709b97c9b14..96a811dbff8 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/tryCatch/falsePositiveSmartcasts_after.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/tryCatch/falsePositiveSmartcasts_after.kt @@ -14,15 +14,15 @@ fun test1() { try { x = null } catch (e: Exception) { - x.length // smartcast shouldn't be allowed (OOME could happen after `x = null`) + x.length // smartcast shouldn't be allowed (OOME could happen after `x = null`) throw e } finally { // smartcast shouldn't be allowed, `x = null` could've happened - x.length + x.length } // smartcast shouldn't be allowed, `x = null` could've happened - x.length + x.length } // With old DFA of try/catch info about unsound smartcasts after try @@ -35,7 +35,7 @@ fun test2() { x = null } catch (e: Exception) { // BAD - x.length + x.length } finally { x.length @@ -51,7 +51,7 @@ fun test3() { } catch (e: Exception) { t2 = null } - t2.not() // wrong smartcast, NPE + t2.not() // wrong smartcast, NPE } } @@ -61,7 +61,7 @@ fun test4() { try { t2 = null } finally { } - t2.not() // wrong smartcast, NPE + t2.not() // wrong smartcast, NPE } } @@ -81,10 +81,10 @@ fun test5() { return } finally { - s1.length - s2.length + s1.length + s2.length } - s1.length + s1.length s2.length } @@ -99,10 +99,10 @@ fun test6(s1: String?, s2: String?) { return } finally { - s.length + s.length requireNotNull(s2) } - s.length - s1.length + s.length + s1.length s2.length -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/tryCatch/tryExpression.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/tryCatch/tryExpression.fir.kt index dfb2e98a923..40b7f8ad40c 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/tryCatch/tryExpression.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/tryCatch/tryExpression.fir.kt @@ -32,4 +32,4 @@ fun test2(): Map = run { } catch (e: ExcA) { mapOf("" to "") } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/tryCatch/tryExpression.kt b/compiler/testData/diagnostics/testsWithStdLib/tryCatch/tryExpression.kt index a1202adfcb2..238aeef76d2 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/tryCatch/tryExpression.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/tryCatch/tryExpression.kt @@ -27,9 +27,9 @@ fun test1(): Map = run { } fun test2(): Map = run { - try { + try { emptyMap() } catch (e: ExcA) { - mapOf("" to "") + mapOf("" to "") } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/when/noTypeArgumentsInConstructor.kt b/compiler/testData/diagnostics/testsWithStdLib/when/noTypeArgumentsInConstructor.kt index 12bae0c69a8..a6037015e9f 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/when/noTypeArgumentsInConstructor.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/when/noTypeArgumentsInConstructor.kt @@ -28,7 +28,7 @@ val test4: Collection = } val test5: Collection = - listOf(1, 2, 3).flatMapTo(LinkedHashSet()) { // TODO + listOf(1, 2, 3).flatMapTo(LinkedHashSet()) { // TODO if (true) listOf(it) else listOf(it) } @@ -40,4 +40,4 @@ val test6: Collection = val test7: Collection = listOf(1, 2, 3).flatMapTo(LinkedHashSet()) { select(listOf(it), listOf(it)) - } \ No newline at end of file + } From 8ddf419be597d819dc7863ffce0e2baf6a08734e Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Tue, 8 Dec 2020 11:24:07 +0300 Subject: [PATCH 100/196] [Build] Fix gradle tests filter for JUnit 5 There is an a optimization in our `projectTest` config which filters out some compiled test classes if they didn't contain specified test (if user ran :test task with --tests flag). This optimization for one tests left only one .class file which contains test. But JUnit 5 for tests in inner classes (with @Nested annotation) requires not only target class, but and all it's containers Test: package.SomeTest$Nested.testMethod JUnit4: package/SomeTest$Nested.class JUnit5: - package/SomeTest.class - package/SomeTest$Nested.class --- buildSrc/src/main/kotlin/tasks.kt | 26 ++++++++++++++++++---- compiler/tests-common-new/build.gradle.kts | 2 +- 2 files changed, 23 insertions(+), 5 deletions(-) diff --git a/buildSrc/src/main/kotlin/tasks.kt b/buildSrc/src/main/kotlin/tasks.kt index 69ad840581a..efce0a21d66 100644 --- a/buildSrc/src/main/kotlin/tasks.kt +++ b/buildSrc/src/main/kotlin/tasks.kt @@ -76,6 +76,7 @@ fun Project.projectTest( taskName: String = "test", parallel: Boolean = false, shortenTempRootName: Boolean = false, + jUnit5Enabled: Boolean = false, body: Test.() -> Unit = {} ): TaskProvider = getOrCreateTask(taskName) { doFirst { @@ -109,12 +110,29 @@ fun Project.projectTest( } } - include { - val path = it.path - if (it.isDirectory) { + val parentNames = if (jUnit5Enabled) { + /* + * If we run test from inner test class with junit 5 we need + * to include all containing classes of our class + */ + val nestedNames = classFileNameWithoutExtension.split("$") + mutableListOf(nestedNames.first()).also { + for (s in nestedNames.subList(1, nestedNames.size)) { + it += "${it.last()}\$$s" + } + } + } else emptyList() + + include { treeElement -> + val path = treeElement.path + if (treeElement.isDirectory) { classFileNameWithoutExtension.startsWith(path) } else { - path == classFileName || (path.endsWith(".class") && path.startsWith("$classFileNameWithoutExtension$")) + if (jUnit5Enabled) { + path == classFileName || (path.endsWith(".class") && parentNames.any { path.startsWith(it) }) + } else { + path == classFileName || (path.endsWith(".class") && path.startsWith("$classFileNameWithoutExtension$")) + } } } } diff --git a/compiler/tests-common-new/build.gradle.kts b/compiler/tests-common-new/build.gradle.kts index c49bba60ea1..092fae7b00d 100644 --- a/compiler/tests-common-new/build.gradle.kts +++ b/compiler/tests-common-new/build.gradle.kts @@ -54,7 +54,7 @@ if (kotlinBuildProperties.isInJpsBuildIdeaSync) { } } -projectTest(parallel = true) { +projectTest(parallel = true, jUnit5Enabled = true) { dependsOn(":dist") workingDir = rootDir jvmArgs!!.removeIf { it.contains("-Xmx") } From b44dc55109aeeec2e835823b36845a6af4ead537 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Tue, 8 Dec 2020 16:18:42 +0300 Subject: [PATCH 101/196] [TD] Mute some javac tests or update their testdata There was a refactoring of AbstractDiagnosticsTest in 9052ef06 which contains bug that `setupEnvironment` for AbstractDiagnosticsTestUsingJavac was not called, so for last year tests `UsingJavac` had no difference with usual diagnostics tests which causes some contradictions in test data --- .../deprecatedSinceKotlinDeclaration.fir.kt | 1 + .../deprecatedSinceKotlinDeclaration.kt | 1 + .../collectionOverrides/removeAtInt.javac.txt | 35 +++++++++++++++++++ ...NullTypeParameterWithKotlinNullable.fir.kt | 1 + .../notNullTypeParameterWithKotlinNullable.kt | 1 + ...ParameterWithKotlinNullableWarnings.fir.kt | 1 + ...TypeParameterWithKotlinNullableWarnings.kt | 1 + .../basicValueClassDeclaration.fir.kt | 1 + .../basicValueClassDeclaration.kt | 1 + .../basicValueClassDeclarationDisabled.fir.kt | 3 +- .../basicValueClassDeclarationDisabled.kt | 3 +- .../constructorsJvmSignaturesClash.fir.kt | 3 +- .../constructorsJvmSignaturesClash.kt | 3 +- .../delegatedPropertyInValueClass.fir.kt | 3 +- .../delegatedPropertyInValueClass.kt | 3 +- .../functionsJvmSignaturesClash.fir.kt | 3 +- .../functionsJvmSignaturesClash.kt | 3 +- ...tionsJvmSignaturesConflictOnInheritance.kt | 2 ++ .../identityComparisonWithValueClasses.fir.kt | 3 +- .../identityComparisonWithValueClasses.kt | 3 +- .../jvmInlineApplicability.fir.kt | 1 + .../valueClasses/jvmInlineApplicability.kt | 1 + .../valueClasses/lateinitValueClasses.fir.kt | 3 +- .../valueClasses/lateinitValueClasses.kt | 3 +- ...senceOfInitializerBlockInsideValueClass.kt | 2 ++ ...OfPublicPrimaryConstructorForValueClass.kt | 2 ++ ...esWithBackingFieldsInsideValueClass.fir.kt | 1 + ...ertiesWithBackingFieldsInsideValueClass.kt | 1 + .../valueClasses/recursiveValueClasses.fir.kt | 3 +- .../valueClasses/recursiveValueClasses.kt | 3 +- ...embersAndConstructsInsideValueClass.fir.kt | 3 +- ...vedMembersAndConstructsInsideValueClass.kt | 3 +- ...alueClassCanOnlyImplementInterfaces.fir.kt | 3 +- .../valueClassCanOnlyImplementInterfaces.kt | 3 +- ...annotImplementInterfaceByDelegation.fir.kt | 3 +- ...assCannotImplementInterfaceByDelegation.kt | 3 +- ...assConstructorParameterWithDefaultValue.kt | 4 ++- .../valueClassDeclarationCheck.fir.kt | 1 + .../valueClassDeclarationCheck.kt | 1 + .../valueClassImplementsCollection.kt | 2 ++ ...lueClassWithForbiddenUnderlyingType.fir.kt | 1 + .../valueClassWithForbiddenUnderlyingType.kt | 1 + .../valueClassesInsideAnnotations.fir.kt | 3 +- .../valueClassesInsideAnnotations.kt | 3 +- ...varargsOnParametersOfValueClassType.fir.kt | 3 +- .../varargsOnParametersOfValueClassType.kt | 3 +- .../testsWithStdLib/inference/kt36951.fir.kt | 1 + .../inference/kt36951.javac.txt | 26 ++++++++++++++ .../testsWithStdLib/inference/kt36951.kt | 1 + 49 files changed, 138 insertions(+), 25 deletions(-) create mode 100644 compiler/testData/diagnostics/testsWithStdLib/inference/kt36951.javac.txt diff --git a/compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin/deprecatedSinceKotlinDeclaration.fir.kt b/compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin/deprecatedSinceKotlinDeclaration.fir.kt index 9f9ead10cba..17137fff6cf 100644 --- a/compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin/deprecatedSinceKotlinDeclaration.fir.kt +++ b/compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin/deprecatedSinceKotlinDeclaration.fir.kt @@ -1,3 +1,4 @@ +// !SKIP_JAVAC package kotlin.sub @Deprecated("", ReplaceWith("")) diff --git a/compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin/deprecatedSinceKotlinDeclaration.kt b/compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin/deprecatedSinceKotlinDeclaration.kt index 6a70d00b41b..da3349e7215 100644 --- a/compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin/deprecatedSinceKotlinDeclaration.kt +++ b/compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin/deprecatedSinceKotlinDeclaration.kt @@ -1,3 +1,4 @@ +// !SKIP_JAVAC package kotlin.sub @Deprecated("", ReplaceWith("")) diff --git a/compiler/testData/diagnostics/tests/j+k/collectionOverrides/removeAtInt.javac.txt b/compiler/testData/diagnostics/tests/j+k/collectionOverrides/removeAtInt.javac.txt index 89cff7b6c76..7e4dcbdc39c 100644 --- a/compiler/testData/diagnostics/tests/j+k/collectionOverrides/removeAtInt.javac.txt +++ b/compiler/testData/diagnostics/tests/j+k/collectionOverrides/removeAtInt.javac.txt @@ -74,3 +74,38 @@ public abstract class B : kotlin.collections.MutableList, java.util. public open override /*1*/ /*fake_override*/ fun toArray(/*0*/ p0: kotlin.Array<(out) T!>!): kotlin.Array<(out) T!>! public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String } + +public abstract class D : java.util.AbstractList { + public constructor D() + protected/*protected and package*/ final override /*1*/ /*fake_override*/ var modCount: kotlin.Int + public abstract override /*1*/ /*fake_override*/ val size: kotlin.Int + public open override /*1*/ /*fake_override*/ fun add(/*0*/ index: kotlin.Int, /*1*/ element: kotlin.Int!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun add(/*0*/ element: kotlin.Int!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ index: kotlin.Int, /*1*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun contains(/*0*/ element: kotlin.Int!): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun containsAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public abstract override /*1*/ /*fake_override*/ fun get(/*0*/ index: kotlin.Int): kotlin.Int! + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun indexOf(/*0*/ element: kotlin.Int!): kotlin.Int + public open override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun iterator(): kotlin.collections.MutableIterator + public open override /*1*/ /*fake_override*/ fun lastIndexOf(/*0*/ element: kotlin.Int!): kotlin.Int + public open override /*1*/ /*fake_override*/ fun listIterator(): kotlin.collections.MutableListIterator + public open override /*1*/ /*fake_override*/ fun listIterator(/*0*/ index: kotlin.Int): kotlin.collections.MutableListIterator + invisible_fake open override /*1*/ /*fake_override*/ fun outOfBoundsMsg(/*0*/ p0: kotlin.Int): kotlin.String! + invisible_fake open override /*1*/ /*fake_override*/ fun rangeCheckForAdd(/*0*/ p0: kotlin.Int): kotlin.Unit + public open override /*1*/ fun remove(/*0*/ element: kotlin.Int): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun removeAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ fun removeAt(/*0*/ index: kotlin.Int): kotlin.Int + protected/*protected and package*/ open override /*1*/ /*fake_override*/ fun removeRange(/*0*/ p0: kotlin.Int, /*1*/ p1: kotlin.Int): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun retainAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun set(/*0*/ index: kotlin.Int, /*1*/ element: kotlin.Int!): kotlin.Int! + public open override /*1*/ /*fake_override*/ fun subList(/*0*/ fromIndex: kotlin.Int, /*1*/ toIndex: kotlin.Int): kotlin.collections.MutableList + public open override /*1*/ /*fake_override*/ fun toArray(): kotlin.Array<(out) kotlin.Any!>! + public open override /*1*/ /*fake_override*/ fun toArray(/*0*/ p0: kotlin.Array<(out) T!>!): kotlin.Array<(out) T!>! + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + diff --git a/compiler/testData/diagnostics/tests/j+k/types/notNullTypeParameterWithKotlinNullable.fir.kt b/compiler/testData/diagnostics/tests/j+k/types/notNullTypeParameterWithKotlinNullable.fir.kt index 00e1edee4f5..fe2f57ae149 100644 --- a/compiler/testData/diagnostics/tests/j+k/types/notNullTypeParameterWithKotlinNullable.fir.kt +++ b/compiler/testData/diagnostics/tests/j+k/types/notNullTypeParameterWithKotlinNullable.fir.kt @@ -1,3 +1,4 @@ +// !SKIP_JAVAC // FILE: SLRUMap.java // !LANGUAGE: +ProhibitUsingNullableTypeParameterAgainstNotNullAnnotated diff --git a/compiler/testData/diagnostics/tests/j+k/types/notNullTypeParameterWithKotlinNullable.kt b/compiler/testData/diagnostics/tests/j+k/types/notNullTypeParameterWithKotlinNullable.kt index bdb2edf8321..6f3750e41e5 100644 --- a/compiler/testData/diagnostics/tests/j+k/types/notNullTypeParameterWithKotlinNullable.kt +++ b/compiler/testData/diagnostics/tests/j+k/types/notNullTypeParameterWithKotlinNullable.kt @@ -1,3 +1,4 @@ +// !SKIP_JAVAC // FILE: SLRUMap.java // !LANGUAGE: +ProhibitUsingNullableTypeParameterAgainstNotNullAnnotated diff --git a/compiler/testData/diagnostics/tests/j+k/types/notNullTypeParameterWithKotlinNullableWarnings.fir.kt b/compiler/testData/diagnostics/tests/j+k/types/notNullTypeParameterWithKotlinNullableWarnings.fir.kt index d1715154e98..a543c1946e4 100644 --- a/compiler/testData/diagnostics/tests/j+k/types/notNullTypeParameterWithKotlinNullableWarnings.fir.kt +++ b/compiler/testData/diagnostics/tests/j+k/types/notNullTypeParameterWithKotlinNullableWarnings.fir.kt @@ -1,3 +1,4 @@ +// !SKIP_JAVAC // FILE: SLRUMap.java // !LANGUAGE: -ProhibitUsingNullableTypeParameterAgainstNotNullAnnotated diff --git a/compiler/testData/diagnostics/tests/j+k/types/notNullTypeParameterWithKotlinNullableWarnings.kt b/compiler/testData/diagnostics/tests/j+k/types/notNullTypeParameterWithKotlinNullableWarnings.kt index 44884f759d2..d845d14c68d 100644 --- a/compiler/testData/diagnostics/tests/j+k/types/notNullTypeParameterWithKotlinNullableWarnings.kt +++ b/compiler/testData/diagnostics/tests/j+k/types/notNullTypeParameterWithKotlinNullableWarnings.kt @@ -1,3 +1,4 @@ +// !SKIP_JAVAC // FILE: SLRUMap.java // !LANGUAGE: -ProhibitUsingNullableTypeParameterAgainstNotNullAnnotated diff --git a/compiler/testData/diagnostics/tests/valueClasses/basicValueClassDeclaration.fir.kt b/compiler/testData/diagnostics/tests/valueClasses/basicValueClassDeclaration.fir.kt index bf36fea2102..fcfa6043252 100644 --- a/compiler/testData/diagnostics/tests/valueClasses/basicValueClassDeclaration.fir.kt +++ b/compiler/testData/diagnostics/tests/valueClasses/basicValueClassDeclaration.fir.kt @@ -1,3 +1,4 @@ +// !SKIP_JAVAC // !LANGUAGE: +InlineClasses package kotlin.jvm diff --git a/compiler/testData/diagnostics/tests/valueClasses/basicValueClassDeclaration.kt b/compiler/testData/diagnostics/tests/valueClasses/basicValueClassDeclaration.kt index b27c46ca10e..577f3415aac 100644 --- a/compiler/testData/diagnostics/tests/valueClasses/basicValueClassDeclaration.kt +++ b/compiler/testData/diagnostics/tests/valueClasses/basicValueClassDeclaration.kt @@ -1,3 +1,4 @@ +// !SKIP_JAVAC // !LANGUAGE: +InlineClasses package kotlin.jvm diff --git a/compiler/testData/diagnostics/tests/valueClasses/basicValueClassDeclarationDisabled.fir.kt b/compiler/testData/diagnostics/tests/valueClasses/basicValueClassDeclarationDisabled.fir.kt index cdb987b0673..9a4bc272ef9 100644 --- a/compiler/testData/diagnostics/tests/valueClasses/basicValueClassDeclarationDisabled.fir.kt +++ b/compiler/testData/diagnostics/tests/valueClasses/basicValueClassDeclarationDisabled.fir.kt @@ -1,3 +1,4 @@ +// !SKIP_JAVAC // !LANGUAGE: -InlineClasses // !DIAGNOSTICS: -UNUSED_PARAMETER @@ -12,4 +13,4 @@ value object InlineObject value enum class InlineEnum @JvmInline -value class NotVal(x: Int) \ No newline at end of file +value class NotVal(x: Int) diff --git a/compiler/testData/diagnostics/tests/valueClasses/basicValueClassDeclarationDisabled.kt b/compiler/testData/diagnostics/tests/valueClasses/basicValueClassDeclarationDisabled.kt index 129eec441aa..32b3ed08bd6 100644 --- a/compiler/testData/diagnostics/tests/valueClasses/basicValueClassDeclarationDisabled.kt +++ b/compiler/testData/diagnostics/tests/valueClasses/basicValueClassDeclarationDisabled.kt @@ -1,3 +1,4 @@ +// !SKIP_JAVAC // !LANGUAGE: -InlineClasses // !DIAGNOSTICS: -UNUSED_PARAMETER @@ -12,4 +13,4 @@ annotation class JvmInline value enum class InlineEnum @JvmInline -value class NotVal(x: Int) \ No newline at end of file +value class NotVal(x: Int) diff --git a/compiler/testData/diagnostics/tests/valueClasses/constructorsJvmSignaturesClash.fir.kt b/compiler/testData/diagnostics/tests/valueClasses/constructorsJvmSignaturesClash.fir.kt index f5e19726e2a..b018d9831e5 100644 --- a/compiler/testData/diagnostics/tests/valueClasses/constructorsJvmSignaturesClash.fir.kt +++ b/compiler/testData/diagnostics/tests/valueClasses/constructorsJvmSignaturesClash.fir.kt @@ -1,3 +1,4 @@ +// !SKIP_JAVAC // !LANGUAGE: +InlineClasses // !DIAGNOSTICS: -UNUSED_PARAMETER @@ -21,4 +22,4 @@ class TestErr1(val a: Int) { class TestErr2(val a: Int, val b: Int) { constructor(x: X) : this(x.x, 1) constructor(z: Z) : this(z.x, 2) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/valueClasses/constructorsJvmSignaturesClash.kt b/compiler/testData/diagnostics/tests/valueClasses/constructorsJvmSignaturesClash.kt index 20f1bd2468d..73ca5f4da72 100644 --- a/compiler/testData/diagnostics/tests/valueClasses/constructorsJvmSignaturesClash.kt +++ b/compiler/testData/diagnostics/tests/valueClasses/constructorsJvmSignaturesClash.kt @@ -1,3 +1,4 @@ +// !SKIP_JAVAC // !LANGUAGE: +InlineClasses // !DIAGNOSTICS: -UNUSED_PARAMETER @@ -21,4 +22,4 @@ class TestErr1(val a: Int) { class TestErr2(val a: Int, val b: Int) { constructor(x: X) : this(x.x, 1) constructor(z: Z) : this(z.x, 2) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/valueClasses/delegatedPropertyInValueClass.fir.kt b/compiler/testData/diagnostics/tests/valueClasses/delegatedPropertyInValueClass.fir.kt index 78978f3ef38..141fd02fafb 100644 --- a/compiler/testData/diagnostics/tests/valueClasses/delegatedPropertyInValueClass.fir.kt +++ b/compiler/testData/diagnostics/tests/valueClasses/delegatedPropertyInValueClass.fir.kt @@ -1,3 +1,4 @@ +// !SKIP_JAVAC // !LANGUAGE: +InlineClasses package kotlin.jvm @@ -30,4 +31,4 @@ value class Z(val data: Int) { val testValBySingleton by ValObject var testVarBySingleton by VarObject -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/valueClasses/delegatedPropertyInValueClass.kt b/compiler/testData/diagnostics/tests/valueClasses/delegatedPropertyInValueClass.kt index 1cd281daed8..7c82d21a155 100644 --- a/compiler/testData/diagnostics/tests/valueClasses/delegatedPropertyInValueClass.kt +++ b/compiler/testData/diagnostics/tests/valueClasses/delegatedPropertyInValueClass.kt @@ -1,3 +1,4 @@ +// !SKIP_JAVAC // !LANGUAGE: +InlineClasses package kotlin.jvm @@ -30,4 +31,4 @@ value class Z(val data: Int) { val testValBySingleton by ValObject var testVarBySingleton by VarObject -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/valueClasses/functionsJvmSignaturesClash.fir.kt b/compiler/testData/diagnostics/tests/valueClasses/functionsJvmSignaturesClash.fir.kt index 6b778549a9a..6f9deb73b3c 100644 --- a/compiler/testData/diagnostics/tests/valueClasses/functionsJvmSignaturesClash.fir.kt +++ b/compiler/testData/diagnostics/tests/valueClasses/functionsJvmSignaturesClash.fir.kt @@ -1,3 +1,4 @@ +// !SKIP_JAVAC // !LANGUAGE: +InlineClasses // !DIAGNOSTICS: -UNUSED_PARAMETER @@ -43,4 +44,4 @@ class C { fun testNonGenericVsGeneric(x: X, y: Number) {} fun testNonGenericVsGeneric(x: X, y: T) {} fun testNonGenericVsGeneric(x: X, y: TC) {} -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/valueClasses/functionsJvmSignaturesClash.kt b/compiler/testData/diagnostics/tests/valueClasses/functionsJvmSignaturesClash.kt index 6a1ce3eefc6..83a738bafa6 100644 --- a/compiler/testData/diagnostics/tests/valueClasses/functionsJvmSignaturesClash.kt +++ b/compiler/testData/diagnostics/tests/valueClasses/functionsJvmSignaturesClash.kt @@ -1,3 +1,4 @@ +// !SKIP_JAVAC // !LANGUAGE: +InlineClasses // !DIAGNOSTICS: -UNUSED_PARAMETER @@ -43,4 +44,4 @@ class C { fun testNonGenericVsGeneric(x: X, y: Number) {} fun testNonGenericVsGeneric(x: X, y: T) {} fun testNonGenericVsGeneric(x: X, y: TC) {} -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/valueClasses/functionsJvmSignaturesConflictOnInheritance.kt b/compiler/testData/diagnostics/tests/valueClasses/functionsJvmSignaturesConflictOnInheritance.kt index 70b0554c770..d6bb03c2625 100644 --- a/compiler/testData/diagnostics/tests/valueClasses/functionsJvmSignaturesConflictOnInheritance.kt +++ b/compiler/testData/diagnostics/tests/valueClasses/functionsJvmSignaturesConflictOnInheritance.kt @@ -1,4 +1,6 @@ // FIR_IDENTICAL +// !SKIP_JAVAC +// FIR_IDENTICAL // !LANGUAGE: +InlineClasses package kotlin.jvm diff --git a/compiler/testData/diagnostics/tests/valueClasses/identityComparisonWithValueClasses.fir.kt b/compiler/testData/diagnostics/tests/valueClasses/identityComparisonWithValueClasses.fir.kt index dd27c6493d6..0fff9c556ff 100644 --- a/compiler/testData/diagnostics/tests/valueClasses/identityComparisonWithValueClasses.fir.kt +++ b/compiler/testData/diagnostics/tests/valueClasses/identityComparisonWithValueClasses.fir.kt @@ -1,3 +1,4 @@ +// !SKIP_JAVAC // !LANGUAGE: +InlineClasses // !DIAGNOSTICS: -UNUSED_VARIABLE @@ -25,4 +26,4 @@ fun test(f1: Foo, f2: Foo, b1: Bar, fn1: Foo?, fn2: Foo?) { val d2 = f1 === any || f1 !== any val d3 = any === fn1 || any !== fn1 val d4 = fn1 === any || fn1 !== any -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/valueClasses/identityComparisonWithValueClasses.kt b/compiler/testData/diagnostics/tests/valueClasses/identityComparisonWithValueClasses.kt index 070d5e588e1..fe5dfeaa5ba 100644 --- a/compiler/testData/diagnostics/tests/valueClasses/identityComparisonWithValueClasses.kt +++ b/compiler/testData/diagnostics/tests/valueClasses/identityComparisonWithValueClasses.kt @@ -1,3 +1,4 @@ +// !SKIP_JAVAC // !LANGUAGE: +InlineClasses // !DIAGNOSTICS: -UNUSED_VARIABLE @@ -25,4 +26,4 @@ fun test(f1: Foo, f2: Foo, b1: Bar, fn1: Foo?, fn2: Foo?) { val d2 = f1 === any || f1 !== any val d3 = any === fn1 || any !== fn1 val d4 = fn1 === any || fn1 !== any -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/valueClasses/jvmInlineApplicability.fir.kt b/compiler/testData/diagnostics/tests/valueClasses/jvmInlineApplicability.fir.kt index 3ad84f8a131..216b252f025 100644 --- a/compiler/testData/diagnostics/tests/valueClasses/jvmInlineApplicability.fir.kt +++ b/compiler/testData/diagnostics/tests/valueClasses/jvmInlineApplicability.fir.kt @@ -1,3 +1,4 @@ +// !SKIP_JAVAC // !LANGUAGE: +InlineClasses package kotlin.jvm diff --git a/compiler/testData/diagnostics/tests/valueClasses/jvmInlineApplicability.kt b/compiler/testData/diagnostics/tests/valueClasses/jvmInlineApplicability.kt index 6590b2eeb53..2993956b92f 100644 --- a/compiler/testData/diagnostics/tests/valueClasses/jvmInlineApplicability.kt +++ b/compiler/testData/diagnostics/tests/valueClasses/jvmInlineApplicability.kt @@ -1,3 +1,4 @@ +// !SKIP_JAVAC // !LANGUAGE: +InlineClasses package kotlin.jvm diff --git a/compiler/testData/diagnostics/tests/valueClasses/lateinitValueClasses.fir.kt b/compiler/testData/diagnostics/tests/valueClasses/lateinitValueClasses.fir.kt index ecd831251b1..d8de417e8f4 100644 --- a/compiler/testData/diagnostics/tests/valueClasses/lateinitValueClasses.fir.kt +++ b/compiler/testData/diagnostics/tests/valueClasses/lateinitValueClasses.fir.kt @@ -1,3 +1,4 @@ +// !SKIP_JAVAC // !LANGUAGE: +InlineClasses // !DIAGNOSTICS: -UNUSED_VARIABLE @@ -12,4 +13,4 @@ lateinit var a: Foo fun foo() { lateinit var b: Foo -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/valueClasses/lateinitValueClasses.kt b/compiler/testData/diagnostics/tests/valueClasses/lateinitValueClasses.kt index c92f98de61c..7e534316a9f 100644 --- a/compiler/testData/diagnostics/tests/valueClasses/lateinitValueClasses.kt +++ b/compiler/testData/diagnostics/tests/valueClasses/lateinitValueClasses.kt @@ -1,3 +1,4 @@ +// !SKIP_JAVAC // !LANGUAGE: +InlineClasses // !DIAGNOSTICS: -UNUSED_VARIABLE @@ -12,4 +13,4 @@ value class Foo(val x: Int) fun foo() { lateinit var b: Foo -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/valueClasses/presenceOfInitializerBlockInsideValueClass.kt b/compiler/testData/diagnostics/tests/valueClasses/presenceOfInitializerBlockInsideValueClass.kt index 72b125b8752..b502a111072 100644 --- a/compiler/testData/diagnostics/tests/valueClasses/presenceOfInitializerBlockInsideValueClass.kt +++ b/compiler/testData/diagnostics/tests/valueClasses/presenceOfInitializerBlockInsideValueClass.kt @@ -1,4 +1,6 @@ // FIR_IDENTICAL +// !SKIP_JAVAC +// FIR_IDENTICAL // !LANGUAGE: +InlineClasses // !DIAGNOSTICS: -UNUSED_VARIABLE diff --git a/compiler/testData/diagnostics/tests/valueClasses/presenceOfPublicPrimaryConstructorForValueClass.kt b/compiler/testData/diagnostics/tests/valueClasses/presenceOfPublicPrimaryConstructorForValueClass.kt index 2e5603bb3a3..cf3e71c8731 100644 --- a/compiler/testData/diagnostics/tests/valueClasses/presenceOfPublicPrimaryConstructorForValueClass.kt +++ b/compiler/testData/diagnostics/tests/valueClasses/presenceOfPublicPrimaryConstructorForValueClass.kt @@ -1,4 +1,6 @@ // FIR_IDENTICAL +// !SKIP_JAVAC +// FIR_IDENTICAL // !LANGUAGE: +InlineClasses package kotlin.jvm diff --git a/compiler/testData/diagnostics/tests/valueClasses/propertiesWithBackingFieldsInsideValueClass.fir.kt b/compiler/testData/diagnostics/tests/valueClasses/propertiesWithBackingFieldsInsideValueClass.fir.kt index 600b744d3c8..d4a0c75eb19 100644 --- a/compiler/testData/diagnostics/tests/valueClasses/propertiesWithBackingFieldsInsideValueClass.fir.kt +++ b/compiler/testData/diagnostics/tests/valueClasses/propertiesWithBackingFieldsInsideValueClass.fir.kt @@ -1,3 +1,4 @@ +// !SKIP_JAVAC // !LANGUAGE: +InlineClasses // !DIAGNOSTICS: -UNUSED_PARAMETER diff --git a/compiler/testData/diagnostics/tests/valueClasses/propertiesWithBackingFieldsInsideValueClass.kt b/compiler/testData/diagnostics/tests/valueClasses/propertiesWithBackingFieldsInsideValueClass.kt index c3d2df146d4..3c9ba609ad5 100644 --- a/compiler/testData/diagnostics/tests/valueClasses/propertiesWithBackingFieldsInsideValueClass.kt +++ b/compiler/testData/diagnostics/tests/valueClasses/propertiesWithBackingFieldsInsideValueClass.kt @@ -1,3 +1,4 @@ +// !SKIP_JAVAC // !LANGUAGE: +InlineClasses // !DIAGNOSTICS: -UNUSED_PARAMETER diff --git a/compiler/testData/diagnostics/tests/valueClasses/recursiveValueClasses.fir.kt b/compiler/testData/diagnostics/tests/valueClasses/recursiveValueClasses.fir.kt index aa805071da2..50de3665385 100644 --- a/compiler/testData/diagnostics/tests/valueClasses/recursiveValueClasses.fir.kt +++ b/compiler/testData/diagnostics/tests/valueClasses/recursiveValueClasses.fir.kt @@ -1,3 +1,4 @@ +// !SKIP_JAVAC // !LANGUAGE: +InlineClasses package kotlin.jvm @@ -34,4 +35,4 @@ value class TestRecursionInUpperBounds>(val x: @JvmInline value class Id(val x: T) @JvmInline -value class TestRecursionThroughId(val x: Id) \ No newline at end of file +value class TestRecursionThroughId(val x: Id) diff --git a/compiler/testData/diagnostics/tests/valueClasses/recursiveValueClasses.kt b/compiler/testData/diagnostics/tests/valueClasses/recursiveValueClasses.kt index 167a6b5dabc..57d949c9208 100644 --- a/compiler/testData/diagnostics/tests/valueClasses/recursiveValueClasses.kt +++ b/compiler/testData/diagnostics/tests/valueClasses/recursiveValueClasses.kt @@ -1,3 +1,4 @@ +// !SKIP_JAVAC // !LANGUAGE: +InlineClasses package kotlin.jvm @@ -34,4 +35,4 @@ value class TestRecursionInUpperBounds>(val x: @JvmInline value class Id(val x: T) @JvmInline -value class TestRecursionThroughId(val x: Id) \ No newline at end of file +value class TestRecursionThroughId(val x: Id) diff --git a/compiler/testData/diagnostics/tests/valueClasses/reservedMembersAndConstructsInsideValueClass.fir.kt b/compiler/testData/diagnostics/tests/valueClasses/reservedMembersAndConstructsInsideValueClass.fir.kt index 1d889336879..32edbbe3dd5 100644 --- a/compiler/testData/diagnostics/tests/valueClasses/reservedMembersAndConstructsInsideValueClass.fir.kt +++ b/compiler/testData/diagnostics/tests/valueClasses/reservedMembersAndConstructsInsideValueClass.fir.kt @@ -1,3 +1,4 @@ +// !SKIP_JAVAC // !LANGUAGE: +InlineClasses // !DIAGNOSTICS: -UNUSED_PARAMETER @@ -51,4 +52,4 @@ value class IC5(val a: String) { constructor(i: Int) : this(i.toString()) { TODO("something") } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/valueClasses/reservedMembersAndConstructsInsideValueClass.kt b/compiler/testData/diagnostics/tests/valueClasses/reservedMembersAndConstructsInsideValueClass.kt index 06debc64d17..c77858a8c9d 100644 --- a/compiler/testData/diagnostics/tests/valueClasses/reservedMembersAndConstructsInsideValueClass.kt +++ b/compiler/testData/diagnostics/tests/valueClasses/reservedMembersAndConstructsInsideValueClass.kt @@ -1,3 +1,4 @@ +// !SKIP_JAVAC // !LANGUAGE: +InlineClasses // !DIAGNOSTICS: -UNUSED_PARAMETER @@ -51,4 +52,4 @@ value class IC5(val a: String) { constructor(i: Int) : this(i.toString()) { TODO("something") } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/valueClasses/valueClassCanOnlyImplementInterfaces.fir.kt b/compiler/testData/diagnostics/tests/valueClasses/valueClassCanOnlyImplementInterfaces.fir.kt index 25ea40e9ea2..35a93cd7982 100644 --- a/compiler/testData/diagnostics/tests/valueClasses/valueClassCanOnlyImplementInterfaces.fir.kt +++ b/compiler/testData/diagnostics/tests/valueClasses/valueClassCanOnlyImplementInterfaces.fir.kt @@ -1,3 +1,4 @@ +// !SKIP_JAVAC // !LANGUAGE: +InlineClasses package kotlin.jvm @@ -17,4 +18,4 @@ value class TestExtendsAbstractClass(val x: Int) : AbstractBaseClass() value class TestExtendsOpenClass(val x: Int) : OpenBaseClass() @JvmInline -value class TestImplementsInterface(val x: Int) : BaseInterface \ No newline at end of file +value class TestImplementsInterface(val x: Int) : BaseInterface diff --git a/compiler/testData/diagnostics/tests/valueClasses/valueClassCanOnlyImplementInterfaces.kt b/compiler/testData/diagnostics/tests/valueClasses/valueClassCanOnlyImplementInterfaces.kt index 9b2fdd735d9..4550ffa6a89 100644 --- a/compiler/testData/diagnostics/tests/valueClasses/valueClassCanOnlyImplementInterfaces.kt +++ b/compiler/testData/diagnostics/tests/valueClasses/valueClassCanOnlyImplementInterfaces.kt @@ -1,3 +1,4 @@ +// !SKIP_JAVAC // !LANGUAGE: +InlineClasses package kotlin.jvm @@ -17,4 +18,4 @@ value class TestExtendsAbstractClass(val x: Int) : OpenBaseClass() @JvmInline -value class TestImplementsInterface(val x: Int) : BaseInterface \ No newline at end of file +value class TestImplementsInterface(val x: Int) : BaseInterface diff --git a/compiler/testData/diagnostics/tests/valueClasses/valueClassCannotImplementInterfaceByDelegation.fir.kt b/compiler/testData/diagnostics/tests/valueClasses/valueClassCannotImplementInterfaceByDelegation.fir.kt index a59356430e0..40d22cb608a 100644 --- a/compiler/testData/diagnostics/tests/valueClasses/valueClassCannotImplementInterfaceByDelegation.fir.kt +++ b/compiler/testData/diagnostics/tests/valueClasses/valueClassCannotImplementInterfaceByDelegation.fir.kt @@ -1,3 +1,4 @@ +// !SKIP_JAVAC // !LANGUAGE: +InlineClasses package kotlin.jvm @@ -12,4 +13,4 @@ object FooImpl : IFoo value class Test1(val x: Any) : IFoo by FooImpl @JvmInline -value class Test2(val x: IFoo) : IFoo by x \ No newline at end of file +value class Test2(val x: IFoo) : IFoo by x diff --git a/compiler/testData/diagnostics/tests/valueClasses/valueClassCannotImplementInterfaceByDelegation.kt b/compiler/testData/diagnostics/tests/valueClasses/valueClassCannotImplementInterfaceByDelegation.kt index f9dbdd81d3e..1aec09d3e4f 100644 --- a/compiler/testData/diagnostics/tests/valueClasses/valueClassCannotImplementInterfaceByDelegation.kt +++ b/compiler/testData/diagnostics/tests/valueClasses/valueClassCannotImplementInterfaceByDelegation.kt @@ -1,3 +1,4 @@ +// !SKIP_JAVAC // !LANGUAGE: +InlineClasses package kotlin.jvm @@ -12,4 +13,4 @@ object FooImpl : IFoo value class Test1(val x: Any) : IFoo by FooImpl @JvmInline -value class Test2(val x: IFoo) : IFoo by x \ No newline at end of file +value class Test2(val x: IFoo) : IFoo by x diff --git a/compiler/testData/diagnostics/tests/valueClasses/valueClassConstructorParameterWithDefaultValue.kt b/compiler/testData/diagnostics/tests/valueClasses/valueClassConstructorParameterWithDefaultValue.kt index 393acf38100..1208b18e499 100644 --- a/compiler/testData/diagnostics/tests/valueClasses/valueClassConstructorParameterWithDefaultValue.kt +++ b/compiler/testData/diagnostics/tests/valueClasses/valueClassConstructorParameterWithDefaultValue.kt @@ -1,4 +1,6 @@ // FIR_IDENTICAL +// !SKIP_JAVAC +// FIR_IDENTICAL // !LANGUAGE: +InlineClasses package kotlin.jvm @@ -6,4 +8,4 @@ package kotlin.jvm annotation class JvmInline @JvmInline -value class Test(val x: Int = 42) \ No newline at end of file +value class Test(val x: Int = 42) diff --git a/compiler/testData/diagnostics/tests/valueClasses/valueClassDeclarationCheck.fir.kt b/compiler/testData/diagnostics/tests/valueClasses/valueClassDeclarationCheck.fir.kt index 0ca3684d5b3..a555bccb1bf 100644 --- a/compiler/testData/diagnostics/tests/valueClasses/valueClassDeclarationCheck.fir.kt +++ b/compiler/testData/diagnostics/tests/valueClasses/valueClassDeclarationCheck.fir.kt @@ -1,3 +1,4 @@ +// !SKIP_JAVAC // !LANGUAGE: +InlineClasses // !DIAGNOSTICS: -UNUSED_PARAMETER diff --git a/compiler/testData/diagnostics/tests/valueClasses/valueClassDeclarationCheck.kt b/compiler/testData/diagnostics/tests/valueClasses/valueClassDeclarationCheck.kt index 8deb953d413..a3337a6371a 100644 --- a/compiler/testData/diagnostics/tests/valueClasses/valueClassDeclarationCheck.kt +++ b/compiler/testData/diagnostics/tests/valueClasses/valueClassDeclarationCheck.kt @@ -1,3 +1,4 @@ +// !SKIP_JAVAC // !LANGUAGE: +InlineClasses // !DIAGNOSTICS: -UNUSED_PARAMETER diff --git a/compiler/testData/diagnostics/tests/valueClasses/valueClassImplementsCollection.kt b/compiler/testData/diagnostics/tests/valueClasses/valueClassImplementsCollection.kt index 8d24d41c91c..6f0b197791a 100644 --- a/compiler/testData/diagnostics/tests/valueClasses/valueClassImplementsCollection.kt +++ b/compiler/testData/diagnostics/tests/valueClasses/valueClassImplementsCollection.kt @@ -1,4 +1,6 @@ // FIR_IDENTICAL +// !SKIP_JAVAC +// FIR_IDENTICAL // !LANGUAGE: +InlineClasses package kotlin.jvm diff --git a/compiler/testData/diagnostics/tests/valueClasses/valueClassWithForbiddenUnderlyingType.fir.kt b/compiler/testData/diagnostics/tests/valueClasses/valueClassWithForbiddenUnderlyingType.fir.kt index 7ed03f8cdd2..55506c247b5 100644 --- a/compiler/testData/diagnostics/tests/valueClasses/valueClassWithForbiddenUnderlyingType.fir.kt +++ b/compiler/testData/diagnostics/tests/valueClasses/valueClassWithForbiddenUnderlyingType.fir.kt @@ -1,3 +1,4 @@ +// !SKIP_JAVAC // !LANGUAGE: +InlineClasses package kotlin.jvm diff --git a/compiler/testData/diagnostics/tests/valueClasses/valueClassWithForbiddenUnderlyingType.kt b/compiler/testData/diagnostics/tests/valueClasses/valueClassWithForbiddenUnderlyingType.kt index 3a680ba0dc4..532ed9867e1 100644 --- a/compiler/testData/diagnostics/tests/valueClasses/valueClassWithForbiddenUnderlyingType.kt +++ b/compiler/testData/diagnostics/tests/valueClasses/valueClassWithForbiddenUnderlyingType.kt @@ -1,3 +1,4 @@ +// !SKIP_JAVAC // !LANGUAGE: +InlineClasses package kotlin.jvm diff --git a/compiler/testData/diagnostics/tests/valueClasses/valueClassesInsideAnnotations.fir.kt b/compiler/testData/diagnostics/tests/valueClasses/valueClassesInsideAnnotations.fir.kt index 2a99108dd6a..5445d5d9c4f 100644 --- a/compiler/testData/diagnostics/tests/valueClasses/valueClassesInsideAnnotations.fir.kt +++ b/compiler/testData/diagnostics/tests/valueClasses/valueClassesInsideAnnotations.fir.kt @@ -1,3 +1,4 @@ +// !SKIP_JAVAC // !LANGUAGE: +InlineClasses package kotlin.jvm @@ -15,4 +16,4 @@ annotation class Ann1(val a: MyInt) annotation class Ann2(val a: Array) annotation class Ann3(vararg val a: MyInt) -annotation class Ann4(val a: KClass) \ No newline at end of file +annotation class Ann4(val a: KClass) diff --git a/compiler/testData/diagnostics/tests/valueClasses/valueClassesInsideAnnotations.kt b/compiler/testData/diagnostics/tests/valueClasses/valueClassesInsideAnnotations.kt index 6f583fff243..bbec44460f8 100644 --- a/compiler/testData/diagnostics/tests/valueClasses/valueClassesInsideAnnotations.kt +++ b/compiler/testData/diagnostics/tests/valueClasses/valueClassesInsideAnnotations.kt @@ -1,3 +1,4 @@ +// !SKIP_JAVAC // !LANGUAGE: +InlineClasses package kotlin.jvm @@ -15,4 +16,4 @@ annotation class Ann1(val a: MyInt) annotation class Ann2(val a: Array) annotation class Ann3(vararg val a: MyInt) -annotation class Ann4(val a: KClass) \ No newline at end of file +annotation class Ann4(val a: KClass) diff --git a/compiler/testData/diagnostics/tests/valueClasses/varargsOnParametersOfValueClassType.fir.kt b/compiler/testData/diagnostics/tests/valueClasses/varargsOnParametersOfValueClassType.fir.kt index 3c5e49a25cc..91fa32f9b9b 100644 --- a/compiler/testData/diagnostics/tests/valueClasses/varargsOnParametersOfValueClassType.fir.kt +++ b/compiler/testData/diagnostics/tests/valueClasses/varargsOnParametersOfValueClassType.fir.kt @@ -1,3 +1,4 @@ +// !SKIP_JAVAC // !LANGUAGE: +InlineClasses // !DIAGNOSTICS: -UNUSED_PARAMETER, -UNUSED_VARIABLE, -UNUSED_ANONYMOUS_PARAMETER @@ -23,4 +24,4 @@ class B(vararg val s: Foo) { constructor(a: Int, vararg s: Foo) : this(*s) } -annotation class Ann(vararg val f: Foo) \ No newline at end of file +annotation class Ann(vararg val f: Foo) diff --git a/compiler/testData/diagnostics/tests/valueClasses/varargsOnParametersOfValueClassType.kt b/compiler/testData/diagnostics/tests/valueClasses/varargsOnParametersOfValueClassType.kt index b12960baf06..c6f060114b0 100644 --- a/compiler/testData/diagnostics/tests/valueClasses/varargsOnParametersOfValueClassType.kt +++ b/compiler/testData/diagnostics/tests/valueClasses/varargsOnParametersOfValueClassType.kt @@ -1,3 +1,4 @@ +// !SKIP_JAVAC // !LANGUAGE: +InlineClasses // !DIAGNOSTICS: -UNUSED_PARAMETER, -UNUSED_VARIABLE, -UNUSED_ANONYMOUS_PARAMETER @@ -23,4 +24,4 @@ class B(vararg val s: Foo) { constructor(a: Int, vararg s: Foo) : this(*s) } -annotation class Ann(vararg val f: Foo) \ No newline at end of file +annotation class Ann(vararg val f: Foo) diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/kt36951.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/kt36951.fir.kt index 7fdcf77c924..3680f122cf3 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/inference/kt36951.fir.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/inference/kt36951.fir.kt @@ -1,3 +1,4 @@ +// !JAVAC_EXPECTED_FILE // !LANGUAGE: +NewInference // !DIAGNOSTICS: -UNUSED_PARAMETER diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/kt36951.javac.txt b/compiler/testData/diagnostics/testsWithStdLib/inference/kt36951.javac.txt new file mode 100644 index 00000000000..904e4a35ec4 --- /dev/null +++ b/compiler/testData/diagnostics/testsWithStdLib/inference/kt36951.javac.txt @@ -0,0 +1,26 @@ +package + +public final class Base : kotlin.collections.HashSet /* = java.util.HashSet */ { + public constructor Base() + invisible_fake final override /*1*/ /*fake_override*/ var map: java.util.HashMap! + public open override /*1*/ /*fake_override*/ val size: kotlin.Int + public open override /*1*/ /*fake_override*/ fun add(/*0*/ element: T): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun addAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun clear(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun clone(): kotlin.Any + public open override /*1*/ /*fake_override*/ fun contains(/*0*/ element: T): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun containsAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public final fun foo(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun isEmpty(): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun iterator(): kotlin.collections.MutableIterator + invisible_fake open override /*1*/ /*fake_override*/ fun readObject(/*0*/ p0: java.io.ObjectInputStream!): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun remove(/*0*/ element: T): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun removeAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun retainAll(/*0*/ elements: kotlin.collections.Collection): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun toArray(): kotlin.Array<(out) kotlin.Any!>! + public open override /*1*/ /*fake_override*/ fun toArray(/*0*/ p0: kotlin.Array<(out) T!>!): kotlin.Array<(out) T!>! + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + invisible_fake open override /*1*/ /*fake_override*/ fun writeObject(/*0*/ p0: java.io.ObjectOutputStream!): kotlin.Unit +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/kt36951.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/kt36951.kt index 76d082ad720..18b5943deaa 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/inference/kt36951.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/inference/kt36951.kt @@ -1,3 +1,4 @@ +// !JAVAC_EXPECTED_FILE // !LANGUAGE: +NewInference // !DIAGNOSTICS: -UNUSED_PARAMETER From 61302a2e081ec33b9a5a7890a39fa1a8e534a6b5 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Tue, 15 Dec 2020 15:22:48 +0300 Subject: [PATCH 102/196] [TEST] Migrate duplicating javac tests to new test runners Also minimize scope of DiagnosticUsingJavac tests to `compiler/testData/diagnostics/tests/javac`. This is fine since javac compilation mode is still not finished and no one not going to support it --- .../tests/javac}/Annotations.kt | 1 + .../tests/javac}/Annotations.txt | 0 .../AsteriskStaticImportsAmbiguity.kt | 1 + .../AsteriskStaticImportsAmbiguity.txt | 0 .../fieldsResolution}/BinaryInitializers.kt | 1 + .../fieldsResolution}/BinaryInitializers.txt | 0 .../fieldsResolution}/ConstantByFqName.kt | 1 + .../fieldsResolution}/ConstantByFqName.txt | 0 .../javac/fieldsResolution}/ConstantValues.kt | 1 + .../fieldsResolution}/ConstantValues.txt | 0 .../ConstantValuesFromKtFile.kt | 1 + .../ConstantValuesFromKtFile.txt | 0 .../fieldsResolution}/FieldFromOuterClass.kt | 1 + .../fieldsResolution}/FieldFromOuterClass.txt | 0 .../javac/fieldsResolution}/InheritedField.kt | 1 + .../fieldsResolution}/InheritedField.txt | 0 .../javac/fieldsResolution}/MultipleOuters.kt | 1 + .../fieldsResolution}/MultipleOuters.txt | 0 .../fieldsResolution}/ResolutionPriority.kt | 1 + .../fieldsResolution}/ResolutionPriority.txt | 0 .../SameFieldInSupertypes.kt | 1 + .../SameFieldInSupertypes.txt | 0 .../javac/fieldsResolution}/StaticImport.kt | 1 + .../javac/fieldsResolution}/StaticImport.txt | 0 .../StaticImportsAmbiguity.kt | 1 + .../StaticImportsAmbiguity.txt | 0 .../imports/AllUnderImportsAmbiguity.fir.kt | 27 + .../imports/AllUnderImportsAmbiguity.kt | 0 .../imports/AllUnderImportsAmbiguity.txt | 0 .../imports/AllUnderImportsLessPriority.kt | 1 + .../imports/AllUnderImportsLessPriority.txt | 0 .../javac}/imports/ClassImportsConflicting.kt | 1 + .../imports/ClassImportsConflicting.txt | 0 .../CurrentPackageAndAllUnderImport.kt | 1 + .../CurrentPackageAndAllUnderImport.txt | 0 .../CurrentPackageAndExplicitImport.kt | 1 + .../CurrentPackageAndExplicitImport.txt | 0 .../CurrentPackageAndExplicitNestedImport.kt | 1 + .../CurrentPackageAndExplicitNestedImport.txt | 0 .../CurrentPackageAndNestedAsteriskImport.kt | 1 + .../CurrentPackageAndNestedAsteriskImport.txt | 0 .../javac}/imports/ImportGenericVsPackage.kt | 1 + .../javac}/imports/ImportGenericVsPackage.txt | 0 .../javac/imports/ImportProtectedClass.fir.kt | 19 + .../javac}/imports/ImportProtectedClass.kt | 0 .../javac}/imports/ImportProtectedClass.txt | 0 .../tests/javac}/imports/ImportTwoTimes.kt | 1 + .../tests/javac}/imports/ImportTwoTimes.txt | 0 .../javac}/imports/ImportTwoTimesStar.kt | 1 + .../javac}/imports/ImportTwoTimesStar.txt | 0 .../NestedAndTopLevelClassClash.fir.kt | 38 + .../imports/NestedAndTopLevelClassClash.kt | 0 .../imports/NestedAndTopLevelClassClash.txt | 0 .../javac/imports/NestedClassClash.fir.kt | 40 + .../tests/javac}/imports/NestedClassClash.kt | 0 .../tests/javac}/imports/NestedClassClash.txt | 0 .../imports/PackageExplicitAndStartImport.kt | 1 + .../imports/PackageExplicitAndStartImport.txt | 0 .../PackagePrivateAndPublicNested.fir.kt | 19 + .../imports/PackagePrivateAndPublicNested.kt | 2 +- .../imports/PackagePrivateAndPublicNested.txt | 0 .../javac}/imports/TopLevelClassVsPackage.kt | 1 + .../javac}/imports/TopLevelClassVsPackage.txt | 0 .../javac}/imports/TopLevelClassVsPackage2.kt | 1 + .../imports/TopLevelClassVsPackage2.txt | 0 .../javac}/inheritance/IheritanceOfInner.kt | 1 + .../javac}/inheritance/IheritanceOfInner.txt | 0 .../inheritance/InheritanceAmbiguity.fir.kt | 27 + .../inheritance/InheritanceAmbiguity.kt | 0 .../inheritance/InheritanceAmbiguity.txt | 0 .../inheritance/InheritanceAmbiguity2.fir.kt | 30 + .../inheritance/InheritanceAmbiguity2.kt | 0 .../inheritance/InheritanceAmbiguity2.txt | 0 .../inheritance/InheritanceAmbiguity3.fir.kt | 25 + .../inheritance/InheritanceAmbiguity3.kt | 0 .../inheritance/InheritanceAmbiguity3.txt | 0 .../inheritance/InheritanceAmbiguity4.fir.kt} | 2 +- .../inheritance/InheritanceAmbiguity4.kt | 0 .../inheritance/InheritanceAmbiguity4.txt | 0 .../inheritance/InheritanceWithKotlin.kt | 1 + .../inheritance/InheritanceWithKotlin.txt | 0 .../InheritanceWithKotlinClasses.kt | 1 + .../InheritanceWithKotlinClasses.txt | 0 .../javac}/inheritance/InheritedInner.kt | 1 + .../javac}/inheritance/InheritedInner.txt | 0 .../javac}/inheritance/InheritedInner2.kt | 3 +- .../javac}/inheritance/InheritedInner2.txt | 0 .../InheritedInnerAndSupertypeWithSameName.kt | 1 + ...InheritedInnerAndSupertypeWithSameName.txt | 0 .../inheritance/InheritedInnerUsageInInner.kt | 1 + .../InheritedInnerUsageInInner.txt | 0 .../inheritance/InheritedKotlinInner.kt | 1 + .../inheritance/InheritedKotlinInner.txt | 0 .../inheritance/InnerAndInheritedInner.kt | 1 + .../inheritance/InnerAndInheritedInner.txt | 0 .../inheritance/ManyInheritedClasses.kt | 1 + .../inheritance/ManyInheritedClasses.txt | 0 ...InnersInSupertypeAndSupertypesSupertype.kt | 1 + ...nnersInSupertypeAndSupertypesSupertype.txt | 0 .../inheritance/SuperTypeWithSameInner.kt | 1 + .../inheritance/SuperTypeWithSameInner.txt | 0 ...rtypeInnerAndTypeParameterWithSameNames.kt | 1 + ...typeInnerAndTypeParameterWithSameNames.txt | 0 .../tests/javac}/inners/ComplexCase.kt | 1 + .../tests/javac}/inners/ComplexCase.txt | 0 .../tests/javac}/inners/ComplexCase2.kt | 1 + .../tests/javac}/inners/ComplexCase2.txt | 0 .../javac}/inners/CurrentPackageAndInner.kt | 1 + .../javac}/inners/CurrentPackageAndInner.txt | 0 .../javac}/inners/ImportThriceNestedClass.kt | 1 + .../javac}/inners/ImportThriceNestedClass.txt | 0 .../tests/javac}/inners/InnerInInner.kt | 1 + .../tests/javac}/inners/InnerInInner.txt | 0 .../tests/javac}/inners/Nested.kt | 1 + .../tests/javac}/inners/Nested.txt | 0 .../tests/javac}/inners/ThriceNestedClass.kt | 1 + .../tests/javac}/inners/ThriceNestedClass.txt | 0 .../GenericClassVsPackage.kt | 1 + .../GenericClassVsPackage.txt | 0 .../qualifiedExpression/PackageVsClass.kt | 1 + .../qualifiedExpression/PackageVsClass.txt | 0 .../PackageVsClass2.fir.kt | 47 + .../qualifiedExpression/PackageVsClass2.kt | 0 .../qualifiedExpression/PackageVsClass2.txt | 0 .../qualifiedExpression/PackageVsRootClass.kt | 1 + .../PackageVsRootClass.txt | 0 .../visibleClassVsQualifiedClass.fir.kt | 57 + .../visibleClassVsQualifiedClass.kt | 0 .../visibleClassVsQualifiedClass.txt | 0 .../tests/javac/typeParameters/Clash.fir.kt | 33 + .../tests/javac}/typeParameters/Clash.kt | 0 .../tests/javac}/typeParameters/Clash.txt | 0 .../javac}/typeParameters/ComplexCase.kt | 1 + .../javac}/typeParameters/ComplexCase.txt | 0 ...ritedInnerAndTypeParameterWithSameNames.kt | 1 + ...itedInnerAndTypeParameterWithSameNames.txt | 0 .../typeParameters/InnerWithTypeParameter.kt | 1 + .../typeParameters/InnerWithTypeParameter.txt | 0 .../javac}/typeParameters/NestedWithInner.kt | 1 + .../javac}/typeParameters/NestedWithInner.txt | 0 .../SeveralInnersWithTypeParameters.kt | 1 + .../SeveralInnersWithTypeParameters.txt | 0 ...eParametersInInnerAndOuterWithSameNames.kt | 1 + ...ParametersInInnerAndOuterWithSameNames.txt | 0 .../tests/inheritance/NoAmbiguity.txt | 73 - .../tests/inheritance/NoAmbiguity2.kt | 49 - .../tests/inheritance/NoAmbiguity2.txt | 76 - .../test/runners/DiagnosticTestGenerated.java | 466 + .../DiagnosticUsingJavacTestGenerated.java | 34425 +--------------- ...irOldFrontendDiagnosticsTestGenerated.java | 466 + .../generators/GenerateNewCompilerTests.kt | 3 +- .../javac/AbstractJavacDiagnosticsTest.kt | 59 - .../javac/AbstractJavacFieldResolutionTest.kt | 42 - .../javac/JavacDiagnosticsTestGenerated.java | 736 - .../JavacFieldResolutionTestGenerated.java | 166 - .../generators/tests/GenerateCompilerTests.kt | 17 - 156 files changed, 1631 insertions(+), 35369 deletions(-) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/Annotations.kt (98%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/Annotations.txt (100%) rename compiler/testData/{javac/fieldsResolution/tests => diagnostics/tests/javac/fieldsResolution}/AsteriskStaticImportsAmbiguity.kt (96%) rename compiler/testData/{javac/fieldsResolution/tests => diagnostics/tests/javac/fieldsResolution}/AsteriskStaticImportsAmbiguity.txt (100%) rename compiler/testData/{javac/fieldsResolution/tests => diagnostics/tests/javac/fieldsResolution}/BinaryInitializers.kt (95%) rename compiler/testData/{javac/fieldsResolution/tests => diagnostics/tests/javac/fieldsResolution}/BinaryInitializers.txt (100%) rename compiler/testData/{javac/fieldsResolution/tests => diagnostics/tests/javac/fieldsResolution}/ConstantByFqName.kt (92%) rename compiler/testData/{javac/fieldsResolution/tests => diagnostics/tests/javac/fieldsResolution}/ConstantByFqName.txt (100%) rename compiler/testData/{javac/fieldsResolution/tests => diagnostics/tests/javac/fieldsResolution}/ConstantValues.kt (98%) rename compiler/testData/{javac/fieldsResolution/tests => diagnostics/tests/javac/fieldsResolution}/ConstantValues.txt (100%) rename compiler/testData/{javac/fieldsResolution/tests => diagnostics/tests/javac/fieldsResolution}/ConstantValuesFromKtFile.kt (95%) rename compiler/testData/{javac/fieldsResolution/tests => diagnostics/tests/javac/fieldsResolution}/ConstantValuesFromKtFile.txt (100%) rename compiler/testData/{javac/fieldsResolution/tests => diagnostics/tests/javac/fieldsResolution}/FieldFromOuterClass.kt (97%) rename compiler/testData/{javac/fieldsResolution/tests => diagnostics/tests/javac/fieldsResolution}/FieldFromOuterClass.txt (100%) rename compiler/testData/{javac/fieldsResolution/tests => diagnostics/tests/javac/fieldsResolution}/InheritedField.kt (94%) rename compiler/testData/{javac/fieldsResolution/tests => diagnostics/tests/javac/fieldsResolution}/InheritedField.txt (100%) rename compiler/testData/{javac/fieldsResolution/tests => diagnostics/tests/javac/fieldsResolution}/MultipleOuters.kt (96%) rename compiler/testData/{javac/fieldsResolution/tests => diagnostics/tests/javac/fieldsResolution}/MultipleOuters.txt (100%) rename compiler/testData/{javac/fieldsResolution/tests => diagnostics/tests/javac/fieldsResolution}/ResolutionPriority.kt (98%) rename compiler/testData/{javac/fieldsResolution/tests => diagnostics/tests/javac/fieldsResolution}/ResolutionPriority.txt (100%) rename compiler/testData/{javac/fieldsResolution/tests => diagnostics/tests/javac/fieldsResolution}/SameFieldInSupertypes.kt (96%) rename compiler/testData/{javac/fieldsResolution/tests => diagnostics/tests/javac/fieldsResolution}/SameFieldInSupertypes.txt (100%) rename compiler/testData/{javac/fieldsResolution/tests => diagnostics/tests/javac/fieldsResolution}/StaticImport.kt (95%) rename compiler/testData/{javac/fieldsResolution/tests => diagnostics/tests/javac/fieldsResolution}/StaticImport.txt (100%) rename compiler/testData/{javac/fieldsResolution/tests => diagnostics/tests/javac/fieldsResolution}/StaticImportsAmbiguity.kt (96%) rename compiler/testData/{javac/fieldsResolution/tests => diagnostics/tests/javac/fieldsResolution}/StaticImportsAmbiguity.txt (100%) create mode 100644 compiler/testData/diagnostics/tests/javac/imports/AllUnderImportsAmbiguity.fir.kt rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/imports/AllUnderImportsAmbiguity.kt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/imports/AllUnderImportsAmbiguity.txt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/imports/AllUnderImportsLessPriority.kt (94%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/imports/AllUnderImportsLessPriority.txt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/imports/ClassImportsConflicting.kt (94%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/imports/ClassImportsConflicting.txt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/imports/CurrentPackageAndAllUnderImport.kt (93%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/imports/CurrentPackageAndAllUnderImport.txt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/imports/CurrentPackageAndExplicitImport.kt (94%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/imports/CurrentPackageAndExplicitImport.txt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/imports/CurrentPackageAndExplicitNestedImport.kt (94%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/imports/CurrentPackageAndExplicitNestedImport.txt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/imports/CurrentPackageAndNestedAsteriskImport.kt (94%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/imports/CurrentPackageAndNestedAsteriskImport.txt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/imports/ImportGenericVsPackage.kt (94%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/imports/ImportGenericVsPackage.txt (100%) create mode 100644 compiler/testData/diagnostics/tests/javac/imports/ImportProtectedClass.fir.kt rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/imports/ImportProtectedClass.kt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/imports/ImportProtectedClass.txt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/imports/ImportTwoTimes.kt (95%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/imports/ImportTwoTimes.txt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/imports/ImportTwoTimesStar.kt (95%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/imports/ImportTwoTimesStar.txt (100%) create mode 100644 compiler/testData/diagnostics/tests/javac/imports/NestedAndTopLevelClassClash.fir.kt rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/imports/NestedAndTopLevelClassClash.kt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/imports/NestedAndTopLevelClassClash.txt (100%) create mode 100644 compiler/testData/diagnostics/tests/javac/imports/NestedClassClash.fir.kt rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/imports/NestedClassClash.kt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/imports/NestedClassClash.txt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/imports/PackageExplicitAndStartImport.kt (94%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/imports/PackageExplicitAndStartImport.txt (100%) create mode 100644 compiler/testData/diagnostics/tests/javac/imports/PackagePrivateAndPublicNested.fir.kt rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/imports/PackagePrivateAndPublicNested.kt (94%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/imports/PackagePrivateAndPublicNested.txt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/imports/TopLevelClassVsPackage.kt (96%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/imports/TopLevelClassVsPackage.txt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/imports/TopLevelClassVsPackage2.kt (97%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/imports/TopLevelClassVsPackage2.txt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/inheritance/IheritanceOfInner.kt (95%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/inheritance/IheritanceOfInner.txt (100%) create mode 100644 compiler/testData/diagnostics/tests/javac/inheritance/InheritanceAmbiguity.fir.kt rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/inheritance/InheritanceAmbiguity.kt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/inheritance/InheritanceAmbiguity.txt (100%) create mode 100644 compiler/testData/diagnostics/tests/javac/inheritance/InheritanceAmbiguity2.fir.kt rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/inheritance/InheritanceAmbiguity2.kt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/inheritance/InheritanceAmbiguity2.txt (100%) create mode 100644 compiler/testData/diagnostics/tests/javac/inheritance/InheritanceAmbiguity3.fir.kt rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/inheritance/InheritanceAmbiguity3.kt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/inheritance/InheritanceAmbiguity3.txt (100%) rename compiler/testData/{javac/diagnostics/tests/inheritance/NoAmbiguity.kt => diagnostics/tests/javac/inheritance/InheritanceAmbiguity4.fir.kt} (96%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/inheritance/InheritanceAmbiguity4.kt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/inheritance/InheritanceAmbiguity4.txt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/inheritance/InheritanceWithKotlin.kt (97%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/inheritance/InheritanceWithKotlin.txt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/inheritance/InheritanceWithKotlinClasses.kt (96%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/inheritance/InheritanceWithKotlinClasses.txt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/inheritance/InheritedInner.kt (93%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/inheritance/InheritedInner.txt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/inheritance/InheritedInner2.kt (89%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/inheritance/InheritedInner2.txt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/inheritance/InheritedInnerAndSupertypeWithSameName.kt (94%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/inheritance/InheritedInnerAndSupertypeWithSameName.txt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/inheritance/InheritedInnerUsageInInner.kt (95%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/inheritance/InheritedInnerUsageInInner.txt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/inheritance/InheritedKotlinInner.kt (93%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/inheritance/InheritedKotlinInner.txt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/inheritance/InnerAndInheritedInner.kt (93%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/inheritance/InnerAndInheritedInner.txt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/inheritance/ManyInheritedClasses.kt (96%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/inheritance/ManyInheritedClasses.txt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/inheritance/SameInnersInSupertypeAndSupertypesSupertype.kt (95%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/inheritance/SameInnersInSupertypeAndSupertypesSupertype.txt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/inheritance/SuperTypeWithSameInner.kt (96%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/inheritance/SuperTypeWithSameInner.txt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/inheritance/SupertypeInnerAndTypeParameterWithSameNames.kt (95%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/inheritance/SupertypeInnerAndTypeParameterWithSameNames.txt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/inners/ComplexCase.kt (96%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/inners/ComplexCase.txt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/inners/ComplexCase2.kt (97%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/inners/ComplexCase2.txt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/inners/CurrentPackageAndInner.kt (94%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/inners/CurrentPackageAndInner.txt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/inners/ImportThriceNestedClass.kt (97%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/inners/ImportThriceNestedClass.txt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/inners/InnerInInner.kt (95%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/inners/InnerInInner.txt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/inners/Nested.kt (94%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/inners/Nested.txt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/inners/ThriceNestedClass.kt (96%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/inners/ThriceNestedClass.txt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/qualifiedExpression/GenericClassVsPackage.kt (97%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/qualifiedExpression/GenericClassVsPackage.txt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/qualifiedExpression/PackageVsClass.kt (97%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/qualifiedExpression/PackageVsClass.txt (100%) create mode 100644 compiler/testData/diagnostics/tests/javac/qualifiedExpression/PackageVsClass2.fir.kt rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/qualifiedExpression/PackageVsClass2.kt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/qualifiedExpression/PackageVsClass2.txt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/qualifiedExpression/PackageVsRootClass.kt (97%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/qualifiedExpression/PackageVsRootClass.txt (100%) create mode 100644 compiler/testData/diagnostics/tests/javac/qualifiedExpression/visibleClassVsQualifiedClass.fir.kt rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/qualifiedExpression/visibleClassVsQualifiedClass.kt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/qualifiedExpression/visibleClassVsQualifiedClass.txt (100%) create mode 100644 compiler/testData/diagnostics/tests/javac/typeParameters/Clash.fir.kt rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/typeParameters/Clash.kt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/typeParameters/Clash.txt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/typeParameters/ComplexCase.kt (98%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/typeParameters/ComplexCase.txt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/typeParameters/InheritedInnerAndTypeParameterWithSameNames.kt (93%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/typeParameters/InheritedInnerAndTypeParameterWithSameNames.txt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/typeParameters/InnerWithTypeParameter.kt (95%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/typeParameters/InnerWithTypeParameter.txt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/typeParameters/NestedWithInner.kt (94%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/typeParameters/NestedWithInner.txt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/typeParameters/SeveralInnersWithTypeParameters.kt (96%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/typeParameters/SeveralInnersWithTypeParameters.txt (100%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/typeParameters/TypeParametersInInnerAndOuterWithSameNames.kt (94%) rename compiler/testData/{javac/diagnostics/tests => diagnostics/tests/javac}/typeParameters/TypeParametersInInnerAndOuterWithSameNames.txt (100%) delete mode 100644 compiler/testData/javac/diagnostics/tests/inheritance/NoAmbiguity.txt delete mode 100644 compiler/testData/javac/diagnostics/tests/inheritance/NoAmbiguity2.kt delete mode 100644 compiler/testData/javac/diagnostics/tests/inheritance/NoAmbiguity2.txt delete mode 100644 compiler/tests-common/tests/org/jetbrains/kotlin/checkers/javac/AbstractJavacDiagnosticsTest.kt delete mode 100644 compiler/tests-common/tests/org/jetbrains/kotlin/checkers/javac/AbstractJavacFieldResolutionTest.kt delete mode 100644 compiler/tests-gen/org/jetbrains/kotlin/checkers/javac/JavacDiagnosticsTestGenerated.java delete mode 100644 compiler/tests-gen/org/jetbrains/kotlin/checkers/javac/JavacFieldResolutionTestGenerated.java diff --git a/compiler/testData/javac/diagnostics/tests/Annotations.kt b/compiler/testData/diagnostics/tests/javac/Annotations.kt similarity index 98% rename from compiler/testData/javac/diagnostics/tests/Annotations.kt rename to compiler/testData/diagnostics/tests/javac/Annotations.kt index 3c242da9372..44aab776b74 100644 --- a/compiler/testData/javac/diagnostics/tests/Annotations.kt +++ b/compiler/testData/diagnostics/tests/javac/Annotations.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: a/ann.java package a; diff --git a/compiler/testData/javac/diagnostics/tests/Annotations.txt b/compiler/testData/diagnostics/tests/javac/Annotations.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/Annotations.txt rename to compiler/testData/diagnostics/tests/javac/Annotations.txt diff --git a/compiler/testData/javac/fieldsResolution/tests/AsteriskStaticImportsAmbiguity.kt b/compiler/testData/diagnostics/tests/javac/fieldsResolution/AsteriskStaticImportsAmbiguity.kt similarity index 96% rename from compiler/testData/javac/fieldsResolution/tests/AsteriskStaticImportsAmbiguity.kt rename to compiler/testData/diagnostics/tests/javac/fieldsResolution/AsteriskStaticImportsAmbiguity.kt index 906d91f47fa..b4457299037 100644 --- a/compiler/testData/javac/fieldsResolution/tests/AsteriskStaticImportsAmbiguity.kt +++ b/compiler/testData/diagnostics/tests/javac/fieldsResolution/AsteriskStaticImportsAmbiguity.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: a/x.java package a; diff --git a/compiler/testData/javac/fieldsResolution/tests/AsteriskStaticImportsAmbiguity.txt b/compiler/testData/diagnostics/tests/javac/fieldsResolution/AsteriskStaticImportsAmbiguity.txt similarity index 100% rename from compiler/testData/javac/fieldsResolution/tests/AsteriskStaticImportsAmbiguity.txt rename to compiler/testData/diagnostics/tests/javac/fieldsResolution/AsteriskStaticImportsAmbiguity.txt diff --git a/compiler/testData/javac/fieldsResolution/tests/BinaryInitializers.kt b/compiler/testData/diagnostics/tests/javac/fieldsResolution/BinaryInitializers.kt similarity index 95% rename from compiler/testData/javac/fieldsResolution/tests/BinaryInitializers.kt rename to compiler/testData/diagnostics/tests/javac/fieldsResolution/BinaryInitializers.kt index a0c16441bc7..ba1c7b1846b 100644 --- a/compiler/testData/javac/fieldsResolution/tests/BinaryInitializers.kt +++ b/compiler/testData/diagnostics/tests/javac/fieldsResolution/BinaryInitializers.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: a/x.java package a; diff --git a/compiler/testData/javac/fieldsResolution/tests/BinaryInitializers.txt b/compiler/testData/diagnostics/tests/javac/fieldsResolution/BinaryInitializers.txt similarity index 100% rename from compiler/testData/javac/fieldsResolution/tests/BinaryInitializers.txt rename to compiler/testData/diagnostics/tests/javac/fieldsResolution/BinaryInitializers.txt diff --git a/compiler/testData/javac/fieldsResolution/tests/ConstantByFqName.kt b/compiler/testData/diagnostics/tests/javac/fieldsResolution/ConstantByFqName.kt similarity index 92% rename from compiler/testData/javac/fieldsResolution/tests/ConstantByFqName.kt rename to compiler/testData/diagnostics/tests/javac/fieldsResolution/ConstantByFqName.kt index 909a1536180..310a325b86e 100644 --- a/compiler/testData/javac/fieldsResolution/tests/ConstantByFqName.kt +++ b/compiler/testData/diagnostics/tests/javac/fieldsResolution/ConstantByFqName.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: a/x.java package a; diff --git a/compiler/testData/javac/fieldsResolution/tests/ConstantByFqName.txt b/compiler/testData/diagnostics/tests/javac/fieldsResolution/ConstantByFqName.txt similarity index 100% rename from compiler/testData/javac/fieldsResolution/tests/ConstantByFqName.txt rename to compiler/testData/diagnostics/tests/javac/fieldsResolution/ConstantByFqName.txt diff --git a/compiler/testData/javac/fieldsResolution/tests/ConstantValues.kt b/compiler/testData/diagnostics/tests/javac/fieldsResolution/ConstantValues.kt similarity index 98% rename from compiler/testData/javac/fieldsResolution/tests/ConstantValues.kt rename to compiler/testData/diagnostics/tests/javac/fieldsResolution/ConstantValues.kt index a40f39e8d21..fa5b4d628c8 100644 --- a/compiler/testData/javac/fieldsResolution/tests/ConstantValues.kt +++ b/compiler/testData/diagnostics/tests/javac/fieldsResolution/ConstantValues.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: a/x.java package a; diff --git a/compiler/testData/javac/fieldsResolution/tests/ConstantValues.txt b/compiler/testData/diagnostics/tests/javac/fieldsResolution/ConstantValues.txt similarity index 100% rename from compiler/testData/javac/fieldsResolution/tests/ConstantValues.txt rename to compiler/testData/diagnostics/tests/javac/fieldsResolution/ConstantValues.txt diff --git a/compiler/testData/javac/fieldsResolution/tests/ConstantValuesFromKtFile.kt b/compiler/testData/diagnostics/tests/javac/fieldsResolution/ConstantValuesFromKtFile.kt similarity index 95% rename from compiler/testData/javac/fieldsResolution/tests/ConstantValuesFromKtFile.kt rename to compiler/testData/diagnostics/tests/javac/fieldsResolution/ConstantValuesFromKtFile.kt index a8a910d9d5c..0abc57519d7 100644 --- a/compiler/testData/javac/fieldsResolution/tests/ConstantValuesFromKtFile.kt +++ b/compiler/testData/diagnostics/tests/javac/fieldsResolution/ConstantValuesFromKtFile.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: test.kt package a diff --git a/compiler/testData/javac/fieldsResolution/tests/ConstantValuesFromKtFile.txt b/compiler/testData/diagnostics/tests/javac/fieldsResolution/ConstantValuesFromKtFile.txt similarity index 100% rename from compiler/testData/javac/fieldsResolution/tests/ConstantValuesFromKtFile.txt rename to compiler/testData/diagnostics/tests/javac/fieldsResolution/ConstantValuesFromKtFile.txt diff --git a/compiler/testData/javac/fieldsResolution/tests/FieldFromOuterClass.kt b/compiler/testData/diagnostics/tests/javac/fieldsResolution/FieldFromOuterClass.kt similarity index 97% rename from compiler/testData/javac/fieldsResolution/tests/FieldFromOuterClass.kt rename to compiler/testData/diagnostics/tests/javac/fieldsResolution/FieldFromOuterClass.kt index da0c2419af4..37e610ec7fb 100644 --- a/compiler/testData/javac/fieldsResolution/tests/FieldFromOuterClass.kt +++ b/compiler/testData/diagnostics/tests/javac/fieldsResolution/FieldFromOuterClass.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: a/x.java package a; diff --git a/compiler/testData/javac/fieldsResolution/tests/FieldFromOuterClass.txt b/compiler/testData/diagnostics/tests/javac/fieldsResolution/FieldFromOuterClass.txt similarity index 100% rename from compiler/testData/javac/fieldsResolution/tests/FieldFromOuterClass.txt rename to compiler/testData/diagnostics/tests/javac/fieldsResolution/FieldFromOuterClass.txt diff --git a/compiler/testData/javac/fieldsResolution/tests/InheritedField.kt b/compiler/testData/diagnostics/tests/javac/fieldsResolution/InheritedField.kt similarity index 94% rename from compiler/testData/javac/fieldsResolution/tests/InheritedField.kt rename to compiler/testData/diagnostics/tests/javac/fieldsResolution/InheritedField.kt index bee64fc5331..ff9f4d29a36 100644 --- a/compiler/testData/javac/fieldsResolution/tests/InheritedField.kt +++ b/compiler/testData/diagnostics/tests/javac/fieldsResolution/InheritedField.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: a/x.java package a; diff --git a/compiler/testData/javac/fieldsResolution/tests/InheritedField.txt b/compiler/testData/diagnostics/tests/javac/fieldsResolution/InheritedField.txt similarity index 100% rename from compiler/testData/javac/fieldsResolution/tests/InheritedField.txt rename to compiler/testData/diagnostics/tests/javac/fieldsResolution/InheritedField.txt diff --git a/compiler/testData/javac/fieldsResolution/tests/MultipleOuters.kt b/compiler/testData/diagnostics/tests/javac/fieldsResolution/MultipleOuters.kt similarity index 96% rename from compiler/testData/javac/fieldsResolution/tests/MultipleOuters.kt rename to compiler/testData/diagnostics/tests/javac/fieldsResolution/MultipleOuters.kt index 442da9dc487..18ad9ce342a 100644 --- a/compiler/testData/javac/fieldsResolution/tests/MultipleOuters.kt +++ b/compiler/testData/diagnostics/tests/javac/fieldsResolution/MultipleOuters.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: a/X.java package a; diff --git a/compiler/testData/javac/fieldsResolution/tests/MultipleOuters.txt b/compiler/testData/diagnostics/tests/javac/fieldsResolution/MultipleOuters.txt similarity index 100% rename from compiler/testData/javac/fieldsResolution/tests/MultipleOuters.txt rename to compiler/testData/diagnostics/tests/javac/fieldsResolution/MultipleOuters.txt diff --git a/compiler/testData/javac/fieldsResolution/tests/ResolutionPriority.kt b/compiler/testData/diagnostics/tests/javac/fieldsResolution/ResolutionPriority.kt similarity index 98% rename from compiler/testData/javac/fieldsResolution/tests/ResolutionPriority.kt rename to compiler/testData/diagnostics/tests/javac/fieldsResolution/ResolutionPriority.kt index 696d4c099e4..a5698ca4528 100644 --- a/compiler/testData/javac/fieldsResolution/tests/ResolutionPriority.kt +++ b/compiler/testData/diagnostics/tests/javac/fieldsResolution/ResolutionPriority.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: a/x.java package a; diff --git a/compiler/testData/javac/fieldsResolution/tests/ResolutionPriority.txt b/compiler/testData/diagnostics/tests/javac/fieldsResolution/ResolutionPriority.txt similarity index 100% rename from compiler/testData/javac/fieldsResolution/tests/ResolutionPriority.txt rename to compiler/testData/diagnostics/tests/javac/fieldsResolution/ResolutionPriority.txt diff --git a/compiler/testData/javac/fieldsResolution/tests/SameFieldInSupertypes.kt b/compiler/testData/diagnostics/tests/javac/fieldsResolution/SameFieldInSupertypes.kt similarity index 96% rename from compiler/testData/javac/fieldsResolution/tests/SameFieldInSupertypes.kt rename to compiler/testData/diagnostics/tests/javac/fieldsResolution/SameFieldInSupertypes.kt index 847a1eba9ac..b0cb31d1f8a 100644 --- a/compiler/testData/javac/fieldsResolution/tests/SameFieldInSupertypes.kt +++ b/compiler/testData/diagnostics/tests/javac/fieldsResolution/SameFieldInSupertypes.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: a/x.java package a; diff --git a/compiler/testData/javac/fieldsResolution/tests/SameFieldInSupertypes.txt b/compiler/testData/diagnostics/tests/javac/fieldsResolution/SameFieldInSupertypes.txt similarity index 100% rename from compiler/testData/javac/fieldsResolution/tests/SameFieldInSupertypes.txt rename to compiler/testData/diagnostics/tests/javac/fieldsResolution/SameFieldInSupertypes.txt diff --git a/compiler/testData/javac/fieldsResolution/tests/StaticImport.kt b/compiler/testData/diagnostics/tests/javac/fieldsResolution/StaticImport.kt similarity index 95% rename from compiler/testData/javac/fieldsResolution/tests/StaticImport.kt rename to compiler/testData/diagnostics/tests/javac/fieldsResolution/StaticImport.kt index 8621406f2c8..57ce2c066e5 100644 --- a/compiler/testData/javac/fieldsResolution/tests/StaticImport.kt +++ b/compiler/testData/diagnostics/tests/javac/fieldsResolution/StaticImport.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: a/x.java package a; diff --git a/compiler/testData/javac/fieldsResolution/tests/StaticImport.txt b/compiler/testData/diagnostics/tests/javac/fieldsResolution/StaticImport.txt similarity index 100% rename from compiler/testData/javac/fieldsResolution/tests/StaticImport.txt rename to compiler/testData/diagnostics/tests/javac/fieldsResolution/StaticImport.txt diff --git a/compiler/testData/javac/fieldsResolution/tests/StaticImportsAmbiguity.kt b/compiler/testData/diagnostics/tests/javac/fieldsResolution/StaticImportsAmbiguity.kt similarity index 96% rename from compiler/testData/javac/fieldsResolution/tests/StaticImportsAmbiguity.kt rename to compiler/testData/diagnostics/tests/javac/fieldsResolution/StaticImportsAmbiguity.kt index 6f630bc0699..a34ef3e51a5 100644 --- a/compiler/testData/javac/fieldsResolution/tests/StaticImportsAmbiguity.kt +++ b/compiler/testData/diagnostics/tests/javac/fieldsResolution/StaticImportsAmbiguity.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: a/x.java package a; diff --git a/compiler/testData/javac/fieldsResolution/tests/StaticImportsAmbiguity.txt b/compiler/testData/diagnostics/tests/javac/fieldsResolution/StaticImportsAmbiguity.txt similarity index 100% rename from compiler/testData/javac/fieldsResolution/tests/StaticImportsAmbiguity.txt rename to compiler/testData/diagnostics/tests/javac/fieldsResolution/StaticImportsAmbiguity.txt diff --git a/compiler/testData/diagnostics/tests/javac/imports/AllUnderImportsAmbiguity.fir.kt b/compiler/testData/diagnostics/tests/javac/imports/AllUnderImportsAmbiguity.fir.kt new file mode 100644 index 00000000000..895ab3a9db4 --- /dev/null +++ b/compiler/testData/diagnostics/tests/javac/imports/AllUnderImportsAmbiguity.fir.kt @@ -0,0 +1,27 @@ +// FILE: a/x.java +package a; + +public class x {} + +// FILE: b/x.java +package b; + +public class x {} + +// FILE: c/d.java +package c; + +import a.*; +import b.*; + +public class d { + public x x() { return null; } +} + +// FILE: c/c.kt +package c + +import a.* +import b.* + +fun test(): x = d().x() diff --git a/compiler/testData/javac/diagnostics/tests/imports/AllUnderImportsAmbiguity.kt b/compiler/testData/diagnostics/tests/javac/imports/AllUnderImportsAmbiguity.kt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/imports/AllUnderImportsAmbiguity.kt rename to compiler/testData/diagnostics/tests/javac/imports/AllUnderImportsAmbiguity.kt diff --git a/compiler/testData/javac/diagnostics/tests/imports/AllUnderImportsAmbiguity.txt b/compiler/testData/diagnostics/tests/javac/imports/AllUnderImportsAmbiguity.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/imports/AllUnderImportsAmbiguity.txt rename to compiler/testData/diagnostics/tests/javac/imports/AllUnderImportsAmbiguity.txt diff --git a/compiler/testData/javac/diagnostics/tests/imports/AllUnderImportsLessPriority.kt b/compiler/testData/diagnostics/tests/javac/imports/AllUnderImportsLessPriority.kt similarity index 94% rename from compiler/testData/javac/diagnostics/tests/imports/AllUnderImportsLessPriority.kt rename to compiler/testData/diagnostics/tests/javac/imports/AllUnderImportsLessPriority.kt index 9d5e05f302f..f94b38d8ec4 100644 --- a/compiler/testData/javac/diagnostics/tests/imports/AllUnderImportsLessPriority.kt +++ b/compiler/testData/diagnostics/tests/javac/imports/AllUnderImportsLessPriority.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: a/X.java package a; diff --git a/compiler/testData/javac/diagnostics/tests/imports/AllUnderImportsLessPriority.txt b/compiler/testData/diagnostics/tests/javac/imports/AllUnderImportsLessPriority.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/imports/AllUnderImportsLessPriority.txt rename to compiler/testData/diagnostics/tests/javac/imports/AllUnderImportsLessPriority.txt diff --git a/compiler/testData/javac/diagnostics/tests/imports/ClassImportsConflicting.kt b/compiler/testData/diagnostics/tests/javac/imports/ClassImportsConflicting.kt similarity index 94% rename from compiler/testData/javac/diagnostics/tests/imports/ClassImportsConflicting.kt rename to compiler/testData/diagnostics/tests/javac/imports/ClassImportsConflicting.kt index 219a36fd843..567031d6120 100644 --- a/compiler/testData/javac/diagnostics/tests/imports/ClassImportsConflicting.kt +++ b/compiler/testData/diagnostics/tests/javac/imports/ClassImportsConflicting.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // SKIP_JAVAC // FILE: b.kt package b diff --git a/compiler/testData/javac/diagnostics/tests/imports/ClassImportsConflicting.txt b/compiler/testData/diagnostics/tests/javac/imports/ClassImportsConflicting.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/imports/ClassImportsConflicting.txt rename to compiler/testData/diagnostics/tests/javac/imports/ClassImportsConflicting.txt diff --git a/compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndAllUnderImport.kt b/compiler/testData/diagnostics/tests/javac/imports/CurrentPackageAndAllUnderImport.kt similarity index 93% rename from compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndAllUnderImport.kt rename to compiler/testData/diagnostics/tests/javac/imports/CurrentPackageAndAllUnderImport.kt index b25a38a5a6b..5f622c24bd4 100644 --- a/compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndAllUnderImport.kt +++ b/compiler/testData/diagnostics/tests/javac/imports/CurrentPackageAndAllUnderImport.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: a/X.java package a; diff --git a/compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndAllUnderImport.txt b/compiler/testData/diagnostics/tests/javac/imports/CurrentPackageAndAllUnderImport.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndAllUnderImport.txt rename to compiler/testData/diagnostics/tests/javac/imports/CurrentPackageAndAllUnderImport.txt diff --git a/compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndExplicitImport.kt b/compiler/testData/diagnostics/tests/javac/imports/CurrentPackageAndExplicitImport.kt similarity index 94% rename from compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndExplicitImport.kt rename to compiler/testData/diagnostics/tests/javac/imports/CurrentPackageAndExplicitImport.kt index a4021952978..fb7abd25c9e 100644 --- a/compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndExplicitImport.kt +++ b/compiler/testData/diagnostics/tests/javac/imports/CurrentPackageAndExplicitImport.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: a/Y.java package a; diff --git a/compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndExplicitImport.txt b/compiler/testData/diagnostics/tests/javac/imports/CurrentPackageAndExplicitImport.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndExplicitImport.txt rename to compiler/testData/diagnostics/tests/javac/imports/CurrentPackageAndExplicitImport.txt diff --git a/compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndExplicitNestedImport.kt b/compiler/testData/diagnostics/tests/javac/imports/CurrentPackageAndExplicitNestedImport.kt similarity index 94% rename from compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndExplicitNestedImport.kt rename to compiler/testData/diagnostics/tests/javac/imports/CurrentPackageAndExplicitNestedImport.kt index a3fbb43864b..50fd98c0189 100644 --- a/compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndExplicitNestedImport.kt +++ b/compiler/testData/diagnostics/tests/javac/imports/CurrentPackageAndExplicitNestedImport.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: a/X.java package a; diff --git a/compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndExplicitNestedImport.txt b/compiler/testData/diagnostics/tests/javac/imports/CurrentPackageAndExplicitNestedImport.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndExplicitNestedImport.txt rename to compiler/testData/diagnostics/tests/javac/imports/CurrentPackageAndExplicitNestedImport.txt diff --git a/compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndNestedAsteriskImport.kt b/compiler/testData/diagnostics/tests/javac/imports/CurrentPackageAndNestedAsteriskImport.kt similarity index 94% rename from compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndNestedAsteriskImport.kt rename to compiler/testData/diagnostics/tests/javac/imports/CurrentPackageAndNestedAsteriskImport.kt index 1933ba18a31..6fc825f30ff 100644 --- a/compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndNestedAsteriskImport.kt +++ b/compiler/testData/diagnostics/tests/javac/imports/CurrentPackageAndNestedAsteriskImport.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: a/X.java package a; diff --git a/compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndNestedAsteriskImport.txt b/compiler/testData/diagnostics/tests/javac/imports/CurrentPackageAndNestedAsteriskImport.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndNestedAsteriskImport.txt rename to compiler/testData/diagnostics/tests/javac/imports/CurrentPackageAndNestedAsteriskImport.txt diff --git a/compiler/testData/javac/diagnostics/tests/imports/ImportGenericVsPackage.kt b/compiler/testData/diagnostics/tests/javac/imports/ImportGenericVsPackage.kt similarity index 94% rename from compiler/testData/javac/diagnostics/tests/imports/ImportGenericVsPackage.kt rename to compiler/testData/diagnostics/tests/javac/imports/ImportGenericVsPackage.kt index 015c27ce30c..03481f1e675 100644 --- a/compiler/testData/javac/diagnostics/tests/imports/ImportGenericVsPackage.kt +++ b/compiler/testData/diagnostics/tests/javac/imports/ImportGenericVsPackage.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: a/x.java package a; diff --git a/compiler/testData/javac/diagnostics/tests/imports/ImportGenericVsPackage.txt b/compiler/testData/diagnostics/tests/javac/imports/ImportGenericVsPackage.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/imports/ImportGenericVsPackage.txt rename to compiler/testData/diagnostics/tests/javac/imports/ImportGenericVsPackage.txt diff --git a/compiler/testData/diagnostics/tests/javac/imports/ImportProtectedClass.fir.kt b/compiler/testData/diagnostics/tests/javac/imports/ImportProtectedClass.fir.kt new file mode 100644 index 00000000000..71fb84a31dc --- /dev/null +++ b/compiler/testData/diagnostics/tests/javac/imports/ImportProtectedClass.fir.kt @@ -0,0 +1,19 @@ +// FILE: p/Foo.java +package p; + +public class Foo { + protected static class Nested {} +} + +// FILE: foo.kt +package a + +import p.Foo +import p.Foo.Nested + +class Bar : Foo() { + protected fun foo(): Nested? = null +} + +private fun foo(): Nested? = null +private fun bar(): p.Foo.Nested? = null diff --git a/compiler/testData/javac/diagnostics/tests/imports/ImportProtectedClass.kt b/compiler/testData/diagnostics/tests/javac/imports/ImportProtectedClass.kt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/imports/ImportProtectedClass.kt rename to compiler/testData/diagnostics/tests/javac/imports/ImportProtectedClass.kt diff --git a/compiler/testData/javac/diagnostics/tests/imports/ImportProtectedClass.txt b/compiler/testData/diagnostics/tests/javac/imports/ImportProtectedClass.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/imports/ImportProtectedClass.txt rename to compiler/testData/diagnostics/tests/javac/imports/ImportProtectedClass.txt diff --git a/compiler/testData/javac/diagnostics/tests/imports/ImportTwoTimes.kt b/compiler/testData/diagnostics/tests/javac/imports/ImportTwoTimes.kt similarity index 95% rename from compiler/testData/javac/diagnostics/tests/imports/ImportTwoTimes.kt rename to compiler/testData/diagnostics/tests/javac/imports/ImportTwoTimes.kt index dd23fa50cd0..fb0e8102de1 100644 --- a/compiler/testData/javac/diagnostics/tests/imports/ImportTwoTimes.kt +++ b/compiler/testData/diagnostics/tests/javac/imports/ImportTwoTimes.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: weatherForecast/Weather.java package weatherForecast; diff --git a/compiler/testData/javac/diagnostics/tests/imports/ImportTwoTimes.txt b/compiler/testData/diagnostics/tests/javac/imports/ImportTwoTimes.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/imports/ImportTwoTimes.txt rename to compiler/testData/diagnostics/tests/javac/imports/ImportTwoTimes.txt diff --git a/compiler/testData/javac/diagnostics/tests/imports/ImportTwoTimesStar.kt b/compiler/testData/diagnostics/tests/javac/imports/ImportTwoTimesStar.kt similarity index 95% rename from compiler/testData/javac/diagnostics/tests/imports/ImportTwoTimesStar.kt rename to compiler/testData/diagnostics/tests/javac/imports/ImportTwoTimesStar.kt index 80e01409fef..3ca138bce9b 100644 --- a/compiler/testData/javac/diagnostics/tests/imports/ImportTwoTimesStar.kt +++ b/compiler/testData/diagnostics/tests/javac/imports/ImportTwoTimesStar.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: weatherForecast/Weather.java package weatherForecast; diff --git a/compiler/testData/javac/diagnostics/tests/imports/ImportTwoTimesStar.txt b/compiler/testData/diagnostics/tests/javac/imports/ImportTwoTimesStar.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/imports/ImportTwoTimesStar.txt rename to compiler/testData/diagnostics/tests/javac/imports/ImportTwoTimesStar.txt diff --git a/compiler/testData/diagnostics/tests/javac/imports/NestedAndTopLevelClassClash.fir.kt b/compiler/testData/diagnostics/tests/javac/imports/NestedAndTopLevelClassClash.fir.kt new file mode 100644 index 00000000000..acc89c2038d --- /dev/null +++ b/compiler/testData/diagnostics/tests/javac/imports/NestedAndTopLevelClassClash.fir.kt @@ -0,0 +1,38 @@ +// SKIP_JAVAC +// FILE: a/B.java +package a; + +public class B {} + +// FILE: a/D.java +package a; + +public class D { + public static class B {} +} + +// FILE: b/A1.java +package b; + +import a.B; +import a.D.B; + +public class A1 { + public B getB() { return null; } +} + +// FILE: b/A2.java +package b; + +import a.*; +import a.D.*; + +public class A2 { + public B getB() { return null; } +} + +// FILE: a.kt +package b + +fun test() = A1().getB() +fun test2() = A2().getB() \ No newline at end of file diff --git a/compiler/testData/javac/diagnostics/tests/imports/NestedAndTopLevelClassClash.kt b/compiler/testData/diagnostics/tests/javac/imports/NestedAndTopLevelClassClash.kt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/imports/NestedAndTopLevelClassClash.kt rename to compiler/testData/diagnostics/tests/javac/imports/NestedAndTopLevelClassClash.kt diff --git a/compiler/testData/javac/diagnostics/tests/imports/NestedAndTopLevelClassClash.txt b/compiler/testData/diagnostics/tests/javac/imports/NestedAndTopLevelClassClash.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/imports/NestedAndTopLevelClassClash.txt rename to compiler/testData/diagnostics/tests/javac/imports/NestedAndTopLevelClassClash.txt diff --git a/compiler/testData/diagnostics/tests/javac/imports/NestedClassClash.fir.kt b/compiler/testData/diagnostics/tests/javac/imports/NestedClassClash.fir.kt new file mode 100644 index 00000000000..289b60b8d6c --- /dev/null +++ b/compiler/testData/diagnostics/tests/javac/imports/NestedClassClash.fir.kt @@ -0,0 +1,40 @@ +// SKIP_JAVAC +// FILE: a/A.java +package a; + +public class A { + public static class B {} +} + +// FILE: a/D.java +package a; + +public class D { + public static class B {} +} + +// FILE: b/A1.java +package b; + +import a.A.B; +import a.D.B; + +public class A1 { + public B getB() { return null; } +} + +// FILE: b/A2.java +package b; + +import a.A.*; +import a.D.*; + +public class A2 { + public B getB() { return null; } +} + +// FILE: a.kt +package b + +fun test() = A1().getB() +fun test2() = A2().getB() diff --git a/compiler/testData/javac/diagnostics/tests/imports/NestedClassClash.kt b/compiler/testData/diagnostics/tests/javac/imports/NestedClassClash.kt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/imports/NestedClassClash.kt rename to compiler/testData/diagnostics/tests/javac/imports/NestedClassClash.kt diff --git a/compiler/testData/javac/diagnostics/tests/imports/NestedClassClash.txt b/compiler/testData/diagnostics/tests/javac/imports/NestedClassClash.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/imports/NestedClassClash.txt rename to compiler/testData/diagnostics/tests/javac/imports/NestedClassClash.txt diff --git a/compiler/testData/javac/diagnostics/tests/imports/PackageExplicitAndStartImport.kt b/compiler/testData/diagnostics/tests/javac/imports/PackageExplicitAndStartImport.kt similarity index 94% rename from compiler/testData/javac/diagnostics/tests/imports/PackageExplicitAndStartImport.kt rename to compiler/testData/diagnostics/tests/javac/imports/PackageExplicitAndStartImport.kt index 02059160140..52a8743e09e 100644 --- a/compiler/testData/javac/diagnostics/tests/imports/PackageExplicitAndStartImport.kt +++ b/compiler/testData/diagnostics/tests/javac/imports/PackageExplicitAndStartImport.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: a/x.java package a; diff --git a/compiler/testData/javac/diagnostics/tests/imports/PackageExplicitAndStartImport.txt b/compiler/testData/diagnostics/tests/javac/imports/PackageExplicitAndStartImport.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/imports/PackageExplicitAndStartImport.txt rename to compiler/testData/diagnostics/tests/javac/imports/PackageExplicitAndStartImport.txt diff --git a/compiler/testData/diagnostics/tests/javac/imports/PackagePrivateAndPublicNested.fir.kt b/compiler/testData/diagnostics/tests/javac/imports/PackagePrivateAndPublicNested.fir.kt new file mode 100644 index 00000000000..dc5b5767b04 --- /dev/null +++ b/compiler/testData/diagnostics/tests/javac/imports/PackagePrivateAndPublicNested.fir.kt @@ -0,0 +1,19 @@ +// FILE: p/Foo.java +package p; + +class Foo { + public static class Nested {} +} + +// FILE: foo.kt +package a + +import p.Foo +import p.Foo.Nested + +class Bar : Foo() { + protected fun foo(): Nested? = null +} + +private fun foo(): Nested? = null +private fun bar(): p.Foo.Nested? = null diff --git a/compiler/testData/javac/diagnostics/tests/imports/PackagePrivateAndPublicNested.kt b/compiler/testData/diagnostics/tests/javac/imports/PackagePrivateAndPublicNested.kt similarity index 94% rename from compiler/testData/javac/diagnostics/tests/imports/PackagePrivateAndPublicNested.kt rename to compiler/testData/diagnostics/tests/javac/imports/PackagePrivateAndPublicNested.kt index 664392a7bb0..27d3f9d4908 100644 --- a/compiler/testData/javac/diagnostics/tests/imports/PackagePrivateAndPublicNested.kt +++ b/compiler/testData/diagnostics/tests/javac/imports/PackagePrivateAndPublicNested.kt @@ -16,4 +16,4 @@ class Bar : Foo< } private fun foo(): Nested? = null -private fun bar(): p.Foo.Nested? = null \ No newline at end of file +private fun bar(): p.Foo.Nested? = null diff --git a/compiler/testData/javac/diagnostics/tests/imports/PackagePrivateAndPublicNested.txt b/compiler/testData/diagnostics/tests/javac/imports/PackagePrivateAndPublicNested.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/imports/PackagePrivateAndPublicNested.txt rename to compiler/testData/diagnostics/tests/javac/imports/PackagePrivateAndPublicNested.txt diff --git a/compiler/testData/javac/diagnostics/tests/imports/TopLevelClassVsPackage.kt b/compiler/testData/diagnostics/tests/javac/imports/TopLevelClassVsPackage.kt similarity index 96% rename from compiler/testData/javac/diagnostics/tests/imports/TopLevelClassVsPackage.kt rename to compiler/testData/diagnostics/tests/javac/imports/TopLevelClassVsPackage.kt index 8cee97895ed..4ed35cfc51f 100644 --- a/compiler/testData/javac/diagnostics/tests/imports/TopLevelClassVsPackage.kt +++ b/compiler/testData/diagnostics/tests/javac/imports/TopLevelClassVsPackage.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: a/b.java package a; diff --git a/compiler/testData/javac/diagnostics/tests/imports/TopLevelClassVsPackage.txt b/compiler/testData/diagnostics/tests/javac/imports/TopLevelClassVsPackage.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/imports/TopLevelClassVsPackage.txt rename to compiler/testData/diagnostics/tests/javac/imports/TopLevelClassVsPackage.txt diff --git a/compiler/testData/javac/diagnostics/tests/imports/TopLevelClassVsPackage2.kt b/compiler/testData/diagnostics/tests/javac/imports/TopLevelClassVsPackage2.kt similarity index 97% rename from compiler/testData/javac/diagnostics/tests/imports/TopLevelClassVsPackage2.kt rename to compiler/testData/diagnostics/tests/javac/imports/TopLevelClassVsPackage2.kt index 73947aaad2e..d885d4b4fb6 100644 --- a/compiler/testData/javac/diagnostics/tests/imports/TopLevelClassVsPackage2.kt +++ b/compiler/testData/diagnostics/tests/javac/imports/TopLevelClassVsPackage2.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: foo/a/b.java package foo.a; diff --git a/compiler/testData/javac/diagnostics/tests/imports/TopLevelClassVsPackage2.txt b/compiler/testData/diagnostics/tests/javac/imports/TopLevelClassVsPackage2.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/imports/TopLevelClassVsPackage2.txt rename to compiler/testData/diagnostics/tests/javac/imports/TopLevelClassVsPackage2.txt diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/IheritanceOfInner.kt b/compiler/testData/diagnostics/tests/javac/inheritance/IheritanceOfInner.kt similarity index 95% rename from compiler/testData/javac/diagnostics/tests/inheritance/IheritanceOfInner.kt rename to compiler/testData/diagnostics/tests/javac/inheritance/IheritanceOfInner.kt index d8ed0041f10..aad8edf7068 100644 --- a/compiler/testData/javac/diagnostics/tests/inheritance/IheritanceOfInner.kt +++ b/compiler/testData/diagnostics/tests/javac/inheritance/IheritanceOfInner.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: a/d.java package a; diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/IheritanceOfInner.txt b/compiler/testData/diagnostics/tests/javac/inheritance/IheritanceOfInner.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/inheritance/IheritanceOfInner.txt rename to compiler/testData/diagnostics/tests/javac/inheritance/IheritanceOfInner.txt diff --git a/compiler/testData/diagnostics/tests/javac/inheritance/InheritanceAmbiguity.fir.kt b/compiler/testData/diagnostics/tests/javac/inheritance/InheritanceAmbiguity.fir.kt new file mode 100644 index 00000000000..d36610b8d74 --- /dev/null +++ b/compiler/testData/diagnostics/tests/javac/inheritance/InheritanceAmbiguity.fir.kt @@ -0,0 +1,27 @@ +// FILE: a/x.java +package a; + +public class x { + public class Z {} +} + +// FILE: a/i.java +package a; + +public interface i { + public class Z {} +} + +// FILE: a/y.java +package a; + +public class y extends x implements i { + + public Z getZ() { return null; } + +} + +// FILE: test.kt +package a + +fun test() = y().getZ() \ No newline at end of file diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity.kt b/compiler/testData/diagnostics/tests/javac/inheritance/InheritanceAmbiguity.kt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity.kt rename to compiler/testData/diagnostics/tests/javac/inheritance/InheritanceAmbiguity.kt diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity.txt b/compiler/testData/diagnostics/tests/javac/inheritance/InheritanceAmbiguity.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity.txt rename to compiler/testData/diagnostics/tests/javac/inheritance/InheritanceAmbiguity.txt diff --git a/compiler/testData/diagnostics/tests/javac/inheritance/InheritanceAmbiguity2.fir.kt b/compiler/testData/diagnostics/tests/javac/inheritance/InheritanceAmbiguity2.fir.kt new file mode 100644 index 00000000000..2fa29683ef7 --- /dev/null +++ b/compiler/testData/diagnostics/tests/javac/inheritance/InheritanceAmbiguity2.fir.kt @@ -0,0 +1,30 @@ +// FILE: a/x.java +package a; + +public class x { + public class Z {} +} + +// FILE: a/i.java +package a; + +public interface i { + public class Z {} +} + +// FILE: a/i2.java +package a; + +public interface i2 extends i {} + +// FILE: a/y.java +package a; + +public class y extends x implements i2 { + public Z getZ() { return null; } +} + +// FILE: test.kt +package a + +fun test() = y().getZ() \ No newline at end of file diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity2.kt b/compiler/testData/diagnostics/tests/javac/inheritance/InheritanceAmbiguity2.kt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity2.kt rename to compiler/testData/diagnostics/tests/javac/inheritance/InheritanceAmbiguity2.kt diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity2.txt b/compiler/testData/diagnostics/tests/javac/inheritance/InheritanceAmbiguity2.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity2.txt rename to compiler/testData/diagnostics/tests/javac/inheritance/InheritanceAmbiguity2.txt diff --git a/compiler/testData/diagnostics/tests/javac/inheritance/InheritanceAmbiguity3.fir.kt b/compiler/testData/diagnostics/tests/javac/inheritance/InheritanceAmbiguity3.fir.kt new file mode 100644 index 00000000000..cf43f950efd --- /dev/null +++ b/compiler/testData/diagnostics/tests/javac/inheritance/InheritanceAmbiguity3.fir.kt @@ -0,0 +1,25 @@ +// FILE: a/i.java +package a; + +public interface i { + public class Z {} +} + +// FILE: a/i2.java +package a; + +public interface i2 { + public class Z {} +} + +// FILE: a/x.java +package a; + +public class x implements i, i2 { + public Z getZ() { return null; } +} + +// FILE: test.kt +package a + +fun test() = x().getZ() \ No newline at end of file diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity3.kt b/compiler/testData/diagnostics/tests/javac/inheritance/InheritanceAmbiguity3.kt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity3.kt rename to compiler/testData/diagnostics/tests/javac/inheritance/InheritanceAmbiguity3.kt diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity3.txt b/compiler/testData/diagnostics/tests/javac/inheritance/InheritanceAmbiguity3.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity3.txt rename to compiler/testData/diagnostics/tests/javac/inheritance/InheritanceAmbiguity3.txt diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/NoAmbiguity.kt b/compiler/testData/diagnostics/tests/javac/inheritance/InheritanceAmbiguity4.fir.kt similarity index 96% rename from compiler/testData/javac/diagnostics/tests/inheritance/NoAmbiguity.kt rename to compiler/testData/diagnostics/tests/javac/inheritance/InheritanceAmbiguity4.fir.kt index 66a664ebaaf..a6efde77d02 100644 --- a/compiler/testData/javac/diagnostics/tests/inheritance/NoAmbiguity.kt +++ b/compiler/testData/diagnostics/tests/javac/inheritance/InheritanceAmbiguity4.fir.kt @@ -2,7 +2,7 @@ package a; public class x { - private class O {} + class O {} } // FILE: a/x1.java diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity4.kt b/compiler/testData/diagnostics/tests/javac/inheritance/InheritanceAmbiguity4.kt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity4.kt rename to compiler/testData/diagnostics/tests/javac/inheritance/InheritanceAmbiguity4.kt diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity4.txt b/compiler/testData/diagnostics/tests/javac/inheritance/InheritanceAmbiguity4.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity4.txt rename to compiler/testData/diagnostics/tests/javac/inheritance/InheritanceAmbiguity4.txt diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/InheritanceWithKotlin.kt b/compiler/testData/diagnostics/tests/javac/inheritance/InheritanceWithKotlin.kt similarity index 97% rename from compiler/testData/javac/diagnostics/tests/inheritance/InheritanceWithKotlin.kt rename to compiler/testData/diagnostics/tests/javac/inheritance/InheritanceWithKotlin.kt index bcfc722f6e2..dec7bae10d3 100644 --- a/compiler/testData/javac/diagnostics/tests/inheritance/InheritanceWithKotlin.kt +++ b/compiler/testData/diagnostics/tests/javac/inheritance/InheritanceWithKotlin.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: test/UseKotlinInner.java package test; diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/InheritanceWithKotlin.txt b/compiler/testData/diagnostics/tests/javac/inheritance/InheritanceWithKotlin.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/inheritance/InheritanceWithKotlin.txt rename to compiler/testData/diagnostics/tests/javac/inheritance/InheritanceWithKotlin.txt diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/InheritanceWithKotlinClasses.kt b/compiler/testData/diagnostics/tests/javac/inheritance/InheritanceWithKotlinClasses.kt similarity index 96% rename from compiler/testData/javac/diagnostics/tests/inheritance/InheritanceWithKotlinClasses.kt rename to compiler/testData/diagnostics/tests/javac/inheritance/InheritanceWithKotlinClasses.kt index e8ca4211dfc..922f71f4437 100644 --- a/compiler/testData/javac/diagnostics/tests/inheritance/InheritanceWithKotlinClasses.kt +++ b/compiler/testData/diagnostics/tests/javac/inheritance/InheritanceWithKotlinClasses.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: a/k.kt package a diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/InheritanceWithKotlinClasses.txt b/compiler/testData/diagnostics/tests/javac/inheritance/InheritanceWithKotlinClasses.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/inheritance/InheritanceWithKotlinClasses.txt rename to compiler/testData/diagnostics/tests/javac/inheritance/InheritanceWithKotlinClasses.txt diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/InheritedInner.kt b/compiler/testData/diagnostics/tests/javac/inheritance/InheritedInner.kt similarity index 93% rename from compiler/testData/javac/diagnostics/tests/inheritance/InheritedInner.kt rename to compiler/testData/diagnostics/tests/javac/inheritance/InheritedInner.kt index 53fdd947891..966ef1553df 100644 --- a/compiler/testData/javac/diagnostics/tests/inheritance/InheritedInner.kt +++ b/compiler/testData/diagnostics/tests/javac/inheritance/InheritedInner.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: a/x.java package a; diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/InheritedInner.txt b/compiler/testData/diagnostics/tests/javac/inheritance/InheritedInner.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/inheritance/InheritedInner.txt rename to compiler/testData/diagnostics/tests/javac/inheritance/InheritedInner.txt diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/InheritedInner2.kt b/compiler/testData/diagnostics/tests/javac/inheritance/InheritedInner2.kt similarity index 89% rename from compiler/testData/javac/diagnostics/tests/inheritance/InheritedInner2.kt rename to compiler/testData/diagnostics/tests/javac/inheritance/InheritedInner2.kt index 0b470a8d6ae..dcf2f0a079f 100644 --- a/compiler/testData/javac/diagnostics/tests/inheritance/InheritedInner2.kt +++ b/compiler/testData/diagnostics/tests/javac/inheritance/InheritedInner2.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: a/x.java package a; @@ -26,4 +27,4 @@ package a fun test1() = x1().getB() fun test2() = x2.B() -fun test3() = x2().getB() \ No newline at end of file +fun test3() = x2().getB() diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/InheritedInner2.txt b/compiler/testData/diagnostics/tests/javac/inheritance/InheritedInner2.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/inheritance/InheritedInner2.txt rename to compiler/testData/diagnostics/tests/javac/inheritance/InheritedInner2.txt diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/InheritedInnerAndSupertypeWithSameName.kt b/compiler/testData/diagnostics/tests/javac/inheritance/InheritedInnerAndSupertypeWithSameName.kt similarity index 94% rename from compiler/testData/javac/diagnostics/tests/inheritance/InheritedInnerAndSupertypeWithSameName.kt rename to compiler/testData/diagnostics/tests/javac/inheritance/InheritedInnerAndSupertypeWithSameName.kt index 371115d35cb..19a199e493e 100644 --- a/compiler/testData/javac/diagnostics/tests/inheritance/InheritedInnerAndSupertypeWithSameName.kt +++ b/compiler/testData/diagnostics/tests/javac/inheritance/InheritedInnerAndSupertypeWithSameName.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: a/x.java package a; diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/InheritedInnerAndSupertypeWithSameName.txt b/compiler/testData/diagnostics/tests/javac/inheritance/InheritedInnerAndSupertypeWithSameName.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/inheritance/InheritedInnerAndSupertypeWithSameName.txt rename to compiler/testData/diagnostics/tests/javac/inheritance/InheritedInnerAndSupertypeWithSameName.txt diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/InheritedInnerUsageInInner.kt b/compiler/testData/diagnostics/tests/javac/inheritance/InheritedInnerUsageInInner.kt similarity index 95% rename from compiler/testData/javac/diagnostics/tests/inheritance/InheritedInnerUsageInInner.kt rename to compiler/testData/diagnostics/tests/javac/inheritance/InheritedInnerUsageInInner.kt index 6f5fd69f83d..ccc208550c8 100644 --- a/compiler/testData/javac/diagnostics/tests/inheritance/InheritedInnerUsageInInner.kt +++ b/compiler/testData/diagnostics/tests/javac/inheritance/InheritedInnerUsageInInner.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: a/x.java package a; diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/InheritedInnerUsageInInner.txt b/compiler/testData/diagnostics/tests/javac/inheritance/InheritedInnerUsageInInner.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/inheritance/InheritedInnerUsageInInner.txt rename to compiler/testData/diagnostics/tests/javac/inheritance/InheritedInnerUsageInInner.txt diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/InheritedKotlinInner.kt b/compiler/testData/diagnostics/tests/javac/inheritance/InheritedKotlinInner.kt similarity index 93% rename from compiler/testData/javac/diagnostics/tests/inheritance/InheritedKotlinInner.kt rename to compiler/testData/diagnostics/tests/javac/inheritance/InheritedKotlinInner.kt index 3eab3443fbc..5c44faf92ca 100644 --- a/compiler/testData/javac/diagnostics/tests/inheritance/InheritedKotlinInner.kt +++ b/compiler/testData/diagnostics/tests/javac/inheritance/InheritedKotlinInner.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: a/x.kt package a diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/InheritedKotlinInner.txt b/compiler/testData/diagnostics/tests/javac/inheritance/InheritedKotlinInner.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/inheritance/InheritedKotlinInner.txt rename to compiler/testData/diagnostics/tests/javac/inheritance/InheritedKotlinInner.txt diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/InnerAndInheritedInner.kt b/compiler/testData/diagnostics/tests/javac/inheritance/InnerAndInheritedInner.kt similarity index 93% rename from compiler/testData/javac/diagnostics/tests/inheritance/InnerAndInheritedInner.kt rename to compiler/testData/diagnostics/tests/javac/inheritance/InnerAndInheritedInner.kt index adee7f316ef..c300f2a6fc4 100644 --- a/compiler/testData/javac/diagnostics/tests/inheritance/InnerAndInheritedInner.kt +++ b/compiler/testData/diagnostics/tests/javac/inheritance/InnerAndInheritedInner.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: a/x.java package a; diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/InnerAndInheritedInner.txt b/compiler/testData/diagnostics/tests/javac/inheritance/InnerAndInheritedInner.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/inheritance/InnerAndInheritedInner.txt rename to compiler/testData/diagnostics/tests/javac/inheritance/InnerAndInheritedInner.txt diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/ManyInheritedClasses.kt b/compiler/testData/diagnostics/tests/javac/inheritance/ManyInheritedClasses.kt similarity index 96% rename from compiler/testData/javac/diagnostics/tests/inheritance/ManyInheritedClasses.kt rename to compiler/testData/diagnostics/tests/javac/inheritance/ManyInheritedClasses.kt index 7bc38a7b79d..aff1bb40bc9 100644 --- a/compiler/testData/javac/diagnostics/tests/inheritance/ManyInheritedClasses.kt +++ b/compiler/testData/diagnostics/tests/javac/inheritance/ManyInheritedClasses.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: a/x.java package a; diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/ManyInheritedClasses.txt b/compiler/testData/diagnostics/tests/javac/inheritance/ManyInheritedClasses.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/inheritance/ManyInheritedClasses.txt rename to compiler/testData/diagnostics/tests/javac/inheritance/ManyInheritedClasses.txt diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/SameInnersInSupertypeAndSupertypesSupertype.kt b/compiler/testData/diagnostics/tests/javac/inheritance/SameInnersInSupertypeAndSupertypesSupertype.kt similarity index 95% rename from compiler/testData/javac/diagnostics/tests/inheritance/SameInnersInSupertypeAndSupertypesSupertype.kt rename to compiler/testData/diagnostics/tests/javac/inheritance/SameInnersInSupertypeAndSupertypesSupertype.kt index 2444c7eedda..1502c0684a0 100644 --- a/compiler/testData/javac/diagnostics/tests/inheritance/SameInnersInSupertypeAndSupertypesSupertype.kt +++ b/compiler/testData/diagnostics/tests/javac/inheritance/SameInnersInSupertypeAndSupertypesSupertype.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: a/x.java package a; diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/SameInnersInSupertypeAndSupertypesSupertype.txt b/compiler/testData/diagnostics/tests/javac/inheritance/SameInnersInSupertypeAndSupertypesSupertype.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/inheritance/SameInnersInSupertypeAndSupertypesSupertype.txt rename to compiler/testData/diagnostics/tests/javac/inheritance/SameInnersInSupertypeAndSupertypesSupertype.txt diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/SuperTypeWithSameInner.kt b/compiler/testData/diagnostics/tests/javac/inheritance/SuperTypeWithSameInner.kt similarity index 96% rename from compiler/testData/javac/diagnostics/tests/inheritance/SuperTypeWithSameInner.kt rename to compiler/testData/diagnostics/tests/javac/inheritance/SuperTypeWithSameInner.kt index 51ca4dd9846..aed5d4f6213 100644 --- a/compiler/testData/javac/diagnostics/tests/inheritance/SuperTypeWithSameInner.kt +++ b/compiler/testData/diagnostics/tests/javac/inheritance/SuperTypeWithSameInner.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: a/x.java package a; diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/SuperTypeWithSameInner.txt b/compiler/testData/diagnostics/tests/javac/inheritance/SuperTypeWithSameInner.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/inheritance/SuperTypeWithSameInner.txt rename to compiler/testData/diagnostics/tests/javac/inheritance/SuperTypeWithSameInner.txt diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/SupertypeInnerAndTypeParameterWithSameNames.kt b/compiler/testData/diagnostics/tests/javac/inheritance/SupertypeInnerAndTypeParameterWithSameNames.kt similarity index 95% rename from compiler/testData/javac/diagnostics/tests/inheritance/SupertypeInnerAndTypeParameterWithSameNames.kt rename to compiler/testData/diagnostics/tests/javac/inheritance/SupertypeInnerAndTypeParameterWithSameNames.kt index 4059266cb47..bb1ff9ff8fa 100644 --- a/compiler/testData/javac/diagnostics/tests/inheritance/SupertypeInnerAndTypeParameterWithSameNames.kt +++ b/compiler/testData/diagnostics/tests/javac/inheritance/SupertypeInnerAndTypeParameterWithSameNames.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: a/Parent.java package a; diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/SupertypeInnerAndTypeParameterWithSameNames.txt b/compiler/testData/diagnostics/tests/javac/inheritance/SupertypeInnerAndTypeParameterWithSameNames.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/inheritance/SupertypeInnerAndTypeParameterWithSameNames.txt rename to compiler/testData/diagnostics/tests/javac/inheritance/SupertypeInnerAndTypeParameterWithSameNames.txt diff --git a/compiler/testData/javac/diagnostics/tests/inners/ComplexCase.kt b/compiler/testData/diagnostics/tests/javac/inners/ComplexCase.kt similarity index 96% rename from compiler/testData/javac/diagnostics/tests/inners/ComplexCase.kt rename to compiler/testData/diagnostics/tests/javac/inners/ComplexCase.kt index 7797c67bc23..5fc916fbf8c 100644 --- a/compiler/testData/javac/diagnostics/tests/inners/ComplexCase.kt +++ b/compiler/testData/diagnostics/tests/javac/inners/ComplexCase.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: p1/I.java package p1; diff --git a/compiler/testData/javac/diagnostics/tests/inners/ComplexCase.txt b/compiler/testData/diagnostics/tests/javac/inners/ComplexCase.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/inners/ComplexCase.txt rename to compiler/testData/diagnostics/tests/javac/inners/ComplexCase.txt diff --git a/compiler/testData/javac/diagnostics/tests/inners/ComplexCase2.kt b/compiler/testData/diagnostics/tests/javac/inners/ComplexCase2.kt similarity index 97% rename from compiler/testData/javac/diagnostics/tests/inners/ComplexCase2.kt rename to compiler/testData/diagnostics/tests/javac/inners/ComplexCase2.kt index e171cadbf85..7d2016236e5 100644 --- a/compiler/testData/javac/diagnostics/tests/inners/ComplexCase2.kt +++ b/compiler/testData/diagnostics/tests/javac/inners/ComplexCase2.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: p1/I.java package p1; diff --git a/compiler/testData/javac/diagnostics/tests/inners/ComplexCase2.txt b/compiler/testData/diagnostics/tests/javac/inners/ComplexCase2.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/inners/ComplexCase2.txt rename to compiler/testData/diagnostics/tests/javac/inners/ComplexCase2.txt diff --git a/compiler/testData/javac/diagnostics/tests/inners/CurrentPackageAndInner.kt b/compiler/testData/diagnostics/tests/javac/inners/CurrentPackageAndInner.kt similarity index 94% rename from compiler/testData/javac/diagnostics/tests/inners/CurrentPackageAndInner.kt rename to compiler/testData/diagnostics/tests/javac/inners/CurrentPackageAndInner.kt index fc053745609..73be86bdfe5 100644 --- a/compiler/testData/javac/diagnostics/tests/inners/CurrentPackageAndInner.kt +++ b/compiler/testData/diagnostics/tests/javac/inners/CurrentPackageAndInner.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: a/x.java package a; diff --git a/compiler/testData/javac/diagnostics/tests/inners/CurrentPackageAndInner.txt b/compiler/testData/diagnostics/tests/javac/inners/CurrentPackageAndInner.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/inners/CurrentPackageAndInner.txt rename to compiler/testData/diagnostics/tests/javac/inners/CurrentPackageAndInner.txt diff --git a/compiler/testData/javac/diagnostics/tests/inners/ImportThriceNestedClass.kt b/compiler/testData/diagnostics/tests/javac/inners/ImportThriceNestedClass.kt similarity index 97% rename from compiler/testData/javac/diagnostics/tests/inners/ImportThriceNestedClass.kt rename to compiler/testData/diagnostics/tests/javac/inners/ImportThriceNestedClass.kt index ca333bf3ff4..02cbca48078 100644 --- a/compiler/testData/javac/diagnostics/tests/inners/ImportThriceNestedClass.kt +++ b/compiler/testData/diagnostics/tests/javac/inners/ImportThriceNestedClass.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: a/x.java package a; diff --git a/compiler/testData/javac/diagnostics/tests/inners/ImportThriceNestedClass.txt b/compiler/testData/diagnostics/tests/javac/inners/ImportThriceNestedClass.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/inners/ImportThriceNestedClass.txt rename to compiler/testData/diagnostics/tests/javac/inners/ImportThriceNestedClass.txt diff --git a/compiler/testData/javac/diagnostics/tests/inners/InnerInInner.kt b/compiler/testData/diagnostics/tests/javac/inners/InnerInInner.kt similarity index 95% rename from compiler/testData/javac/diagnostics/tests/inners/InnerInInner.kt rename to compiler/testData/diagnostics/tests/javac/inners/InnerInInner.kt index 358effd79c2..80f96a92ad5 100644 --- a/compiler/testData/javac/diagnostics/tests/inners/InnerInInner.kt +++ b/compiler/testData/diagnostics/tests/javac/inners/InnerInInner.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: a/x.java package a; diff --git a/compiler/testData/javac/diagnostics/tests/inners/InnerInInner.txt b/compiler/testData/diagnostics/tests/javac/inners/InnerInInner.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/inners/InnerInInner.txt rename to compiler/testData/diagnostics/tests/javac/inners/InnerInInner.txt diff --git a/compiler/testData/javac/diagnostics/tests/inners/Nested.kt b/compiler/testData/diagnostics/tests/javac/inners/Nested.kt similarity index 94% rename from compiler/testData/javac/diagnostics/tests/inners/Nested.kt rename to compiler/testData/diagnostics/tests/javac/inners/Nested.kt index 7bc94acebe8..bc2b983a20b 100644 --- a/compiler/testData/javac/diagnostics/tests/inners/Nested.kt +++ b/compiler/testData/diagnostics/tests/javac/inners/Nested.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: p/p.kt package p diff --git a/compiler/testData/javac/diagnostics/tests/inners/Nested.txt b/compiler/testData/diagnostics/tests/javac/inners/Nested.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/inners/Nested.txt rename to compiler/testData/diagnostics/tests/javac/inners/Nested.txt diff --git a/compiler/testData/javac/diagnostics/tests/inners/ThriceNestedClass.kt b/compiler/testData/diagnostics/tests/javac/inners/ThriceNestedClass.kt similarity index 96% rename from compiler/testData/javac/diagnostics/tests/inners/ThriceNestedClass.kt rename to compiler/testData/diagnostics/tests/javac/inners/ThriceNestedClass.kt index 6b0867dd472..db9a8a37797 100644 --- a/compiler/testData/javac/diagnostics/tests/inners/ThriceNestedClass.kt +++ b/compiler/testData/diagnostics/tests/javac/inners/ThriceNestedClass.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: a/x.java package a; diff --git a/compiler/testData/javac/diagnostics/tests/inners/ThriceNestedClass.txt b/compiler/testData/diagnostics/tests/javac/inners/ThriceNestedClass.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/inners/ThriceNestedClass.txt rename to compiler/testData/diagnostics/tests/javac/inners/ThriceNestedClass.txt diff --git a/compiler/testData/javac/diagnostics/tests/qualifiedExpression/GenericClassVsPackage.kt b/compiler/testData/diagnostics/tests/javac/qualifiedExpression/GenericClassVsPackage.kt similarity index 97% rename from compiler/testData/javac/diagnostics/tests/qualifiedExpression/GenericClassVsPackage.kt rename to compiler/testData/diagnostics/tests/javac/qualifiedExpression/GenericClassVsPackage.kt index abc49279f2f..de89a441b61 100644 --- a/compiler/testData/javac/diagnostics/tests/qualifiedExpression/GenericClassVsPackage.kt +++ b/compiler/testData/diagnostics/tests/javac/qualifiedExpression/GenericClassVsPackage.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: a/b/c.java package a.b; diff --git a/compiler/testData/javac/diagnostics/tests/qualifiedExpression/GenericClassVsPackage.txt b/compiler/testData/diagnostics/tests/javac/qualifiedExpression/GenericClassVsPackage.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/qualifiedExpression/GenericClassVsPackage.txt rename to compiler/testData/diagnostics/tests/javac/qualifiedExpression/GenericClassVsPackage.txt diff --git a/compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsClass.kt b/compiler/testData/diagnostics/tests/javac/qualifiedExpression/PackageVsClass.kt similarity index 97% rename from compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsClass.kt rename to compiler/testData/diagnostics/tests/javac/qualifiedExpression/PackageVsClass.kt index b741c70d261..0a5a9f6a7ed 100644 --- a/compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsClass.kt +++ b/compiler/testData/diagnostics/tests/javac/qualifiedExpression/PackageVsClass.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: a/b/c.java package a.b; diff --git a/compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsClass.txt b/compiler/testData/diagnostics/tests/javac/qualifiedExpression/PackageVsClass.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsClass.txt rename to compiler/testData/diagnostics/tests/javac/qualifiedExpression/PackageVsClass.txt diff --git a/compiler/testData/diagnostics/tests/javac/qualifiedExpression/PackageVsClass2.fir.kt b/compiler/testData/diagnostics/tests/javac/qualifiedExpression/PackageVsClass2.fir.kt new file mode 100644 index 00000000000..401a4a90d69 --- /dev/null +++ b/compiler/testData/diagnostics/tests/javac/qualifiedExpression/PackageVsClass2.fir.kt @@ -0,0 +1,47 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER +// FILE: a/a.java +package a; + +public class a {} + +// FILE: a/b.java +package a; + +public class b { + public void a_b() {} +} + +// FILE: test/a.java +package test; + +public class a {} + +// FILE: test/d.java +package test; + +public class d { + public a.b getB() { return null; } +} + +// FILE: b.kt +package test + +val x = d().getB() + +// FILE: test/c.java +package test; + +import a.a; + +public class c { + public static a getA() { return null; } +} + +// FILE: c.kt +package test + +fun foo() { + val a = c.getA() + a.a + a.a() +} diff --git a/compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsClass2.kt b/compiler/testData/diagnostics/tests/javac/qualifiedExpression/PackageVsClass2.kt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsClass2.kt rename to compiler/testData/diagnostics/tests/javac/qualifiedExpression/PackageVsClass2.kt diff --git a/compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsClass2.txt b/compiler/testData/diagnostics/tests/javac/qualifiedExpression/PackageVsClass2.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsClass2.txt rename to compiler/testData/diagnostics/tests/javac/qualifiedExpression/PackageVsClass2.txt diff --git a/compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsRootClass.kt b/compiler/testData/diagnostics/tests/javac/qualifiedExpression/PackageVsRootClass.kt similarity index 97% rename from compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsRootClass.kt rename to compiler/testData/diagnostics/tests/javac/qualifiedExpression/PackageVsRootClass.kt index 1e69edf8855..b0c2ea1d9c1 100644 --- a/compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsRootClass.kt +++ b/compiler/testData/diagnostics/tests/javac/qualifiedExpression/PackageVsRootClass.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: a/b.java package a; diff --git a/compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsRootClass.txt b/compiler/testData/diagnostics/tests/javac/qualifiedExpression/PackageVsRootClass.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsRootClass.txt rename to compiler/testData/diagnostics/tests/javac/qualifiedExpression/PackageVsRootClass.txt diff --git a/compiler/testData/diagnostics/tests/javac/qualifiedExpression/visibleClassVsQualifiedClass.fir.kt b/compiler/testData/diagnostics/tests/javac/qualifiedExpression/visibleClassVsQualifiedClass.fir.kt new file mode 100644 index 00000000000..50e8b111c5a --- /dev/null +++ b/compiler/testData/diagnostics/tests/javac/qualifiedExpression/visibleClassVsQualifiedClass.fir.kt @@ -0,0 +1,57 @@ +// FILE: a/b.java +package a; + +public class b { + public void a_b() {} +} + +// FILE:some/a.java +package some; + +public class a { + public static class b { + public void some_ab() {} + } +} + +// FILE: c1.kt +package other + +class a {} + +fun test(a_: a.b) { + val a_2 = a.b() +} + +//FILE: c2.kt +package other2 + +class a { + class b { + fun other2_ab() {} + } +} + +fun test(_ab: a.b) { + _ab.other2_ab() + + val _ab2 = a.b() + _ab2.other2_ab() +} + +// FILE: c3.kt +package some + +fun test(_ab: a.b) { + _ab.some_ab() + + val _ab2 = a.b() + _ab2.some_ab() +} + +// FILE: c4.kt +package a + +fun test(_b: b) { + _b.a_b() +} diff --git a/compiler/testData/javac/diagnostics/tests/qualifiedExpression/visibleClassVsQualifiedClass.kt b/compiler/testData/diagnostics/tests/javac/qualifiedExpression/visibleClassVsQualifiedClass.kt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/qualifiedExpression/visibleClassVsQualifiedClass.kt rename to compiler/testData/diagnostics/tests/javac/qualifiedExpression/visibleClassVsQualifiedClass.kt diff --git a/compiler/testData/javac/diagnostics/tests/qualifiedExpression/visibleClassVsQualifiedClass.txt b/compiler/testData/diagnostics/tests/javac/qualifiedExpression/visibleClassVsQualifiedClass.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/qualifiedExpression/visibleClassVsQualifiedClass.txt rename to compiler/testData/diagnostics/tests/javac/qualifiedExpression/visibleClassVsQualifiedClass.txt diff --git a/compiler/testData/diagnostics/tests/javac/typeParameters/Clash.fir.kt b/compiler/testData/diagnostics/tests/javac/typeParameters/Clash.fir.kt new file mode 100644 index 00000000000..7eaf99dfb65 --- /dev/null +++ b/compiler/testData/diagnostics/tests/javac/typeParameters/Clash.fir.kt @@ -0,0 +1,33 @@ +// FILE: a/x.java +package a; + +public class x { + public class O {} +} + +// FILE: a/i.java +package a; + +public interface i { + public class O {} +} + +// FILE: a/i2.java +package a; + +public interface i2 extends i { + public O getO(); +} + +// FILE: a/Test.java +package a; + +public class Test extends x implements i2 { + @Override + public O getO() { return null; } +} + +// FILE: test.kt +package a + +fun test() = Test().getO() \ No newline at end of file diff --git a/compiler/testData/javac/diagnostics/tests/typeParameters/Clash.kt b/compiler/testData/diagnostics/tests/javac/typeParameters/Clash.kt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/typeParameters/Clash.kt rename to compiler/testData/diagnostics/tests/javac/typeParameters/Clash.kt diff --git a/compiler/testData/javac/diagnostics/tests/typeParameters/Clash.txt b/compiler/testData/diagnostics/tests/javac/typeParameters/Clash.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/typeParameters/Clash.txt rename to compiler/testData/diagnostics/tests/javac/typeParameters/Clash.txt diff --git a/compiler/testData/javac/diagnostics/tests/typeParameters/ComplexCase.kt b/compiler/testData/diagnostics/tests/javac/typeParameters/ComplexCase.kt similarity index 98% rename from compiler/testData/javac/diagnostics/tests/typeParameters/ComplexCase.kt rename to compiler/testData/diagnostics/tests/javac/typeParameters/ComplexCase.kt index 5284bcb203a..55a2975fa82 100644 --- a/compiler/testData/javac/diagnostics/tests/typeParameters/ComplexCase.kt +++ b/compiler/testData/diagnostics/tests/javac/typeParameters/ComplexCase.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: p/J.java package p; diff --git a/compiler/testData/javac/diagnostics/tests/typeParameters/ComplexCase.txt b/compiler/testData/diagnostics/tests/javac/typeParameters/ComplexCase.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/typeParameters/ComplexCase.txt rename to compiler/testData/diagnostics/tests/javac/typeParameters/ComplexCase.txt diff --git a/compiler/testData/javac/diagnostics/tests/typeParameters/InheritedInnerAndTypeParameterWithSameNames.kt b/compiler/testData/diagnostics/tests/javac/typeParameters/InheritedInnerAndTypeParameterWithSameNames.kt similarity index 93% rename from compiler/testData/javac/diagnostics/tests/typeParameters/InheritedInnerAndTypeParameterWithSameNames.kt rename to compiler/testData/diagnostics/tests/javac/typeParameters/InheritedInnerAndTypeParameterWithSameNames.kt index 591d0e2fe8a..8482deb9697 100644 --- a/compiler/testData/javac/diagnostics/tests/typeParameters/InheritedInnerAndTypeParameterWithSameNames.kt +++ b/compiler/testData/diagnostics/tests/javac/typeParameters/InheritedInnerAndTypeParameterWithSameNames.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: a/x.java package a; diff --git a/compiler/testData/javac/diagnostics/tests/typeParameters/InheritedInnerAndTypeParameterWithSameNames.txt b/compiler/testData/diagnostics/tests/javac/typeParameters/InheritedInnerAndTypeParameterWithSameNames.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/typeParameters/InheritedInnerAndTypeParameterWithSameNames.txt rename to compiler/testData/diagnostics/tests/javac/typeParameters/InheritedInnerAndTypeParameterWithSameNames.txt diff --git a/compiler/testData/javac/diagnostics/tests/typeParameters/InnerWithTypeParameter.kt b/compiler/testData/diagnostics/tests/javac/typeParameters/InnerWithTypeParameter.kt similarity index 95% rename from compiler/testData/javac/diagnostics/tests/typeParameters/InnerWithTypeParameter.kt rename to compiler/testData/diagnostics/tests/javac/typeParameters/InnerWithTypeParameter.kt index 9c396ebf5d1..99be98c6a1b 100644 --- a/compiler/testData/javac/diagnostics/tests/typeParameters/InnerWithTypeParameter.kt +++ b/compiler/testData/diagnostics/tests/javac/typeParameters/InnerWithTypeParameter.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: a/x.java package a; diff --git a/compiler/testData/javac/diagnostics/tests/typeParameters/InnerWithTypeParameter.txt b/compiler/testData/diagnostics/tests/javac/typeParameters/InnerWithTypeParameter.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/typeParameters/InnerWithTypeParameter.txt rename to compiler/testData/diagnostics/tests/javac/typeParameters/InnerWithTypeParameter.txt diff --git a/compiler/testData/javac/diagnostics/tests/typeParameters/NestedWithInner.kt b/compiler/testData/diagnostics/tests/javac/typeParameters/NestedWithInner.kt similarity index 94% rename from compiler/testData/javac/diagnostics/tests/typeParameters/NestedWithInner.kt rename to compiler/testData/diagnostics/tests/javac/typeParameters/NestedWithInner.kt index 29546061f5d..458d8895e4b 100644 --- a/compiler/testData/javac/diagnostics/tests/typeParameters/NestedWithInner.kt +++ b/compiler/testData/diagnostics/tests/javac/typeParameters/NestedWithInner.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: a/x.java package a; diff --git a/compiler/testData/javac/diagnostics/tests/typeParameters/NestedWithInner.txt b/compiler/testData/diagnostics/tests/javac/typeParameters/NestedWithInner.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/typeParameters/NestedWithInner.txt rename to compiler/testData/diagnostics/tests/javac/typeParameters/NestedWithInner.txt diff --git a/compiler/testData/javac/diagnostics/tests/typeParameters/SeveralInnersWithTypeParameters.kt b/compiler/testData/diagnostics/tests/javac/typeParameters/SeveralInnersWithTypeParameters.kt similarity index 96% rename from compiler/testData/javac/diagnostics/tests/typeParameters/SeveralInnersWithTypeParameters.kt rename to compiler/testData/diagnostics/tests/javac/typeParameters/SeveralInnersWithTypeParameters.kt index 762bcb1ee24..e9e46d44e5c 100644 --- a/compiler/testData/javac/diagnostics/tests/typeParameters/SeveralInnersWithTypeParameters.kt +++ b/compiler/testData/diagnostics/tests/javac/typeParameters/SeveralInnersWithTypeParameters.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: a/x.java package a; diff --git a/compiler/testData/javac/diagnostics/tests/typeParameters/SeveralInnersWithTypeParameters.txt b/compiler/testData/diagnostics/tests/javac/typeParameters/SeveralInnersWithTypeParameters.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/typeParameters/SeveralInnersWithTypeParameters.txt rename to compiler/testData/diagnostics/tests/javac/typeParameters/SeveralInnersWithTypeParameters.txt diff --git a/compiler/testData/javac/diagnostics/tests/typeParameters/TypeParametersInInnerAndOuterWithSameNames.kt b/compiler/testData/diagnostics/tests/javac/typeParameters/TypeParametersInInnerAndOuterWithSameNames.kt similarity index 94% rename from compiler/testData/javac/diagnostics/tests/typeParameters/TypeParametersInInnerAndOuterWithSameNames.kt rename to compiler/testData/diagnostics/tests/javac/typeParameters/TypeParametersInInnerAndOuterWithSameNames.kt index 7a800a3de22..1ee2ff7847c 100644 --- a/compiler/testData/javac/diagnostics/tests/typeParameters/TypeParametersInInnerAndOuterWithSameNames.kt +++ b/compiler/testData/diagnostics/tests/javac/typeParameters/TypeParametersInInnerAndOuterWithSameNames.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // FILE: a/x.java package a; diff --git a/compiler/testData/javac/diagnostics/tests/typeParameters/TypeParametersInInnerAndOuterWithSameNames.txt b/compiler/testData/diagnostics/tests/javac/typeParameters/TypeParametersInInnerAndOuterWithSameNames.txt similarity index 100% rename from compiler/testData/javac/diagnostics/tests/typeParameters/TypeParametersInInnerAndOuterWithSameNames.txt rename to compiler/testData/diagnostics/tests/javac/typeParameters/TypeParametersInInnerAndOuterWithSameNames.txt diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/NoAmbiguity.txt b/compiler/testData/javac/diagnostics/tests/inheritance/NoAmbiguity.txt deleted file mode 100644 index 88e59eb2cfa..00000000000 --- a/compiler/testData/javac/diagnostics/tests/inheritance/NoAmbiguity.txt +++ /dev/null @@ -1,73 +0,0 @@ -package - -package a { - public fun test1(): a.i2.O! - - public interface i { - public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int - public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String - - public open class O { - public constructor O() - public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int - public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String - } - } - - public interface i2 : a.i { - public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int - public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String - - public open class O { - public constructor O() - public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int - public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String - } - } - - public interface i3 : a.i2 { - public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int - public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String - } - - public open class test : a.x2, a.i3 { - public constructor test() - public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - public open fun getO(): a.i2.O! - public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int - public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String - } - - public open class x { - public constructor x() - public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int - public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String - - private open inner class O { - private constructor O() - public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int - public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String - } - } - - public open class x1 : a.x { - public constructor x1() - public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int - public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String - } - - public open class x2 : a.x1 { - public constructor x2() - public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int - public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String - } -} diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/NoAmbiguity2.kt b/compiler/testData/javac/diagnostics/tests/inheritance/NoAmbiguity2.kt deleted file mode 100644 index 893a71a7977..00000000000 --- a/compiler/testData/javac/diagnostics/tests/inheritance/NoAmbiguity2.kt +++ /dev/null @@ -1,49 +0,0 @@ -// FILE: a/x.java -package a; - -public class x { - class O {} -} - -// FILE: a/x1.java -package a; - -public class x1 extends x {} - -// FILE: a/x2.java -package a; - -public class x2 extends x1 {} - -// FILE: a/i.java -package a; - -public interface i { - public class O {} -} - -// FILE: a/i2.java -package a; - -public interface i2 extends i { - public class O {} -} - -// FILE: a/i3.java -package a; - -public interface i3 extends i2 {} - -// FILE: b/test.java -package b; - -import a.*; - -public class test extends x2 implements i3 { - public O getO() { return null; } -} - -// FILE: test.kt -package b - -fun test1() = test().getO() \ No newline at end of file diff --git a/compiler/testData/javac/diagnostics/tests/inheritance/NoAmbiguity2.txt b/compiler/testData/javac/diagnostics/tests/inheritance/NoAmbiguity2.txt deleted file mode 100644 index c46930883bf..00000000000 --- a/compiler/testData/javac/diagnostics/tests/inheritance/NoAmbiguity2.txt +++ /dev/null @@ -1,76 +0,0 @@ -package - -package a { - - public interface i { - public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int - public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String - - public open class O { - public constructor O() - public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int - public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String - } - } - - public interface i2 : a.i { - public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int - public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String - - public open class O { - public constructor O() - public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int - public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String - } - } - - public interface i3 : a.i2 { - public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int - public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String - } - - public open class x { - public constructor x() - public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int - public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String - - public/*package*/ open inner class O { - public/*package*/ constructor O() - public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int - public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String - } - } - - public open class x1 : a.x { - public constructor x1() - public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int - public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String - } - - public open class x2 : a.x1 { - public constructor x2() - public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int - public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String - } -} - -package b { - public fun test1(): a.i2.O! - - public open class test : a.x2, a.i3 { - public constructor test() - public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - public open fun getO(): a.i2.O! - public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int - public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String - } -} diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java index 776ba577819..c4100e77895 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java @@ -16502,6 +16502,472 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { } } + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/javac") + @TestDataPath("$PROJECT_ROOT") + public class Javac extends AbstractDiagnosticTest { + @Test + public void testAllFilesPresentInJavac() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + } + + @Test + @TestMetadata("Annotations.kt") + public void testAnnotations() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/Annotations.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/javac/fieldsResolution") + @TestDataPath("$PROJECT_ROOT") + public class FieldsResolution extends AbstractDiagnosticTest { + @Test + public void testAllFilesPresentInFieldsResolution() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/fieldsResolution"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + } + + @Test + @TestMetadata("AsteriskStaticImportsAmbiguity.kt") + public void testAsteriskStaticImportsAmbiguity() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/fieldsResolution/AsteriskStaticImportsAmbiguity.kt"); + } + + @Test + @TestMetadata("BinaryInitializers.kt") + public void testBinaryInitializers() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/fieldsResolution/BinaryInitializers.kt"); + } + + @Test + @TestMetadata("ConstantByFqName.kt") + public void testConstantByFqName() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/fieldsResolution/ConstantByFqName.kt"); + } + + @Test + @TestMetadata("ConstantValues.kt") + public void testConstantValues() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/fieldsResolution/ConstantValues.kt"); + } + + @Test + @TestMetadata("ConstantValuesFromKtFile.kt") + public void testConstantValuesFromKtFile() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/fieldsResolution/ConstantValuesFromKtFile.kt"); + } + + @Test + @TestMetadata("FieldFromOuterClass.kt") + public void testFieldFromOuterClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/fieldsResolution/FieldFromOuterClass.kt"); + } + + @Test + @TestMetadata("InheritedField.kt") + public void testInheritedField() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/fieldsResolution/InheritedField.kt"); + } + + @Test + @TestMetadata("MultipleOuters.kt") + public void testMultipleOuters() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/fieldsResolution/MultipleOuters.kt"); + } + + @Test + @TestMetadata("ResolutionPriority.kt") + public void testResolutionPriority() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/fieldsResolution/ResolutionPriority.kt"); + } + + @Test + @TestMetadata("SameFieldInSupertypes.kt") + public void testSameFieldInSupertypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/fieldsResolution/SameFieldInSupertypes.kt"); + } + + @Test + @TestMetadata("StaticImport.kt") + public void testStaticImport() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/fieldsResolution/StaticImport.kt"); + } + + @Test + @TestMetadata("StaticImportsAmbiguity.kt") + public void testStaticImportsAmbiguity() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/fieldsResolution/StaticImportsAmbiguity.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/javac/imports") + @TestDataPath("$PROJECT_ROOT") + public class Imports extends AbstractDiagnosticTest { + @Test + public void testAllFilesPresentInImports() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/imports"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + } + + @Test + @TestMetadata("AllUnderImportsAmbiguity.kt") + public void testAllUnderImportsAmbiguity() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/AllUnderImportsAmbiguity.kt"); + } + + @Test + @TestMetadata("AllUnderImportsLessPriority.kt") + public void testAllUnderImportsLessPriority() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/AllUnderImportsLessPriority.kt"); + } + + @Test + @TestMetadata("ClassImportsConflicting.kt") + public void testClassImportsConflicting() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/ClassImportsConflicting.kt"); + } + + @Test + @TestMetadata("CurrentPackageAndAllUnderImport.kt") + public void testCurrentPackageAndAllUnderImport() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/CurrentPackageAndAllUnderImport.kt"); + } + + @Test + @TestMetadata("CurrentPackageAndExplicitImport.kt") + public void testCurrentPackageAndExplicitImport() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/CurrentPackageAndExplicitImport.kt"); + } + + @Test + @TestMetadata("CurrentPackageAndExplicitNestedImport.kt") + public void testCurrentPackageAndExplicitNestedImport() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/CurrentPackageAndExplicitNestedImport.kt"); + } + + @Test + @TestMetadata("CurrentPackageAndNestedAsteriskImport.kt") + public void testCurrentPackageAndNestedAsteriskImport() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/CurrentPackageAndNestedAsteriskImport.kt"); + } + + @Test + @TestMetadata("ImportGenericVsPackage.kt") + public void testImportGenericVsPackage() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/ImportGenericVsPackage.kt"); + } + + @Test + @TestMetadata("ImportProtectedClass.kt") + public void testImportProtectedClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/ImportProtectedClass.kt"); + } + + @Test + @TestMetadata("ImportTwoTimes.kt") + public void testImportTwoTimes() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/ImportTwoTimes.kt"); + } + + @Test + @TestMetadata("ImportTwoTimesStar.kt") + public void testImportTwoTimesStar() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/ImportTwoTimesStar.kt"); + } + + @Test + @TestMetadata("NestedAndTopLevelClassClash.kt") + public void testNestedAndTopLevelClassClash() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/NestedAndTopLevelClassClash.kt"); + } + + @Test + @TestMetadata("NestedClassClash.kt") + public void testNestedClassClash() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/NestedClassClash.kt"); + } + + @Test + @TestMetadata("PackageExplicitAndStartImport.kt") + public void testPackageExplicitAndStartImport() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/PackageExplicitAndStartImport.kt"); + } + + @Test + @TestMetadata("PackagePrivateAndPublicNested.kt") + public void testPackagePrivateAndPublicNested() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/PackagePrivateAndPublicNested.kt"); + } + + @Test + @TestMetadata("TopLevelClassVsPackage.kt") + public void testTopLevelClassVsPackage() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/TopLevelClassVsPackage.kt"); + } + + @Test + @TestMetadata("TopLevelClassVsPackage2.kt") + public void testTopLevelClassVsPackage2() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/TopLevelClassVsPackage2.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/javac/inheritance") + @TestDataPath("$PROJECT_ROOT") + public class Inheritance extends AbstractDiagnosticTest { + @Test + public void testAllFilesPresentInInheritance() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/inheritance"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + } + + @Test + @TestMetadata("IheritanceOfInner.kt") + public void testIheritanceOfInner() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/IheritanceOfInner.kt"); + } + + @Test + @TestMetadata("InheritanceAmbiguity.kt") + public void testInheritanceAmbiguity() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/InheritanceAmbiguity.kt"); + } + + @Test + @TestMetadata("InheritanceAmbiguity2.kt") + public void testInheritanceAmbiguity2() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/InheritanceAmbiguity2.kt"); + } + + @Test + @TestMetadata("InheritanceAmbiguity3.kt") + public void testInheritanceAmbiguity3() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/InheritanceAmbiguity3.kt"); + } + + @Test + @TestMetadata("InheritanceAmbiguity4.kt") + public void testInheritanceAmbiguity4() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/InheritanceAmbiguity4.kt"); + } + + @Test + @TestMetadata("InheritanceWithKotlin.kt") + public void testInheritanceWithKotlin() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/InheritanceWithKotlin.kt"); + } + + @Test + @TestMetadata("InheritanceWithKotlinClasses.kt") + public void testInheritanceWithKotlinClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/InheritanceWithKotlinClasses.kt"); + } + + @Test + @TestMetadata("InheritedInner.kt") + public void testInheritedInner() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/InheritedInner.kt"); + } + + @Test + @TestMetadata("InheritedInner2.kt") + public void testInheritedInner2() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/InheritedInner2.kt"); + } + + @Test + @TestMetadata("InheritedInnerAndSupertypeWithSameName.kt") + public void testInheritedInnerAndSupertypeWithSameName() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/InheritedInnerAndSupertypeWithSameName.kt"); + } + + @Test + @TestMetadata("InheritedInnerUsageInInner.kt") + public void testInheritedInnerUsageInInner() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/InheritedInnerUsageInInner.kt"); + } + + @Test + @TestMetadata("InheritedKotlinInner.kt") + public void testInheritedKotlinInner() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/InheritedKotlinInner.kt"); + } + + @Test + @TestMetadata("InnerAndInheritedInner.kt") + public void testInnerAndInheritedInner() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/InnerAndInheritedInner.kt"); + } + + @Test + @TestMetadata("ManyInheritedClasses.kt") + public void testManyInheritedClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/ManyInheritedClasses.kt"); + } + + @Test + @TestMetadata("SameInnersInSupertypeAndSupertypesSupertype.kt") + public void testSameInnersInSupertypeAndSupertypesSupertype() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/SameInnersInSupertypeAndSupertypesSupertype.kt"); + } + + @Test + @TestMetadata("SuperTypeWithSameInner.kt") + public void testSuperTypeWithSameInner() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/SuperTypeWithSameInner.kt"); + } + + @Test + @TestMetadata("SupertypeInnerAndTypeParameterWithSameNames.kt") + public void testSupertypeInnerAndTypeParameterWithSameNames() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/SupertypeInnerAndTypeParameterWithSameNames.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/javac/inners") + @TestDataPath("$PROJECT_ROOT") + public class Inners extends AbstractDiagnosticTest { + @Test + public void testAllFilesPresentInInners() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/inners"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + } + + @Test + @TestMetadata("ComplexCase.kt") + public void testComplexCase() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inners/ComplexCase.kt"); + } + + @Test + @TestMetadata("ComplexCase2.kt") + public void testComplexCase2() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inners/ComplexCase2.kt"); + } + + @Test + @TestMetadata("CurrentPackageAndInner.kt") + public void testCurrentPackageAndInner() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inners/CurrentPackageAndInner.kt"); + } + + @Test + @TestMetadata("ImportThriceNestedClass.kt") + public void testImportThriceNestedClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inners/ImportThriceNestedClass.kt"); + } + + @Test + @TestMetadata("InnerInInner.kt") + public void testInnerInInner() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inners/InnerInInner.kt"); + } + + @Test + @TestMetadata("Nested.kt") + public void testNested() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inners/Nested.kt"); + } + + @Test + @TestMetadata("ThriceNestedClass.kt") + public void testThriceNestedClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inners/ThriceNestedClass.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/javac/qualifiedExpression") + @TestDataPath("$PROJECT_ROOT") + public class QualifiedExpression extends AbstractDiagnosticTest { + @Test + public void testAllFilesPresentInQualifiedExpression() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/qualifiedExpression"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + } + + @Test + @TestMetadata("GenericClassVsPackage.kt") + public void testGenericClassVsPackage() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/qualifiedExpression/GenericClassVsPackage.kt"); + } + + @Test + @TestMetadata("PackageVsClass.kt") + public void testPackageVsClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/qualifiedExpression/PackageVsClass.kt"); + } + + @Test + @TestMetadata("PackageVsClass2.kt") + public void testPackageVsClass2() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/qualifiedExpression/PackageVsClass2.kt"); + } + + @Test + @TestMetadata("PackageVsRootClass.kt") + public void testPackageVsRootClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/qualifiedExpression/PackageVsRootClass.kt"); + } + + @Test + @TestMetadata("visibleClassVsQualifiedClass.kt") + public void testVisibleClassVsQualifiedClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/qualifiedExpression/visibleClassVsQualifiedClass.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/javac/typeParameters") + @TestDataPath("$PROJECT_ROOT") + public class TypeParameters extends AbstractDiagnosticTest { + @Test + public void testAllFilesPresentInTypeParameters() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/typeParameters"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + } + + @Test + @TestMetadata("Clash.kt") + public void testClash() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/typeParameters/Clash.kt"); + } + + @Test + @TestMetadata("ComplexCase.kt") + public void testComplexCase() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/typeParameters/ComplexCase.kt"); + } + + @Test + @TestMetadata("InheritedInnerAndTypeParameterWithSameNames.kt") + public void testInheritedInnerAndTypeParameterWithSameNames() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/typeParameters/InheritedInnerAndTypeParameterWithSameNames.kt"); + } + + @Test + @TestMetadata("InnerWithTypeParameter.kt") + public void testInnerWithTypeParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/typeParameters/InnerWithTypeParameter.kt"); + } + + @Test + @TestMetadata("NestedWithInner.kt") + public void testNestedWithInner() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/typeParameters/NestedWithInner.kt"); + } + + @Test + @TestMetadata("SeveralInnersWithTypeParameters.kt") + public void testSeveralInnersWithTypeParameters() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/typeParameters/SeveralInnersWithTypeParameters.kt"); + } + + @Test + @TestMetadata("TypeParametersInInnerAndOuterWithSameNames.kt") + public void testTypeParametersInInnerAndOuterWithSameNames() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/typeParameters/TypeParametersInInnerAndOuterWithSameNames.kt"); + } + } + } + @Nested @TestMetadata("compiler/testData/diagnostics/tests/labels") @TestDataPath("$PROJECT_ROOT") diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticUsingJavacTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticUsingJavacTestGenerated.java index b005fac525a..dad8d6856ae 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticUsingJavacTestGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticUsingJavacTestGenerated.java @@ -16,34334 +16,467 @@ import java.util.regex.Pattern; /** This class is generated by {@link org.jetbrains.kotlin.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */ @SuppressWarnings("all") +@TestMetadata("compiler/testData/diagnostics/tests/javac") +@TestDataPath("$PROJECT_ROOT") public class DiagnosticUsingJavacTestGenerated extends AbstractDiagnosticUsingJavacTest { + @Test + public void testAllFilesPresentInJavac() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + } + + @Test + @TestMetadata("Annotations.kt") + public void testAnnotations() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/Annotations.kt"); + } + @Nested - @TestMetadata("compiler/testData/diagnostics/tests") + @TestMetadata("compiler/testData/diagnostics/tests/javac/fieldsResolution") @TestDataPath("$PROJECT_ROOT") - public class Tests extends AbstractDiagnosticUsingJavacTest { + public class FieldsResolution extends AbstractDiagnosticUsingJavacTest { @Test - @TestMetadata("Abstract.kt") - public void testAbstract() throws Exception { - runTest("compiler/testData/diagnostics/tests/Abstract.kt"); + public void testAllFilesPresentInFieldsResolution() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/fieldsResolution"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test - @TestMetadata("AbstractAccessor.kt") - public void testAbstractAccessor() throws Exception { - runTest("compiler/testData/diagnostics/tests/AbstractAccessor.kt"); + @TestMetadata("AsteriskStaticImportsAmbiguity.kt") + public void testAsteriskStaticImportsAmbiguity() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/fieldsResolution/AsteriskStaticImportsAmbiguity.kt"); } @Test - @TestMetadata("AbstractInAbstractClass.kt") - public void testAbstractInAbstractClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/AbstractInAbstractClass.kt"); + @TestMetadata("BinaryInitializers.kt") + public void testBinaryInitializers() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/fieldsResolution/BinaryInitializers.kt"); } @Test - @TestMetadata("AbstractInClass.kt") - public void testAbstractInClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/AbstractInClass.kt"); + @TestMetadata("ConstantByFqName.kt") + public void testConstantByFqName() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/fieldsResolution/ConstantByFqName.kt"); } @Test - @TestMetadata("AbstractInTrait.kt") - public void testAbstractInTrait() throws Exception { - runTest("compiler/testData/diagnostics/tests/AbstractInTrait.kt"); + @TestMetadata("ConstantValues.kt") + public void testConstantValues() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/fieldsResolution/ConstantValues.kt"); } @Test - public void testAllFilesPresentInTests() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + @TestMetadata("ConstantValuesFromKtFile.kt") + public void testConstantValuesFromKtFile() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/fieldsResolution/ConstantValuesFromKtFile.kt"); } @Test - @TestMetadata("AnonymousInitializerVarAndConstructor.kt") - public void testAnonymousInitializerVarAndConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/AnonymousInitializerVarAndConstructor.kt"); + @TestMetadata("FieldFromOuterClass.kt") + public void testFieldFromOuterClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/fieldsResolution/FieldFromOuterClass.kt"); } @Test - @TestMetadata("AnonymousInitializers.kt") - public void testAnonymousInitializers() throws Exception { - runTest("compiler/testData/diagnostics/tests/AnonymousInitializers.kt"); + @TestMetadata("InheritedField.kt") + public void testInheritedField() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/fieldsResolution/InheritedField.kt"); } @Test - @TestMetadata("AssignToArrayElement.kt") - public void testAssignToArrayElement() throws Exception { - runTest("compiler/testData/diagnostics/tests/AssignToArrayElement.kt"); + @TestMetadata("MultipleOuters.kt") + public void testMultipleOuters() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/fieldsResolution/MultipleOuters.kt"); } @Test - @TestMetadata("AutoCreatedIt.kt") - public void testAutoCreatedIt() throws Exception { - runTest("compiler/testData/diagnostics/tests/AutoCreatedIt.kt"); + @TestMetadata("ResolutionPriority.kt") + public void testResolutionPriority() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/fieldsResolution/ResolutionPriority.kt"); } @Test - @TestMetadata("BacktickNames.kt") - public void testBacktickNames() throws Exception { - runTest("compiler/testData/diagnostics/tests/BacktickNames.kt"); + @TestMetadata("SameFieldInSupertypes.kt") + public void testSameFieldInSupertypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/fieldsResolution/SameFieldInSupertypes.kt"); } @Test - @TestMetadata("Basic.kt") - public void testBasic() throws Exception { - runTest("compiler/testData/diagnostics/tests/Basic.kt"); + @TestMetadata("StaticImport.kt") + public void testStaticImport() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/fieldsResolution/StaticImport.kt"); } @Test - @TestMetadata("BinaryCallsOnNullableValues.kt") - public void testBinaryCallsOnNullableValues() throws Exception { - runTest("compiler/testData/diagnostics/tests/BinaryCallsOnNullableValues.kt"); - } - - @Test - @TestMetadata("Bounds.kt") - public void testBounds() throws Exception { - runTest("compiler/testData/diagnostics/tests/Bounds.kt"); - } - - @Test - @TestMetadata("BreakContinue.kt") - public void testBreakContinue() throws Exception { - runTest("compiler/testData/diagnostics/tests/BreakContinue.kt"); - } - - @Test - @TestMetadata("BreakContinueInWhen_after.kt") - public void testBreakContinueInWhen_after() throws Exception { - runTest("compiler/testData/diagnostics/tests/BreakContinueInWhen_after.kt"); - } - - @Test - @TestMetadata("BreakContinueInWhen_before.kt") - public void testBreakContinueInWhen_before() throws Exception { - runTest("compiler/testData/diagnostics/tests/BreakContinueInWhen_before.kt"); - } - - @Test - @TestMetadata("Builders.kt") - public void testBuilders() throws Exception { - runTest("compiler/testData/diagnostics/tests/Builders.kt"); - } - - @Test - @TestMetadata("Casts.kt") - public void testCasts() throws Exception { - runTest("compiler/testData/diagnostics/tests/Casts.kt"); - } - - @Test - @TestMetadata("CharacterLiterals.kt") - public void testCharacterLiterals() throws Exception { - runTest("compiler/testData/diagnostics/tests/CharacterLiterals.kt"); - } - - @Test - @TestMetadata("checkType.kt") - public void testCheckType() throws Exception { - runTest("compiler/testData/diagnostics/tests/checkType.kt"); - } - - @Test - @TestMetadata("CompareToWithErrorType.kt") - public void testCompareToWithErrorType() throws Exception { - runTest("compiler/testData/diagnostics/tests/CompareToWithErrorType.kt"); - } - - @Test - @TestMetadata("Constants.kt") - public void testConstants() throws Exception { - runTest("compiler/testData/diagnostics/tests/Constants.kt"); - } - - @Test - @TestMetadata("Constructors.kt") - public void testConstructors() throws Exception { - runTest("compiler/testData/diagnostics/tests/Constructors.kt"); - } - - @Test - @TestMetadata("ConstructorsOfPrimitives.kt") - public void testConstructorsOfPrimitives() throws Exception { - runTest("compiler/testData/diagnostics/tests/ConstructorsOfPrimitives.kt"); - } - - @Test - @TestMetadata("CovariantOverrideType.kt") - public void testCovariantOverrideType() throws Exception { - runTest("compiler/testData/diagnostics/tests/CovariantOverrideType.kt"); - } - - @Test - @TestMetadata("DefaultValueForParameterInFunctionType.kt") - public void testDefaultValueForParameterInFunctionType() throws Exception { - runTest("compiler/testData/diagnostics/tests/DefaultValueForParameterInFunctionType.kt"); - } - - @Test - @TestMetadata("DefaultValuesCheckWithoutBody.kt") - public void testDefaultValuesCheckWithoutBody() throws Exception { - runTest("compiler/testData/diagnostics/tests/DefaultValuesCheckWithoutBody.kt"); - } - - @Test - @TestMetadata("DefaultValuesTypechecking.kt") - public void testDefaultValuesTypechecking() throws Exception { - runTest("compiler/testData/diagnostics/tests/DefaultValuesTypechecking.kt"); - } - - @Test - @TestMetadata("DeferredTypes.kt") - public void testDeferredTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/DeferredTypes.kt"); - } - - @Test - @TestMetadata("DeprecatedGetSetPropertyDelegateConvention.kt") - public void testDeprecatedGetSetPropertyDelegateConvention() throws Exception { - runTest("compiler/testData/diagnostics/tests/DeprecatedGetSetPropertyDelegateConvention.kt"); - } - - @Test - @TestMetadata("DeprecatedUnaryOperatorConventions.kt") - public void testDeprecatedUnaryOperatorConventions() throws Exception { - runTest("compiler/testData/diagnostics/tests/DeprecatedUnaryOperatorConventions.kt"); - } - - @Test - @TestMetadata("DiamondFunction.kt") - public void testDiamondFunction() throws Exception { - runTest("compiler/testData/diagnostics/tests/DiamondFunction.kt"); - } - - @Test - @TestMetadata("DiamondFunctionGeneric.kt") - public void testDiamondFunctionGeneric() throws Exception { - runTest("compiler/testData/diagnostics/tests/DiamondFunctionGeneric.kt"); - } - - @Test - @TestMetadata("DiamondProperty.kt") - public void testDiamondProperty() throws Exception { - runTest("compiler/testData/diagnostics/tests/DiamondProperty.kt"); - } - - @Test - @TestMetadata("Dollar.kt") - public void testDollar() throws Exception { - runTest("compiler/testData/diagnostics/tests/Dollar.kt"); - } - - @Test - @TestMetadata("EnumEntryAsType.kt") - public void testEnumEntryAsType() throws Exception { - runTest("compiler/testData/diagnostics/tests/EnumEntryAsType.kt"); - } - - @Test - @TestMetadata("ExtensionCallInvoke.kt") - public void testExtensionCallInvoke() throws Exception { - runTest("compiler/testData/diagnostics/tests/ExtensionCallInvoke.kt"); - } - - @Test - @TestMetadata("ExternalAccessors.kt") - public void testExternalAccessors() throws Exception { - runTest("compiler/testData/diagnostics/tests/ExternalAccessors.kt"); - } - - @Test - @TestMetadata("ExternalAndAbstract.kt") - public void testExternalAndAbstract() throws Exception { - runTest("compiler/testData/diagnostics/tests/ExternalAndAbstract.kt"); - } - - @Test - @TestMetadata("fileDependencyRecursion.kt") - public void testFileDependencyRecursion() throws Exception { - runTest("compiler/testData/diagnostics/tests/fileDependencyRecursion.kt"); - } - - @Test - @TestMetadata("ForRangeConventions.kt") - public void testForRangeConventions() throws Exception { - runTest("compiler/testData/diagnostics/tests/ForRangeConventions.kt"); - } - - @Test - @TestMetadata("FreeFunctionCalledAsExtension.kt") - public void testFreeFunctionCalledAsExtension() throws Exception { - runTest("compiler/testData/diagnostics/tests/FreeFunctionCalledAsExtension.kt"); - } - - @Test - @TestMetadata("FunctionCalleeExpressions.kt") - public void testFunctionCalleeExpressions() throws Exception { - runTest("compiler/testData/diagnostics/tests/FunctionCalleeExpressions.kt"); - } - - @Test - @TestMetadata("FunctionParameterWithoutType.kt") - public void testFunctionParameterWithoutType() throws Exception { - runTest("compiler/testData/diagnostics/tests/FunctionParameterWithoutType.kt"); - } - - @Test - @TestMetadata("FunctionReturnTypes.kt") - public void testFunctionReturnTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/FunctionReturnTypes.kt"); - } - - @Test - @TestMetadata("GenericArgumentConsistency.kt") - public void testGenericArgumentConsistency() throws Exception { - runTest("compiler/testData/diagnostics/tests/GenericArgumentConsistency.kt"); - } - - @Test - @TestMetadata("GenericFunctionIsLessSpecific.kt") - public void testGenericFunctionIsLessSpecific() throws Exception { - runTest("compiler/testData/diagnostics/tests/GenericFunctionIsLessSpecific.kt"); - } - - @Test - @TestMetadata("IdentityComparisonWithPrimitives.kt") - public void testIdentityComparisonWithPrimitives() throws Exception { - runTest("compiler/testData/diagnostics/tests/IdentityComparisonWithPrimitives.kt"); - } - - @Test - @TestMetadata("implicitIntersection.kt") - public void testImplicitIntersection() throws Exception { - runTest("compiler/testData/diagnostics/tests/implicitIntersection.kt"); - } - - @Test - @TestMetadata("implicitNestedIntersection.kt") - public void testImplicitNestedIntersection() throws Exception { - runTest("compiler/testData/diagnostics/tests/implicitNestedIntersection.kt"); - } - - @Test - @TestMetadata("implicitNothing.kt") - public void testImplicitNothing() throws Exception { - runTest("compiler/testData/diagnostics/tests/implicitNothing.kt"); - } - - @Test - @TestMetadata("IncDec.kt") - public void testIncDec() throws Exception { - runTest("compiler/testData/diagnostics/tests/IncDec.kt"); - } - - @Test - @TestMetadata("IncorrectCharacterLiterals.kt") - public void testIncorrectCharacterLiterals() throws Exception { - runTest("compiler/testData/diagnostics/tests/IncorrectCharacterLiterals.kt"); - } - - @Test - @TestMetadata("InferNullabilityInThenBlock.kt") - public void testInferNullabilityInThenBlock() throws Exception { - runTest("compiler/testData/diagnostics/tests/InferNullabilityInThenBlock.kt"); - } - - @Test - @TestMetadata("Infix.kt") - public void testInfix() throws Exception { - runTest("compiler/testData/diagnostics/tests/Infix.kt"); - } - - @Test - @TestMetadata("InfixModifierApplicability.kt") - public void testInfixModifierApplicability() throws Exception { - runTest("compiler/testData/diagnostics/tests/InfixModifierApplicability.kt"); - } - - @Test - @TestMetadata("InvokeAndRecursiveResolve.kt") - public void testInvokeAndRecursiveResolve() throws Exception { - runTest("compiler/testData/diagnostics/tests/InvokeAndRecursiveResolve.kt"); - } - - @Test - @TestMetadata("IsExpressions.kt") - public void testIsExpressions() throws Exception { - runTest("compiler/testData/diagnostics/tests/IsExpressions.kt"); - } - - @Test - @TestMetadata("kt13401.kt") - public void testKt13401() throws Exception { - runTest("compiler/testData/diagnostics/tests/kt13401.kt"); - } - - @Test - @TestMetadata("kt310.kt") - public void testKt310() throws Exception { - runTest("compiler/testData/diagnostics/tests/kt310.kt"); - } - - @Test - @TestMetadata("kt34857.kt") - public void testKt34857() throws Exception { - runTest("compiler/testData/diagnostics/tests/kt34857.kt"); - } - - @Test - @TestMetadata("kt435.kt") - public void testKt435() throws Exception { - runTest("compiler/testData/diagnostics/tests/kt435.kt"); - } - - @Test - @TestMetadata("kt53.kt") - public void testKt53() throws Exception { - runTest("compiler/testData/diagnostics/tests/kt53.kt"); - } - - @Test - @TestMetadata("LValueAssignment.kt") - public void testLValueAssignment() throws Exception { - runTest("compiler/testData/diagnostics/tests/LValueAssignment.kt"); - } - - @Test - @TestMetadata("LiteralAsResult.kt") - public void testLiteralAsResult() throws Exception { - runTest("compiler/testData/diagnostics/tests/LiteralAsResult.kt"); - } - - @Test - @TestMetadata("LocalClassAndShortSubpackageNames.kt") - public void testLocalClassAndShortSubpackageNames() throws Exception { - runTest("compiler/testData/diagnostics/tests/LocalClassAndShortSubpackageNames.kt"); - } - - @Test - @TestMetadata("localInterfaces.kt") - public void testLocalInterfaces() throws Exception { - runTest("compiler/testData/diagnostics/tests/localInterfaces.kt"); - } - - @Test - @TestMetadata("MultilineStringTemplates.kt") - public void testMultilineStringTemplates() throws Exception { - runTest("compiler/testData/diagnostics/tests/MultilineStringTemplates.kt"); - } - - @Test - @TestMetadata("MultipleBounds.kt") - public void testMultipleBounds() throws Exception { - runTest("compiler/testData/diagnostics/tests/MultipleBounds.kt"); - } - - @Test - @TestMetadata("NamedFunctionTypeParameterInSupertype.kt") - public void testNamedFunctionTypeParameterInSupertype() throws Exception { - runTest("compiler/testData/diagnostics/tests/NamedFunctionTypeParameterInSupertype.kt"); - } - - @Test - @TestMetadata("Nullability.kt") - public void testNullability() throws Exception { - runTest("compiler/testData/diagnostics/tests/Nullability.kt"); - } - - @Test - @TestMetadata("NumberPrefixAndSuffix.kt") - public void testNumberPrefixAndSuffix() throws Exception { - runTest("compiler/testData/diagnostics/tests/NumberPrefixAndSuffix.kt"); - } - - @Test - @TestMetadata("ObjectWithConstructor.kt") - public void testObjectWithConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/ObjectWithConstructor.kt"); - } - - @Test - @TestMetadata("OperatorChecks.kt") - public void testOperatorChecks() throws Exception { - runTest("compiler/testData/diagnostics/tests/OperatorChecks.kt"); - } - - @Test - @TestMetadata("Operators.kt") - public void testOperators() throws Exception { - runTest("compiler/testData/diagnostics/tests/Operators.kt"); - } - - @Test - @TestMetadata("OperatorsWithWrongNames.kt") - public void testOperatorsWithWrongNames() throws Exception { - runTest("compiler/testData/diagnostics/tests/OperatorsWithWrongNames.kt"); - } - - @Test - @TestMetadata("OverrideFunctionWithParamDefaultValue.kt") - public void testOverrideFunctionWithParamDefaultValue() throws Exception { - runTest("compiler/testData/diagnostics/tests/OverrideFunctionWithParamDefaultValue.kt"); - } - - @Test - @TestMetadata("OverridenFunctionAndSpecifiedTypeParameter.kt") - public void testOverridenFunctionAndSpecifiedTypeParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/OverridenFunctionAndSpecifiedTypeParameter.kt"); - } - - @Test - @TestMetadata("OverridenSetterVisibility.kt") - public void testOverridenSetterVisibility() throws Exception { - runTest("compiler/testData/diagnostics/tests/OverridenSetterVisibility.kt"); - } - - @Test - @TestMetadata("OverridingVarByVal.kt") - public void testOverridingVarByVal() throws Exception { - runTest("compiler/testData/diagnostics/tests/OverridingVarByVal.kt"); - } - - @Test - @TestMetadata("PackageInExpressionPosition.kt") - public void testPackageInExpressionPosition() throws Exception { - runTest("compiler/testData/diagnostics/tests/PackageInExpressionPosition.kt"); - } - - @Test - @TestMetadata("PackageInTypePosition.kt") - public void testPackageInTypePosition() throws Exception { - runTest("compiler/testData/diagnostics/tests/PackageInTypePosition.kt"); - } - - @Test - @TestMetadata("PackageQualified.kt") - public void testPackageQualified() throws Exception { - runTest("compiler/testData/diagnostics/tests/PackageQualified.kt"); - } - - @Test - @TestMetadata("PrimaryConstructors.kt") - public void testPrimaryConstructors() throws Exception { - runTest("compiler/testData/diagnostics/tests/PrimaryConstructors.kt"); - } - - @Test - @TestMetadata("PrivateFromOuterPackage.kt") - public void testPrivateFromOuterPackage() throws Exception { - runTest("compiler/testData/diagnostics/tests/PrivateFromOuterPackage.kt"); - } - - @Test - @TestMetadata("PrivateSetterForOverridden.kt") - public void testPrivateSetterForOverridden() throws Exception { - runTest("compiler/testData/diagnostics/tests/PrivateSetterForOverridden.kt"); - } - - @Test - @TestMetadata("ProcessingEmptyImport.kt") - public void testProcessingEmptyImport() throws Exception { - runTest("compiler/testData/diagnostics/tests/ProcessingEmptyImport.kt"); - } - - @Test - @TestMetadata("ProjectionOnFunctionArgumentErrror.kt") - public void testProjectionOnFunctionArgumentErrror() throws Exception { - runTest("compiler/testData/diagnostics/tests/ProjectionOnFunctionArgumentErrror.kt"); - } - - @Test - @TestMetadata("ProjectionsInSupertypes.kt") - public void testProjectionsInSupertypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/ProjectionsInSupertypes.kt"); - } - - @Test - @TestMetadata("properDefaultInitializationInTailrec.kt") - public void testProperDefaultInitializationInTailrec() throws Exception { - runTest("compiler/testData/diagnostics/tests/properDefaultInitializationInTailrec.kt"); - } - - @Test - @TestMetadata("Properties.kt") - public void testProperties() throws Exception { - runTest("compiler/testData/diagnostics/tests/Properties.kt"); - } - - @Test - @TestMetadata("PropertyInitializers.kt") - public void testPropertyInitializers() throws Exception { - runTest("compiler/testData/diagnostics/tests/PropertyInitializers.kt"); - } - - @Test - @TestMetadata("publishedApi.kt") - public void testPublishedApi() throws Exception { - runTest("compiler/testData/diagnostics/tests/publishedApi.kt"); - } - - @Test - @TestMetadata("QualifiedExpressions.kt") - public void testQualifiedExpressions() throws Exception { - runTest("compiler/testData/diagnostics/tests/QualifiedExpressions.kt"); - } - - @Test - @TestMetadata("RecursiveResolve.kt") - public void testRecursiveResolve() throws Exception { - runTest("compiler/testData/diagnostics/tests/RecursiveResolve.kt"); - } - - @Test - @TestMetadata("RecursiveTypeInference.kt") - public void testRecursiveTypeInference() throws Exception { - runTest("compiler/testData/diagnostics/tests/RecursiveTypeInference.kt"); - } - - @Test - @TestMetadata("ReserveYield.kt") - public void testReserveYield() throws Exception { - runTest("compiler/testData/diagnostics/tests/ReserveYield.kt"); - } - - @Test - @TestMetadata("ReserveYield2.kt") - public void testReserveYield2() throws Exception { - runTest("compiler/testData/diagnostics/tests/ReserveYield2.kt"); - } - - @Test - @TestMetadata("ResolveOfJavaGenerics.kt") - public void testResolveOfJavaGenerics() throws Exception { - runTest("compiler/testData/diagnostics/tests/ResolveOfJavaGenerics.kt"); - } - - @Test - @TestMetadata("ResolveToJava.kt") - public void testResolveToJava() throws Exception { - runTest("compiler/testData/diagnostics/tests/ResolveToJava.kt"); - } - - @Test - @TestMetadata("Return.kt") - public void testReturn() throws Exception { - runTest("compiler/testData/diagnostics/tests/Return.kt"); - } - - @Test - @TestMetadata("ReturnInFunctionWithoutBody.kt") - public void testReturnInFunctionWithoutBody() throws Exception { - runTest("compiler/testData/diagnostics/tests/ReturnInFunctionWithoutBody.kt"); - } - - @Test - @TestMetadata("safeCall.kt") - public void testSafeCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/safeCall.kt"); - } - - @Test - @TestMetadata("SafeCallInvoke.kt") - public void testSafeCallInvoke() throws Exception { - runTest("compiler/testData/diagnostics/tests/SafeCallInvoke.kt"); - } - - @Test - @TestMetadata("SafeCallNonNullReceiver.kt") - public void testSafeCallNonNullReceiver() throws Exception { - runTest("compiler/testData/diagnostics/tests/SafeCallNonNullReceiver.kt"); - } - - @Test - @TestMetadata("SafeCallNonNullReceiverReturnNull.kt") - public void testSafeCallNonNullReceiverReturnNull() throws Exception { - runTest("compiler/testData/diagnostics/tests/SafeCallNonNullReceiverReturnNull.kt"); - } - - @Test - @TestMetadata("SafeCallOnFakePackage.kt") - public void testSafeCallOnFakePackage() throws Exception { - runTest("compiler/testData/diagnostics/tests/SafeCallOnFakePackage.kt"); - } - - @Test - @TestMetadata("SafeCallOnSuperReceiver.kt") - public void testSafeCallOnSuperReceiver() throws Exception { - runTest("compiler/testData/diagnostics/tests/SafeCallOnSuperReceiver.kt"); - } - - @Test - @TestMetadata("Serializable.kt") - public void testSerializable() throws Exception { - runTest("compiler/testData/diagnostics/tests/Serializable.kt"); - } - - @Test - @TestMetadata("SetterVisibility.kt") - public void testSetterVisibility() throws Exception { - runTest("compiler/testData/diagnostics/tests/SetterVisibility.kt"); - } - - @Test - @TestMetadata("ShiftFunctionTypes.kt") - public void testShiftFunctionTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/ShiftFunctionTypes.kt"); - } - - @Test - @TestMetadata("SingleUnderscoreUnsupported.kt") - public void testSingleUnderscoreUnsupported() throws Exception { - runTest("compiler/testData/diagnostics/tests/SingleUnderscoreUnsupported.kt"); - } - - @Test - @TestMetadata("StarsInFunctionCalls.kt") - public void testStarsInFunctionCalls() throws Exception { - runTest("compiler/testData/diagnostics/tests/StarsInFunctionCalls.kt"); - } - - @Test - @TestMetadata("StringPrefixAndSuffix.kt") - public void testStringPrefixAndSuffix() throws Exception { - runTest("compiler/testData/diagnostics/tests/StringPrefixAndSuffix.kt"); - } - - @Test - @TestMetadata("StringTemplates.kt") - public void testStringTemplates() throws Exception { - runTest("compiler/testData/diagnostics/tests/StringTemplates.kt"); - } - - @Test - @TestMetadata("SupertypeListChecks.kt") - public void testSupertypeListChecks() throws Exception { - runTest("compiler/testData/diagnostics/tests/SupertypeListChecks.kt"); - } - - @Test - @TestMetadata("SyntaxErrorInTestHighlighting.kt") - public void testSyntaxErrorInTestHighlighting() throws Exception { - runTest("compiler/testData/diagnostics/tests/SyntaxErrorInTestHighlighting.kt"); - } - - @Test - @TestMetadata("SyntaxErrorInTestHighlightingEof.kt") - public void testSyntaxErrorInTestHighlightingEof() throws Exception { - runTest("compiler/testData/diagnostics/tests/SyntaxErrorInTestHighlightingEof.kt"); - } - - @Test - @TestMetadata("tailRecOnVirtualMember.kt") - public void testTailRecOnVirtualMember() throws Exception { - runTest("compiler/testData/diagnostics/tests/tailRecOnVirtualMember.kt"); - } - - @Test - @TestMetadata("tailRecOnVirtualMemberError.kt") - public void testTailRecOnVirtualMemberError() throws Exception { - runTest("compiler/testData/diagnostics/tests/tailRecOnVirtualMemberError.kt"); - } - - @Test - @TestMetadata("tailRecOverridden.kt") - public void testTailRecOverridden() throws Exception { - runTest("compiler/testData/diagnostics/tests/tailRecOverridden.kt"); - } - - @Test - @TestMetadata("tailRecursionComplex.kt") - public void testTailRecursionComplex() throws Exception { - runTest("compiler/testData/diagnostics/tests/tailRecursionComplex.kt"); - } - - @Test - @TestMetadata("TraitOverrideObjectMethods.kt") - public void testTraitOverrideObjectMethods() throws Exception { - runTest("compiler/testData/diagnostics/tests/TraitOverrideObjectMethods.kt"); - } - - @Test - @TestMetadata("TraitWithConstructor.kt") - public void testTraitWithConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/TraitWithConstructor.kt"); - } - - @Test - @TestMetadata("TypeInference.kt") - public void testTypeInference() throws Exception { - runTest("compiler/testData/diagnostics/tests/TypeInference.kt"); - } - - @Test - @TestMetadata("TypeMismatchOnOverrideWithSyntaxErrors.kt") - public void testTypeMismatchOnOverrideWithSyntaxErrors() throws Exception { - runTest("compiler/testData/diagnostics/tests/TypeMismatchOnOverrideWithSyntaxErrors.kt"); - } - - @Test - @TestMetadata("Underscore.kt") - public void testUnderscore() throws Exception { - runTest("compiler/testData/diagnostics/tests/Underscore.kt"); - } - - @Test - @TestMetadata("UnderscoreUsageInAnnotation.kt") - public void testUnderscoreUsageInAnnotation() throws Exception { - runTest("compiler/testData/diagnostics/tests/UnderscoreUsageInAnnotation.kt"); - } - - @Test - @TestMetadata("UnderscoreUsageInCall.kt") - public void testUnderscoreUsageInCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/UnderscoreUsageInCall.kt"); - } - - @Test - @TestMetadata("UnderscoreUsageInCallableRefTypeLHS.kt") - public void testUnderscoreUsageInCallableRefTypeLHS() throws Exception { - runTest("compiler/testData/diagnostics/tests/UnderscoreUsageInCallableRefTypeLHS.kt"); - } - - @Test - @TestMetadata("UnderscoreUsageInType.kt") - public void testUnderscoreUsageInType() throws Exception { - runTest("compiler/testData/diagnostics/tests/UnderscoreUsageInType.kt"); - } - - @Test - @TestMetadata("UnderscoreUsageInVariableAsFunctionCall.kt") - public void testUnderscoreUsageInVariableAsFunctionCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/UnderscoreUsageInVariableAsFunctionCall.kt"); - } - - @Test - @TestMetadata("UnitByDefaultForFunctionTypes.kt") - public void testUnitByDefaultForFunctionTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/UnitByDefaultForFunctionTypes.kt"); - } - - @Test - @TestMetadata("UnitValue.kt") - public void testUnitValue() throws Exception { - runTest("compiler/testData/diagnostics/tests/UnitValue.kt"); - } - - @Test - @TestMetadata("unproperDefaultInitializationInTailrec.kt") - public void testUnproperDefaultInitializationInTailrec() throws Exception { - runTest("compiler/testData/diagnostics/tests/unproperDefaultInitializationInTailrec.kt"); - } - - @Test - @TestMetadata("Unresolved.kt") - public void testUnresolved() throws Exception { - runTest("compiler/testData/diagnostics/tests/Unresolved.kt"); - } - - @Test - @TestMetadata("UnusedInDestructuring.kt") - public void testUnusedInDestructuring() throws Exception { - runTest("compiler/testData/diagnostics/tests/UnusedInDestructuring.kt"); - } - - @Test - @TestMetadata("UnusedParameters.kt") - public void testUnusedParameters() throws Exception { - runTest("compiler/testData/diagnostics/tests/UnusedParameters.kt"); - } - - @Test - @TestMetadata("UnusedParametersVersion10.kt") - public void testUnusedParametersVersion10() throws Exception { - runTest("compiler/testData/diagnostics/tests/UnusedParametersVersion10.kt"); - } - - @Test - @TestMetadata("UnusedVariables.kt") - public void testUnusedVariables() throws Exception { - runTest("compiler/testData/diagnostics/tests/UnusedVariables.kt"); - } - - @Test - @TestMetadata("ValAndFunOverrideCompatibilityClash.kt") - public void testValAndFunOverrideCompatibilityClash() throws Exception { - runTest("compiler/testData/diagnostics/tests/ValAndFunOverrideCompatibilityClash.kt"); - } - - @Test - @TestMetadata("VarargTypes.kt") - public void testVarargTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/VarargTypes.kt"); - } - - @Test - @TestMetadata("Varargs.kt") - public void testVarargs() throws Exception { - runTest("compiler/testData/diagnostics/tests/Varargs.kt"); - } - - @Test - @TestMetadata("Variance.kt") - public void testVariance() throws Exception { - runTest("compiler/testData/diagnostics/tests/Variance.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/annotations") - @TestDataPath("$PROJECT_ROOT") - public class Annotations extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("AmbigiousAnnotationConstructor.kt") - public void testAmbigiousAnnotationConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/AmbigiousAnnotationConstructor.kt"); - } - - @Test - @TestMetadata("AnnotatedConstructor.kt") - public void testAnnotatedConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/AnnotatedConstructor.kt"); - } - - @Test - @TestMetadata("AnnotatedConstructorParams.kt") - public void testAnnotatedConstructorParams() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/AnnotatedConstructorParams.kt"); - } - - @Test - @TestMetadata("annotatedExpressionInsideAnnotation.kt") - public void testAnnotatedExpressionInsideAnnotation() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/annotatedExpressionInsideAnnotation.kt"); - } - - @Test - @TestMetadata("AnnotatedLocalObjectFun.kt") - public void testAnnotatedLocalObjectFun() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/AnnotatedLocalObjectFun.kt"); - } - - @Test - @TestMetadata("AnnotatedLocalObjectProperty.kt") - public void testAnnotatedLocalObjectProperty() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/AnnotatedLocalObjectProperty.kt"); - } - - @Test - @TestMetadata("AnnotatedLoop.kt") - public void testAnnotatedLoop() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/AnnotatedLoop.kt"); - } - - @Test - @TestMetadata("AnnotatedResultType.kt") - public void testAnnotatedResultType() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/AnnotatedResultType.kt"); - } - - @Test - @TestMetadata("AnnotatedTryCatch.kt") - public void testAnnotatedTryCatch() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/AnnotatedTryCatch.kt"); - } - - @Test - @TestMetadata("AnnotationAsDefaultParameter.kt") - public void testAnnotationAsDefaultParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/AnnotationAsDefaultParameter.kt"); - } - - @Test - @TestMetadata("AnnotationForClassTypeParameter.kt") - public void testAnnotationForClassTypeParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/AnnotationForClassTypeParameter.kt"); - } - - @Test - @TestMetadata("AnnotationForFunctionTypeParameter.kt") - public void testAnnotationForFunctionTypeParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/AnnotationForFunctionTypeParameter.kt"); - } - - @Test - @TestMetadata("AnnotationForObject.kt") - public void testAnnotationForObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/AnnotationForObject.kt"); - } - - @Test - @TestMetadata("AnnotationIdentifier.kt") - public void testAnnotationIdentifier() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/AnnotationIdentifier.kt"); - } - - @Test - @TestMetadata("annotationInheritance.kt") - public void testAnnotationInheritance() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/annotationInheritance.kt"); - } - - @Test - @TestMetadata("annotationModifier.kt") - public void testAnnotationModifier() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/annotationModifier.kt"); - } - - @Test - @TestMetadata("AnnotationOnObject.kt") - public void testAnnotationOnObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/AnnotationOnObject.kt"); - } - - @Test - @TestMetadata("annotationOnParameterInFunctionType.kt") - public void testAnnotationOnParameterInFunctionType() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/annotationOnParameterInFunctionType.kt"); - } - - @Test - @TestMetadata("annotationRenderingInTypes.kt") - public void testAnnotationRenderingInTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/annotationRenderingInTypes.kt"); - } - - @Test - @TestMetadata("AnnotationsForClasses.kt") - public void testAnnotationsForClasses() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/AnnotationsForClasses.kt"); - } - - @Test - @TestMetadata("AnnotationsForPropertyTypeParameter.kt") - public void testAnnotationsForPropertyTypeParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/AnnotationsForPropertyTypeParameter.kt"); - } - - @Test - @TestMetadata("annotationsOnLambdaAsCallArgument.kt") - public void testAnnotationsOnLambdaAsCallArgument() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/annotationsOnLambdaAsCallArgument.kt"); - } - - @Test - @TestMetadata("annotationsOnNullableTypes.kt") - public void testAnnotationsOnNullableTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/annotationsOnNullableTypes.kt"); - } - - @Test - @TestMetadata("atAnnotationResolve.kt") - public void testAtAnnotationResolve() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/atAnnotationResolve.kt"); - } - - @Test - @TestMetadata("BasicAnnotations.kt") - public void testBasicAnnotations() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/BasicAnnotations.kt"); - } - - @Test - @TestMetadata("blockLevelOnTheSameLineWarning.kt") - public void testBlockLevelOnTheSameLineWarning() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/blockLevelOnTheSameLineWarning.kt"); - } - - @Test - @TestMetadata("ConstructorCall.kt") - public void testConstructorCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/ConstructorCall.kt"); - } - - @Test - @TestMetadata("DanglingInScript.kts") - public void testDanglingInScript() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/DanglingInScript.kts"); - } - - @Test - @TestMetadata("DanglingMixed.kt") - public void testDanglingMixed() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/DanglingMixed.kt"); - } - - @Test - @TestMetadata("DanglingNoBrackets.kt") - public void testDanglingNoBrackets() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/DanglingNoBrackets.kt"); - } - - @Test - @TestMetadata("DanglingWithBrackets.kt") - public void testDanglingWithBrackets() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/DanglingWithBrackets.kt"); - } - - @Test - @TestMetadata("Deprecated.kt") - public void testDeprecated() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/Deprecated.kt"); - } - - @Test - @TestMetadata("deprecatedRepeatable.kt") - public void testDeprecatedRepeatable() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/deprecatedRepeatable.kt"); - } - - @Test - @TestMetadata("dontReportWarningAboutChangingExecutionOrderForVararg.kt") - public void testDontReportWarningAboutChangingExecutionOrderForVararg() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/dontReportWarningAboutChangingExecutionOrderForVararg.kt"); - } - - @Test - @TestMetadata("extensionFunctionType.kt") - public void testExtensionFunctionType() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/extensionFunctionType.kt"); - } - - @Test - @TestMetadata("forParameterAnnotationResolve.kt") - public void testForParameterAnnotationResolve() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/forParameterAnnotationResolve.kt"); - } - - @Test - @TestMetadata("illegalRequireKotlinValue.kt") - public void testIllegalRequireKotlinValue() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/illegalRequireKotlinValue.kt"); - } - - @Test - @TestMetadata("illegalSinceKotlinValue.kt") - public void testIllegalSinceKotlinValue() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/illegalSinceKotlinValue.kt"); - } - - @Test - @TestMetadata("inheritFromAnnotationClass.kt") - public void testInheritFromAnnotationClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/inheritFromAnnotationClass.kt"); - } - - @Test - @TestMetadata("inheritFromAnnotationClass2.kt") - public void testInheritFromAnnotationClass2() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/inheritFromAnnotationClass2.kt"); - } - - @Test - @TestMetadata("invalidTypesInAnnotationConstructor.kt") - public void testInvalidTypesInAnnotationConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/invalidTypesInAnnotationConstructor.kt"); - } - - @Test - @TestMetadata("JavaAnnotationConstructors.kt") - public void testJavaAnnotationConstructors() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/JavaAnnotationConstructors.kt"); - } - - @Test - @TestMetadata("javaRepeatable.kt") - public void testJavaRepeatable() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/javaRepeatable.kt"); - } - - @Test - @TestMetadata("javaRepeatableRetention.kt") - public void testJavaRepeatableRetention() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/javaRepeatableRetention.kt"); - } - - @Test - @TestMetadata("javaUnrepeatable.kt") - public void testJavaUnrepeatable() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/javaUnrepeatable.kt"); - } - - @Test - @TestMetadata("kt1860-negative.kt") - public void testKt1860_negative() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/kt1860-negative.kt"); - } - - @Test - @TestMetadata("kt1860-positive.kt") - public void testKt1860_positive() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/kt1860-positive.kt"); - } - - @Test - @TestMetadata("kt1886annotationBody_after.kt") - public void testKt1886annotationBody_after() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/kt1886annotationBody_after.kt"); - } - - @Test - @TestMetadata("kt1886annotationBody_before.kt") - public void testKt1886annotationBody_before() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/kt1886annotationBody_before.kt"); - } - - @Test - @TestMetadata("missingValOnParameter.kt") - public void testMissingValOnParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/missingValOnParameter.kt"); - } - - @Test - @TestMetadata("MultiDeclaration.kt") - public void testMultiDeclaration() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/MultiDeclaration.kt"); - } - - @Test - @TestMetadata("MutuallyRecursivelyAnnotatedGlobalFunction.kt") - public void testMutuallyRecursivelyAnnotatedGlobalFunction() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/MutuallyRecursivelyAnnotatedGlobalFunction.kt"); - } - - @Test - @TestMetadata("nestedClassesInAnnotations.kt") - public void testNestedClassesInAnnotations() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/nestedClassesInAnnotations.kt"); - } - - @Test - @TestMetadata("noNameProperty.kt") - public void testNoNameProperty() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/noNameProperty.kt"); - } - - @Test - @TestMetadata("NonAnnotationClass.kt") - public void testNonAnnotationClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/NonAnnotationClass.kt"); - } - - @Test - @TestMetadata("onExpression.kt") - public void testOnExpression() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/onExpression.kt"); - } - - @Test - @TestMetadata("onFunctionParameter.kt") - public void testOnFunctionParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/onFunctionParameter.kt"); - } - - @Test - @TestMetadata("onInitializer.kt") - public void testOnInitializer() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/onInitializer.kt"); - } - - @Test - @TestMetadata("onLoops.kt") - public void testOnLoops() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/onLoops.kt"); - } - - @Test - @TestMetadata("onLoopsUnreachable.kt") - public void testOnLoopsUnreachable() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/onLoopsUnreachable.kt"); - } - - @Test - @TestMetadata("onMultiDeclaration.kt") - public void testOnMultiDeclaration() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/onMultiDeclaration.kt"); - } - - @Test - @TestMetadata("RecursivelyAnnotated.kt") - public void testRecursivelyAnnotated() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotated.kt"); - } - - @Test - @TestMetadata("RecursivelyAnnotatedFunctionParameter.kt") - public void testRecursivelyAnnotatedFunctionParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedFunctionParameter.kt"); - } - - @Test - @TestMetadata("RecursivelyAnnotatedGlobalFunction.kt") - public void testRecursivelyAnnotatedGlobalFunction() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedGlobalFunction.kt"); - } - - @Test - @TestMetadata("RecursivelyAnnotatedGlobalProperty.kt") - public void testRecursivelyAnnotatedGlobalProperty() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedGlobalProperty.kt"); - } - - @Test - @TestMetadata("RecursivelyAnnotatedParameter.kt") - public void testRecursivelyAnnotatedParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedParameter.kt"); - } - - @Test - @TestMetadata("RecursivelyAnnotatedParameterType.kt") - public void testRecursivelyAnnotatedParameterType() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedParameterType.kt"); - } - - @Test - @TestMetadata("RecursivelyAnnotatedParameterWithAt.kt") - public void testRecursivelyAnnotatedParameterWithAt() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedParameterWithAt.kt"); - } - - @Test - @TestMetadata("RecursivelyAnnotatedProperty.kt") - public void testRecursivelyAnnotatedProperty() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedProperty.kt"); - } - - @Test - @TestMetadata("RecursivelyIncorrectlyAnnotatedParameter.kt") - public void testRecursivelyIncorrectlyAnnotatedParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/RecursivelyIncorrectlyAnnotatedParameter.kt"); - } - - @Test - @TestMetadata("RetentionsOfAnnotationWithExpressionTarget_after.kt") - public void testRetentionsOfAnnotationWithExpressionTarget_after() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/RetentionsOfAnnotationWithExpressionTarget_after.kt"); - } - - @Test - @TestMetadata("RetentionsOfAnnotationWithExpressionTarget_before.kt") - public void testRetentionsOfAnnotationWithExpressionTarget_before() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/RetentionsOfAnnotationWithExpressionTarget_before.kt"); - } - - @Test - @TestMetadata("typeAnnotations.kt") - public void testTypeAnnotations() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/typeAnnotations.kt"); - } - - @Test - @TestMetadata("typeParameterAsAnnotation.kt") - public void testTypeParameterAsAnnotation() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/typeParameterAsAnnotation.kt"); - } - - @Test - @TestMetadata("UnresolvedAnnotationOnObject.kt") - public void testUnresolvedAnnotationOnObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/UnresolvedAnnotationOnObject.kt"); - } - - @Test - @TestMetadata("unresolvedReferenceRange.kt") - public void testUnresolvedReferenceRange() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/unresolvedReferenceRange.kt"); - } - - @Test - @TestMetadata("WrongAnnotationArgsOnObject.kt") - public void testWrongAnnotationArgsOnObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/WrongAnnotationArgsOnObject.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant") - @TestDataPath("$PROJECT_ROOT") - public class AnnotationParameterMustBeConstant extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInAnnotationParameterMustBeConstant() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("annotationConstructorDefaultParameter.kt") - public void testAnnotationConstructorDefaultParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/annotationConstructorDefaultParameter.kt"); - } - - @Test - @TestMetadata("booleanLocalVal.kt") - public void testBooleanLocalVal() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/booleanLocalVal.kt"); - } - - @Test - @TestMetadata("compareAndEquals.kt") - public void testCompareAndEquals() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/compareAndEquals.kt"); - } - - @Test - @TestMetadata("enumConst_after.kt") - public void testEnumConst_after() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/enumConst_after.kt"); - } - - @Test - @TestMetadata("enumConst_before.kt") - public void testEnumConst_before() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/enumConst_before.kt"); - } - - @Test - @TestMetadata("javaProperties.kt") - public void testJavaProperties() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/javaProperties.kt"); - } - - @Test - @TestMetadata("kotlinProperties.kt") - public void testKotlinProperties() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/kotlinProperties.kt"); - } - - @Test - @TestMetadata("standaloneInExpression.kt") - public void testStandaloneInExpression() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/standaloneInExpression.kt"); - } - - @Test - @TestMetadata("strings.kt") - public void testStrings() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/strings.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/annotations/functionalTypes") - @TestDataPath("$PROJECT_ROOT") - public class FunctionalTypes extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInFunctionalTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations/functionalTypes"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("nonParenthesizedAnnotationsWithError.kt") - public void testNonParenthesizedAnnotationsWithError() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/functionalTypes/nonParenthesizedAnnotationsWithError.kt"); - } - - @Test - @TestMetadata("nonParenthesizedAnnotationsWithoutError.kt") - public void testNonParenthesizedAnnotationsWithoutError() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/functionalTypes/nonParenthesizedAnnotationsWithoutError.kt"); - } - - @Test - @TestMetadata("parenthesizedAnnotations.kt") - public void testParenthesizedAnnotations() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/functionalTypes/parenthesizedAnnotations.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/annotations/options") - @TestDataPath("$PROJECT_ROOT") - public class Options extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInOptions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations/options"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("annotationAsArg.kt") - public void testAnnotationAsArg() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/options/annotationAsArg.kt"); - } - - @Test - @TestMetadata("annotationAsArgComplex.kt") - public void testAnnotationAsArgComplex() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/options/annotationAsArgComplex.kt"); - } - - @Test - @TestMetadata("assignment.kt") - public void testAssignment() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/options/assignment.kt"); - } - - @Test - @TestMetadata("documented.kt") - public void testDocumented() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/options/documented.kt"); - } - - @Test - @TestMetadata("forParam.kt") - public void testForParam() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/options/forParam.kt"); - } - - @Test - @TestMetadata("functionExpression.kt") - public void testFunctionExpression() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/options/functionExpression.kt"); - } - - @Test - @TestMetadata("functions.kt") - public void testFunctions() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/options/functions.kt"); - } - - @Test - @TestMetadata("javaDocumented.kt") - public void testJavaDocumented() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/options/javaDocumented.kt"); - } - - @Test - @TestMetadata("javaKotlinTargetRetention.kt") - public void testJavaKotlinTargetRetention() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/options/javaKotlinTargetRetention.kt"); - } - - @Test - @TestMetadata("javaretention.kt") - public void testJavaretention() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/options/javaretention.kt"); - } - - @Test - @TestMetadata("multiDeclaration.kt") - public void testMultiDeclaration() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/options/multiDeclaration.kt"); - } - - @Test - @TestMetadata("objectLiteral.kt") - public void testObjectLiteral() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/options/objectLiteral.kt"); - } - - @Test - @TestMetadata("prefix.kt") - public void testPrefix() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/options/prefix.kt"); - } - - @Test - @TestMetadata("repeatable.kt") - public void testRepeatable() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/options/repeatable.kt"); - } - - @Test - @TestMetadata("retention.kt") - public void testRetention() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/options/retention.kt"); - } - - @Test - @TestMetadata("setterParam.kt") - public void testSetterParam() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/options/setterParam.kt"); - } - - @Test - @TestMetadata("target.kt") - public void testTarget() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/options/target.kt"); - } - - @Test - @TestMetadata("unrepeatable.kt") - public void testUnrepeatable() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/options/unrepeatable.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/annotations/options/targets") - @TestDataPath("$PROJECT_ROOT") - public class Targets extends AbstractDiagnosticUsingJavacTest { - @Test - @TestMetadata("accessors.kt") - public void testAccessors() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/options/targets/accessors.kt"); - } - - @Test - public void testAllFilesPresentInTargets() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations/options/targets"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("annotation.kt") - public void testAnnotation() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/options/targets/annotation.kt"); - } - - @Test - @TestMetadata("classifier.kt") - public void testClassifier() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/options/targets/classifier.kt"); - } - - @Test - @TestMetadata("constructor.kt") - public void testConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/options/targets/constructor.kt"); - } - - @Test - @TestMetadata("empty.kt") - public void testEmpty() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/options/targets/empty.kt"); - } - - @Test - @TestMetadata("expr.kt") - public void testExpr() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/options/targets/expr.kt"); - } - - @Test - @TestMetadata("field.kt") - public void testField() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/options/targets/field.kt"); - } - - @Test - @TestMetadata("file.kt") - public void testFile() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/options/targets/file.kt"); - } - - @Test - @TestMetadata("function.kt") - public void testFunction() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/options/targets/function.kt"); - } - - @Test - @TestMetadata("funtypeargs.kt") - public void testFuntypeargs() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/options/targets/funtypeargs.kt"); - } - - @Test - @TestMetadata("incorrect.kt") - public void testIncorrect() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/options/targets/incorrect.kt"); - } - - @Test - @TestMetadata("init.kt") - public void testInit() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/options/targets/init.kt"); - } - - @Test - @TestMetadata("java.kt") - public void testJava() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/options/targets/java.kt"); - } - - @Test - @TestMetadata("local.kt") - public void testLocal() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/options/targets/local.kt"); - } - - @Test - @TestMetadata("nested.kt") - public void testNested() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/options/targets/nested.kt"); - } - - @Test - @TestMetadata("property.kt") - public void testProperty() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/options/targets/property.kt"); - } - - @Test - @TestMetadata("returntype.kt") - public void testReturntype() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/options/targets/returntype.kt"); - } - - @Test - @TestMetadata("suppress.kt") - public void testSuppress() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/options/targets/suppress.kt"); - } - - @Test - @TestMetadata("type.kt") - public void testType() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/options/targets/type.kt"); - } - - @Test - @TestMetadata("typeParams.kt") - public void testTypeParams() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/options/targets/typeParams.kt"); - } - - @Test - @TestMetadata("typeargs.kt") - public void testTypeargs() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/options/targets/typeargs.kt"); - } - - @Test - @TestMetadata("valueparam.kt") - public void testValueparam() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/options/targets/valueparam.kt"); - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/annotations/rendering") - @TestDataPath("$PROJECT_ROOT") - public class Rendering extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInRendering() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations/rendering"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("cannotOverrideInvisibleMember.kt") - public void testCannotOverrideInvisibleMember() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/rendering/cannotOverrideInvisibleMember.kt"); - } - - @Test - @TestMetadata("conflictingOverloads.kt") - public void testConflictingOverloads() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/rendering/conflictingOverloads.kt"); - } - - @Test - @TestMetadata("differentNamesForParameter.kt") - public void testDifferentNamesForParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/rendering/differentNamesForParameter.kt"); - } - - @Test - @TestMetadata("memberProjectedOut.kt") - public void testMemberProjectedOut() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/rendering/memberProjectedOut.kt"); - } - - @Test - @TestMetadata("multipleInheritedDefaults.kt") - public void testMultipleInheritedDefaults() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/rendering/multipleInheritedDefaults.kt"); - } - - @Test - @TestMetadata("notImplementedMembers.kt") - public void testNotImplementedMembers() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/rendering/notImplementedMembers.kt"); - } - - @Test - @TestMetadata("tooManyArguments.kt") - public void testTooManyArguments() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/rendering/tooManyArguments.kt"); - } - - @Test - @TestMetadata("typeMismatchDueToTypeProjections.kt") - public void testTypeMismatchDueToTypeProjections() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/rendering/typeMismatchDueToTypeProjections.kt"); - } - - @Test - @TestMetadata("typeMismatchOnOverride.kt") - public void testTypeMismatchOnOverride() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/rendering/typeMismatchOnOverride.kt"); - } - - @Test - @TestMetadata("typeMismatchOnOverrideJavaNullable.kt") - public void testTypeMismatchOnOverrideJavaNullable() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/rendering/typeMismatchOnOverrideJavaNullable.kt"); - } - - @Test - @TestMetadata("unusedValue.kt") - public void testUnusedValue() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/rendering/unusedValue.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget") - @TestDataPath("$PROJECT_ROOT") - public class WithUseSiteTarget extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInWithUseSiteTarget() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("DelegateAnnotations.kt") - public void testDelegateAnnotations() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/DelegateAnnotations.kt"); - } - - @Test - @TestMetadata("diagnosticFileAnnotationInWrongPlace.kt") - public void testDiagnosticFileAnnotationInWrongPlace() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/diagnosticFileAnnotationInWrongPlace.kt"); - } - - @Test - @TestMetadata("diagnosticWithoutPackage.kt") - public void testDiagnosticWithoutPackage() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/diagnosticWithoutPackage.kt"); - } - - @Test - @TestMetadata("diagnosticWithoutPackageWithSimpleAnnotation.kt") - public void testDiagnosticWithoutPackageWithSimpleAnnotation() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/diagnosticWithoutPackageWithSimpleAnnotation.kt"); - } - - @Test - @TestMetadata("FieldAnnotations.kt") - public void testFieldAnnotations() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/FieldAnnotations.kt"); - } - - @Test - @TestMetadata("fileAnnotationWithoutColon_after.kt") - public void testFileAnnotationWithoutColon_after() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/fileAnnotationWithoutColon_after.kt"); - } - - @Test - @TestMetadata("fileAnnotationWithoutColon_before.kt") - public void testFileAnnotationWithoutColon_before() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/fileAnnotationWithoutColon_before.kt"); - } - - @Test - @TestMetadata("FileAnnotations.kt") - public void testFileAnnotations() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/FileAnnotations.kt"); - } - - @Test - @TestMetadata("GetterAnnotations.kt") - public void testGetterAnnotations() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/GetterAnnotations.kt"); - } - - @Test - @TestMetadata("kt23992.kt") - public void testKt23992() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/kt23992.kt"); - } - - @Test - @TestMetadata("kt23992_after.kt") - public void testKt23992_after() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/kt23992_after.kt"); - } - - @Test - @TestMetadata("kt26638.kt") - public void testKt26638() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/kt26638.kt"); - } - - @Test - @TestMetadata("kt26638_after.kt") - public void testKt26638_after() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/kt26638_after.kt"); - } - - @Test - @TestMetadata("ParamAnnotations.kt") - public void testParamAnnotations() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/ParamAnnotations.kt"); - } - - @Test - @TestMetadata("PropertyAnnotations.kt") - public void testPropertyAnnotations() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/PropertyAnnotations.kt"); - } - - @Test - @TestMetadata("ReceiverAnnotations.kt") - public void testReceiverAnnotations() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/ReceiverAnnotations.kt"); - } - - @Test - @TestMetadata("receiverUseSiteTargetOnExtensionFunction_after.kt") - public void testReceiverUseSiteTargetOnExtensionFunction_after() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/receiverUseSiteTargetOnExtensionFunction_after.kt"); - } - - @Test - @TestMetadata("receiverUseSiteTargetOnExtensionFunction_before.kt") - public void testReceiverUseSiteTargetOnExtensionFunction_before() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/receiverUseSiteTargetOnExtensionFunction_before.kt"); - } - - @Test - @TestMetadata("repeatable.kt") - public void testRepeatable() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/repeatable.kt"); - } - - @Test - @TestMetadata("SetterAnnotations.kt") - public void testSetterAnnotations() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/SetterAnnotations.kt"); - } - - @Test - @TestMetadata("SparamAnnotations.kt") - public void testSparamAnnotations() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/SparamAnnotations.kt"); - } - - @Test - @TestMetadata("wrongParamAnnotationsOnTypesError.kt") - public void testWrongParamAnnotationsOnTypesError() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/wrongParamAnnotationsOnTypesError.kt"); - } - - @Test - @TestMetadata("wrongParamAnnotationsOnTypes_after.kt") - public void testWrongParamAnnotationsOnTypes_after() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/wrongParamAnnotationsOnTypes_after.kt"); - } - - @Test - @TestMetadata("wrongParamAnnotationsOnTypes_before.kt") - public void testWrongParamAnnotationsOnTypes_before() throws Exception { - runTest("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/wrongParamAnnotationsOnTypes_before.kt"); - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/backingField") - @TestDataPath("$PROJECT_ROOT") - public class BackingField extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInBackingField() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/backingField"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("CustomGetSet.kt") - public void testCustomGetSet() throws Exception { - runTest("compiler/testData/diagnostics/tests/backingField/CustomGetSet.kt"); - } - - @Test - @TestMetadata("CustomGetVal.kt") - public void testCustomGetVal() throws Exception { - runTest("compiler/testData/diagnostics/tests/backingField/CustomGetVal.kt"); - } - - @Test - @TestMetadata("CustomGetValGlobal.kt") - public void testCustomGetValGlobal() throws Exception { - runTest("compiler/testData/diagnostics/tests/backingField/CustomGetValGlobal.kt"); - } - - @Test - @TestMetadata("CustomGetVar.kt") - public void testCustomGetVar() throws Exception { - runTest("compiler/testData/diagnostics/tests/backingField/CustomGetVar.kt"); - } - - @Test - @TestMetadata("CustomSet.kt") - public void testCustomSet() throws Exception { - runTest("compiler/testData/diagnostics/tests/backingField/CustomSet.kt"); - } - - @Test - @TestMetadata("ExtensionProperty.kt") - public void testExtensionProperty() throws Exception { - runTest("compiler/testData/diagnostics/tests/backingField/ExtensionProperty.kt"); - } - - @Test - @TestMetadata("FieldAsParam.kt") - public void testFieldAsParam() throws Exception { - runTest("compiler/testData/diagnostics/tests/backingField/FieldAsParam.kt"); - } - - @Test - @TestMetadata("FieldAsProperty.kt") - public void testFieldAsProperty() throws Exception { - runTest("compiler/testData/diagnostics/tests/backingField/FieldAsProperty.kt"); - } - - @Test - @TestMetadata("FieldDerived.kt") - public void testFieldDerived() throws Exception { - runTest("compiler/testData/diagnostics/tests/backingField/FieldDerived.kt"); - } - - @Test - @TestMetadata("FieldInInterface.kt") - public void testFieldInInterface() throws Exception { - runTest("compiler/testData/diagnostics/tests/backingField/FieldInInterface.kt"); - } - - @Test - @TestMetadata("FieldInLocal.kt") - public void testFieldInLocal() throws Exception { - runTest("compiler/testData/diagnostics/tests/backingField/FieldInLocal.kt"); - } - - @Test - @TestMetadata("FieldOnVal.kt") - public void testFieldOnVal() throws Exception { - runTest("compiler/testData/diagnostics/tests/backingField/FieldOnVal.kt"); - } - - @Test - @TestMetadata("FieldOnVar.kt") - public void testFieldOnVar() throws Exception { - runTest("compiler/testData/diagnostics/tests/backingField/FieldOnVar.kt"); - } - - @Test - @TestMetadata("FieldReassignment_after.kt") - public void testFieldReassignment_after() throws Exception { - runTest("compiler/testData/diagnostics/tests/backingField/FieldReassignment_after.kt"); - } - - @Test - @TestMetadata("FieldReassignment_before.kt") - public void testFieldReassignment_before() throws Exception { - runTest("compiler/testData/diagnostics/tests/backingField/FieldReassignment_before.kt"); - } - - @Test - @TestMetadata("FieldShadow.kt") - public void testFieldShadow() throws Exception { - runTest("compiler/testData/diagnostics/tests/backingField/FieldShadow.kt"); - } - - @Test - @TestMetadata("InitCustomSetter.kt") - public void testInitCustomSetter() throws Exception { - runTest("compiler/testData/diagnostics/tests/backingField/InitCustomSetter.kt"); - } - - @Test - @TestMetadata("InitOpenSetter.kt") - public void testInitOpenSetter() throws Exception { - runTest("compiler/testData/diagnostics/tests/backingField/InitOpenSetter.kt"); - } - - @Test - @TestMetadata("kt782packageLevel.kt") - public void testKt782packageLevel() throws Exception { - runTest("compiler/testData/diagnostics/tests/backingField/kt782packageLevel.kt"); - } - - @Test - @TestMetadata("SetterWithExplicitType.kt") - public void testSetterWithExplicitType() throws Exception { - runTest("compiler/testData/diagnostics/tests/backingField/SetterWithExplicitType.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/callableReference") - @TestDataPath("$PROJECT_ROOT") - public class CallableReference extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("bareType.kt") - public void testBareType() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/bareType.kt"); - } - - @Test - @TestMetadata("callableReferenceAsLastExpressionInBlock.kt") - public void testCallableReferenceAsLastExpressionInBlock() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/callableReferenceAsLastExpressionInBlock.kt"); - } - - @Test - @TestMetadata("classVsPackage.kt") - public void testClassVsPackage() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/classVsPackage.kt"); - } - - @Test - @TestMetadata("compatibilityResolveWithVarargAndOperatorCall.kt") - public void testCompatibilityResolveWithVarargAndOperatorCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/compatibilityResolveWithVarargAndOperatorCall.kt"); - } - - @Test - @TestMetadata("constraintFromLHSWithCorrectDirection.kt") - public void testConstraintFromLHSWithCorrectDirection() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/constraintFromLHSWithCorrectDirection.kt"); - } - - @Test - @TestMetadata("constraintFromLHSWithCorrectDirectionError.kt") - public void testConstraintFromLHSWithCorrectDirectionError() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/constraintFromLHSWithCorrectDirectionError.kt"); - } - - @Test - @TestMetadata("correctCandidateWithCompatibilityForSeveralCandidates.kt") - public void testCorrectCandidateWithCompatibilityForSeveralCandidates() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/correctCandidateWithCompatibilityForSeveralCandidates.kt"); - } - - @Test - @TestMetadata("correctInfoAfterArrayLikeCall.kt") - public void testCorrectInfoAfterArrayLikeCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/correctInfoAfterArrayLikeCall.kt"); - } - - @Test - @TestMetadata("ea81649_errorPropertyLHS.kt") - public void testEa81649_errorPropertyLHS() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/ea81649_errorPropertyLHS.kt"); - } - - @Test - @TestMetadata("emptyLhs.kt") - public void testEmptyLhs() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/emptyLhs.kt"); - } - - @Test - @TestMetadata("expectedTypeAsSubtypeOfFunctionType.kt") - public void testExpectedTypeAsSubtypeOfFunctionType() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/expectedTypeAsSubtypeOfFunctionType.kt"); - } - - @Test - @TestMetadata("functionReferenceWithDefaultValueAsOtherFunctionType.kt") - public void testFunctionReferenceWithDefaultValueAsOtherFunctionType() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/functionReferenceWithDefaultValueAsOtherFunctionType.kt"); - } - - @Test - @TestMetadata("functionReferenceWithDefaultValueAsOtherFunctionType_enabled.kt") - public void testFunctionReferenceWithDefaultValueAsOtherFunctionType_enabled() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/functionReferenceWithDefaultValueAsOtherFunctionType_enabled.kt"); - } - - @Test - @TestMetadata("genericCallWithReferenceAgainstVararg.kt") - public void testGenericCallWithReferenceAgainstVararg() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/genericCallWithReferenceAgainstVararg.kt"); - } - - @Test - @TestMetadata("genericCallWithReferenceAgainstVarargAndKFunction.kt") - public void testGenericCallWithReferenceAgainstVarargAndKFunction() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/genericCallWithReferenceAgainstVarargAndKFunction.kt"); - } - - @Test - @TestMetadata("kt15439_completeCall.kt") - public void testKt15439_completeCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/kt15439_completeCall.kt"); - } - - @Test - @TestMetadata("kt25433.kt") - public void testKt25433() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/kt25433.kt"); - } - - @Test - @TestMetadata("kt31981.kt") - public void testKt31981() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/kt31981.kt"); - } - - @Test - @TestMetadata("kt32256.kt") - public void testKt32256() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/kt32256.kt"); - } - - @Test - @TestMetadata("kt32267.kt") - public void testKt32267() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/kt32267.kt"); - } - - @Test - @TestMetadata("kt34314.kt") - public void testKt34314() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/kt34314.kt"); - } - - @Test - @TestMetadata("kt34314_lambda.kt") - public void testKt34314_lambda() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/kt34314_lambda.kt"); - } - - @Test - @TestMetadata("kt35105.kt") - public void testKt35105() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/kt35105.kt"); - } - - @Test - @TestMetadata("kt35959.kt") - public void testKt35959() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/kt35959.kt"); - } - - @Test - @TestMetadata("kt37530.kt") - public void testKt37530() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/kt37530.kt"); - } - - @Test - @TestMetadata("kt7430_wrongClassOnLHS.kt") - public void testKt7430_wrongClassOnLHS() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/kt7430_wrongClassOnLHS.kt"); - } - - @Test - @TestMetadata("lambdaResult.kt") - public void testLambdaResult() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/lambdaResult.kt"); - } - - @Test - @TestMetadata("memberExtensionsImportedFromObjectsUnsupported.kt") - public void testMemberExtensionsImportedFromObjectsUnsupported() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/memberExtensionsImportedFromObjectsUnsupported.kt"); - } - - @Test - @TestMetadata("noAmbiguityWhenAllReferencesAreInapplicable.kt") - public void testNoAmbiguityWhenAllReferencesAreInapplicable() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/noAmbiguityWhenAllReferencesAreInapplicable.kt"); - } - - @Test - @TestMetadata("noCompatibilityResolveWithProressiveModeForNI.kt") - public void testNoCompatibilityResolveWithProressiveModeForNI() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/noCompatibilityResolveWithProressiveModeForNI.kt"); - } - - @Test - @TestMetadata("noExceptionOnRedCodeWithArrayLikeCall.kt") - public void testNoExceptionOnRedCodeWithArrayLikeCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/noExceptionOnRedCodeWithArrayLikeCall.kt"); - } - - @Test - @TestMetadata("packageInLhs.kt") - public void testPackageInLhs() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/packageInLhs.kt"); - } - - @Test - @TestMetadata("parsingPriorityOfGenericArgumentsVsLess.kt") - public void testParsingPriorityOfGenericArgumentsVsLess() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/parsingPriorityOfGenericArgumentsVsLess.kt"); - } - - @Test - @TestMetadata("propertyOfNestedGenericClass.kt") - public void testPropertyOfNestedGenericClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/propertyOfNestedGenericClass.kt"); - } - - @Test - @TestMetadata("referenceAdaptationCompatibility.kt") - public void testReferenceAdaptationCompatibility() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/referenceAdaptationCompatibility.kt"); - } - - @Test - @TestMetadata("referenceAdaptationHasDependencyOnApi14.kt") - public void testReferenceAdaptationHasDependencyOnApi14() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/referenceAdaptationHasDependencyOnApi14.kt"); - } - - @Test - @TestMetadata("referenceToCompanionObjectMemberViaClassName.kt") - public void testReferenceToCompanionObjectMemberViaClassName() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/referenceToCompanionObjectMemberViaClassName.kt"); - } - - @Test - @TestMetadata("referenceToCompanionObjectMemberViaClassNameCompatibility.kt") - public void testReferenceToCompanionObjectMemberViaClassNameCompatibility() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/referenceToCompanionObjectMemberViaClassNameCompatibility.kt"); - } - - @Test - @TestMetadata("rewriteAtSliceOnGetOperator.kt") - public void testRewriteAtSliceOnGetOperator() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/rewriteAtSliceOnGetOperator.kt"); - } - - @Test - @TestMetadata("sam.kt") - public void testSam() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/sam.kt"); - } - - @Test - @TestMetadata("subtypeArgumentFromRHSForReference.kt") - public void testSubtypeArgumentFromRHSForReference() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/subtypeArgumentFromRHSForReference.kt"); - } - - @Test - @TestMetadata("suspendCallableReference.kt") - public void testSuspendCallableReference() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/suspendCallableReference.kt"); - } - - @Test - @TestMetadata("typealiases.kt") - public void testTypealiases() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/typealiases.kt"); - } - - @Test - @TestMetadata("unitAdaptationForReferenceCompatibility.kt") - public void testUnitAdaptationForReferenceCompatibility() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/unitAdaptationForReferenceCompatibility.kt"); - } - - @Test - @TestMetadata("unused.kt") - public void testUnused() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/unused.kt"); - } - - @Test - @TestMetadata("whitespacesInExpression.kt") - public void testWhitespacesInExpression() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/whitespacesInExpression.kt"); - } - - @Test - @TestMetadata("withQuestionMarks.kt") - public void testWithQuestionMarks() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/withQuestionMarks.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/callableReference/bound") - @TestDataPath("$PROJECT_ROOT") - public class Bound extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInBound() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference/bound"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("classVsStarImportedCompanion.kt") - public void testClassVsStarImportedCompanion() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/bound/classVsStarImportedCompanion.kt"); - } - - @Test - @TestMetadata("classVsStarImportedObject.kt") - public void testClassVsStarImportedObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/bound/classVsStarImportedObject.kt"); - } - - @Test - @TestMetadata("companionObject.kt") - public void testCompanionObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/bound/companionObject.kt"); - } - - @Test - @TestMetadata("controlFlow.kt") - public void testControlFlow() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/bound/controlFlow.kt"); - } - - @Test - @TestMetadata("dataFlow.kt") - public void testDataFlow() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/bound/dataFlow.kt"); - } - - @Test - @TestMetadata("expectedType.kt") - public void testExpectedType() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/bound/expectedType.kt"); - } - - @Test - @TestMetadata("expressionWithNullableType.kt") - public void testExpressionWithNullableType() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/bound/expressionWithNullableType.kt"); - } - - @Test - @TestMetadata("functionCallWithoutArguments.kt") - public void testFunctionCallWithoutArguments() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/bound/functionCallWithoutArguments.kt"); - } - - @Test - @TestMetadata("innerNested.kt") - public void testInnerNested() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/bound/innerNested.kt"); - } - - @Test - @TestMetadata("kt12843.kt") - public void testKt12843() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/bound/kt12843.kt"); - } - - @Test - @TestMetadata("noThisInSuperCall.kt") - public void testNoThisInSuperCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/bound/noThisInSuperCall.kt"); - } - - @Test - @TestMetadata("object.kt") - public void testObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/bound/object.kt"); - } - - @Test - @TestMetadata("privateToThis.kt") - public void testPrivateToThis() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/bound/privateToThis.kt"); - } - - @Test - @TestMetadata("referenceToStaticMethodOnInstance.kt") - public void testReferenceToStaticMethodOnInstance() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/bound/referenceToStaticMethodOnInstance.kt"); - } - - @Test - @TestMetadata("reservedExpressionSyntax.kt") - public void testReservedExpressionSyntax() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/bound/reservedExpressionSyntax.kt"); - } - - @Test - @TestMetadata("reservedExpressionSyntax2.kt") - public void testReservedExpressionSyntax2() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/bound/reservedExpressionSyntax2.kt"); - } - - @Test - @TestMetadata("reservedExpressionSyntax3.kt") - public void testReservedExpressionSyntax3() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/bound/reservedExpressionSyntax3.kt"); - } - - @Test - @TestMetadata("syntheticExtensionOnLHS.kt") - public void testSyntheticExtensionOnLHS() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/bound/syntheticExtensionOnLHS.kt"); - } - - @Test - @TestMetadata("valueOfTypeParameterType.kt") - public void testValueOfTypeParameterType() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/bound/valueOfTypeParameterType.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/callableReference/function") - @TestDataPath("$PROJECT_ROOT") - public class Function extends AbstractDiagnosticUsingJavacTest { - @Test - @TestMetadata("abstractClassConstructors.kt") - public void testAbstractClassConstructors() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/abstractClassConstructors.kt"); - } - - @Test - public void testAllFilesPresentInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference/function"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("ambiguityTopLevelVsTopLevel.kt") - public void testAmbiguityTopLevelVsTopLevel() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/ambiguityTopLevelVsTopLevel.kt"); - } - - @Test - @TestMetadata("annotationClassConstructor.kt") - public void testAnnotationClassConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/annotationClassConstructor.kt"); - } - - @Test - @TestMetadata("callableRefrenceOnNestedObject.kt") - public void testCallableRefrenceOnNestedObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/callableRefrenceOnNestedObject.kt"); - } - - @Test - @TestMetadata("classMemberVsConstructorLikeFunction.kt") - public void testClassMemberVsConstructorLikeFunction() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/classMemberVsConstructorLikeFunction.kt"); - } - - @Test - @TestMetadata("constructorFromClass.kt") - public void testConstructorFromClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/constructorFromClass.kt"); - } - - @Test - @TestMetadata("constructorFromCompanion.kt") - public void testConstructorFromCompanion() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/constructorFromCompanion.kt"); - } - - @Test - @TestMetadata("constructorFromExtension.kt") - public void testConstructorFromExtension() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/constructorFromExtension.kt"); - } - - @Test - @TestMetadata("constructorFromExtensionInClass.kt") - public void testConstructorFromExtensionInClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/constructorFromExtensionInClass.kt"); - } - - @Test - @TestMetadata("constructorFromTopLevel.kt") - public void testConstructorFromTopLevel() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/constructorFromTopLevel.kt"); - } - - @Test - @TestMetadata("constructorOfNestedClassInObject.kt") - public void testConstructorOfNestedClassInObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/constructorOfNestedClassInObject.kt"); - } - - @Test - @TestMetadata("differentPackageClass.kt") - public void testDifferentPackageClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/differentPackageClass.kt"); - } - - @Test - @TestMetadata("differentPackageExtension.kt") - public void testDifferentPackageExtension() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/differentPackageExtension.kt"); - } - - @Test - @TestMetadata("differentPackageTopLevel.kt") - public void testDifferentPackageTopLevel() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/differentPackageTopLevel.kt"); - } - - @Test - @TestMetadata("empty.kt") - public void testEmpty() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/empty.kt"); - } - - @Test - @TestMetadata("extensionFromTopLevel.kt") - public void testExtensionFromTopLevel() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/extensionFromTopLevel.kt"); - } - - @Test - @TestMetadata("extensionInClassDisallowed.kt") - public void testExtensionInClassDisallowed() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/extensionInClassDisallowed.kt"); - } - - @Test - @TestMetadata("extensionOnNullable.kt") - public void testExtensionOnNullable() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/extensionOnNullable.kt"); - } - - @Test - @TestMetadata("extensionToSupertype.kt") - public void testExtensionToSupertype() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/extensionToSupertype.kt"); - } - - @Test - @TestMetadata("fakeOverrideType.kt") - public void testFakeOverrideType() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/fakeOverrideType.kt"); - } - - @Test - @TestMetadata("genericClassFromTopLevel.kt") - public void testGenericClassFromTopLevel() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/genericClassFromTopLevel.kt"); - } - - @Test - @TestMetadata("importedInnerConstructor.kt") - public void testImportedInnerConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/importedInnerConstructor.kt"); - } - - @Test - @TestMetadata("innerConstructorFromClass.kt") - public void testInnerConstructorFromClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/innerConstructorFromClass.kt"); - } - - @Test - @TestMetadata("innerConstructorFromExtension.kt") - public void testInnerConstructorFromExtension() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/innerConstructorFromExtension.kt"); - } - - @Test - @TestMetadata("innerConstructorFromTopLevel.kt") - public void testInnerConstructorFromTopLevel() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/innerConstructorFromTopLevel.kt"); - } - - @Test - @TestMetadata("javaStaticMethod.kt") - public void testJavaStaticMethod() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/javaStaticMethod.kt"); - } - - @Test - @TestMetadata("lhsNotAClass.kt") - public void testLhsNotAClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/lhsNotAClass.kt"); - } - - @Test - @TestMetadata("localConstructor.kt") - public void testLocalConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/localConstructor.kt"); - } - - @Test - @TestMetadata("localConstructorFromExtensionInLocalClass.kt") - public void testLocalConstructorFromExtensionInLocalClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/localConstructorFromExtensionInLocalClass.kt"); - } - - @Test - @TestMetadata("localConstructorFromLocalClass.kt") - public void testLocalConstructorFromLocalClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/localConstructorFromLocalClass.kt"); - } - - @Test - @TestMetadata("localConstructorFromLocalExtension.kt") - public void testLocalConstructorFromLocalExtension() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/localConstructorFromLocalExtension.kt"); - } - - @Test - @TestMetadata("localNamedFun.kt") - public void testLocalNamedFun() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/localNamedFun.kt"); - } - - @Test - @TestMetadata("localNamedFunFromExtensionInLocalClass.kt") - public void testLocalNamedFunFromExtensionInLocalClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/localNamedFunFromExtensionInLocalClass.kt"); - } - - @Test - @TestMetadata("localNamedFunFromLocalClass.kt") - public void testLocalNamedFunFromLocalClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/localNamedFunFromLocalClass.kt"); - } - - @Test - @TestMetadata("localNamedFunFromLocalExtension.kt") - public void testLocalNamedFunFromLocalExtension() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/localNamedFunFromLocalExtension.kt"); - } - - @Test - @TestMetadata("longQualifiedName.kt") - public void testLongQualifiedName() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/longQualifiedName.kt"); - } - - @Test - @TestMetadata("longQualifiedNameGeneric.kt") - public void testLongQualifiedNameGeneric() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/longQualifiedNameGeneric.kt"); - } - - @Test - @TestMetadata("memberFromTopLevel.kt") - public void testMemberFromTopLevel() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/memberFromTopLevel.kt"); - } - - @Test - @TestMetadata("nestedConstructorFromClass.kt") - public void testNestedConstructorFromClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/nestedConstructorFromClass.kt"); - } - - @Test - @TestMetadata("nestedConstructorFromExtension.kt") - public void testNestedConstructorFromExtension() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/nestedConstructorFromExtension.kt"); - } - - @Test - @TestMetadata("nestedConstructorFromTopLevel.kt") - public void testNestedConstructorFromTopLevel() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/nestedConstructorFromTopLevel.kt"); - } - - @Test - @TestMetadata("noAmbiguityLocalVsTopLevel.kt") - public void testNoAmbiguityLocalVsTopLevel() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/noAmbiguityLocalVsTopLevel.kt"); - } - - @Test - @TestMetadata("noAmbiguityMemberVsExtension.kt") - public void testNoAmbiguityMemberVsExtension() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/noAmbiguityMemberVsExtension.kt"); - } - - @Test - @TestMetadata("noAmbiguityMemberVsTopLevel.kt") - public void testNoAmbiguityMemberVsTopLevel() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/noAmbiguityMemberVsTopLevel.kt"); - } - - @Test - @TestMetadata("privateStaticAndPublicMember.kt") - public void testPrivateStaticAndPublicMember() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/privateStaticAndPublicMember.kt"); - } - - @Test - @TestMetadata("renameOnImport.kt") - public void testRenameOnImport() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/renameOnImport.kt"); - } - - @Test - @TestMetadata("topLevelFromClass.kt") - public void testTopLevelFromClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/topLevelFromClass.kt"); - } - - @Test - @TestMetadata("topLevelFromExtension.kt") - public void testTopLevelFromExtension() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/topLevelFromExtension.kt"); - } - - @Test - @TestMetadata("topLevelFromExtensionInClass.kt") - public void testTopLevelFromExtensionInClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/topLevelFromExtensionInClass.kt"); - } - - @Test - @TestMetadata("topLevelFromTopLevel.kt") - public void testTopLevelFromTopLevel() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/topLevelFromTopLevel.kt"); - } - - @Test - @TestMetadata("unresolved.kt") - public void testUnresolved() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/function/unresolved.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/callableReference/generic") - @TestDataPath("$PROJECT_ROOT") - public class Generic extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInGeneric() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference/generic"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("argumentAndReturnExpectedType.kt") - public void testArgumentAndReturnExpectedType() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/generic/argumentAndReturnExpectedType.kt"); - } - - @Test - @TestMetadata("argumentExpectedType.kt") - public void testArgumentExpectedType() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/generic/argumentExpectedType.kt"); - } - - @Test - @TestMetadata("dependOnArgumentType.kt") - public void testDependOnArgumentType() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/generic/dependOnArgumentType.kt"); - } - - @Test - @TestMetadata("expectedFunctionType.kt") - public void testExpectedFunctionType() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/generic/expectedFunctionType.kt"); - } - - @Test - @TestMetadata("explicitTypeArguments.kt") - public void testExplicitTypeArguments() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/generic/explicitTypeArguments.kt"); - } - - @Test - @TestMetadata("genericExtensionFunction.kt") - public void testGenericExtensionFunction() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/generic/genericExtensionFunction.kt"); - } - - @Test - @TestMetadata("genericFunctionsWithNullableTypes.kt") - public void testGenericFunctionsWithNullableTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/generic/genericFunctionsWithNullableTypes.kt"); - } - - @Test - @TestMetadata("kt10968.kt") - public void testKt10968() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/generic/kt10968.kt"); - } - - @Test - @TestMetadata("kt11075.kt") - public void testKt11075() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/generic/kt11075.kt"); - } - - @Test - @TestMetadata("kt12286.kt") - public void testKt12286() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/generic/kt12286.kt"); - } - - @Test - @TestMetadata("kt35896.kt") - public void testKt35896() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/generic/kt35896.kt"); - } - - @Test - @TestMetadata("kt7470.kt") - public void testKt7470() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/generic/kt7470.kt"); - } - - @Test - @TestMetadata("nestedCallWithOverload.kt") - public void testNestedCallWithOverload() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/generic/nestedCallWithOverload.kt"); - } - - @Test - @TestMetadata("noInferenceFeatureForCallableReferences.kt") - public void testNoInferenceFeatureForCallableReferences() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/generic/noInferenceFeatureForCallableReferences.kt"); - } - - @Test - @TestMetadata("resolutionGenericCallableWithNullableTypes.kt") - public void testResolutionGenericCallableWithNullableTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/generic/resolutionGenericCallableWithNullableTypes.kt"); - } - - @Test - @TestMetadata("resolutionWithGenericCallable.kt") - public void testResolutionWithGenericCallable() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/generic/resolutionWithGenericCallable.kt"); - } - - @Test - @TestMetadata("specialCalls.kt") - public void testSpecialCalls() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/generic/specialCalls.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/callableReference/property") - @TestDataPath("$PROJECT_ROOT") - public class Property extends AbstractDiagnosticUsingJavacTest { - @Test - @TestMetadata("abstractPropertyViaSubclasses.kt") - public void testAbstractPropertyViaSubclasses() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/property/abstractPropertyViaSubclasses.kt"); - } - - @Test - @TestMetadata("accessViaSubclass.kt") - public void testAccessViaSubclass() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/property/accessViaSubclass.kt"); - } - - @Test - public void testAllFilesPresentInProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference/property"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("classFromClass.kt") - public void testClassFromClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/property/classFromClass.kt"); - } - - @Test - @TestMetadata("extensionFromTopLevel.kt") - public void testExtensionFromTopLevel() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/property/extensionFromTopLevel.kt"); - } - - @Test - @TestMetadata("extensionPropertyOnNullable.kt") - public void testExtensionPropertyOnNullable() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/property/extensionPropertyOnNullable.kt"); - } - - @Test - @TestMetadata("extensionsSameName.kt") - public void testExtensionsSameName() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/property/extensionsSameName.kt"); - } - - @Test - @TestMetadata("genericClass.kt") - public void testGenericClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/property/genericClass.kt"); - } - - @Test - @TestMetadata("javaInstanceField.kt") - public void testJavaInstanceField() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/property/javaInstanceField.kt"); - } - - @Test - @TestMetadata("javaStaticFieldViaImport.kt") - public void testJavaStaticFieldViaImport() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/property/javaStaticFieldViaImport.kt"); - } - - @Test - @TestMetadata("kt7564.kt") - public void testKt7564() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/property/kt7564.kt"); - } - - @Test - @TestMetadata("kt7945_unrelatedClass.kt") - public void testKt7945_unrelatedClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/property/kt7945_unrelatedClass.kt"); - } - - @Test - @TestMetadata("memberFromTopLevel.kt") - public void testMemberFromTopLevel() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/property/memberFromTopLevel.kt"); - } - - @Test - @TestMetadata("protectedVarFromClass.kt") - public void testProtectedVarFromClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/property/protectedVarFromClass.kt"); - } - - @Test - @TestMetadata("returnTypeDependentOnGenericProperty.kt") - public void testReturnTypeDependentOnGenericProperty() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/property/returnTypeDependentOnGenericProperty.kt"); - } - - @Test - @TestMetadata("samePriorityForFunctionsAndProperties.kt") - public void testSamePriorityForFunctionsAndProperties() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/property/samePriorityForFunctionsAndProperties.kt"); - } - - @Test - @TestMetadata("topLevelFromTopLevel.kt") - public void testTopLevelFromTopLevel() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/property/topLevelFromTopLevel.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/callableReference/resolve") - @TestDataPath("$PROJECT_ROOT") - public class Resolve extends AbstractDiagnosticUsingJavacTest { - @Test - @TestMetadata("adaptedReferenceAgainstKCallable.kt") - public void testAdaptedReferenceAgainstKCallable() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/resolve/adaptedReferenceAgainstKCallable.kt"); - } - - @Test - @TestMetadata("adaptedReferenceAgainstReflectionType.kt") - public void testAdaptedReferenceAgainstReflectionType() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/resolve/adaptedReferenceAgainstReflectionType.kt"); - } - - @Test - public void testAllFilesPresentInResolve() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference/resolve"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("ambiguityWhenNoApplicableCallableReferenceCandidate.kt") - public void testAmbiguityWhenNoApplicableCallableReferenceCandidate() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/resolve/ambiguityWhenNoApplicableCallableReferenceCandidate.kt"); - } - - @Test - @TestMetadata("ambiguityWithBoundExtensionReceiver.kt") - public void testAmbiguityWithBoundExtensionReceiver() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/resolve/ambiguityWithBoundExtensionReceiver.kt"); - } - - @Test - @TestMetadata("ambiguousWithVararg.kt") - public void testAmbiguousWithVararg() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/resolve/ambiguousWithVararg.kt"); - } - - @Test - @TestMetadata("applicableCallableReferenceFromDistantScope.kt") - public void testApplicableCallableReferenceFromDistantScope() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/resolve/applicableCallableReferenceFromDistantScope.kt"); - } - - @Test - @TestMetadata("byArgType.kt") - public void testByArgType() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/resolve/byArgType.kt"); - } - - @Test - @TestMetadata("byGenericArgType.kt") - public void testByGenericArgType() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/resolve/byGenericArgType.kt"); - } - - @Test - @TestMetadata("byValType.kt") - public void testByValType() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/resolve/byValType.kt"); - } - - @Test - @TestMetadata("callableReferenceToVarargWithOverload.kt") - public void testCallableReferenceToVarargWithOverload() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/resolve/callableReferenceToVarargWithOverload.kt"); - } - - @Test - @TestMetadata("chooseCallableReferenceDependingOnInferredReceiver.kt") - public void testChooseCallableReferenceDependingOnInferredReceiver() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/resolve/chooseCallableReferenceDependingOnInferredReceiver.kt"); - } - - @Test - @TestMetadata("chooseMostSpecificCandidateUsingCandidateDescriptorNotReflectionType.kt") - public void testChooseMostSpecificCandidateUsingCandidateDescriptorNotReflectionType() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/resolve/chooseMostSpecificCandidateUsingCandidateDescriptorNotReflectionType.kt"); - } - - @Test - @TestMetadata("chooseOuterCallBySingleCallableReference.kt") - public void testChooseOuterCallBySingleCallableReference() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/resolve/chooseOuterCallBySingleCallableReference.kt"); - } - - @Test - @TestMetadata("commonSupertypeFromReturnTypesOfCallableReference.kt") - public void testCommonSupertypeFromReturnTypesOfCallableReference() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/resolve/commonSupertypeFromReturnTypesOfCallableReference.kt"); - } - - @Test - @TestMetadata("compatibilityWarningOnReferenceAgainstReflectiveType.kt") - public void testCompatibilityWarningOnReferenceAgainstReflectiveType() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/resolve/compatibilityWarningOnReferenceAgainstReflectiveType.kt"); - } - - @Test - @TestMetadata("constructor.kt") - public void testConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/resolve/constructor.kt"); - } - - @Test - @TestMetadata("eagerAndPostponedCallableReferences.kt") - public void testEagerAndPostponedCallableReferences() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/resolve/eagerAndPostponedCallableReferences.kt"); - } - - @Test - @TestMetadata("eagerResolveOfSingleCallableReference.kt") - public void testEagerResolveOfSingleCallableReference() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/resolve/eagerResolveOfSingleCallableReference.kt"); - } - - @Test - @TestMetadata("innerClassConstructorOnOuterClassInstance.kt") - public void testInnerClassConstructorOnOuterClassInstance() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/resolve/innerClassConstructorOnOuterClassInstance.kt"); - } - - @Test - @TestMetadata("intersectionTypeOverloadWithWrongParameter.kt") - public void testIntersectionTypeOverloadWithWrongParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/resolve/intersectionTypeOverloadWithWrongParameter.kt"); - } - - @Test - @TestMetadata("kt10036.kt") - public void testKt10036() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/resolve/kt10036.kt"); - } - - @Test - @TestMetadata("kt10036_bound.kt") - public void testKt10036_bound() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/resolve/kt10036_bound.kt"); - } - - @Test - @TestMetadata("kt12338.kt") - public void testKt12338() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/resolve/kt12338.kt"); - } - - @Test - @TestMetadata("kt12751.kt") - public void testKt12751() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/resolve/kt12751.kt"); - } - - @Test - @TestMetadata("kt35887.kt") - public void testKt35887() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/resolve/kt35887.kt"); - } - - @Test - @TestMetadata("kt35887_simple.kt") - public void testKt35887_simple() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/resolve/kt35887_simple.kt"); - } - - @Test - @TestMetadata("kt35920.kt") - public void testKt35920() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/resolve/kt35920.kt"); - } - - @Test - @TestMetadata("kt8596.kt") - public void testKt8596() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/resolve/kt8596.kt"); - } - - @Test - @TestMetadata("kt9601.kt") - public void testKt9601() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/resolve/kt9601.kt"); - } - - @Test - @TestMetadata("moreSpecificAmbiguousExtensions.kt") - public void testMoreSpecificAmbiguousExtensions() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/resolve/moreSpecificAmbiguousExtensions.kt"); - } - - @Test - @TestMetadata("moreSpecificSimple.kt") - public void testMoreSpecificSimple() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/resolve/moreSpecificSimple.kt"); - } - - @Test - @TestMetadata("multipleOutersAndMultipleCallableReferences.kt") - public void testMultipleOutersAndMultipleCallableReferences() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/resolve/multipleOutersAndMultipleCallableReferences.kt"); - } - - @Test - @TestMetadata("nestedReferenceCallAgainstExpectedType.kt") - public void testNestedReferenceCallAgainstExpectedType() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/resolve/nestedReferenceCallAgainstExpectedType.kt"); - } - - @Test - @TestMetadata("noAmbiguityBetweenTopLevelAndMemberProperty.kt") - public void testNoAmbiguityBetweenTopLevelAndMemberProperty() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/resolve/noAmbiguityBetweenTopLevelAndMemberProperty.kt"); - } - - @Test - @TestMetadata("noFakeDescriptorForObject.kt") - public void testNoFakeDescriptorForObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/resolve/noFakeDescriptorForObject.kt"); - } - - @Test - @TestMetadata("overloadAmbiguityForSimpleLastExpressionOfBlock.kt") - public void testOverloadAmbiguityForSimpleLastExpressionOfBlock() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/resolve/overloadAmbiguityForSimpleLastExpressionOfBlock.kt"); - } - - @Test - @TestMetadata("overloads.kt") - public void testOverloads() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/resolve/overloads.kt"); - } - - @Test - @TestMetadata("overloadsBound.kt") - public void testOverloadsBound() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/resolve/overloadsBound.kt"); - } - - @Test - @TestMetadata("overloadsMember.kt") - public void testOverloadsMember() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/resolve/overloadsMember.kt"); - } - - @Test - @TestMetadata("postponedResolveOfManyCallableReference.kt") - public void testPostponedResolveOfManyCallableReference() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/resolve/postponedResolveOfManyCallableReference.kt"); - } - - @Test - @TestMetadata("resolveCallableReferencesAfterAllSimpleArguments.kt") - public void testResolveCallableReferencesAfterAllSimpleArguments() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/resolve/resolveCallableReferencesAfterAllSimpleArguments.kt"); - } - - @Test - @TestMetadata("resolveEqualsOperatorWithAnyExpectedType.kt") - public void testResolveEqualsOperatorWithAnyExpectedType() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/resolve/resolveEqualsOperatorWithAnyExpectedType.kt"); - } - - @Test - @TestMetadata("resolveReferenceAgainstKFunctionAndKPrpoerty.kt") - public void testResolveReferenceAgainstKFunctionAndKPrpoerty() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/resolve/resolveReferenceAgainstKFunctionAndKPrpoerty.kt"); - } - - @Test - @TestMetadata("resolveTwoReferencesAgainstGenerics.kt") - public void testResolveTwoReferencesAgainstGenerics() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/resolve/resolveTwoReferencesAgainstGenerics.kt"); - } - - @Test - @TestMetadata("valVsFun.kt") - public void testValVsFun() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/resolve/valVsFun.kt"); - } - - @Test - @TestMetadata("withAs.kt") - public void testWithAs() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/resolve/withAs.kt"); - } - - @Test - @TestMetadata("withExtFun.kt") - public void testWithExtFun() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/resolve/withExtFun.kt"); - } - - @Test - @TestMetadata("withGenericFun.kt") - public void testWithGenericFun() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/resolve/withGenericFun.kt"); - } - - @Test - @TestMetadata("withPlaceholderTypes.kt") - public void testWithPlaceholderTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/resolve/withPlaceholderTypes.kt"); - } - - @Test - @TestMetadata("withVararg.kt") - public void testWithVararg() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/resolve/withVararg.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/callableReference/unsupported") - @TestDataPath("$PROJECT_ROOT") - public class Unsupported extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInUnsupported() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference/unsupported"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("callableReferenceToLocalVariable.kt") - public void testCallableReferenceToLocalVariable() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/unsupported/callableReferenceToLocalVariable.kt"); - } - - @Test - @TestMetadata("localVariable.kt") - public void testLocalVariable() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/unsupported/localVariable.kt"); - } - - @Test - @TestMetadata("localVariableWithSubstitution.kt") - public void testLocalVariableWithSubstitution() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/unsupported/localVariableWithSubstitution.kt"); - } - - @Test - @TestMetadata("parameterWithSubstitution.kt") - public void testParameterWithSubstitution() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/unsupported/parameterWithSubstitution.kt"); - } - - @Test - @TestMetadata("syntheticProperties.kt") - public void testSyntheticProperties() throws Exception { - runTest("compiler/testData/diagnostics/tests/callableReference/unsupported/syntheticProperties.kt"); - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/cast") - @TestDataPath("$PROJECT_ROOT") - public class Cast extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInCast() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/cast"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("AsArray.kt") - public void testAsArray() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/AsArray.kt"); - } - - @Test - @TestMetadata("AsErasedError.kt") - public void testAsErasedError() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/AsErasedError.kt"); - } - - @Test - @TestMetadata("AsErasedFine.kt") - public void testAsErasedFine() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/AsErasedFine.kt"); - } - - @Test - @TestMetadata("AsErasedStar.kt") - public void testAsErasedStar() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/AsErasedStar.kt"); - } - - @Test - @TestMetadata("AsErasedWarning.kt") - public void testAsErasedWarning() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/AsErasedWarning.kt"); - } - - @Test - @TestMetadata("AsInBinaryUnary.kt") - public void testAsInBinaryUnary() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/AsInBinaryUnary.kt"); - } - - @Test - @TestMetadata("AsInBlockWithReturnType.kt") - public void testAsInBlockWithReturnType() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/AsInBlockWithReturnType.kt"); - } - - @Test - @TestMetadata("AsInExpressionBody.kt") - public void testAsInExpressionBody() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/AsInExpressionBody.kt"); - } - - @Test - @TestMetadata("AsInPropertyAndPropertyAccessor.kt") - public void testAsInPropertyAndPropertyAccessor() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/AsInPropertyAndPropertyAccessor.kt"); - } - - @Test - @TestMetadata("AsNothing.kt") - public void testAsNothing() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/AsNothing.kt"); - } - - @Test - @TestMetadata("AsTypeAlias.kt") - public void testAsTypeAlias() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/AsTypeAlias.kt"); - } - - @Test - @TestMetadata("AsWithOtherParameter.kt") - public void testAsWithOtherParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/AsWithOtherParameter.kt"); - } - - @Test - @TestMetadata("checkCastToNullableType.kt") - public void testCheckCastToNullableType() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/checkCastToNullableType.kt"); - } - - @Test - @TestMetadata("constants.kt") - public void testConstants() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/constants.kt"); - } - - @Test - @TestMetadata("DowncastMap.kt") - public void testDowncastMap() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/DowncastMap.kt"); - } - - @Test - @TestMetadata("ExtensionAsNonExtension.kt") - public void testExtensionAsNonExtension() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/ExtensionAsNonExtension.kt"); - } - - @Test - @TestMetadata("FlexibleTargetType.kt") - public void testFlexibleTargetType() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/FlexibleTargetType.kt"); - } - - @Test - @TestMetadata("IsErasedAllowForDerivedWithOneSubstitutedAndOneSameGeneric.kt") - public void testIsErasedAllowForDerivedWithOneSubstitutedAndOneSameGeneric() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/IsErasedAllowForDerivedWithOneSubstitutedAndOneSameGeneric.kt"); - } - - @Test - @TestMetadata("IsErasedAllowForExactSupertypeCheck.kt") - public void testIsErasedAllowForExactSupertypeCheck() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/IsErasedAllowForExactSupertypeCheck.kt"); - } - - @Test - @TestMetadata("IsErasedAllowForOverridenVarianceWithProjection.kt") - public void testIsErasedAllowForOverridenVarianceWithProjection() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/IsErasedAllowForOverridenVarianceWithProjection.kt"); - } - - @Test - @TestMetadata("IsErasedAllowForSupertypeCheckWithContrvariance.kt") - public void testIsErasedAllowForSupertypeCheckWithContrvariance() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/IsErasedAllowForSupertypeCheckWithContrvariance.kt"); - } - - @Test - @TestMetadata("IsErasedAllowForSupertypeCheckWithCovariance.kt") - public void testIsErasedAllowForSupertypeCheckWithCovariance() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/IsErasedAllowForSupertypeCheckWithCovariance.kt"); - } - - @Test - @TestMetadata("IsErasedAllowForTypeWithIrrelevantMixin.kt") - public void testIsErasedAllowForTypeWithIrrelevantMixin() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/IsErasedAllowForTypeWithIrrelevantMixin.kt"); - } - - @Test - @TestMetadata("IsErasedAllowForTypeWithTwoSameTypeSubstitutions.kt") - public void testIsErasedAllowForTypeWithTwoSameTypeSubstitutions() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/IsErasedAllowForTypeWithTwoSameTypeSubstitutions.kt"); - } - - @Test - @TestMetadata("IsErasedAllowForTypeWithoutTypeArguments.kt") - public void testIsErasedAllowForTypeWithoutTypeArguments() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/IsErasedAllowForTypeWithoutTypeArguments.kt"); - } - - @Test - @TestMetadata("IsErasedAllowFromOut.kt") - public void testIsErasedAllowFromOut() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/IsErasedAllowFromOut.kt"); - } - - @Test - @TestMetadata("IsErasedAllowFromOut2.kt") - public void testIsErasedAllowFromOut2() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/IsErasedAllowFromOut2.kt"); - } - - @Test - @TestMetadata("IsErasedAllowFromOutAtClass.kt") - public void testIsErasedAllowFromOutAtClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/IsErasedAllowFromOutAtClass.kt"); - } - - @Test - @TestMetadata("IsErasedAllowParameterSubtype.kt") - public void testIsErasedAllowParameterSubtype() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/IsErasedAllowParameterSubtype.kt"); - } - - @Test - @TestMetadata("IsErasedAllowSameClassParameter.kt") - public void testIsErasedAllowSameClassParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/IsErasedAllowSameClassParameter.kt"); - } - - @Test - @TestMetadata("IsErasedAllowSameParameterParameter.kt") - public void testIsErasedAllowSameParameterParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/IsErasedAllowSameParameterParameter.kt"); - } - - @Test - @TestMetadata("isErasedAnyAndStarred.kt") - public void testIsErasedAnyAndStarred() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/isErasedAnyAndStarred.kt"); - } - - @Test - @TestMetadata("IsErasedDisallowDifferentArgInvariantPosition.kt") - public void testIsErasedDisallowDifferentArgInvariantPosition() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/IsErasedDisallowDifferentArgInvariantPosition.kt"); - } - - @Test - @TestMetadata("IsErasedDisallowForOverridenVariance.kt") - public void testIsErasedDisallowForOverridenVariance() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/IsErasedDisallowForOverridenVariance.kt"); - } - - @Test - @TestMetadata("IsErasedDisallowForTypeWithConstraints.kt") - public void testIsErasedDisallowForTypeWithConstraints() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/IsErasedDisallowForTypeWithConstraints.kt"); - } - - @Test - @TestMetadata("IsErasedDisallowFromAny.kt") - public void testIsErasedDisallowFromAny() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/IsErasedDisallowFromAny.kt"); - } - - @Test - @TestMetadata("IsErasedDisallowFromIn.kt") - public void testIsErasedDisallowFromIn() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/IsErasedDisallowFromIn.kt"); - } - - @Test - @TestMetadata("IsErasedDisallowFromOut.kt") - public void testIsErasedDisallowFromOut() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/IsErasedDisallowFromOut.kt"); - } - - @Test - @TestMetadata("IsErasedDisallowFromOutAtClass.kt") - public void testIsErasedDisallowFromOutAtClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/IsErasedDisallowFromOutAtClass.kt"); - } - - @Test - @TestMetadata("IsErasedDissallowForSubtypeMappedToTwoParamsWithFirstInvalid.kt") - public void testIsErasedDissallowForSubtypeMappedToTwoParamsWithFirstInvalid() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/IsErasedDissallowForSubtypeMappedToTwoParamsWithFirstInvalid.kt"); - } - - @Test - @TestMetadata("IsErasedDissallowForSubtypeMappedToTwoParamsWithSecondInvalid.kt") - public void testIsErasedDissallowForSubtypeMappedToTwoParamsWithSecondInvalid() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/IsErasedDissallowForSubtypeMappedToTwoParamsWithSecondInvalid.kt"); - } - - @Test - @TestMetadata("IsErasedNonGeneric.kt") - public void testIsErasedNonGeneric() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/IsErasedNonGeneric.kt"); - } - - @Test - @TestMetadata("IsErasedNullableTasT.kt") - public void testIsErasedNullableTasT() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/IsErasedNullableTasT.kt"); - } - - @Test - @TestMetadata("IsErasedStar.kt") - public void testIsErasedStar() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/IsErasedStar.kt"); - } - - @Test - @TestMetadata("isErasedTAndStarred.kt") - public void testIsErasedTAndStarred() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/isErasedTAndStarred.kt"); - } - - @Test - @TestMetadata("IsErasedTasT.kt") - public void testIsErasedTasT() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/IsErasedTasT.kt"); - } - - @Test - @TestMetadata("IsErasedToErrorType.kt") - public void testIsErasedToErrorType() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/IsErasedToErrorType.kt"); - } - - @Test - @TestMetadata("isErasedUnrelatedAndStarred.kt") - public void testIsErasedUnrelatedAndStarred() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/isErasedUnrelatedAndStarred.kt"); - } - - @Test - @TestMetadata("IsErasedUpcastToNonReified.kt") - public void testIsErasedUpcastToNonReified() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/IsErasedUpcastToNonReified.kt"); - } - - @Test - @TestMetadata("IsForTypeWithComplexUpperBound.kt") - public void testIsForTypeWithComplexUpperBound() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/IsForTypeWithComplexUpperBound.kt"); - } - - @Test - @TestMetadata("IsRecursionSustainable.kt") - public void testIsRecursionSustainable() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/IsRecursionSustainable.kt"); - } - - @Test - @TestMetadata("IsTraits.kt") - public void testIsTraits() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/IsTraits.kt"); - } - - @Test - @TestMetadata("IsWithCycleUpperBounds.kt") - public void testIsWithCycleUpperBounds() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/IsWithCycleUpperBounds.kt"); - } - - @Test - @TestMetadata("kt15161.kt") - public void testKt15161() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/kt15161.kt"); - } - - @Test - @TestMetadata("kt614.kt") - public void testKt614() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/kt614.kt"); - } - - @Test - @TestMetadata("nothingAs.kt") - public void testNothingAs() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/nothingAs.kt"); - } - - @Test - @TestMetadata("NullableToNullable.kt") - public void testNullableToNullable() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/NullableToNullable.kt"); - } - - @Test - @TestMetadata("StableTypeForUselessCast.kt") - public void testStableTypeForUselessCast() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/StableTypeForUselessCast.kt"); - } - - @Test - @TestMetadata("UselessSafeCast.kt") - public void testUselessSafeCast() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/UselessSafeCast.kt"); - } - - @Test - @TestMetadata("WhenErasedDisallowFromAny.kt") - public void testWhenErasedDisallowFromAny() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/WhenErasedDisallowFromAny.kt"); - } - - @Test - @TestMetadata("WhenWithExpression.kt") - public void testWhenWithExpression() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/WhenWithExpression.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/cast/bare") - @TestDataPath("$PROJECT_ROOT") - public class Bare extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInBare() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/cast/bare"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("AsNestedBare.kt") - public void testAsNestedBare() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/bare/AsNestedBare.kt"); - } - - @Test - @TestMetadata("AsNullable.kt") - public void testAsNullable() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/bare/AsNullable.kt"); - } - - @Test - @TestMetadata("AsNullableNotEnough.kt") - public void testAsNullableNotEnough() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/bare/AsNullableNotEnough.kt"); - } - - @Test - @TestMetadata("EitherAs.kt") - public void testEitherAs() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/bare/EitherAs.kt"); - } - - @Test - @TestMetadata("EitherIs.kt") - public void testEitherIs() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/bare/EitherIs.kt"); - } - - @Test - @TestMetadata("EitherNotIs.kt") - public void testEitherNotIs() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/bare/EitherNotIs.kt"); - } - - @Test - @TestMetadata("EitherSafeAs.kt") - public void testEitherSafeAs() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/bare/EitherSafeAs.kt"); - } - - @Test - @TestMetadata("EitherWhen.kt") - public void testEitherWhen() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/bare/EitherWhen.kt"); - } - - @Test - @TestMetadata("ErrorsInSubstitution.kt") - public void testErrorsInSubstitution() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/bare/ErrorsInSubstitution.kt"); - } - - @Test - @TestMetadata("FromErrorType.kt") - public void testFromErrorType() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/bare/FromErrorType.kt"); - } - - @Test - @TestMetadata("NullableAs.kt") - public void testNullableAs() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/bare/NullableAs.kt"); - } - - @Test - @TestMetadata("NullableAsNotEnough.kt") - public void testNullableAsNotEnough() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/bare/NullableAsNotEnough.kt"); - } - - @Test - @TestMetadata("NullableAsNullable.kt") - public void testNullableAsNullable() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/bare/NullableAsNullable.kt"); - } - - @Test - @TestMetadata("NullableAsNullableNotEnough.kt") - public void testNullableAsNullableNotEnough() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/bare/NullableAsNullableNotEnough.kt"); - } - - @Test - @TestMetadata("RedundantNullable.kt") - public void testRedundantNullable() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/bare/RedundantNullable.kt"); - } - - @Test - @TestMetadata("ToErrorType.kt") - public void testToErrorType() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/bare/ToErrorType.kt"); - } - - @Test - @TestMetadata("UnrelatedAs.kt") - public void testUnrelatedAs() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/bare/UnrelatedAs.kt"); - } - - @Test - @TestMetadata("UnrelatedColon.kt") - public void testUnrelatedColon() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/bare/UnrelatedColon.kt"); - } - - @Test - @TestMetadata("UnrelatedIs.kt") - public void testUnrelatedIs() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/bare/UnrelatedIs.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/cast/neverSucceeds") - @TestDataPath("$PROJECT_ROOT") - public class NeverSucceeds extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInNeverSucceeds() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/cast/neverSucceeds"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("CastToNotNullSuper.kt") - public void testCastToNotNullSuper() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/neverSucceeds/CastToNotNullSuper.kt"); - } - - @Test - @TestMetadata("MappedDirect.kt") - public void testMappedDirect() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/neverSucceeds/MappedDirect.kt"); - } - - @Test - @TestMetadata("MappedSubtypes.kt") - public void testMappedSubtypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/neverSucceeds/MappedSubtypes.kt"); - } - - @Test - @TestMetadata("NoGenericsRelated.kt") - public void testNoGenericsRelated() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/neverSucceeds/NoGenericsRelated.kt"); - } - - @Test - @TestMetadata("NoGenericsUnrelated.kt") - public void testNoGenericsUnrelated() throws Exception { - runTest("compiler/testData/diagnostics/tests/cast/neverSucceeds/NoGenericsUnrelated.kt"); - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/checkArguments") - @TestDataPath("$PROJECT_ROOT") - public class CheckArguments extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInCheckArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/checkArguments"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("arrayAccessSet.kt") - public void testArrayAccessSet() throws Exception { - runTest("compiler/testData/diagnostics/tests/checkArguments/arrayAccessSet.kt"); - } - - @Test - @TestMetadata("arrayAccessSetTooManyArgs.kt") - public void testArrayAccessSetTooManyArgs() throws Exception { - runTest("compiler/testData/diagnostics/tests/checkArguments/arrayAccessSetTooManyArgs.kt"); - } - - @Test - @TestMetadata("booleanExpressions.kt") - public void testBooleanExpressions() throws Exception { - runTest("compiler/testData/diagnostics/tests/checkArguments/booleanExpressions.kt"); - } - - @Test - @TestMetadata("kt17691.kt") - public void testKt17691() throws Exception { - runTest("compiler/testData/diagnostics/tests/checkArguments/kt17691.kt"); - } - - @Test - @TestMetadata("kt17691WithEnabledFeature.kt") - public void testKt17691WithEnabledFeature() throws Exception { - runTest("compiler/testData/diagnostics/tests/checkArguments/kt17691WithEnabledFeature.kt"); - } - - @Test - @TestMetadata("kt1897_diagnostic_part.kt") - public void testKt1897_diagnostic_part() throws Exception { - runTest("compiler/testData/diagnostics/tests/checkArguments/kt1897_diagnostic_part.kt"); - } - - @Test - @TestMetadata("kt1940.kt") - public void testKt1940() throws Exception { - runTest("compiler/testData/diagnostics/tests/checkArguments/kt1940.kt"); - } - - @Test - @TestMetadata("overloadedFunction.kt") - public void testOverloadedFunction() throws Exception { - runTest("compiler/testData/diagnostics/tests/checkArguments/overloadedFunction.kt"); - } - - @Test - @TestMetadata("SpreadVarargs.kt") - public void testSpreadVarargs() throws Exception { - runTest("compiler/testData/diagnostics/tests/checkArguments/SpreadVarargs.kt"); - } - - @Test - @TestMetadata("twoLambdasFunction.kt") - public void testTwoLambdasFunction() throws Exception { - runTest("compiler/testData/diagnostics/tests/checkArguments/twoLambdasFunction.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/classLiteral") - @TestDataPath("$PROJECT_ROOT") - public class ClassLiteral extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInClassLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/classLiteral"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("arrays.kt") - public void testArrays() throws Exception { - runTest("compiler/testData/diagnostics/tests/classLiteral/arrays.kt"); - } - - @Test - @TestMetadata("classAndObjectLiteralType.kt") - public void testClassAndObjectLiteralType() throws Exception { - runTest("compiler/testData/diagnostics/tests/classLiteral/classAndObjectLiteralType.kt"); - } - - @Test - @TestMetadata("classLiteralType.kt") - public void testClassLiteralType() throws Exception { - runTest("compiler/testData/diagnostics/tests/classLiteral/classLiteralType.kt"); - } - - @Test - @TestMetadata("expressionWithNullableType.kt") - public void testExpressionWithNullableType() throws Exception { - runTest("compiler/testData/diagnostics/tests/classLiteral/expressionWithNullableType.kt"); - } - - @Test - @TestMetadata("genericArrays.kt") - public void testGenericArrays() throws Exception { - runTest("compiler/testData/diagnostics/tests/classLiteral/genericArrays.kt"); - } - - @Test - @TestMetadata("genericClasses.kt") - public void testGenericClasses() throws Exception { - runTest("compiler/testData/diagnostics/tests/classLiteral/genericClasses.kt"); - } - - @Test - @TestMetadata("inAnnotationArguments.kt") - public void testInAnnotationArguments() throws Exception { - runTest("compiler/testData/diagnostics/tests/classLiteral/inAnnotationArguments.kt"); - } - - @Test - @TestMetadata("inAnnotationArguments_noTypeParams.kt") - public void testInAnnotationArguments_noTypeParams() throws Exception { - runTest("compiler/testData/diagnostics/tests/classLiteral/inAnnotationArguments_noTypeParams.kt"); - } - - @Test - @TestMetadata("integerValueType.kt") - public void testIntegerValueType() throws Exception { - runTest("compiler/testData/diagnostics/tests/classLiteral/integerValueType.kt"); - } - - @Test - @TestMetadata("nonClassesOnLHS.kt") - public void testNonClassesOnLHS() throws Exception { - runTest("compiler/testData/diagnostics/tests/classLiteral/nonClassesOnLHS.kt"); - } - - @Test - @TestMetadata("qualifiedClassLiteral.kt") - public void testQualifiedClassLiteral() throws Exception { - runTest("compiler/testData/diagnostics/tests/classLiteral/qualifiedClassLiteral.kt"); - } - - @Test - @TestMetadata("simpleClassLiteral.kt") - public void testSimpleClassLiteral() throws Exception { - runTest("compiler/testData/diagnostics/tests/classLiteral/simpleClassLiteral.kt"); - } - - @Test - @TestMetadata("smartCast.kt") - public void testSmartCast() throws Exception { - runTest("compiler/testData/diagnostics/tests/classLiteral/smartCast.kt"); - } - - @Test - @TestMetadata("typealiases.kt") - public void testTypealiases() throws Exception { - runTest("compiler/testData/diagnostics/tests/classLiteral/typealiases.kt"); - } - - @Test - @TestMetadata("unresolvedClass.kt") - public void testUnresolvedClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/classLiteral/unresolvedClass.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/classObjects") - @TestDataPath("$PROJECT_ROOT") - public class ClassObjects extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInClassObjects() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/classObjects"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("builtInClassObjects.kt") - public void testBuiltInClassObjects() throws Exception { - runTest("compiler/testData/diagnostics/tests/classObjects/builtInClassObjects.kt"); - } - - @Test - @TestMetadata("ClassObjectCannotAccessClassFields.kt") - public void testClassObjectCannotAccessClassFields() throws Exception { - runTest("compiler/testData/diagnostics/tests/classObjects/ClassObjectCannotAccessClassFields.kt"); - } - - @Test - @TestMetadata("classObjectHeader.kt") - public void testClassObjectHeader() throws Exception { - runTest("compiler/testData/diagnostics/tests/classObjects/classObjectHeader.kt"); - } - - @Test - @TestMetadata("classObjectInLocalClass.kt") - public void testClassObjectInLocalClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/classObjects/classObjectInLocalClass.kt"); - } - - @Test - @TestMetadata("classObjectRedeclaration.kt") - public void testClassObjectRedeclaration() throws Exception { - runTest("compiler/testData/diagnostics/tests/classObjects/classObjectRedeclaration.kt"); - } - - @Test - @TestMetadata("ClassObjectVisibility.kt") - public void testClassObjectVisibility() throws Exception { - runTest("compiler/testData/diagnostics/tests/classObjects/ClassObjectVisibility.kt"); - } - - @Test - @TestMetadata("ClassObjects.kt") - public void testClassObjects() throws Exception { - runTest("compiler/testData/diagnostics/tests/classObjects/ClassObjects.kt"); - } - - @Test - @TestMetadata("companionObjectOfPrivateClassVisibility.kt") - public void testCompanionObjectOfPrivateClassVisibility() throws Exception { - runTest("compiler/testData/diagnostics/tests/classObjects/companionObjectOfPrivateClassVisibility.kt"); - } - - @Test - @TestMetadata("importClassInClassObject.kt") - public void testImportClassInClassObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/classObjects/importClassInClassObject.kt"); - } - - @Test - @TestMetadata("InnerClassAccessThroughClassObject.kt") - public void testInnerClassAccessThroughClassObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/classObjects/InnerClassAccessThroughClassObject.kt"); - } - - @Test - @TestMetadata("InnerClassAccessThroughEnum_after.kt") - public void testInnerClassAccessThroughEnum_after() throws Exception { - runTest("compiler/testData/diagnostics/tests/classObjects/InnerClassAccessThroughEnum_after.kt"); - } - - @Test - @TestMetadata("InnerClassAccessThroughEnum_before.kt") - public void testInnerClassAccessThroughEnum_before() throws Exception { - runTest("compiler/testData/diagnostics/tests/classObjects/InnerClassAccessThroughEnum_before.kt"); - } - - @Test - @TestMetadata("InnerClassClassObject.kt") - public void testInnerClassClassObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/classObjects/InnerClassClassObject.kt"); - } - - @Test - @TestMetadata("invisibleClassObjects.kt") - public void testInvisibleClassObjects() throws Exception { - runTest("compiler/testData/diagnostics/tests/classObjects/invisibleClassObjects.kt"); - } - - @Test - @TestMetadata("kt3866.kt") - public void testKt3866() throws Exception { - runTest("compiler/testData/diagnostics/tests/classObjects/kt3866.kt"); - } - - @Test - @TestMetadata("multipleDissallowedDefaultObjects.kt") - public void testMultipleDissallowedDefaultObjects() throws Exception { - runTest("compiler/testData/diagnostics/tests/classObjects/multipleDissallowedDefaultObjects.kt"); - } - - @Test - @TestMetadata("nestedClassInPrivateClassObject.kt") - public void testNestedClassInPrivateClassObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/classObjects/nestedClassInPrivateClassObject.kt"); - } - - @Test - @TestMetadata("resolveFunctionInsideClassObject.kt") - public void testResolveFunctionInsideClassObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/classObjects/resolveFunctionInsideClassObject.kt"); - } - - @Test - @TestMetadata("typeParametersInAnnonymousObject.kt") - public void testTypeParametersInAnnonymousObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/classObjects/typeParametersInAnnonymousObject.kt"); - } - - @Test - @TestMetadata("typeParametersInAnnonymousObject_after.kt") - public void testTypeParametersInAnnonymousObject_after() throws Exception { - runTest("compiler/testData/diagnostics/tests/classObjects/typeParametersInAnnonymousObject_after.kt"); - } - - @Test - @TestMetadata("typeParametersInObject.kt") - public void testTypeParametersInObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/classObjects/typeParametersInObject.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/collectionLiterals") - @TestDataPath("$PROJECT_ROOT") - public class CollectionLiterals extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInCollectionLiterals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/collectionLiterals"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("argumentsOfAnnotation.kt") - public void testArgumentsOfAnnotation() throws Exception { - runTest("compiler/testData/diagnostics/tests/collectionLiterals/argumentsOfAnnotation.kt"); - } - - @Test - @TestMetadata("argumentsOfAnnotationWithKClass.kt") - public void testArgumentsOfAnnotationWithKClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/collectionLiterals/argumentsOfAnnotationWithKClass.kt"); - } - - @Test - @TestMetadata("basicCollectionLiterals.kt") - public void testBasicCollectionLiterals() throws Exception { - runTest("compiler/testData/diagnostics/tests/collectionLiterals/basicCollectionLiterals.kt"); - } - - @Test - @TestMetadata("collectionLiteralsAsPrimitiveArrays.kt") - public void testCollectionLiteralsAsPrimitiveArrays() throws Exception { - runTest("compiler/testData/diagnostics/tests/collectionLiterals/collectionLiteralsAsPrimitiveArrays.kt"); - } - - @Test - @TestMetadata("collectionLiteralsOutsideOfAnnotations.kt") - public void testCollectionLiteralsOutsideOfAnnotations() throws Exception { - runTest("compiler/testData/diagnostics/tests/collectionLiterals/collectionLiteralsOutsideOfAnnotations.kt"); - } - - @Test - @TestMetadata("collectionLiteralsWithVarargs.kt") - public void testCollectionLiteralsWithVarargs() throws Exception { - runTest("compiler/testData/diagnostics/tests/collectionLiterals/collectionLiteralsWithVarargs.kt"); - } - - @Test - @TestMetadata("defaultValuesInAnnotation.kt") - public void testDefaultValuesInAnnotation() throws Exception { - runTest("compiler/testData/diagnostics/tests/collectionLiterals/defaultValuesInAnnotation.kt"); - } - - @Test - @TestMetadata("defaultValuesWithConstantsInAnnotation.kt") - public void testDefaultValuesWithConstantsInAnnotation() throws Exception { - runTest("compiler/testData/diagnostics/tests/collectionLiterals/defaultValuesWithConstantsInAnnotation.kt"); - } - - @Test - @TestMetadata("noArrayLiteralsInAnnotationsFeature.kt") - public void testNoArrayLiteralsInAnnotationsFeature() throws Exception { - runTest("compiler/testData/diagnostics/tests/collectionLiterals/noArrayLiteralsInAnnotationsFeature.kt"); - } - - @Test - @TestMetadata("noCollectionLiterals.kt") - public void testNoCollectionLiterals() throws Exception { - runTest("compiler/testData/diagnostics/tests/collectionLiterals/noCollectionLiterals.kt"); - } - - @Test - @TestMetadata("resolveToFunctionFromBuiltIns.kt") - public void testResolveToFunctionFromBuiltIns() throws Exception { - runTest("compiler/testData/diagnostics/tests/collectionLiterals/resolveToFunctionFromBuiltIns.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/constructorConsistency") - @TestDataPath("$PROJECT_ROOT") - public class ConstructorConsistency extends AbstractDiagnosticUsingJavacTest { - @Test - @TestMetadata("afterInitialization.kt") - public void testAfterInitialization() throws Exception { - runTest("compiler/testData/diagnostics/tests/constructorConsistency/afterInitialization.kt"); - } - - @Test - @TestMetadata("aliencall.kt") - public void testAliencall() throws Exception { - runTest("compiler/testData/diagnostics/tests/constructorConsistency/aliencall.kt"); - } - - @Test - public void testAllFilesPresentInConstructorConsistency() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/constructorConsistency"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("assignment.kt") - public void testAssignment() throws Exception { - runTest("compiler/testData/diagnostics/tests/constructorConsistency/assignment.kt"); - } - - @Test - @TestMetadata("backing.kt") - public void testBacking() throws Exception { - runTest("compiler/testData/diagnostics/tests/constructorConsistency/backing.kt"); - } - - @Test - @TestMetadata("basic.kt") - public void testBasic() throws Exception { - runTest("compiler/testData/diagnostics/tests/constructorConsistency/basic.kt"); - } - - @Test - @TestMetadata("companion.kt") - public void testCompanion() throws Exception { - runTest("compiler/testData/diagnostics/tests/constructorConsistency/companion.kt"); - } - - @Test - @TestMetadata("comparison.kt") - public void testComparison() throws Exception { - runTest("compiler/testData/diagnostics/tests/constructorConsistency/comparison.kt"); - } - - @Test - @TestMetadata("delegate.kt") - public void testDelegate() throws Exception { - runTest("compiler/testData/diagnostics/tests/constructorConsistency/delegate.kt"); - } - - @Test - @TestMetadata("derived.kt") - public void testDerived() throws Exception { - runTest("compiler/testData/diagnostics/tests/constructorConsistency/derived.kt"); - } - - @Test - @TestMetadata("derivedProperty.kt") - public void testDerivedProperty() throws Exception { - runTest("compiler/testData/diagnostics/tests/constructorConsistency/derivedProperty.kt"); - } - - @Test - @TestMetadata("getset.kt") - public void testGetset() throws Exception { - runTest("compiler/testData/diagnostics/tests/constructorConsistency/getset.kt"); - } - - @Test - @TestMetadata("init.kt") - public void testInit() throws Exception { - runTest("compiler/testData/diagnostics/tests/constructorConsistency/init.kt"); - } - - @Test - @TestMetadata("initializerWithSecondaryConstructor.kt") - public void testInitializerWithSecondaryConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/constructorConsistency/initializerWithSecondaryConstructor.kt"); - } - - @Test - @TestMetadata("initwithgetter.kt") - public void testInitwithgetter() throws Exception { - runTest("compiler/testData/diagnostics/tests/constructorConsistency/initwithgetter.kt"); - } - - @Test - @TestMetadata("inspection.kt") - public void testInspection() throws Exception { - runTest("compiler/testData/diagnostics/tests/constructorConsistency/inspection.kt"); - } - - @Test - @TestMetadata("lambdaInObject.kt") - public void testLambdaInObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/constructorConsistency/lambdaInObject.kt"); - } - - @Test - @TestMetadata("lateInit.kt") - public void testLateInit() throws Exception { - runTest("compiler/testData/diagnostics/tests/constructorConsistency/lateInit.kt"); - } - - @Test - @TestMetadata("localObject.kt") - public void testLocalObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/constructorConsistency/localObject.kt"); - } - - @Test - @TestMetadata("multipleAreNull.kt") - public void testMultipleAreNull() throws Exception { - runTest("compiler/testData/diagnostics/tests/constructorConsistency/multipleAreNull.kt"); - } - - @Test - @TestMetadata("nobacking.kt") - public void testNobacking() throws Exception { - runTest("compiler/testData/diagnostics/tests/constructorConsistency/nobacking.kt"); - } - - @Test - @TestMetadata("open.kt") - public void testOpen() throws Exception { - runTest("compiler/testData/diagnostics/tests/constructorConsistency/open.kt"); - } - - @Test - @TestMetadata("openProperty.kt") - public void testOpenProperty() throws Exception { - runTest("compiler/testData/diagnostics/tests/constructorConsistency/openProperty.kt"); - } - - @Test - @TestMetadata("outer.kt") - public void testOuter() throws Exception { - runTest("compiler/testData/diagnostics/tests/constructorConsistency/outer.kt"); - } - - @Test - @TestMetadata("property.kt") - public void testProperty() throws Exception { - runTest("compiler/testData/diagnostics/tests/constructorConsistency/property.kt"); - } - - @Test - @TestMetadata("propertyAccess.kt") - public void testPropertyAccess() throws Exception { - runTest("compiler/testData/diagnostics/tests/constructorConsistency/propertyAccess.kt"); - } - - @Test - @TestMetadata("twoSecondaryConstructors.kt") - public void testTwoSecondaryConstructors() throws Exception { - runTest("compiler/testData/diagnostics/tests/constructorConsistency/twoSecondaryConstructors.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis") - @TestDataPath("$PROJECT_ROOT") - public class ControlFlowAnalysis extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInControlFlowAnalysis() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/controlFlowAnalysis"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("assignedInFinally.kt") - public void testAssignedInFinally() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/assignedInFinally.kt"); - } - - @Test - @TestMetadata("assignedInIfElse.kt") - public void testAssignedInIfElse() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/assignedInIfElse.kt"); - } - - @Test - @TestMetadata("assignedInTryWithCatch.kt") - public void testAssignedInTryWithCatch() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/assignedInTryWithCatch.kt"); - } - - @Test - @TestMetadata("assignedInTryWithoutCatch.kt") - public void testAssignedInTryWithoutCatch() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/assignedInTryWithoutCatch.kt"); - } - - @Test - @TestMetadata("assignmentInLocalsInConstructor.kt") - public void testAssignmentInLocalsInConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/assignmentInLocalsInConstructor.kt"); - } - - @Test - @TestMetadata("backingFieldInsideGetter_after.kt") - public void testBackingFieldInsideGetter_after() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/backingFieldInsideGetter_after.kt"); - } - - @Test - @TestMetadata("backingFieldInsideGetter_before.kt") - public void testBackingFieldInsideGetter_before() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/backingFieldInsideGetter_before.kt"); - } - - @Test - @TestMetadata("breakContinueInTryFinally.kt") - public void testBreakContinueInTryFinally() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/breakContinueInTryFinally.kt"); - } - - @Test - @TestMetadata("breakInsideLocal.kt") - public void testBreakInsideLocal() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/breakInsideLocal.kt"); - } - - @Test - @TestMetadata("breakOrContinueInLoopCondition.kt") - public void testBreakOrContinueInLoopCondition() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/breakOrContinueInLoopCondition.kt"); - } - - @Test - @TestMetadata("checkInnerLocalDeclarations.kt") - public void testCheckInnerLocalDeclarations() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/checkInnerLocalDeclarations.kt"); - } - - @Test - @TestMetadata("checkPropertyAccessor.kt") - public void testCheckPropertyAccessor() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/checkPropertyAccessor.kt"); - } - - @Test - @TestMetadata("constructorPropertyInterdependence.kt") - public void testConstructorPropertyInterdependence() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/constructorPropertyInterdependence.kt"); - } - - @Test - @TestMetadata("definiteReturnInWhen.kt") - public void testDefiniteReturnInWhen() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/definiteReturnInWhen.kt"); - } - - @Test - @TestMetadata("delegatedPropertyEarlyAccess.kt") - public void testDelegatedPropertyEarlyAccess() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/delegatedPropertyEarlyAccess.kt"); - } - - @Test - @TestMetadata("doWhileAssignment.kt") - public void testDoWhileAssignment() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/doWhileAssignment.kt"); - } - - @Test - @TestMetadata("doWhileNotDefined.kt") - public void testDoWhileNotDefined() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/doWhileNotDefined.kt"); - } - - @Test - @TestMetadata("elvisNotProcessed.kt") - public void testElvisNotProcessed() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/elvisNotProcessed.kt"); - } - - @Test - @TestMetadata("enumCompanionInterdependence.kt") - public void testEnumCompanionInterdependence() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/enumCompanionInterdependence.kt"); - } - - @Test - @TestMetadata("enumInterdependence.kt") - public void testEnumInterdependence() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/enumInterdependence.kt"); - } - - @Test - @TestMetadata("fieldAsClassDelegate.kt") - public void testFieldAsClassDelegate() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/fieldAsClassDelegate.kt"); - } - - @Test - @TestMetadata("fieldInitialization.kt") - public void testFieldInitialization() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/fieldInitialization.kt"); - } - - @Test - @TestMetadata("infiniteLoops.kt") - public void testInfiniteLoops() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/infiniteLoops.kt"); - } - - @Test - @TestMetadata("initializationInLambda.kt") - public void testInitializationInLambda() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/initializationInLambda.kt"); - } - - @Test - @TestMetadata("initializationInLocalClass.kt") - public void testInitializationInLocalClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/initializationInLocalClass.kt"); - } - - @Test - @TestMetadata("initializationInLocalFun.kt") - public void testInitializationInLocalFun() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/initializationInLocalFun.kt"); - } - - @Test - @TestMetadata("initializationInLocalViaExplicitThis_after.kt") - public void testInitializationInLocalViaExplicitThis_after() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/initializationInLocalViaExplicitThis_after.kt"); - } - - @Test - @TestMetadata("initializationInLocalViaExplicitThis_before.kt") - public void testInitializationInLocalViaExplicitThis_before() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/initializationInLocalViaExplicitThis_before.kt"); - } - - @Test - @TestMetadata("kt1001.kt") - public void testKt1001() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt1001.kt"); - } - - @Test - @TestMetadata("kt1027.kt") - public void testKt1027() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt1027.kt"); - } - - @Test - @TestMetadata("kt1066.kt") - public void testKt1066() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt1066.kt"); - } - - @Test - @TestMetadata("kt10805.kt") - public void testKt10805() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt10805.kt"); - } - - @Test - @TestMetadata("kt10823.kt") - public void testKt10823() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt10823.kt"); - } - - @Test - @TestMetadata("kt1156.kt") - public void testKt1156() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt1156.kt"); - } - - @Test - @TestMetadata("kt1185enums.kt") - public void testKt1185enums() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt1185enums.kt"); - } - - @Test - @TestMetadata("kt1189.kt") - public void testKt1189() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt1189.kt"); - } - - @Test - @TestMetadata("kt1191.kt") - public void testKt1191() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt1191.kt"); - } - - @Test - @TestMetadata("kt1219.1301.kt") - public void testKt1219_1301() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt1219.1301.kt"); - } - - @Test - @TestMetadata("kt1571.kt") - public void testKt1571() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt1571.kt"); - } - - @Test - @TestMetadata("kt1977.kt") - public void testKt1977() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt1977.kt"); - } - - @Test - @TestMetadata("kt2166_kt2103.kt") - public void testKt2166_kt2103() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt2166_kt2103.kt"); - } - - @Test - @TestMetadata("kt2226.kt") - public void testKt2226() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt2226.kt"); - } - - @Test - @TestMetadata("kt2330.kt") - public void testKt2330() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt2330.kt"); - } - - @Test - @TestMetadata("kt2334.kt") - public void testKt2334() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt2334.kt"); - } - - @Test - @TestMetadata("kt2369.kt") - public void testKt2369() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt2369.kt"); - } - - @Test - @TestMetadata("kt2845.kt") - public void testKt2845() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt2845.kt"); - } - - @Test - @TestMetadata("kt2960.kt") - public void testKt2960() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt2960.kt"); - } - - @Test - @TestMetadata("kt2972.kt") - public void testKt2972() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt2972.kt"); - } - - @Test - @TestMetadata("kt3444.kt") - public void testKt3444() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt3444.kt"); - } - - @Test - @TestMetadata("kt3501.kt") - public void testKt3501() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt3501.kt"); - } - - @Test - @TestMetadata("kt4126.kt") - public void testKt4126() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt4126.kt"); - } - - @Test - @TestMetadata("kt4405.kt") - public void testKt4405() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt4405.kt"); - } - - @Test - @TestMetadata("kt510.kt") - public void testKt510() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt510.kt"); - } - - @Test - @TestMetadata("kt607.kt") - public void testKt607() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt607.kt"); - } - - @Test - @TestMetadata("kt609.kt") - public void testKt609() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt609.kt"); - } - - @Test - @TestMetadata("kt610.kt") - public void testKt610() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt610.kt"); - } - - @Test - @TestMetadata("kt6788.kt") - public void testKt6788() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt6788.kt"); - } - - @Test - @TestMetadata("kt776.kt") - public void testKt776() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt776.kt"); - } - - @Test - @TestMetadata("kt843.kt") - public void testKt843() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt843.kt"); - } - - @Test - @TestMetadata("kt897.kt") - public void testKt897() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/kt897.kt"); - } - - @Test - @TestMetadata("localClasses.kt") - public void testLocalClasses() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/localClasses.kt"); - } - - @Test - @TestMetadata("localObjectInConstructor.kt") - public void testLocalObjectInConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/localObjectInConstructor.kt"); - } - - @Test - @TestMetadata("mainWithWarningOnUnusedParam.kt") - public void testMainWithWarningOnUnusedParam() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/mainWithWarningOnUnusedParam.kt"); - } - - @Test - @TestMetadata("mainWithoutWarningOnUnusedParam.kt") - public void testMainWithoutWarningOnUnusedParam() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/mainWithoutWarningOnUnusedParam.kt"); - } - - @Test - @TestMetadata("nestedTryFinally.kt") - public void testNestedTryFinally() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/nestedTryFinally.kt"); - } - - @Test - @TestMetadata("nonLocalReturnUnreachable.kt") - public void testNonLocalReturnUnreachable() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/nonLocalReturnUnreachable.kt"); - } - - @Test - @TestMetadata("nonLocalReturnWithFinally.kt") - public void testNonLocalReturnWithFinally() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/nonLocalReturnWithFinally.kt"); - } - - @Test - @TestMetadata("privateSetter.kt") - public void testPrivateSetter() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/privateSetter.kt"); - } - - @Test - @TestMetadata("propertiesInitWithOtherInstance.kt") - public void testPropertiesInitWithOtherInstance() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/propertiesInitWithOtherInstance.kt"); - } - - @Test - @TestMetadata("propertiesInitWithOtherInstanceInner.kt") - public void testPropertiesInitWithOtherInstanceInner() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/propertiesInitWithOtherInstanceInner.kt"); - } - - @Test - @TestMetadata("propertiesInitWithOtherInstanceThisLabel.kt") - public void testPropertiesInitWithOtherInstanceThisLabel() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/propertiesInitWithOtherInstanceThisLabel.kt"); - } - - @Test - @TestMetadata("propertiesOrderInPackage.kt") - public void testPropertiesOrderInPackage() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/propertiesOrderInPackage.kt"); - } - - @Test - @TestMetadata("reassignmentInTryCatch.kt") - public void testReassignmentInTryCatch() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/reassignmentInTryCatch.kt"); - } - - @Test - @TestMetadata("reassignmentInTryCatchWithJumps.kt") - public void testReassignmentInTryCatchWithJumps() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/reassignmentInTryCatchWithJumps.kt"); - } - - @Test - @TestMetadata("referenceToPropertyInitializer.kt") - public void testReferenceToPropertyInitializer() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/referenceToPropertyInitializer.kt"); - } - - @Test - @TestMetadata("repeatUnitializedErrorOnlyForLocalVars.kt") - public void testRepeatUnitializedErrorOnlyForLocalVars() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/repeatUnitializedErrorOnlyForLocalVars.kt"); - } - - @Test - @TestMetadata("scopeOfAnonymousInitializer.kt") - public void testScopeOfAnonymousInitializer() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/scopeOfAnonymousInitializer.kt"); - } - - @Test - @TestMetadata("throwInLambda.kt") - public void testThrowInLambda() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/throwInLambda.kt"); - } - - @Test - @TestMetadata("tryWithAssignmentUsedInCatch.kt") - public void testTryWithAssignmentUsedInCatch() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/tryWithAssignmentUsedInCatch.kt"); - } - - @Test - @TestMetadata("uninitializedInLocalDeclarations.kt") - public void testUninitializedInLocalDeclarations() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/uninitializedInLocalDeclarations.kt"); - } - - @Test - @TestMetadata("UninitializedOrReassignedVariables.kt") - public void testUninitializedOrReassignedVariables() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/UninitializedOrReassignedVariables.kt"); - } - - @Test - @TestMetadata("unmappedArgs.kt") - public void testUnmappedArgs() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/unmappedArgs.kt"); - } - - @Test - @TestMetadata("unresolvedReference.kt") - public void testUnresolvedReference() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/unresolvedReference.kt"); - } - - @Test - @TestMetadata("unusedInAnonymous.kt") - public void testUnusedInAnonymous() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/unusedInAnonymous.kt"); - } - - @Test - @TestMetadata("useUninitializedInLambda.kt") - public void testUseUninitializedInLambda() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/useUninitializedInLambda.kt"); - } - - @Test - @TestMetadata("varInitializationInIfInCycle.kt") - public void testVarInitializationInIfInCycle() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/varInitializationInIfInCycle.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode") - @TestDataPath("$PROJECT_ROOT") - public class DeadCode extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInDeadCode() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("commasAndWhitespaces.kt") - public void testCommasAndWhitespaces() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/commasAndWhitespaces.kt"); - } - - @Test - @TestMetadata("commentsInDeadCode.kt") - public void testCommentsInDeadCode() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/commentsInDeadCode.kt"); - } - - @Test - @TestMetadata("deadCallInInvokeCall.kt") - public void testDeadCallInInvokeCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCallInInvokeCall.kt"); - } - - @Test - @TestMetadata("deadCallInReceiver.kt") - public void testDeadCallInReceiver() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCallInReceiver.kt"); - } - - @Test - @TestMetadata("deadCodeDifferentExamples.kt") - public void testDeadCodeDifferentExamples() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeDifferentExamples.kt"); - } - - @Test - @TestMetadata("deadCodeFromDifferentSources.kt") - public void testDeadCodeFromDifferentSources() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeFromDifferentSources.kt"); - } - - @Test - @TestMetadata("deadCodeInArrayAccess.kt") - public void testDeadCodeInArrayAccess() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeInArrayAccess.kt"); - } - - @Test - @TestMetadata("deadCodeInAssignment.kt") - public void testDeadCodeInAssignment() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeInAssignment.kt"); - } - - @Test - @TestMetadata("deadCodeInBinaryExpressions.kt") - public void testDeadCodeInBinaryExpressions() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeInBinaryExpressions.kt"); - } - - @Test - @TestMetadata("deadCodeInCalls.kt") - public void testDeadCodeInCalls() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeInCalls.kt"); - } - - @Test - @TestMetadata("deadCodeInDeadCode.kt") - public void testDeadCodeInDeadCode() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeInDeadCode.kt"); - } - - @Test - @TestMetadata("deadCodeInIf.kt") - public void testDeadCodeInIf() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeInIf.kt"); - } - - @Test - @TestMetadata("deadCodeInInnerExpressions.kt") - public void testDeadCodeInInnerExpressions() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeInInnerExpressions.kt"); - } - - @Test - @TestMetadata("deadCodeInLocalDeclarations.kt") - public void testDeadCodeInLocalDeclarations() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeInLocalDeclarations.kt"); - } - - @Test - @TestMetadata("deadCodeInLoops.kt") - public void testDeadCodeInLoops() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeInLoops.kt"); - } - - @Test - @TestMetadata("deadCodeInReturn.kt") - public void testDeadCodeInReturn() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeInReturn.kt"); - } - - @Test - @TestMetadata("deadCodeInUnaryExpr.kt") - public void testDeadCodeInUnaryExpr() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeInUnaryExpr.kt"); - } - - @Test - @TestMetadata("deadCodeInWhileFromBreak.kt") - public void testDeadCodeInWhileFromBreak() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeInWhileFromBreak.kt"); - } - - @Test - @TestMetadata("expressionInUnitLiteral.kt") - public void testExpressionInUnitLiteral() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/expressionInUnitLiteral.kt"); - } - - @Test - @TestMetadata("kt2585_1.kt") - public void testKt2585_1() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/kt2585_1.kt"); - } - - @Test - @TestMetadata("kt2585_2.kt") - public void testKt2585_2() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/kt2585_2.kt"); - } - - @Test - @TestMetadata("kt2585_3.kt") - public void testKt2585_3() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/kt2585_3.kt"); - } - - @Test - @TestMetadata("kt3162tryAsInitializer.kt") - public void testKt3162tryAsInitializer() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/kt3162tryAsInitializer.kt"); - } - - @Test - @TestMetadata("kt5200DeadCodeInLambdas.kt") - public void testKt5200DeadCodeInLambdas() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/kt5200DeadCodeInLambdas.kt"); - } - - @Test - @TestMetadata("returnInDeadLambda.kt") - public void testReturnInDeadLambda() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/returnInDeadLambda.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/definiteReturn") - @TestDataPath("$PROJECT_ROOT") - public class DefiniteReturn extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInDefiniteReturn() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/controlFlowAnalysis/definiteReturn"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("kt3444_ReturnFromLocalFunctions.kt") - public void testKt3444_ReturnFromLocalFunctions() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/definiteReturn/kt3444_ReturnFromLocalFunctions.kt"); - } - - @Test - @TestMetadata("kt4034.kt") - public void testKt4034() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/definiteReturn/kt4034.kt"); - } - - @Test - @TestMetadata("ReturnFromFunctionInObject.kt") - public void testReturnFromFunctionInObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/definiteReturn/ReturnFromFunctionInObject.kt"); - } - - @Test - @TestMetadata("simpleClass.kt") - public void testSimpleClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/definiteReturn/simpleClass.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit") - @TestDataPath("$PROJECT_ROOT") - public class UnnecessaryLateinit extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInUnnecessaryLateinit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("lateinitRecursiveInLambda.kt") - public void testLateinitRecursiveInLambda() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/lateinitRecursiveInLambda.kt"); - } - - @Test - @TestMetadata("lateinitWithConstructor.kt") - public void testLateinitWithConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/lateinitWithConstructor.kt"); - } - - @Test - @TestMetadata("lateinitWithErroneousDelegation.kt") - public void testLateinitWithErroneousDelegation() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/lateinitWithErroneousDelegation.kt"); - } - - @Test - @TestMetadata("lateinitWithInit.kt") - public void testLateinitWithInit() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/lateinitWithInit.kt"); - } - - @Test - @TestMetadata("lateinitWithMultipleConstructors.kt") - public void testLateinitWithMultipleConstructors() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/lateinitWithMultipleConstructors.kt"); - } - - @Test - @TestMetadata("lateinitWithMultipleConstructorsAndDelegation.kt") - public void testLateinitWithMultipleConstructorsAndDelegation() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/lateinitWithMultipleConstructorsAndDelegation.kt"); - } - - @Test - @TestMetadata("lateinitWithPlusAssign.kt") - public void testLateinitWithPlusAssign() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/lateinitWithPlusAssign.kt"); - } - - @Test - @TestMetadata("lateinitWithPrimaryConstructorAndConstructor.kt") - public void testLateinitWithPrimaryConstructorAndConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/lateinitWithPrimaryConstructorAndConstructor.kt"); - } - - @Test - @TestMetadata("normalLateinit.kt") - public void testNormalLateinit() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/normalLateinit.kt"); - } - - @Test - @TestMetadata("normalLateinitWithTwoConstructors.kt") - public void testNormalLateinitWithTwoConstructors() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/normalLateinitWithTwoConstructors.kt"); - } - - @Test - @TestMetadata("secondaryConstructorDelegateItself.kt") - public void testSecondaryConstructorDelegateItself() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/secondaryConstructorDelegateItself.kt"); - } - - @Test - @TestMetadata("secondaryConstructorDelegateLoop.kt") - public void testSecondaryConstructorDelegateLoop() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit/secondaryConstructorDelegateLoop.kt"); - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/controlStructures") - @TestDataPath("$PROJECT_ROOT") - public class ControlStructures extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInControlStructures() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/controlStructures"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("catchGenerics.kt") - public void testCatchGenerics() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlStructures/catchGenerics.kt"); - } - - @Test - @TestMetadata("catchInnerClassesOfGenerics.kt") - public void testCatchInnerClassesOfGenerics() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlStructures/catchInnerClassesOfGenerics.kt"); - } - - @Test - @TestMetadata("catchInnerClassesOfGenerics_deprecation.kt") - public void testCatchInnerClassesOfGenerics_deprecation() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlStructures/catchInnerClassesOfGenerics_deprecation.kt"); - } - - @Test - @TestMetadata("catchWithDefault.kt") - public void testCatchWithDefault() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlStructures/catchWithDefault.kt"); - } - - @Test - @TestMetadata("catchingLocalClassesCapturingTypeParameters.kt") - public void testCatchingLocalClassesCapturingTypeParameters() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlStructures/catchingLocalClassesCapturingTypeParameters.kt"); - } - - @Test - @TestMetadata("commonSupertypeOfT.kt") - public void testCommonSupertypeOfT() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlStructures/commonSupertypeOfT.kt"); - } - - @Test - @TestMetadata("continueAndBreakLabelWithSameFunctionName.kt") - public void testContinueAndBreakLabelWithSameFunctionName() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlStructures/continueAndBreakLabelWithSameFunctionName.kt"); - } - - @Test - @TestMetadata("emptyIf.kt") - public void testEmptyIf() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlStructures/emptyIf.kt"); - } - - @Test - @TestMetadata("ForLoopWithExtensionIteratorOnNullable.kt") - public void testForLoopWithExtensionIteratorOnNullable() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlStructures/ForLoopWithExtensionIteratorOnNullable.kt"); - } - - @Test - @TestMetadata("forLoopWithNullableRange.kt") - public void testForLoopWithNullableRange() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlStructures/forLoopWithNullableRange.kt"); - } - - @Test - @TestMetadata("forWithNullableIterator.kt") - public void testForWithNullableIterator() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlStructures/forWithNullableIterator.kt"); - } - - @Test - @TestMetadata("ForWithoutBraces.kt") - public void testForWithoutBraces() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlStructures/ForWithoutBraces.kt"); - } - - @Test - @TestMetadata("ForbidStatementAsDirectFunctionBody.kt") - public void testForbidStatementAsDirectFunctionBody() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlStructures/ForbidStatementAsDirectFunctionBody.kt"); - } - - @Test - @TestMetadata("ifElseIntersection.kt") - public void testIfElseIntersection() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlStructures/ifElseIntersection.kt"); - } - - @Test - @TestMetadata("ifInResultOfLambda.kt") - public void testIfInResultOfLambda() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlStructures/ifInResultOfLambda.kt"); - } - - @Test - @TestMetadata("ifToAnyDiscriminatingUsages.kt") - public void testIfToAnyDiscriminatingUsages() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlStructures/ifToAnyDiscriminatingUsages.kt"); - } - - @Test - @TestMetadata("ifWhenToAnyComplexExpressions.kt") - public void testIfWhenToAnyComplexExpressions() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlStructures/ifWhenToAnyComplexExpressions.kt"); - } - - @Test - @TestMetadata("ifWhenWithoutElse.kt") - public void testIfWhenWithoutElse() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlStructures/ifWhenWithoutElse.kt"); - } - - @Test - @TestMetadata("improperElseInExpression.kt") - public void testImproperElseInExpression() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlStructures/improperElseInExpression.kt"); - } - - @Test - @TestMetadata("jumpAcrossFunctionBoundary.kt") - public void testJumpAcrossFunctionBoundary() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlStructures/jumpAcrossFunctionBoundary.kt"); - } - - @Test - @TestMetadata("kt10322.kt") - public void testKt10322() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlStructures/kt10322.kt"); - } - - @Test - @TestMetadata("kt10706.kt") - public void testKt10706() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlStructures/kt10706.kt"); - } - - @Test - @TestMetadata("kt10717.kt") - public void testKt10717() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlStructures/kt10717.kt"); - } - - @Test - @TestMetadata("kt1075.kt") - public void testKt1075() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlStructures/kt1075.kt"); - } - - @Test - @TestMetadata("kt30406.kt") - public void testKt30406() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlStructures/kt30406.kt"); - } - - @Test - @TestMetadata("kt4310.kt") - public void testKt4310() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlStructures/kt4310.kt"); - } - - @Test - @TestMetadata("kt657.kt") - public void testKt657() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlStructures/kt657.kt"); - } - - @Test - @TestMetadata("kt770.kt351.kt735_StatementType.kt") - public void testKt770_kt351_kt735_StatementType() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlStructures/kt770.kt351.kt735_StatementType.kt"); - } - - @Test - @TestMetadata("kt786.kt") - public void testKt786() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlStructures/kt786.kt"); - } - - @Test - @TestMetadata("kt799.kt") - public void testKt799() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlStructures/kt799.kt"); - } - - @Test - @TestMetadata("lambdasInExclExclAndElvis.kt") - public void testLambdasInExclExclAndElvis() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlStructures/lambdasInExclExclAndElvis.kt"); - } - - @Test - @TestMetadata("localReturnInsidePropertyAccessor.kt") - public void testLocalReturnInsidePropertyAccessor() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlStructures/localReturnInsidePropertyAccessor.kt"); - } - - @Test - @TestMetadata("notAFunctionLabel_after.kt") - public void testNotAFunctionLabel_after() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlStructures/notAFunctionLabel_after.kt"); - } - - @Test - @TestMetadata("notAFunctionLabel_before.kt") - public void testNotAFunctionLabel_before() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlStructures/notAFunctionLabel_before.kt"); - } - - @Test - @TestMetadata("redundantLabel.kt") - public void testRedundantLabel() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlStructures/redundantLabel.kt"); - } - - @Test - @TestMetadata("specialConstructsAndPlatformTypes.kt") - public void testSpecialConstructsAndPlatformTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlStructures/specialConstructsAndPlatformTypes.kt"); - } - - @Test - @TestMetadata("specialConstructsWithNullableExpectedType.kt") - public void testSpecialConstructsWithNullableExpectedType() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlStructures/specialConstructsWithNullableExpectedType.kt"); - } - - @Test - @TestMetadata("tryReturnType.kt") - public void testTryReturnType() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlStructures/tryReturnType.kt"); - } - - @Test - @TestMetadata("typeInferenceForExclExcl.kt") - public void testTypeInferenceForExclExcl() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlStructures/typeInferenceForExclExcl.kt"); - } - - @Test - @TestMetadata("valVarCatchParameter.kt") - public void testValVarCatchParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlStructures/valVarCatchParameter.kt"); - } - - @Test - @TestMetadata("valVarLoopParameter.kt") - public void testValVarLoopParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlStructures/valVarLoopParameter.kt"); - } - - @Test - @TestMetadata("whenInResultOfLambda.kt") - public void testWhenInResultOfLambda() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlStructures/whenInResultOfLambda.kt"); - } - - @Test - @TestMetadata("whenToAnyDiscriminatingUsages.kt") - public void testWhenToAnyDiscriminatingUsages() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlStructures/whenToAnyDiscriminatingUsages.kt"); - } - - @Test - @TestMetadata("when.kt234.kt973.kt") - public void testWhen_kt234_kt973() throws Exception { - runTest("compiler/testData/diagnostics/tests/controlStructures/when.kt234.kt973.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/coroutines") - @TestDataPath("$PROJECT_ROOT") - public class Coroutines extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInCoroutines() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/coroutines"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("suspendInvokeInsideTry.kt") - public void testSuspendInvokeInsideTry() throws Exception { - runTest("compiler/testData/diagnostics/tests/coroutines/suspendInvokeInsideTry.kt"); - } - - @Test - @TestMetadata("suspendInvokeInsideWhen.kt") - public void testSuspendInvokeInsideWhen() throws Exception { - runTest("compiler/testData/diagnostics/tests/coroutines/suspendInvokeInsideWhen.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/coroutines/callableReference") - @TestDataPath("$PROJECT_ROOT") - public class CallableReference extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/coroutines/callableReference"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("invokeOutideSuspend.kt") - public void testInvokeOutideSuspend() throws Exception { - runTest("compiler/testData/diagnostics/tests/coroutines/callableReference/invokeOutideSuspend.kt"); - } - - @Test - @TestMetadata("outsideSuspend.kt") - public void testOutsideSuspend() throws Exception { - runTest("compiler/testData/diagnostics/tests/coroutines/callableReference/outsideSuspend.kt"); - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/cyclicHierarchy") - @TestDataPath("$PROJECT_ROOT") - public class CyclicHierarchy extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInCyclicHierarchy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/cyclicHierarchy"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("classIndirectlyInheritsNested.kt") - public void testClassIndirectlyInheritsNested() throws Exception { - runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/classIndirectlyInheritsNested.kt"); - } - - @Test - @TestMetadata("classInheritsNested.kt") - public void testClassInheritsNested() throws Exception { - runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/classInheritsNested.kt"); - } - - @Test - @TestMetadata("commonSupertypeForCyclicAndUsualTypes.kt") - public void testCommonSupertypeForCyclicAndUsualTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/commonSupertypeForCyclicAndUsualTypes.kt"); - } - - @Test - @TestMetadata("commonSupertypeForCyclicTypes.kt") - public void testCommonSupertypeForCyclicTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/commonSupertypeForCyclicTypes.kt"); - } - - @Test - @TestMetadata("cyclicHierarchy.kt") - public void testCyclicHierarchy() throws Exception { - runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/cyclicHierarchy.kt"); - } - - @Test - @TestMetadata("javaJavaCycle.kt") - public void testJavaJavaCycle() throws Exception { - runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/javaJavaCycle.kt"); - } - - @Test - @TestMetadata("javaJavaNested.kt") - public void testJavaJavaNested() throws Exception { - runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/javaJavaNested.kt"); - } - - @Test - @TestMetadata("javaKotlinJavaCycle.kt") - public void testJavaKotlinJavaCycle() throws Exception { - runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/javaKotlinJavaCycle.kt"); - } - - @Test - @TestMetadata("kotlinJavaCycle.kt") - public void testKotlinJavaCycle() throws Exception { - runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/kotlinJavaCycle.kt"); - } - - @Test - @TestMetadata("kotlinJavaKotlinCycle.kt") - public void testKotlinJavaKotlinCycle() throws Exception { - runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/kotlinJavaKotlinCycle.kt"); - } - - @Test - @TestMetadata("kotlinJavaNestedCycle.kt") - public void testKotlinJavaNestedCycle() throws Exception { - runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/kotlinJavaNestedCycle.kt"); - } - - @Test - @TestMetadata("kt303.kt") - public void testKt303() throws Exception { - runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/kt303.kt"); - } - - @Test - @TestMetadata("nestedClassInSuperClassParameter.kt") - public void testNestedClassInSuperClassParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/nestedClassInSuperClassParameter.kt"); - } - - @Test - @TestMetadata("objectInheritsNested.kt") - public void testObjectInheritsNested() throws Exception { - runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/objectInheritsNested.kt"); - } - - @Test - @TestMetadata("twoClassesWithNestedCycle.kt") - public void testTwoClassesWithNestedCycle() throws Exception { - runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/twoClassesWithNestedCycle.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion") - @TestDataPath("$PROJECT_ROOT") - public class WithCompanion extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInWithCompanion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("everythingInOneScope_after.kt") - public void testEverythingInOneScope_after() throws Exception { - runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion/everythingInOneScope_after.kt"); - } - - @Test - @TestMetadata("everythingInOneScope_before.kt") - public void testEverythingInOneScope_before() throws Exception { - runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion/everythingInOneScope_before.kt"); - } - - @Test - @TestMetadata("noMembers_after.kt") - public void testNoMembers_after() throws Exception { - runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion/noMembers_after.kt"); - } - - @Test - @TestMetadata("noMembers_before.kt") - public void testNoMembers_before() throws Exception { - runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion/noMembers_before.kt"); - } - - @Test - @TestMetadata("onlyInterfaces_after.kt") - public void testOnlyInterfaces_after() throws Exception { - runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion/onlyInterfaces_after.kt"); - } - - @Test - @TestMetadata("onlyInterfaces_before.kt") - public void testOnlyInterfaces_before() throws Exception { - runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion/onlyInterfaces_before.kt"); - } - - @Test - @TestMetadata("typeIsLowEnough.kt") - public void testTypeIsLowEnough() throws Exception { - runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion/typeIsLowEnough.kt"); - } - - @Test - @TestMetadata("withIrrelevantInterface_after.kt") - public void testWithIrrelevantInterface_after() throws Exception { - runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion/withIrrelevantInterface_after.kt"); - } - - @Test - @TestMetadata("withIrrelevantInterface_before.kt") - public void testWithIrrelevantInterface_before() throws Exception { - runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion/withIrrelevantInterface_before.kt"); - } - - @Test - @TestMetadata("withMembers_after.kt") - public void testWithMembers_after() throws Exception { - runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion/withMembers_after.kt"); - } - - @Test - @TestMetadata("withMembers_before.kt") - public void testWithMembers_before() throws Exception { - runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion/withMembers_before.kt"); - } - - @Test - @TestMetadata("withoutTypeReference.kt") - public void testWithoutTypeReference() throws Exception { - runTest("compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion/withoutTypeReference.kt"); - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/dataClasses") - @TestDataPath("$PROJECT_ROOT") - public class DataClasses extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInDataClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/dataClasses"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("componentNamedComponent1.kt") - public void testComponentNamedComponent1() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataClasses/componentNamedComponent1.kt"); - } - - @Test - @TestMetadata("conflictingCopyOverloads.kt") - public void testConflictingCopyOverloads() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataClasses/conflictingCopyOverloads.kt"); - } - - @Test - @TestMetadata("conflictingOverloads.kt") - public void testConflictingOverloads() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataClasses/conflictingOverloads.kt"); - } - - @Test - @TestMetadata("copyOfPrivateClass.kt") - public void testCopyOfPrivateClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataClasses/copyOfPrivateClass.kt"); - } - - @Test - @TestMetadata("dataClassExplicitlyOverridingCopyNoDefaults.kt") - public void testDataClassExplicitlyOverridingCopyNoDefaults() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataClasses/dataClassExplicitlyOverridingCopyNoDefaults.kt"); - } - - @Test - @TestMetadata("dataClassExplicitlyOverridingCopyWithDefaults.kt") - public void testDataClassExplicitlyOverridingCopyWithDefaults() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataClasses/dataClassExplicitlyOverridingCopyWithDefaults.kt"); - } - - @Test - @TestMetadata("dataClassNoName.kt") - public void testDataClassNoName() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataClasses/dataClassNoName.kt"); - } - - @Test - @TestMetadata("dataClassNotOverridingCopy.kt") - public void testDataClassNotOverridingCopy() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataClasses/dataClassNotOverridingCopy.kt"); - } - - @Test - @TestMetadata("dataClassOverridingCopy_lv12.kt") - public void testDataClassOverridingCopy_lv12() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataClasses/dataClassOverridingCopy_lv12.kt"); - } - - @Test - @TestMetadata("dataClassOverridingCopy_lv13.kt") - public void testDataClassOverridingCopy_lv13() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataClasses/dataClassOverridingCopy_lv13.kt"); - } - - @Test - @TestMetadata("dataClassVarargParam.kt") - public void testDataClassVarargParam() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataClasses/dataClassVarargParam.kt"); - } - - @Test - @TestMetadata("dataInheritance.kt") - public void testDataInheritance() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataClasses/dataInheritance.kt"); - } - - @Test - @TestMetadata("dataObject.kt") - public void testDataObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataClasses/dataObject.kt"); - } - - @Test - @TestMetadata("emptyConstructor.kt") - public void testEmptyConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataClasses/emptyConstructor.kt"); - } - - @Test - @TestMetadata("errorTypesInDataClasses.kt") - public void testErrorTypesInDataClasses() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataClasses/errorTypesInDataClasses.kt"); - } - - @Test - @TestMetadata("extensionComponentsOnNullable.kt") - public void testExtensionComponentsOnNullable() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataClasses/extensionComponentsOnNullable.kt"); - } - - @Test - @TestMetadata("finalMembersInBaseClass.kt") - public void testFinalMembersInBaseClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataClasses/finalMembersInBaseClass.kt"); - } - - @Test - @TestMetadata("implementMethodsFromInterface.kt") - public void testImplementMethodsFromInterface() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataClasses/implementMethodsFromInterface.kt"); - } - - @Test - @TestMetadata("implementTraitWhichHasComponent1.kt") - public void testImplementTraitWhichHasComponent1() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataClasses/implementTraitWhichHasComponent1.kt"); - } - - @Test - @TestMetadata("implementTraitWhichHasFinalComponent1.kt") - public void testImplementTraitWhichHasFinalComponent1() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataClasses/implementTraitWhichHasFinalComponent1.kt"); - } - - @Test - @TestMetadata("innerDataClass.kt") - public void testInnerDataClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataClasses/innerDataClass.kt"); - } - - @Test - @TestMetadata("innerOuterDataClass.kt") - public void testInnerOuterDataClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataClasses/innerOuterDataClass.kt"); - } - - @Test - @TestMetadata("multiDeclaration.kt") - public void testMultiDeclaration() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataClasses/multiDeclaration.kt"); - } - - @Test - @TestMetadata("multiDeclarationFor.kt") - public void testMultiDeclarationFor() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataClasses/multiDeclarationFor.kt"); - } - - @Test - @TestMetadata("noConstructor.kt") - public void testNoConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataClasses/noConstructor.kt"); - } - - @Test - @TestMetadata("notADataClass.kt") - public void testNotADataClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataClasses/notADataClass.kt"); - } - - @Test - @TestMetadata("oneValParam.kt") - public void testOneValParam() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataClasses/oneValParam.kt"); - } - - @Test - @TestMetadata("repeatedProperties.kt") - public void testRepeatedProperties() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataClasses/repeatedProperties.kt"); - } - - @Test - @TestMetadata("sealedDataClass.kt") - public void testSealedDataClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataClasses/sealedDataClass.kt"); - } - - @Test - @TestMetadata("strange.kt") - public void testStrange() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataClasses/strange.kt"); - } - - @Test - @TestMetadata("twoValParams.kt") - public void testTwoValParams() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataClasses/twoValParams.kt"); - } - - @Test - @TestMetadata("twoVarParams.kt") - public void testTwoVarParams() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataClasses/twoVarParams.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/dataFlow") - @TestDataPath("$PROJECT_ROOT") - public class DataFlow extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInDataFlow() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/dataFlow"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("CalleeExpression.kt") - public void testCalleeExpression() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlow/CalleeExpression.kt"); - } - - @Test - @TestMetadata("EmptyIf.kt") - public void testEmptyIf() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlow/EmptyIf.kt"); - } - - @Test - @TestMetadata("IsExpression.kt") - public void testIsExpression() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlow/IsExpression.kt"); - } - - @Test - @TestMetadata("WhenSubject.kt") - public void testWhenSubject() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlow/WhenSubject.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/dataFlow/assignment") - @TestDataPath("$PROJECT_ROOT") - public class Assignment extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInAssignment() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/dataFlow/assignment"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("assignToNewVal.kt") - public void testAssignToNewVal() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlow/assignment/assignToNewVal.kt"); - } - - @Test - @TestMetadata("kt6118.kt") - public void testKt6118() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlow/assignment/kt6118.kt"); - } - - @Test - @TestMetadata("uninitializedValIsCheck.kt") - public void testUninitializedValIsCheck() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlow/assignment/uninitializedValIsCheck.kt"); - } - - @Test - @TestMetadata("uninitializedValNullability.kt") - public void testUninitializedValNullability() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlow/assignment/uninitializedValNullability.kt"); - } - - @Test - @TestMetadata("when.kt") - public void testWhen() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlow/assignment/when.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/dataFlow/local") - @TestDataPath("$PROJECT_ROOT") - public class Local extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInLocal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/dataFlow/local"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("kt2835.kt") - public void testKt2835() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlow/local/kt2835.kt"); - } - - @Test - @TestMetadata("LocalClassBase.kt") - public void testLocalClassBase() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlow/local/LocalClassBase.kt"); - } - - @Test - @TestMetadata("LocalClassDefaultParameters.kt") - public void testLocalClassDefaultParameters() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlow/local/LocalClassDefaultParameters.kt"); - } - - @Test - @TestMetadata("LocalClassDelegatedProperties.kt") - public void testLocalClassDelegatedProperties() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlow/local/LocalClassDelegatedProperties.kt"); - } - - @Test - @TestMetadata("LocalClassDelegation.kt") - public void testLocalClassDelegation() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlow/local/LocalClassDelegation.kt"); - } - - @Test - @TestMetadata("LocalClassFunctions.kt") - public void testLocalClassFunctions() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlow/local/LocalClassFunctions.kt"); - } - - @Test - @TestMetadata("LocalClassInMemberOfLocalClass.kt") - public void testLocalClassInMemberOfLocalClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlow/local/LocalClassInMemberOfLocalClass.kt"); - } - - @Test - @TestMetadata("LocalClassInitializer.kt") - public void testLocalClassInitializer() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlow/local/LocalClassInitializer.kt"); - } - - @Test - @TestMetadata("LocalClassProperty.kt") - public void testLocalClassProperty() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlow/local/LocalClassProperty.kt"); - } - - @Test - @TestMetadata("LocalObject.kt") - public void testLocalObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlow/local/LocalObject.kt"); - } - - @Test - @TestMetadata("LocalObjectDelegation.kt") - public void testLocalObjectDelegation() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlow/local/LocalObjectDelegation.kt"); - } - - @Test - @TestMetadata("NestedLocalClass.kt") - public void testNestedLocalClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlow/local/NestedLocalClass.kt"); - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal") - @TestDataPath("$PROJECT_ROOT") - public class DataFlowInfoTraversal extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInDataFlowInfoTraversal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/dataFlowInfoTraversal"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("AndOr.kt") - public void testAndOr() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/AndOr.kt"); - } - - @Test - @TestMetadata("ArrayAccess.kt") - public void testArrayAccess() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ArrayAccess.kt"); - } - - @Test - @TestMetadata("ArrayExpression.kt") - public void testArrayExpression() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ArrayExpression.kt"); - } - - @Test - @TestMetadata("ArrayGetSetConvention.kt") - public void testArrayGetSetConvention() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ArrayGetSetConvention.kt"); - } - - @Test - @TestMetadata("ArrayIndices.kt") - public void testArrayIndices() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ArrayIndices.kt"); - } - - @Test - @TestMetadata("Assignment.kt") - public void testAssignment() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/Assignment.kt"); - } - - @Test - @TestMetadata("AssignmentInInitializer.kt") - public void testAssignmentInInitializer() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/AssignmentInInitializer.kt"); - } - - @Test - @TestMetadata("AssignmentOperation.kt") - public void testAssignmentOperation() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/AssignmentOperation.kt"); - } - - @Test - @TestMetadata("AssignmentToArrayElement.kt") - public void testAssignmentToArrayElement() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/AssignmentToArrayElement.kt"); - } - - @Test - @TestMetadata("BinaryExpression.kt") - public void testBinaryExpression() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpression.kt"); - } - - @Test - @TestMetadata("BinaryExpressionBooleanOperations.kt") - public void testBinaryExpressionBooleanOperations() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpressionBooleanOperations.kt"); - } - - @Test - @TestMetadata("BinaryExpressionCompareToConvention.kt") - public void testBinaryExpressionCompareToConvention() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpressionCompareToConvention.kt"); - } - - @Test - @TestMetadata("BinaryExpressionContainsConvention.kt") - public void testBinaryExpressionContainsConvention() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpressionContainsConvention.kt"); - } - - @Test - @TestMetadata("BinaryExpressionElvis.kt") - public void testBinaryExpressionElvis() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpressionElvis.kt"); - } - - @Test - @TestMetadata("BinaryExpressionEqualsConvention.kt") - public void testBinaryExpressionEqualsConvention() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpressionEqualsConvention.kt"); - } - - @Test - @TestMetadata("BinaryExpressionIdentifier.kt") - public void testBinaryExpressionIdentifier() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpressionIdentifier.kt"); - } - - @Test - @TestMetadata("BinaryExpressionPlusConvention.kt") - public void testBinaryExpressionPlusConvention() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/BinaryExpressionPlusConvention.kt"); - } - - @Test - @TestMetadata("Condition.kt") - public void testCondition() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/Condition.kt"); - } - - @Test - @TestMetadata("ContinueOuterLoop.kt") - public void testContinueOuterLoop() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ContinueOuterLoop.kt"); - } - - @Test - @TestMetadata("DeepIf.kt") - public void testDeepIf() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/DeepIf.kt"); - } - - @Test - @TestMetadata("DoWhile.kt") - public void testDoWhile() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/DoWhile.kt"); - } - - @Test - @TestMetadata("DoWhileCondition.kt") - public void testDoWhileCondition() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/DoWhileCondition.kt"); - } - - @Test - @TestMetadata("Elvis.kt") - public void testElvis() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/Elvis.kt"); - } - - @Test - @TestMetadata("ExclExcl.kt") - public void testExclExcl() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ExclExcl.kt"); - } - - @Test - @TestMetadata("For.kt") - public void testFor() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/For.kt"); - } - - @Test - @TestMetadata("ForLoopRange.kt") - public void testForLoopRange() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ForLoopRange.kt"); - } - - @Test - @TestMetadata("FunctionLiteral.kt") - public void testFunctionLiteral() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/FunctionLiteral.kt"); - } - - @Test - @TestMetadata("IfStatement.kt") - public void testIfStatement() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/IfStatement.kt"); - } - - @Test - @TestMetadata("IfThenElse.kt") - public void testIfThenElse() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/IfThenElse.kt"); - } - - @Test - @TestMetadata("IfThenElseBothInvalid.kt") - public void testIfThenElseBothInvalid() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/IfThenElseBothInvalid.kt"); - } - - @Test - @TestMetadata("IsExpression.kt") - public void testIsExpression() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/IsExpression.kt"); - } - - @Test - @TestMetadata("kt4332WhenBranches.kt") - public void testKt4332WhenBranches() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/kt4332WhenBranches.kt"); - } - - @Test - @TestMetadata("kt5155WhenBranches.kt") - public void testKt5155WhenBranches() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/kt5155WhenBranches.kt"); - } - - @Test - @TestMetadata("kt5182WhenBranches.kt") - public void testKt5182WhenBranches() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/kt5182WhenBranches.kt"); - } - - @Test - @TestMetadata("ManyIfs.kt") - public void testManyIfs() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ManyIfs.kt"); - } - - @Test - @TestMetadata("MultiDeclaration.kt") - public void testMultiDeclaration() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/MultiDeclaration.kt"); - } - - @Test - @TestMetadata("ObjectExpression.kt") - public void testObjectExpression() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ObjectExpression.kt"); - } - - @Test - @TestMetadata("QualifiedExpression.kt") - public void testQualifiedExpression() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/QualifiedExpression.kt"); - } - - @Test - @TestMetadata("Return.kt") - public void testReturn() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/Return.kt"); - } - - @Test - @TestMetadata("StringTemplate.kt") - public void testStringTemplate() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/StringTemplate.kt"); - } - - @Test - @TestMetadata("ThisSuper.kt") - public void testThisSuper() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ThisSuper.kt"); - } - - @Test - @TestMetadata("Throw.kt") - public void testThrow() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/Throw.kt"); - } - - @Test - @TestMetadata("TryCatch.kt") - public void testTryCatch() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/TryCatch.kt"); - } - - @Test - @TestMetadata("TryFinally.kt") - public void testTryFinally() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/TryFinally.kt"); - } - - @Test - @TestMetadata("UnaryExpression.kt") - public void testUnaryExpression() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/UnaryExpression.kt"); - } - - @Test - @TestMetadata("When.kt") - public void testWhen() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/When.kt"); - } - - @Test - @TestMetadata("WhenEntryAs.kt") - public void testWhenEntryAs() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/WhenEntryAs.kt"); - } - - @Test - @TestMetadata("WhenEntryIs.kt") - public void testWhenEntryIs() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/WhenEntryIs.kt"); - } - - @Test - @TestMetadata("WhenIn.kt") - public void testWhenIn() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/WhenIn.kt"); - } - - @Test - @TestMetadata("WhenSubject.kt") - public void testWhenSubject() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/WhenSubject.kt"); - } - - @Test - @TestMetadata("While.kt") - public void testWhile() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/While.kt"); - } - - @Test - @TestMetadata("WhileCondition.kt") - public void testWhileCondition() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/WhileCondition.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/smartcasts") - @TestDataPath("$PROJECT_ROOT") - public class Smartcasts extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInSmartcasts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/smartcasts"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("SmartcastAmbiguitites.kt") - public void testSmartcastAmbiguitites() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/smartcasts/SmartcastAmbiguitites.kt"); - } - - @Test - @TestMetadata("SmartcastsForStableIdentifiers.kt") - public void testSmartcastsForStableIdentifiers() throws Exception { - runTest("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/smartcasts/SmartcastsForStableIdentifiers.kt"); - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/declarationChecks") - @TestDataPath("$PROJECT_ROOT") - public class DeclarationChecks extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInDeclarationChecks() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/declarationChecks"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("ambiguousObjectExpressionType.kt") - public void testAmbiguousObjectExpressionType() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/ambiguousObjectExpressionType.kt"); - } - - @Test - @TestMetadata("anonymousFunAsLastExpressionInBlock.kt") - public void testAnonymousFunAsLastExpressionInBlock() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/anonymousFunAsLastExpressionInBlock.kt"); - } - - @Test - @TestMetadata("anonymousFunUnusedLastExpressionInBlock.kt") - public void testAnonymousFunUnusedLastExpressionInBlock() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/anonymousFunUnusedLastExpressionInBlock.kt"); - } - - @Test - @TestMetadata("ComponentFunctionReturnTypeMismatch.kt") - public void testComponentFunctionReturnTypeMismatch() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/ComponentFunctionReturnTypeMismatch.kt"); - } - - @Test - @TestMetadata("ConflictingAndRedundantProjections.kt") - public void testConflictingAndRedundantProjections() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/ConflictingAndRedundantProjections.kt"); - } - - @Test - @TestMetadata("DataFlowInMultiDeclInFor.kt") - public void testDataFlowInMultiDeclInFor() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/DataFlowInMultiDeclInFor.kt"); - } - - @Test - @TestMetadata("DataFlowInfoInMultiDecl.kt") - public void testDataFlowInfoInMultiDecl() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/DataFlowInfoInMultiDecl.kt"); - } - - @Test - @TestMetadata("FunctionWithMissingNames.kt") - public void testFunctionWithMissingNames() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/FunctionWithMissingNames.kt"); - } - - @Test - @TestMetadata("illegalModifiersOnClass.kt") - public void testIllegalModifiersOnClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/illegalModifiersOnClass.kt"); - } - - @Test - @TestMetadata("kClassInSignature.kt") - public void testKClassInSignature() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/kClassInSignature.kt"); - } - - @Test - @TestMetadata("kt1141.kt") - public void testKt1141() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/kt1141.kt"); - } - - @Test - @TestMetadata("kt1193.kt") - public void testKt1193() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/kt1193.kt"); - } - - @Test - @TestMetadata("kt2096.kt") - public void testKt2096() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/kt2096.kt"); - } - - @Test - @TestMetadata("kt2142.kt") - public void testKt2142() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/kt2142.kt"); - } - - @Test - @TestMetadata("kt2397.kt") - public void testKt2397() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/kt2397.kt"); - } - - @Test - @TestMetadata("kt2631_MultipleDeclaration.kt") - public void testKt2631_MultipleDeclaration() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/kt2631_MultipleDeclaration.kt"); - } - - @Test - @TestMetadata("kt2643MultiDeclInControlFlow.kt") - public void testKt2643MultiDeclInControlFlow() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/kt2643MultiDeclInControlFlow.kt"); - } - - @Test - @TestMetadata("kt559.kt") - public void testKt559() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/kt559.kt"); - } - - @Test - @TestMetadata("localDeclarationModifiers.kt") - public void testLocalDeclarationModifiers() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/localDeclarationModifiers.kt"); - } - - @Test - @TestMetadata("localFunctionNoInheritVisibility.kt") - public void testLocalFunctionNoInheritVisibility() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/localFunctionNoInheritVisibility.kt"); - } - - @Test - @TestMetadata("LocalVariableWithNoTypeInformation.kt") - public void testLocalVariableWithNoTypeInformation() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/LocalVariableWithNoTypeInformation.kt"); - } - - @Test - @TestMetadata("localVariablesWithTypeParameters_1_3.kt") - public void testLocalVariablesWithTypeParameters_1_3() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/localVariablesWithTypeParameters_1_3.kt"); - } - - @Test - @TestMetadata("localVariablesWithTypeParameters_1_4.kt") - public void testLocalVariablesWithTypeParameters_1_4() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/localVariablesWithTypeParameters_1_4.kt"); - } - - @Test - @TestMetadata("mulitpleVarargParameters.kt") - public void testMulitpleVarargParameters() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/mulitpleVarargParameters.kt"); - } - - @Test - @TestMetadata("MultiDeclarationErrors.kt") - public void testMultiDeclarationErrors() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/MultiDeclarationErrors.kt"); - } - - @Test - @TestMetadata("nameWithDangerousCharacters.kt") - public void testNameWithDangerousCharacters() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/nameWithDangerousCharacters.kt"); - } - - @Test - @TestMetadata("namedFunAsLastExpressionInBlock.kt") - public void testNamedFunAsLastExpressionInBlock() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/namedFunAsLastExpressionInBlock.kt"); - } - - @Test - @TestMetadata("packageDeclarationModifiers.kt") - public void testPackageDeclarationModifiers() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/packageDeclarationModifiers.kt"); - } - - @Test - @TestMetadata("propertyInPackageHasNoInheritVisibility.kt") - public void testPropertyInPackageHasNoInheritVisibility() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/propertyInPackageHasNoInheritVisibility.kt"); - } - - @Test - @TestMetadata("RedeclarationsInMultiDecl.kt") - public void testRedeclarationsInMultiDecl() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/RedeclarationsInMultiDecl.kt"); - } - - @Test - @TestMetadata("ScalaLikeNamedFun.kt") - public void testScalaLikeNamedFun() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/ScalaLikeNamedFun.kt"); - } - - @Test - @TestMetadata("sealedOnMembers.kt") - public void testSealedOnMembers() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/sealedOnMembers.kt"); - } - - @Test - @TestMetadata("unambiguousObjectExpressionType.kt") - public void testUnambiguousObjectExpressionType() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/unambiguousObjectExpressionType.kt"); - } - - @Test - @TestMetadata("valVarFunctionParameter.kt") - public void testValVarFunctionParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/valVarFunctionParameter.kt"); - } - - @Test - @TestMetadata("VarianceOnFunctionAndPropertyTypeParameters.kt") - public void testVarianceOnFunctionAndPropertyTypeParameters() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/VarianceOnFunctionAndPropertyTypeParameters.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations") - @TestDataPath("$PROJECT_ROOT") - public class DestructuringDeclarations extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInDestructuringDeclarations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("destructuringDeclarationAssignedUnresolved.kt") - public void testDestructuringDeclarationAssignedUnresolved() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/destructuringDeclarationAssignedUnresolved.kt"); - } - - @Test - @TestMetadata("destructuringDeclarationMissingInitializer.kt") - public void testDestructuringDeclarationMissingInitializer() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/destructuringDeclarationMissingInitializer.kt"); - } - - @Test - @TestMetadata("DoubleDeclForLoop.kt") - public void testDoubleDeclForLoop() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/DoubleDeclForLoop.kt"); - } - - @Test - @TestMetadata("FolLoopTypeComponentTypeMismatch.kt") - public void testFolLoopTypeComponentTypeMismatch() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/FolLoopTypeComponentTypeMismatch.kt"); - } - - @Test - @TestMetadata("ForLoopComponentFunctionAmbiguity.kt") - public void testForLoopComponentFunctionAmbiguity() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/ForLoopComponentFunctionAmbiguity.kt"); - } - - @Test - @TestMetadata("ForLoopComponentFunctionMissing.kt") - public void testForLoopComponentFunctionMissing() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/ForLoopComponentFunctionMissing.kt"); - } - - @Test - @TestMetadata("ForLoopMissingLoopParameter.kt") - public void testForLoopMissingLoopParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/ForLoopMissingLoopParameter.kt"); - } - - @Test - @TestMetadata("ForLoopWithExtensions.kt") - public void testForLoopWithExtensions() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/ForLoopWithExtensions.kt"); - } - - @Test - @TestMetadata("ForWithExplicitTypes.kt") - public void testForWithExplicitTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/ForWithExplicitTypes.kt"); - } - - @Test - @TestMetadata("kt2829.kt") - public void testKt2829() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/kt2829.kt"); - } - - @Test - @TestMetadata("lastDestructuringDeclarationInBlock.kt") - public void testLastDestructuringDeclarationInBlock() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/lastDestructuringDeclarationInBlock.kt"); - } - - @Test - @TestMetadata("RedeclarationInForLoop.kt") - public void testRedeclarationInForLoop() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/RedeclarationInForLoop.kt"); - } - - @Test - @TestMetadata("SingleDeclForLoop.kt") - public void testSingleDeclForLoop() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/SingleDeclForLoop.kt"); - } - - @Test - @TestMetadata("underscore.kt") - public void testUnderscore() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/underscore.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/declarationChecks/finiteBoundRestriction") - @TestDataPath("$PROJECT_ROOT") - public class FiniteBoundRestriction extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInFiniteBoundRestriction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/declarationChecks/finiteBoundRestriction"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("CasesWithOneTypeParameter.kt") - public void testCasesWithOneTypeParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/finiteBoundRestriction/CasesWithOneTypeParameter.kt"); - } - - @Test - @TestMetadata("CasesWithTwoTypeParameters.kt") - public void testCasesWithTwoTypeParameters() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/finiteBoundRestriction/CasesWithTwoTypeParameters.kt"); - } - - @Test - @TestMetadata("JavaSuperType.kt") - public void testJavaSuperType() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/finiteBoundRestriction/JavaSuperType.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/declarationChecks/nonExpansiveInheritanceRestriction") - @TestDataPath("$PROJECT_ROOT") - public class NonExpansiveInheritanceRestriction extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInNonExpansiveInheritanceRestriction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/declarationChecks/nonExpansiveInheritanceRestriction"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("JavaWithKotlin.kt") - public void testJavaWithKotlin() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/nonExpansiveInheritanceRestriction/JavaWithKotlin.kt"); - } - - @Test - @TestMetadata("JavaWithKotlin2.kt") - public void testJavaWithKotlin2() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/nonExpansiveInheritanceRestriction/JavaWithKotlin2.kt"); - } - - @Test - @TestMetadata("PureKotlin.kt") - public void testPureKotlin() throws Exception { - runTest("compiler/testData/diagnostics/tests/declarationChecks/nonExpansiveInheritanceRestriction/PureKotlin.kt"); - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/defaultArguments") - @TestDataPath("$PROJECT_ROOT") - public class DefaultArguments extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInDefaultArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/defaultArguments"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("kt5232.kt") - public void testKt5232() throws Exception { - runTest("compiler/testData/diagnostics/tests/defaultArguments/kt5232.kt"); - } - - @Test - @TestMetadata("superCall.kt") - public void testSuperCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/defaultArguments/superCall.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/delegatedProperty") - @TestDataPath("$PROJECT_ROOT") - public class DelegatedProperty extends AbstractDiagnosticUsingJavacTest { - @Test - @TestMetadata("absentErrorAboutInitializer.kt") - public void testAbsentErrorAboutInitializer() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/absentErrorAboutInitializer.kt"); - } - - @Test - @TestMetadata("absentErrorAboutType.kt") - public void testAbsentErrorAboutType() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/absentErrorAboutType.kt"); - } - - @Test - @TestMetadata("abstractDelegatedProperty.kt") - public void testAbstractDelegatedProperty() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/abstractDelegatedProperty.kt"); - } - - @Test - public void testAllFilesPresentInDelegatedProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/delegatedProperty"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("backingField.kt") - public void testBackingField() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/backingField.kt"); - } - - @Test - @TestMetadata("defaultGetter.kt") - public void testDefaultGetter() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/defaultGetter.kt"); - } - - @Test - @TestMetadata("defaultSetter.kt") - public void testDefaultSetter() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/defaultSetter.kt"); - } - - @Test - @TestMetadata("delegatedPropertyOverridedInTrait.kt") - public void testDelegatedPropertyOverridedInTrait() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/delegatedPropertyOverridedInTrait.kt"); - } - - @Test - @TestMetadata("delegatedPropertyOverridedInTraitTypeMismatch.kt") - public void testDelegatedPropertyOverridedInTraitTypeMismatch() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/delegatedPropertyOverridedInTraitTypeMismatch.kt"); - } - - @Test - @TestMetadata("disallowImplInTypeParameter.kt") - public void testDisallowImplInTypeParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/disallowImplInTypeParameter.kt"); - } - - @Test - @TestMetadata("genericGetter.kt") - public void testGenericGetter() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/genericGetter.kt"); - } - - @Test - @TestMetadata("getterWithSubtype.kt") - public void testGetterWithSubtype() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/getterWithSubtype.kt"); - } - - @Test - @TestMetadata("inTrait.kt") - public void testInTrait() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/inTrait.kt"); - } - - @Test - @TestMetadata("incompleteTypeInference.kt") - public void testIncompleteTypeInference() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/incompleteTypeInference.kt"); - } - - @Test - @TestMetadata("kt4640.kt") - public void testKt4640() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/kt4640.kt"); - } - - @Test - @TestMetadata("localVariable.kt") - public void testLocalVariable() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/localVariable.kt"); - } - - @Test - @TestMetadata("localWithSmartCast.kt") - public void testLocalWithSmartCast() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/localWithSmartCast.kt"); - } - - @Test - @TestMetadata("missedGetter.kt") - public void testMissedGetter() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/missedGetter.kt"); - } - - @Test - @TestMetadata("missedSetter.kt") - public void testMissedSetter() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/missedSetter.kt"); - } - - @Test - @TestMetadata("nonDefaultAccessors.kt") - public void testNonDefaultAccessors() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/nonDefaultAccessors.kt"); - } - - @Test - @TestMetadata("propertyDefferedType.kt") - public void testPropertyDefferedType() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/propertyDefferedType.kt"); - } - - @Test - @TestMetadata("recursiveType.kt") - public void testRecursiveType() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/recursiveType.kt"); - } - - @Test - @TestMetadata("redundantGetter.kt") - public void testRedundantGetter() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/redundantGetter.kt"); - } - - @Test - @TestMetadata("redundantSetter.kt") - public void testRedundantSetter() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/redundantSetter.kt"); - } - - @Test - @TestMetadata("setterThisTypeMismatch.kt") - public void testSetterThisTypeMismatch() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/setterThisTypeMismatch.kt"); - } - - @Test - @TestMetadata("setterWithSupertype.kt") - public void testSetterWithSupertype() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/setterWithSupertype.kt"); - } - - @Test - @TestMetadata("severalReceivers.kt") - public void testSeveralReceivers() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/severalReceivers.kt"); - } - - @Test - @TestMetadata("thisInDelegate.kt") - public void testThisInDelegate() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/thisInDelegate.kt"); - } - - @Test - @TestMetadata("thisOfAnyType.kt") - public void testThisOfAnyType() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/thisOfAnyType.kt"); - } - - @Test - @TestMetadata("thisOfNothingNullableType.kt") - public void testThisOfNothingNullableType() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/thisOfNothingNullableType.kt"); - } - - @Test - @TestMetadata("thisOfNothingType.kt") - public void testThisOfNothingType() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/thisOfNothingType.kt"); - } - - @Test - @TestMetadata("twoGetMethods.kt") - public void testTwoGetMethods() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/twoGetMethods.kt"); - } - - @Test - @TestMetadata("typeMismatchForGetReturnType.kt") - public void testTypeMismatchForGetReturnType() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/typeMismatchForGetReturnType.kt"); - } - - @Test - @TestMetadata("typeMismatchForGetWithGeneric.kt") - public void testTypeMismatchForGetWithGeneric() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/typeMismatchForGetWithGeneric.kt"); - } - - @Test - @TestMetadata("typeMismatchForSetParameter.kt") - public void testTypeMismatchForSetParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/typeMismatchForSetParameter.kt"); - } - - @Test - @TestMetadata("typeMismatchForThisGetParameter.kt") - public void testTypeMismatchForThisGetParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/typeMismatchForThisGetParameter.kt"); - } - - @Test - @TestMetadata("wrongCountOfParametersInGet.kt") - public void testWrongCountOfParametersInGet() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/wrongCountOfParametersInGet.kt"); - } - - @Test - @TestMetadata("wrongCountOfParametersInSet.kt") - public void testWrongCountOfParametersInSet() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/wrongCountOfParametersInSet.kt"); - } - - @Test - @TestMetadata("wrongSetterReturnType.kt") - public void testWrongSetterReturnType() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/wrongSetterReturnType.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/delegatedProperty/inference") - @TestDataPath("$PROJECT_ROOT") - public class Inference extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInInference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/delegatedProperty/inference"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("callableReferenceArgumentInDelegatedExpression.kt") - public void testCallableReferenceArgumentInDelegatedExpression() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/inference/callableReferenceArgumentInDelegatedExpression.kt"); - } - - @Test - @TestMetadata("delegateExpressionAsLambda.kt") - public void testDelegateExpressionAsLambda() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/inference/delegateExpressionAsLambda.kt"); - } - - @Test - @TestMetadata("delegatedExpressionWithLabeledReturnInsideLambda.kt") - public void testDelegatedExpressionWithLabeledReturnInsideLambda() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/inference/delegatedExpressionWithLabeledReturnInsideLambda.kt"); - } - - @Test - @TestMetadata("differentDelegatedExpressions.kt") - public void testDifferentDelegatedExpressions() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/inference/differentDelegatedExpressions.kt"); - } - - @Test - @TestMetadata("extensionGet.kt") - public void testExtensionGet() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/inference/extensionGet.kt"); - } - - @Test - @TestMetadata("extensionProperty.kt") - public void testExtensionProperty() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/inference/extensionProperty.kt"); - } - - @Test - @TestMetadata("genericMethodInGenericClass.kt") - public void testGenericMethodInGenericClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/inference/genericMethodInGenericClass.kt"); - } - - @Test - @TestMetadata("genericMethods.kt") - public void testGenericMethods() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/inference/genericMethods.kt"); - } - - @Test - @TestMetadata("labeledDelegatedExpression.kt") - public void testLabeledDelegatedExpression() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/inference/labeledDelegatedExpression.kt"); - } - - @Test - @TestMetadata("manyIncompleteCandidates.kt") - public void testManyIncompleteCandidates() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/inference/manyIncompleteCandidates.kt"); - } - - @Test - @TestMetadata("noErrorsForImplicitConstraints.kt") - public void testNoErrorsForImplicitConstraints() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/inference/noErrorsForImplicitConstraints.kt"); - } - - @Test - @TestMetadata("noExpectedTypeForSupertypeConstraint.kt") - public void testNoExpectedTypeForSupertypeConstraint() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/inference/noExpectedTypeForSupertypeConstraint.kt"); - } - - @Test - @TestMetadata("resultTypeOfLambdaForConventionMethods.kt") - public void testResultTypeOfLambdaForConventionMethods() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/inference/resultTypeOfLambdaForConventionMethods.kt"); - } - - @Test - @TestMetadata("typeOfLazyDelegatedPropertyWithObject.kt") - public void testTypeOfLazyDelegatedPropertyWithObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/inference/typeOfLazyDelegatedPropertyWithObject.kt"); - } - - @Test - @TestMetadata("useCompleterWithoutExpectedType.kt") - public void testUseCompleterWithoutExpectedType() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/inference/useCompleterWithoutExpectedType.kt"); - } - - @Test - @TestMetadata("useExpectedType.kt") - public void testUseExpectedType() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/inference/useExpectedType.kt"); - } - - @Test - @TestMetadata("useExpectedTypeForVal.kt") - public void testUseExpectedTypeForVal() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/inference/useExpectedTypeForVal.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate") - @TestDataPath("$PROJECT_ROOT") - public class ProvideDelegate extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInProvideDelegate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("commonCaseForInference.kt") - public void testCommonCaseForInference() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/commonCaseForInference.kt"); - } - - @Test - @TestMetadata("genericProvideDelegate.kt") - public void testGenericProvideDelegate() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/genericProvideDelegate.kt"); - } - - @Test - @TestMetadata("hostAndReceiver1.kt") - public void testHostAndReceiver1() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/hostAndReceiver1.kt"); - } - - @Test - @TestMetadata("hostAndReceiver2.kt") - public void testHostAndReceiver2() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/hostAndReceiver2.kt"); - } - - @Test - @TestMetadata("hostAndReceiver3.kt") - public void testHostAndReceiver3() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/hostAndReceiver3.kt"); - } - - @Test - @TestMetadata("inferenceFromReceiver1.kt") - public void testInferenceFromReceiver1() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/inferenceFromReceiver1.kt"); - } - - @Test - @TestMetadata("inferenceFromReceiver2.kt") - public void testInferenceFromReceiver2() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/inferenceFromReceiver2.kt"); - } - - @Test - @TestMetadata("kt38714.kt") - public void testKt38714() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/kt38714.kt"); - } - - @Test - @TestMetadata("localDelegatedProperty.kt") - public void testLocalDelegatedProperty() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/localDelegatedProperty.kt"); - } - - @Test - @TestMetadata("noOperatorModifierOnProvideDelegate.kt") - public void testNoOperatorModifierOnProvideDelegate() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/noOperatorModifierOnProvideDelegate.kt"); - } - - @Test - @TestMetadata("overloadResolutionForSeveralProvideDelegates.kt") - public void testOverloadResolutionForSeveralProvideDelegates() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/overloadResolutionForSeveralProvideDelegates.kt"); - } - - @Test - @TestMetadata("provideDelegateOnFunctionalTypeWithThis.kt") - public void testProvideDelegateOnFunctionalTypeWithThis() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/provideDelegateOnFunctionalTypeWithThis.kt"); - } - - @Test - @TestMetadata("provideDelegateOperatorDeclaration.kt") - public void testProvideDelegateOperatorDeclaration() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/provideDelegateOperatorDeclaration.kt"); - } - - @Test - @TestMetadata("provideDelegateResolutionWithStubTypes.kt") - public void testProvideDelegateResolutionWithStubTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/provideDelegateResolutionWithStubTypes.kt"); - } - - @Test - @TestMetadata("setValue.kt") - public void testSetValue() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/setValue.kt"); - } - - @Test - @TestMetadata("simpleProvideDelegate.kt") - public void testSimpleProvideDelegate() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/simpleProvideDelegate.kt"); - } - - @Test - @TestMetadata("unsupportedOperatorProvideDelegate.kt") - public void testUnsupportedOperatorProvideDelegate() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/unsupportedOperatorProvideDelegate.kt"); - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/delegation") - @TestDataPath("$PROJECT_ROOT") - public class Delegation extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInDelegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/delegation"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("DelegationAndOverriding.kt") - public void testDelegationAndOverriding() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegation/DelegationAndOverriding.kt"); - } - - @Test - @TestMetadata("DelegationExpectedType.kt") - public void testDelegationExpectedType() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegation/DelegationExpectedType.kt"); - } - - @Test - @TestMetadata("DelegationNotTotrait.kt") - public void testDelegationNotTotrait() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegation/DelegationNotTotrait.kt"); - } - - @Test - @TestMetadata("DelegationToJavaIface.kt") - public void testDelegationToJavaIface() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegation/DelegationToJavaIface.kt"); - } - - @Test - @TestMetadata("Delegation_ClashingFunctions.kt") - public void testDelegation_ClashingFunctions() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegation/Delegation_ClashingFunctions.kt"); - } - - @Test - @TestMetadata("Delegation_Hierarchy.kt") - public void testDelegation_Hierarchy() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegation/Delegation_Hierarchy.kt"); - } - - @Test - @TestMetadata("Delegation_MultipleDelegates.kt") - public void testDelegation_MultipleDelegates() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegation/Delegation_MultipleDelegates.kt"); - } - - @Test - @TestMetadata("Delegation_ScopeInitializationOrder.kt") - public void testDelegation_ScopeInitializationOrder() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegation/Delegation_ScopeInitializationOrder.kt"); - } - - @Test - @TestMetadata("kt8154.kt") - public void testKt8154() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegation/kt8154.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/delegation/clashes") - @TestDataPath("$PROJECT_ROOT") - public class Clashes extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInClashes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/delegation/clashes"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("finalMemberOverridden.kt") - public void testFinalMemberOverridden() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegation/clashes/finalMemberOverridden.kt"); - } - - @Test - @TestMetadata("propertyTypeMismatch.kt") - public void testPropertyTypeMismatch() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegation/clashes/propertyTypeMismatch.kt"); - } - - @Test - @TestMetadata("returnTypeMismatch.kt") - public void testReturnTypeMismatch() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegation/clashes/returnTypeMismatch.kt"); - } - - @Test - @TestMetadata("varOverriddenByVal.kt") - public void testVarOverriddenByVal() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegation/clashes/varOverriddenByVal.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/delegation/covariantOverrides") - @TestDataPath("$PROJECT_ROOT") - public class CovariantOverrides extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInCovariantOverrides() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/delegation/covariantOverrides"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("fromClass.kt") - public void testFromClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegation/covariantOverrides/fromClass.kt"); - } - - @Test - @TestMetadata("irrelevant.kt") - public void testIrrelevant() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegation/covariantOverrides/irrelevant.kt"); - } - - @Test - @TestMetadata("kt13952.kt") - public void testKt13952() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegation/covariantOverrides/kt13952.kt"); - } - - @Test - @TestMetadata("simple.kt") - public void testSimple() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegation/covariantOverrides/simple.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride") - @TestDataPath("$PROJECT_ROOT") - public class MemberHidesSupertypeOverride extends AbstractDiagnosticUsingJavacTest { - @Test - @TestMetadata("abstractOverride.kt") - public void testAbstractOverride() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/abstractOverride.kt"); - } - - @Test - public void testAllFilesPresentInMemberHidesSupertypeOverride() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("delegationToSubType.kt") - public void testDelegationToSubType() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/delegationToSubType.kt"); - } - - @Test - @TestMetadata("delegationToSubTypeProperty.kt") - public void testDelegationToSubTypeProperty() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/delegationToSubTypeProperty.kt"); - } - - @Test - @TestMetadata("delegationToSubTypeWithOverride.kt") - public void testDelegationToSubTypeWithOverride() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/delegationToSubTypeWithOverride.kt"); - } - - @Test - @TestMetadata("delegationToSubTypeWithOverrideProperty.kt") - public void testDelegationToSubTypeWithOverrideProperty() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/delegationToSubTypeWithOverrideProperty.kt"); - } - - @Test - @TestMetadata("diamond.kt") - public void testDiamond() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/diamond.kt"); - } - - @Test - @TestMetadata("explicitOverride.kt") - public void testExplicitOverride() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/explicitOverride.kt"); - } - - @Test - @TestMetadata("fakeOverrideInTheMiddle.kt") - public void testFakeOverrideInTheMiddle() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/fakeOverrideInTheMiddle.kt"); - } - - @Test - @TestMetadata("generic.kt") - public void testGeneric() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/generic.kt"); - } - - @Test - @TestMetadata("sameDelegationInHierarchy.kt") - public void testSameDelegationInHierarchy() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/sameDelegationInHierarchy.kt"); - } - - @Test - @TestMetadata("sameDelegationInHierarchy2.kt") - public void testSameDelegationInHierarchy2() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/sameDelegationInHierarchy2.kt"); - } - - @Test - @TestMetadata("severalDelegates.kt") - public void testSeveralDelegates() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/severalDelegates.kt"); - } - - @Test - @TestMetadata("simple.kt") - public void testSimple() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/simple.kt"); - } - - @Test - @TestMetadata("simpleNoOverride.kt") - public void testSimpleNoOverride() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/simpleNoOverride.kt"); - } - - @Test - @TestMetadata("simpleProp.kt") - public void testSimpleProp() throws Exception { - runTest("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride/simpleProp.kt"); - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/deparenthesize") - @TestDataPath("$PROJECT_ROOT") - public class Deparenthesize extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInDeparenthesize() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/deparenthesize"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("annotatedSafeCall.kt") - public void testAnnotatedSafeCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/deparenthesize/annotatedSafeCall.kt"); - } - - @Test - @TestMetadata("checkDeparenthesizedType.kt") - public void testCheckDeparenthesizedType() throws Exception { - runTest("compiler/testData/diagnostics/tests/deparenthesize/checkDeparenthesizedType.kt"); - } - - @Test - @TestMetadata("labeledSafeCall.kt") - public void testLabeledSafeCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/deparenthesize/labeledSafeCall.kt"); - } - - @Test - @TestMetadata("multiParenthesizedSafeCall.kt") - public void testMultiParenthesizedSafeCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/deparenthesize/multiParenthesizedSafeCall.kt"); - } - - @Test - @TestMetadata("parenthesizedSafeCall.kt") - public void testParenthesizedSafeCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/deparenthesize/parenthesizedSafeCall.kt"); - } - - @Test - @TestMetadata("ParenthesizedVariable.kt") - public void testParenthesizedVariable() throws Exception { - runTest("compiler/testData/diagnostics/tests/deparenthesize/ParenthesizedVariable.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/deprecated") - @TestDataPath("$PROJECT_ROOT") - public class Deprecated extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInDeprecated() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/deprecated"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("annotationUsage.kt") - public void testAnnotationUsage() throws Exception { - runTest("compiler/testData/diagnostics/tests/deprecated/annotationUsage.kt"); - } - - @Test - @TestMetadata("classWithCompanionObject.kt") - public void testClassWithCompanionObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/deprecated/classWithCompanionObject.kt"); - } - - @Test - @TestMetadata("companionObjectUsage.kt") - public void testCompanionObjectUsage() throws Exception { - runTest("compiler/testData/diagnostics/tests/deprecated/companionObjectUsage.kt"); - } - - @Test - @TestMetadata("componentUsage.kt") - public void testComponentUsage() throws Exception { - runTest("compiler/testData/diagnostics/tests/deprecated/componentUsage.kt"); - } - - @Test - @TestMetadata("deprecatedConstructor.kt") - public void testDeprecatedConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/deprecated/deprecatedConstructor.kt"); - } - - @Test - @TestMetadata("deprecatedError.kt") - public void testDeprecatedError() throws Exception { - runTest("compiler/testData/diagnostics/tests/deprecated/deprecatedError.kt"); - } - - @Test - @TestMetadata("deprecatedErrorBuilder.kt") - public void testDeprecatedErrorBuilder() throws Exception { - runTest("compiler/testData/diagnostics/tests/deprecated/deprecatedErrorBuilder.kt"); - } - - @Test - @TestMetadata("deprecatedHidden.kt") - public void testDeprecatedHidden() throws Exception { - runTest("compiler/testData/diagnostics/tests/deprecated/deprecatedHidden.kt"); - } - - @Test - @TestMetadata("deprecatedHiddenOnCallableReferenceArgument.kt") - public void testDeprecatedHiddenOnCallableReferenceArgument() throws Exception { - runTest("compiler/testData/diagnostics/tests/deprecated/deprecatedHiddenOnCallableReferenceArgument.kt"); - } - - @Test - @TestMetadata("deprecatedInheritance.kt") - public void testDeprecatedInheritance() throws Exception { - runTest("compiler/testData/diagnostics/tests/deprecated/deprecatedInheritance.kt"); - } - - @Test - @TestMetadata("deprecatedPropertyInheritance.kt") - public void testDeprecatedPropertyInheritance() throws Exception { - runTest("compiler/testData/diagnostics/tests/deprecated/deprecatedPropertyInheritance.kt"); - } - - @Test - @TestMetadata("functionUsage.kt") - public void testFunctionUsage() throws Exception { - runTest("compiler/testData/diagnostics/tests/deprecated/functionUsage.kt"); - } - - @Test - @TestMetadata("genericConstructorUsage.kt") - public void testGenericConstructorUsage() throws Exception { - runTest("compiler/testData/diagnostics/tests/deprecated/genericConstructorUsage.kt"); - } - - @Test - @TestMetadata("hiddenPropertyAccessors.kt") - public void testHiddenPropertyAccessors() throws Exception { - runTest("compiler/testData/diagnostics/tests/deprecated/hiddenPropertyAccessors.kt"); - } - - @Test - @TestMetadata("importJavaSamInterface.kt") - public void testImportJavaSamInterface() throws Exception { - runTest("compiler/testData/diagnostics/tests/deprecated/importJavaSamInterface.kt"); - } - - @Test - @TestMetadata("imports.kt") - public void testImports() throws Exception { - runTest("compiler/testData/diagnostics/tests/deprecated/imports.kt"); - } - - @Test - @TestMetadata("iteratorUsage.kt") - public void testIteratorUsage() throws Exception { - runTest("compiler/testData/diagnostics/tests/deprecated/iteratorUsage.kt"); - } - - @Test - @TestMetadata("javaDeprecated.kt") - public void testJavaDeprecated() throws Exception { - runTest("compiler/testData/diagnostics/tests/deprecated/javaDeprecated.kt"); - } - - @Test - @TestMetadata("javaDeprecatedInheritance.kt") - public void testJavaDeprecatedInheritance() throws Exception { - runTest("compiler/testData/diagnostics/tests/deprecated/javaDeprecatedInheritance.kt"); - } - - @Test - @TestMetadata("javaDocDeprecated.kt") - public void testJavaDocDeprecated() throws Exception { - runTest("compiler/testData/diagnostics/tests/deprecated/javaDocDeprecated.kt"); - } - - @Test - @TestMetadata("nestedTypesUsage.kt") - public void testNestedTypesUsage() throws Exception { - runTest("compiler/testData/diagnostics/tests/deprecated/nestedTypesUsage.kt"); - } - - @Test - @TestMetadata("objectUsage.kt") - public void testObjectUsage() throws Exception { - runTest("compiler/testData/diagnostics/tests/deprecated/objectUsage.kt"); - } - - @Test - @TestMetadata("propertyUsage.kt") - public void testPropertyUsage() throws Exception { - runTest("compiler/testData/diagnostics/tests/deprecated/propertyUsage.kt"); - } - - @Test - @TestMetadata("propertyUseSiteTargetedAnnotations.kt") - public void testPropertyUseSiteTargetedAnnotations() throws Exception { - runTest("compiler/testData/diagnostics/tests/deprecated/propertyUseSiteTargetedAnnotations.kt"); - } - - @Test - @TestMetadata("propertyWithInvoke.kt") - public void testPropertyWithInvoke() throws Exception { - runTest("compiler/testData/diagnostics/tests/deprecated/propertyWithInvoke.kt"); - } - - @Test - @TestMetadata("thisUsage.kt") - public void testThisUsage() throws Exception { - runTest("compiler/testData/diagnostics/tests/deprecated/thisUsage.kt"); - } - - @Test - @TestMetadata("typeUsage.kt") - public void testTypeUsage() throws Exception { - runTest("compiler/testData/diagnostics/tests/deprecated/typeUsage.kt"); - } - - @Test - @TestMetadata("typealiasCompanionObject.kt") - public void testTypealiasCompanionObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/deprecated/typealiasCompanionObject.kt"); - } - - @Test - @TestMetadata("typealiasConstructor.kt") - public void testTypealiasConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/deprecated/typealiasConstructor.kt"); - } - - @Test - @TestMetadata("typealiasForDeprecatedClass.kt") - public void testTypealiasForDeprecatedClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/deprecated/typealiasForDeprecatedClass.kt"); - } - - @Test - @TestMetadata("typealiasUsage.kt") - public void testTypealiasUsage() throws Exception { - runTest("compiler/testData/diagnostics/tests/deprecated/typealiasUsage.kt"); - } - - @Test - @TestMetadata("unusedImport.kt") - public void testUnusedImport() throws Exception { - runTest("compiler/testData/diagnostics/tests/deprecated/unusedImport.kt"); - } - - @Test - @TestMetadata("warningOnConstructorErrorOnClass.kt") - public void testWarningOnConstructorErrorOnClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/deprecated/warningOnConstructorErrorOnClass.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin") - @TestDataPath("$PROJECT_ROOT") - public class DeprecatedSinceKotlin extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInDeprecatedSinceKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("checkValuesAreParseableAsVersion.kt") - public void testCheckValuesAreParseableAsVersion() throws Exception { - runTest("compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin/checkValuesAreParseableAsVersion.kt"); - } - - @Test - @TestMetadata("deprecatedSinceKotlinDeclaration.kt") - public void testDeprecatedSinceKotlinDeclaration() throws Exception { - runTest("compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin/deprecatedSinceKotlinDeclaration.kt"); - } - - @Test - @TestMetadata("deprecatedSinceKotlinHiddenOnReferenceArgument.kt") - public void testDeprecatedSinceKotlinHiddenOnReferenceArgument() throws Exception { - runTest("compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin/deprecatedSinceKotlinHiddenOnReferenceArgument.kt"); - } - - @Test - @TestMetadata("deprecatedSinceKotlinOutsideKotlinPackage.kt") - public void testDeprecatedSinceKotlinOutsideKotlinPackage() throws Exception { - runTest("compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin/deprecatedSinceKotlinOutsideKotlinPackage.kt"); - } - - @Test - @TestMetadata("deprecatedSinceKotlinWithoutArguments.kt") - public void testDeprecatedSinceKotlinWithoutArguments() throws Exception { - runTest("compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin/deprecatedSinceKotlinWithoutArguments.kt"); - } - - @Test - @TestMetadata("error.kt") - public void testError() throws Exception { - runTest("compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin/error.kt"); - } - - @Test - @TestMetadata("hidden.kt") - public void testHidden() throws Exception { - runTest("compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin/hidden.kt"); - } - - @Test - @TestMetadata("messageFromDeprecatedAnnotation.kt") - public void testMessageFromDeprecatedAnnotation() throws Exception { - runTest("compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin/messageFromDeprecatedAnnotation.kt"); - } - - @Test - @TestMetadata("warning.kt") - public void testWarning() throws Exception { - runTest("compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin/warning.kt"); - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature") - @TestDataPath("$PROJECT_ROOT") - public class DuplicateJvmSignature extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInDuplicateJvmSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("caseInProperties.kt") - public void testCaseInProperties() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/caseInProperties.kt"); - } - - @Test - @TestMetadata("missingNames.kt") - public void testMissingNames() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/missingNames.kt"); - } - - @Test - @TestMetadata("vararg.kt") - public void testVararg() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/vararg.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides") - @TestDataPath("$PROJECT_ROOT") - public class AccidentalOverrides extends AbstractDiagnosticUsingJavacTest { - @Test - @TestMetadata("accidentalOverrideFromGrandparent.kt") - public void testAccidentalOverrideFromGrandparent() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/accidentalOverrideFromGrandparent.kt"); - } - - @Test - public void testAllFilesPresentInAccidentalOverrides() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("classFunctionOverriddenByProperty.kt") - public void testClassFunctionOverriddenByProperty() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/classFunctionOverriddenByProperty.kt"); - } - - @Test - @TestMetadata("classFunctionOverriddenByPropertyInConstructor.kt") - public void testClassFunctionOverriddenByPropertyInConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/classFunctionOverriddenByPropertyInConstructor.kt"); - } - - @Test - @TestMetadata("classFunctionOverriddenByPropertyNoGetter.kt") - public void testClassFunctionOverriddenByPropertyNoGetter() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/classFunctionOverriddenByPropertyNoGetter.kt"); - } - - @Test - @TestMetadata("classPropertyOverriddenByFunction.kt") - public void testClassPropertyOverriddenByFunction() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/classPropertyOverriddenByFunction.kt"); - } - - @Test - @TestMetadata("defaultFunction.kt") - public void testDefaultFunction() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/defaultFunction.kt"); - } - - @Test - @TestMetadata("delegatedFunctionOverriddenByProperty.kt") - public void testDelegatedFunctionOverriddenByProperty() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/delegatedFunctionOverriddenByProperty.kt"); - } - - @Test - @TestMetadata("genericClassFunction.kt") - public void testGenericClassFunction() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/genericClassFunction.kt"); - } - - @Test - @TestMetadata("overridesNothing.kt") - public void testOverridesNothing() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/overridesNothing.kt"); - } - - @Test - @TestMetadata("privateClassFunctionOverriddenByProperty.kt") - public void testPrivateClassFunctionOverriddenByProperty() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/privateClassFunctionOverriddenByProperty.kt"); - } - - @Test - @TestMetadata("require.kt") - public void testRequire() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/require.kt"); - } - - @Test - @TestMetadata("traitFunctionOverriddenByProperty.kt") - public void testTraitFunctionOverriddenByProperty() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/traitFunctionOverriddenByProperty.kt"); - } - - @Test - @TestMetadata("traitFunctionOverriddenByPropertyNoImpl.kt") - public void testTraitFunctionOverriddenByPropertyNoImpl() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/traitFunctionOverriddenByPropertyNoImpl.kt"); - } - - @Test - @TestMetadata("traitPropertyOverriddenByFunction.kt") - public void testTraitPropertyOverriddenByFunction() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/traitPropertyOverriddenByFunction.kt"); - } - - @Test - @TestMetadata("traitPropertyOverriddenByFunctionNoImpl.kt") - public void testTraitPropertyOverriddenByFunctionNoImpl() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides/traitPropertyOverriddenByFunctionNoImpl.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/bridges") - @TestDataPath("$PROJECT_ROOT") - public class Bridges extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInBridges() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/bridges"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("class.kt") - public void testClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/bridges/class.kt"); - } - - @Test - @TestMetadata("fakeOverrideTrait.kt") - public void testFakeOverrideTrait() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/bridges/fakeOverrideTrait.kt"); - } - - @Test - @TestMetadata("trait.kt") - public void testTrait() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/bridges/trait.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure") - @TestDataPath("$PROJECT_ROOT") - public class Erasure extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInErasure() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("clashFromInterfaceAndSuperClass.kt") - public void testClashFromInterfaceAndSuperClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/clashFromInterfaceAndSuperClass.kt"); - } - - @Test - @TestMetadata("collections.kt") - public void testCollections() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/collections.kt"); - } - - @Test - @TestMetadata("delegateToTwoTraits.kt") - public void testDelegateToTwoTraits() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/delegateToTwoTraits.kt"); - } - - @Test - @TestMetadata("delegationAndOwnMethod.kt") - public void testDelegationAndOwnMethod() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/delegationAndOwnMethod.kt"); - } - - @Test - @TestMetadata("delegationToTraitImplAndOwnMethod.kt") - public void testDelegationToTraitImplAndOwnMethod() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/delegationToTraitImplAndOwnMethod.kt"); - } - - @Test - @TestMetadata("extensionProperties.kt") - public void testExtensionProperties() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/extensionProperties.kt"); - } - - @Test - @TestMetadata("genericType.kt") - public void testGenericType() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/genericType.kt"); - } - - @Test - @TestMetadata("inheritFromTwoTraits.kt") - public void testInheritFromTwoTraits() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/inheritFromTwoTraits.kt"); - } - - @Test - @TestMetadata("kotlinAndJavaCollections.kt") - public void testKotlinAndJavaCollections() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/kotlinAndJavaCollections.kt"); - } - - @Test - @TestMetadata("nullableType.kt") - public void testNullableType() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/nullableType.kt"); - } - - @Test - @TestMetadata("superTraitAndDelegationToTraitImpl.kt") - public void testSuperTraitAndDelegationToTraitImpl() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/superTraitAndDelegationToTraitImpl.kt"); - } - - @Test - @TestMetadata("twoTraitsAndOwnFunction.kt") - public void testTwoTraitsAndOwnFunction() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/twoTraitsAndOwnFunction.kt"); - } - - @Test - @TestMetadata("typeMappedToJava.kt") - public void testTypeMappedToJava() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/typeMappedToJava.kt"); - } - - @Test - @TestMetadata("typeParameter.kt") - public void testTypeParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/typeParameter.kt"); - } - - @Test - @TestMetadata("typeParameterWithBound.kt") - public void testTypeParameterWithBound() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/typeParameterWithBound.kt"); - } - - @Test - @TestMetadata("typeParameterWithTwoBounds.kt") - public void testTypeParameterWithTwoBounds() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/typeParameterWithTwoBounds.kt"); - } - - @Test - @TestMetadata("typeParameterWithTwoBoundsInWhere.kt") - public void testTypeParameterWithTwoBoundsInWhere() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure/typeParameterWithTwoBoundsInWhere.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/finalMembersFromBuiltIns") - @TestDataPath("$PROJECT_ROOT") - public class FinalMembersFromBuiltIns extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInFinalMembersFromBuiltIns() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/finalMembersFromBuiltIns"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("enumMembers.kt") - public void testEnumMembers() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/finalMembersFromBuiltIns/enumMembers.kt"); - } - - @Test - @TestMetadata("waitNotifyGetClass.kt") - public void testWaitNotifyGetClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/finalMembersFromBuiltIns/waitNotifyGetClass.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty") - @TestDataPath("$PROJECT_ROOT") - public class FunctionAndProperty extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInFunctionAndProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("class.kt") - public void testClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/class.kt"); - } - - @Test - @TestMetadata("classObject.kt") - public void testClassObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/classObject.kt"); - } - - @Test - @TestMetadata("classPropertyInConstructor.kt") - public void testClassPropertyInConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/classPropertyInConstructor.kt"); - } - - @Test - @TestMetadata("extensionFunctionAndNormalFunction.kt") - public void testExtensionFunctionAndNormalFunction() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/extensionFunctionAndNormalFunction.kt"); - } - - @Test - @TestMetadata("extensionPropertyAndFunction.kt") - public void testExtensionPropertyAndFunction() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/extensionPropertyAndFunction.kt"); - } - - @Test - @TestMetadata("functionAndSetter.kt") - public void testFunctionAndSetter() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/functionAndSetter.kt"); - } - - @Test - @TestMetadata("functionAndVar.kt") - public void testFunctionAndVar() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/functionAndVar.kt"); - } - - @Test - @TestMetadata("localClass.kt") - public void testLocalClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/localClass.kt"); - } - - @Test - @TestMetadata("localClassInClass.kt") - public void testLocalClassInClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/localClassInClass.kt"); - } - - @Test - @TestMetadata("nestedClass.kt") - public void testNestedClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/nestedClass.kt"); - } - - @Test - @TestMetadata("object.kt") - public void testObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/object.kt"); - } - - @Test - @TestMetadata("objectExpression.kt") - public void testObjectExpression() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/objectExpression.kt"); - } - - @Test - @TestMetadata("objectExpressionInConstructor.kt") - public void testObjectExpressionInConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/objectExpressionInConstructor.kt"); - } - - @Test - @TestMetadata("privateClassPropertyNoClash.kt") - public void testPrivateClassPropertyNoClash() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/privateClassPropertyNoClash.kt"); - } - - @Test - @TestMetadata("topLevel.kt") - public void testTopLevel() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/topLevel.kt"); - } - - @Test - @TestMetadata("topLevelDifferentFiles.kt") - public void testTopLevelDifferentFiles() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/topLevelDifferentFiles.kt"); - } - - @Test - @TestMetadata("topLevelGetter.kt") - public void testTopLevelGetter() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/topLevelGetter.kt"); - } - - @Test - @TestMetadata("trait.kt") - public void testTrait() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/trait.kt"); - } - - @Test - @TestMetadata("withErrorTypes.kt") - public void testWithErrorTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty/withErrorTypes.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames") - @TestDataPath("$PROJECT_ROOT") - public class SpecialNames extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInSpecialNames() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("classObject.kt") - public void testClassObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/classObject.kt"); - } - - @Test - @TestMetadata("classObjectCopiedField.kt") - public void testClassObjectCopiedField() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/classObjectCopiedField.kt"); - } - - @Test - @TestMetadata("classObjectCopiedFieldObject.kt") - public void testClassObjectCopiedFieldObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/classObjectCopiedFieldObject.kt"); - } - - @Test - @TestMetadata("dataClassCopy.kt") - public void testDataClassCopy() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/dataClassCopy.kt"); - } - - @Test - @TestMetadata("delegationBy.kt") - public void testDelegationBy() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/delegationBy.kt"); - } - - @Test - @TestMetadata("enum.kt") - public void testEnum() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/enum.kt"); - } - - @Test - @TestMetadata("innerClassField.kt") - public void testInnerClassField() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/innerClassField.kt"); - } - - @Test - @TestMetadata("instance.kt") - public void testInstance() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/instance.kt"); - } - - @Test - @TestMetadata("propertyMetadataCache.kt") - public void testPropertyMetadataCache() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/propertyMetadataCache.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/statics") - @TestDataPath("$PROJECT_ROOT") - public class Statics extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInStatics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/statics"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("jkjk.kt") - public void testJkjk() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/jkjk.kt"); - } - - @Test - @TestMetadata("kotlinClassExtendsJavaClass.kt") - public void testKotlinClassExtendsJavaClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/kotlinClassExtendsJavaClass.kt"); - } - - @Test - @TestMetadata("kotlinClassExtendsJavaClassExtendsJavaClass.kt") - public void testKotlinClassExtendsJavaClassExtendsJavaClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/kotlinClassExtendsJavaClassExtendsJavaClass.kt"); - } - - @Test - @TestMetadata("kotlinClassImplementsJavaInterface.kt") - public void testKotlinClassImplementsJavaInterface() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/kotlinClassImplementsJavaInterface.kt"); - } - - @Test - @TestMetadata("kotlinClassImplementsJavaInterfaceExtendsJavaInteface.kt") - public void testKotlinClassImplementsJavaInterfaceExtendsJavaInteface() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/kotlinClassImplementsJavaInterfaceExtendsJavaInteface.kt"); - } - - @Test - @TestMetadata("kotlinMembersVsJavaNonVisibleStatics.kt") - public void testKotlinMembersVsJavaNonVisibleStatics() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/statics/kotlinMembersVsJavaNonVisibleStatics.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/synthesized") - @TestDataPath("$PROJECT_ROOT") - public class Synthesized extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInSynthesized() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/synthesized"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("enumValuesValueOf.kt") - public void testEnumValuesValueOf() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/synthesized/enumValuesValueOf.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/duplicateJvmSignature/traitImpl") - @TestDataPath("$PROJECT_ROOT") - public class TraitImpl extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInTraitImpl() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/traitImpl"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("oneTrait.kt") - public void testOneTrait() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/traitImpl/oneTrait.kt"); - } - - @Test - @TestMetadata("traitFunctionOverriddenByPropertyInTrait.kt") - public void testTraitFunctionOverriddenByPropertyInTrait() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/traitImpl/traitFunctionOverriddenByPropertyInTrait.kt"); - } - - @Test - @TestMetadata("traitPropertyOverriddenByFunctionInTrait.kt") - public void testTraitPropertyOverriddenByFunctionInTrait() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/traitImpl/traitPropertyOverriddenByFunctionInTrait.kt"); - } - - @Test - @TestMetadata("twoTraits.kt") - public void testTwoTraits() throws Exception { - runTest("compiler/testData/diagnostics/tests/duplicateJvmSignature/traitImpl/twoTraits.kt"); - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/dynamicTypes") - @TestDataPath("$PROJECT_ROOT") - public class DynamicTypes extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInDynamicTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/dynamicTypes"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("delegationBy.kt") - public void testDelegationBy() throws Exception { - runTest("compiler/testData/diagnostics/tests/dynamicTypes/delegationBy.kt"); - } - - @Test - @TestMetadata("unsupported.kt") - public void testUnsupported() throws Exception { - runTest("compiler/testData/diagnostics/tests/dynamicTypes/unsupported.kt"); - } - - @Test - @TestMetadata("withInvisibleSynthesized.kt") - public void testWithInvisibleSynthesized() throws Exception { - runTest("compiler/testData/diagnostics/tests/dynamicTypes/withInvisibleSynthesized.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/enum") - @TestDataPath("$PROJECT_ROOT") - public class Enum extends AbstractDiagnosticUsingJavacTest { - @Test - @TestMetadata("AbstractEnum.kt") - public void testAbstractEnum() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/AbstractEnum.kt"); - } - - @Test - @TestMetadata("AbstractInEnum.kt") - public void testAbstractInEnum() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/AbstractInEnum.kt"); - } - - @Test - @TestMetadata("AbstractOverrideInEnum.kt") - public void testAbstractOverrideInEnum() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/AbstractOverrideInEnum.kt"); - } - - @Test - public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/enum"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("classObjectInEnum.kt") - public void testClassObjectInEnum() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/classObjectInEnum.kt"); - } - - @Test - @TestMetadata("classObjectInEnumPrivate.kt") - public void testClassObjectInEnumPrivate() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/classObjectInEnumPrivate.kt"); - } - - @Test - @TestMetadata("commonSupertype.kt") - public void testCommonSupertype() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/commonSupertype.kt"); - } - - @Test - @TestMetadata("compareTwoDifferentEnums.kt") - public void testCompareTwoDifferentEnums() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/compareTwoDifferentEnums.kt"); - } - - @Test - @TestMetadata("ConstructorCallFromOutside.kt") - public void testConstructorCallFromOutside() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/ConstructorCallFromOutside.kt"); - } - - @Test - @TestMetadata("constructorWithDefaultParametersOnly.kt") - public void testConstructorWithDefaultParametersOnly() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/constructorWithDefaultParametersOnly.kt"); - } - - @Test - @TestMetadata("dontCreatePackageTypeForEnumEntry_after.kt") - public void testDontCreatePackageTypeForEnumEntry_after() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/dontCreatePackageTypeForEnumEntry_after.kt"); - } - - @Test - @TestMetadata("dontCreatePackageTypeForEnumEntry_before.kt") - public void testDontCreatePackageTypeForEnumEntry_before() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/dontCreatePackageTypeForEnumEntry_before.kt"); - } - - @Test - @TestMetadata("emptyConstructor.kt") - public void testEmptyConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/emptyConstructor.kt"); - } - - @Test - @TestMetadata("entryShouldBeOfEnumType.kt") - public void testEntryShouldBeOfEnumType() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/entryShouldBeOfEnumType.kt"); - } - - @Test - @TestMetadata("enumEntryCannotHaveClassObject.kt") - public void testEnumEntryCannotHaveClassObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/enumEntryCannotHaveClassObject.kt"); - } - - @Test - @TestMetadata("enumEntryInAbstractEnum.kt") - public void testEnumEntryInAbstractEnum() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/enumEntryInAbstractEnum.kt"); - } - - @Test - @TestMetadata("enumImplementingTrait.kt") - public void testEnumImplementingTrait() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/enumImplementingTrait.kt"); - } - - @Test - @TestMetadata("enumInheritance.kt") - public void testEnumInheritance() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/enumInheritance.kt"); - } - - @Test - @TestMetadata("enumIsAssignableToBuiltInEnum.kt") - public void testEnumIsAssignableToBuiltInEnum() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/enumIsAssignableToBuiltInEnum.kt"); - } - - @Test - @TestMetadata("enumMissingName.kt") - public void testEnumMissingName() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/enumMissingName.kt"); - } - - @Test - @TestMetadata("enumModifier.kt") - public void testEnumModifier() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/enumModifier.kt"); - } - - @Test - @TestMetadata("enumStarImport.kt") - public void testEnumStarImport() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/enumStarImport.kt"); - } - - @Test - @TestMetadata("enumSubjectTypeCheck.kt") - public void testEnumSubjectTypeCheck() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/enumSubjectTypeCheck.kt"); - } - - @Test - @TestMetadata("enumWithAnnotationKeyword.kt") - public void testEnumWithAnnotationKeyword() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/enumWithAnnotationKeyword.kt"); - } - - @Test - @TestMetadata("enumWithEmptyName.kt") - public void testEnumWithEmptyName() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/enumWithEmptyName.kt"); - } - - @Test - @TestMetadata("ExplicitConstructorCall.kt") - public void testExplicitConstructorCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/ExplicitConstructorCall.kt"); - } - - @Test - @TestMetadata("extendingEnumDirectly.kt") - public void testExtendingEnumDirectly() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/extendingEnumDirectly.kt"); - } - - @Test - @TestMetadata("extensionNamedAsEnumEntry.kt") - public void testExtensionNamedAsEnumEntry() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/extensionNamedAsEnumEntry.kt"); - } - - @Test - @TestMetadata("ifEnumEntry.kt") - public void testIfEnumEntry() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/ifEnumEntry.kt"); - } - - @Test - @TestMetadata("importEnumFromJava.kt") - public void testImportEnumFromJava() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/importEnumFromJava.kt"); - } - - @Test - @TestMetadata("incompatibleEnumEntryClasses.kt") - public void testIncompatibleEnumEntryClasses() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/incompatibleEnumEntryClasses.kt"); - } - - @Test - @TestMetadata("incompatibleEnums.kt") - public void testIncompatibleEnums() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/incompatibleEnums.kt"); - } - - @Test - @TestMetadata("incompatibleEnums_1_4.kt") - public void testIncompatibleEnums_1_4() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/incompatibleEnums_1_4.kt"); - } - - @Test - @TestMetadata("inheritFromEnumEntry.kt") - public void testInheritFromEnumEntry() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/inheritFromEnumEntry.kt"); - } - - @Test - @TestMetadata("inheritanceFromEnum.kt") - public void testInheritanceFromEnum() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/inheritanceFromEnum.kt"); - } - - @Test - @TestMetadata("inline.kt") - public void testInline() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/inline.kt"); - } - - @Test - @TestMetadata("InsideEntryConstructorCall.kt") - public void testInsideEntryConstructorCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/InsideEntryConstructorCall.kt"); - } - - @Test - @TestMetadata("InsideSecondaryConstructorCall.kt") - public void testInsideSecondaryConstructorCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/InsideSecondaryConstructorCall.kt"); - } - - @Test - @TestMetadata("interfaceWithEnumKeyword.kt") - public void testInterfaceWithEnumKeyword() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/interfaceWithEnumKeyword.kt"); - } - - @Test - @TestMetadata("isEnumEntry.kt") - public void testIsEnumEntry() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/isEnumEntry.kt"); - } - - @Test - @TestMetadata("javaEnumValueOfMethod.kt") - public void testJavaEnumValueOfMethod() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/javaEnumValueOfMethod.kt"); - } - - @Test - @TestMetadata("javaEnumValuesMethod.kt") - public void testJavaEnumValuesMethod() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/javaEnumValuesMethod.kt"); - } - - @Test - @TestMetadata("javaEnumWithAbstractFun.kt") - public void testJavaEnumWithAbstractFun() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/javaEnumWithAbstractFun.kt"); - } - - @Test - @TestMetadata("javaEnumWithFuns.kt") - public void testJavaEnumWithFuns() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/javaEnumWithFuns.kt"); - } - - @Test - @TestMetadata("javaEnumWithNameClashing.kt") - public void testJavaEnumWithNameClashing() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/javaEnumWithNameClashing.kt"); - } - - @Test - @TestMetadata("javaEnumWithProperty.kt") - public void testJavaEnumWithProperty() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/javaEnumWithProperty.kt"); - } - - @Test - @TestMetadata("kt2834.kt") - public void testKt2834() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/kt2834.kt"); - } - - @Test - @TestMetadata("kt8972_cloneNotAllowed.kt") - public void testKt8972_cloneNotAllowed() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/kt8972_cloneNotAllowed.kt"); - } - - @Test - @TestMetadata("localEnums.kt") - public void testLocalEnums() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/localEnums.kt"); - } - - @Test - @TestMetadata("modifiersOnEnumEntry.kt") - public void testModifiersOnEnumEntry() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/modifiersOnEnumEntry.kt"); - } - - @Test - @TestMetadata("multipleConstructors.kt") - public void testMultipleConstructors() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/multipleConstructors.kt"); - } - - @Test - @TestMetadata("NonPrivateConstructor.kt") - public void testNonPrivateConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/NonPrivateConstructor.kt"); - } - - @Test - @TestMetadata("openMemberInEnum.kt") - public void testOpenMemberInEnum() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/openMemberInEnum.kt"); - } - - @Test - @TestMetadata("overrideFinalEnumMethods.kt") - public void testOverrideFinalEnumMethods() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/overrideFinalEnumMethods.kt"); - } - - @Test - @TestMetadata("SecondaryConstructorCall.kt") - public void testSecondaryConstructorCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/SecondaryConstructorCall.kt"); - } - - @Test - @TestMetadata("secondaryConstructorWithoutDelegatingToPrimaryOne.kt") - public void testSecondaryConstructorWithoutDelegatingToPrimaryOne() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/secondaryConstructorWithoutDelegatingToPrimaryOne.kt"); - } - - @Test - @TestMetadata("secondaryConstructorWithoutDelegatingToPrimaryOneWithEnabledFeature.kt") - public void testSecondaryConstructorWithoutDelegatingToPrimaryOneWithEnabledFeature() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/secondaryConstructorWithoutDelegatingToPrimaryOneWithEnabledFeature.kt"); - } - - @Test - @TestMetadata("starImportNestedClassAndEntries.kt") - public void testStarImportNestedClassAndEntries() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/starImportNestedClassAndEntries.kt"); - } - - @Test - @TestMetadata("typeParametersInEnum.kt") - public void testTypeParametersInEnum() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/typeParametersInEnum.kt"); - } - - @Test - @TestMetadata("valuesValueOfAndEntriesAccessibility.kt") - public void testValuesValueOfAndEntriesAccessibility() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/valuesValueOfAndEntriesAccessibility.kt"); - } - - @Test - @TestMetadata("wrongUnitializedEnumCompanion.kt") - public void testWrongUnitializedEnumCompanion() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/wrongUnitializedEnumCompanion.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/enum/inner") - @TestDataPath("$PROJECT_ROOT") - public class Inner extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInInner() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/enum/inner"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("existingClassObject.kt") - public void testExistingClassObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/inner/existingClassObject.kt"); - } - - @Test - @TestMetadata("insideClass.kt") - public void testInsideClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/inner/insideClass.kt"); - } - - @Test - @TestMetadata("insideClassObject.kt") - public void testInsideClassObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/inner/insideClassObject.kt"); - } - - @Test - @TestMetadata("insideEnum.kt") - public void testInsideEnum() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/inner/insideEnum.kt"); - } - - @Test - @TestMetadata("insideEnumEntry_after.kt") - public void testInsideEnumEntry_after() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/inner/insideEnumEntry_after.kt"); - } - - @Test - @TestMetadata("insideEnumEntry_before.kt") - public void testInsideEnumEntry_before() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/inner/insideEnumEntry_before.kt"); - } - - @Test - @TestMetadata("insideInnerClassNotAllowed.kt") - public void testInsideInnerClassNotAllowed() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/inner/insideInnerClassNotAllowed.kt"); - } - - @Test - @TestMetadata("insideObject.kt") - public void testInsideObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/inner/insideObject.kt"); - } - - @Test - @TestMetadata("insideTrait.kt") - public void testInsideTrait() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/inner/insideTrait.kt"); - } - - @Test - @TestMetadata("redeclarationInClassObject.kt") - public void testRedeclarationInClassObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/inner/redeclarationInClassObject.kt"); - } - - @Test - @TestMetadata("twoEnums.kt") - public void testTwoEnums() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/inner/twoEnums.kt"); - } - - @Test - @TestMetadata("twoEnumsInClassObjectAndInnerClass.kt") - public void testTwoEnumsInClassObjectAndInnerClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/enum/inner/twoEnumsInClassObjectAndInnerClass.kt"); - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/evaluate") - @TestDataPath("$PROJECT_ROOT") - public class Evaluate extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInEvaluate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/evaluate"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("binaryMinusDepOnExpType.kt") - public void testBinaryMinusDepOnExpType() throws Exception { - runTest("compiler/testData/diagnostics/tests/evaluate/binaryMinusDepOnExpType.kt"); - } - - @Test - @TestMetadata("binaryMinusIndepWoExpType.kt") - public void testBinaryMinusIndepWoExpType() throws Exception { - runTest("compiler/testData/diagnostics/tests/evaluate/binaryMinusIndepWoExpType.kt"); - } - - @Test - @TestMetadata("binaryMinusIndependentExpType.kt") - public void testBinaryMinusIndependentExpType() throws Exception { - runTest("compiler/testData/diagnostics/tests/evaluate/binaryMinusIndependentExpType.kt"); - } - - @Test - @TestMetadata("divisionByZero.kt") - public void testDivisionByZero() throws Exception { - runTest("compiler/testData/diagnostics/tests/evaluate/divisionByZero.kt"); - } - - @Test - @TestMetadata("float.kt") - public void testFloat() throws Exception { - runTest("compiler/testData/diagnostics/tests/evaluate/float.kt"); - } - - @Test - @TestMetadata("floatLiteralOutOfRange.kt") - public void testFloatLiteralOutOfRange() throws Exception { - runTest("compiler/testData/diagnostics/tests/evaluate/floatLiteralOutOfRange.kt"); - } - - @Test - @TestMetadata("infixFunOverBuiltinMemberInConst.kt") - public void testInfixFunOverBuiltinMemberInConst() throws Exception { - runTest("compiler/testData/diagnostics/tests/evaluate/infixFunOverBuiltinMemberInConst.kt"); - } - - @Test - @TestMetadata("intOverflow.kt") - public void testIntOverflow() throws Exception { - runTest("compiler/testData/diagnostics/tests/evaluate/intOverflow.kt"); - } - - @Test - @TestMetadata("intOverflowWithJavaProperties.kt") - public void testIntOverflowWithJavaProperties() throws Exception { - runTest("compiler/testData/diagnostics/tests/evaluate/intOverflowWithJavaProperties.kt"); - } - - @Test - @TestMetadata("integer.kt") - public void testInteger() throws Exception { - runTest("compiler/testData/diagnostics/tests/evaluate/integer.kt"); - } - - @Test - @TestMetadata("logicWithNumber.kt") - public void testLogicWithNumber() throws Exception { - runTest("compiler/testData/diagnostics/tests/evaluate/logicWithNumber.kt"); - } - - @Test - @TestMetadata("longOverflow.kt") - public void testLongOverflow() throws Exception { - runTest("compiler/testData/diagnostics/tests/evaluate/longOverflow.kt"); - } - - @Test - @TestMetadata("noOverflowWithZero.kt") - public void testNoOverflowWithZero() throws Exception { - runTest("compiler/testData/diagnostics/tests/evaluate/noOverflowWithZero.kt"); - } - - @Test - @TestMetadata("numberBinaryOperations.kt") - public void testNumberBinaryOperations() throws Exception { - runTest("compiler/testData/diagnostics/tests/evaluate/numberBinaryOperations.kt"); - } - - @Test - @TestMetadata("numberBinaryOperationsCall.kt") - public void testNumberBinaryOperationsCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/evaluate/numberBinaryOperationsCall.kt"); - } - - @Test - @TestMetadata("numberBinaryOperationsInfixCall.kt") - public void testNumberBinaryOperationsInfixCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/evaluate/numberBinaryOperationsInfixCall.kt"); - } - - @Test - @TestMetadata("otherOverflow.kt") - public void testOtherOverflow() throws Exception { - runTest("compiler/testData/diagnostics/tests/evaluate/otherOverflow.kt"); - } - - @Test - @TestMetadata("parentesized.kt") - public void testParentesized() throws Exception { - runTest("compiler/testData/diagnostics/tests/evaluate/parentesized.kt"); - } - - @Test - @TestMetadata("qualifiedExpressions.kt") - public void testQualifiedExpressions() throws Exception { - runTest("compiler/testData/diagnostics/tests/evaluate/qualifiedExpressions.kt"); - } - - @Test - @TestMetadata("unaryMinusDepOnExpType.kt") - public void testUnaryMinusDepOnExpType() throws Exception { - runTest("compiler/testData/diagnostics/tests/evaluate/unaryMinusDepOnExpType.kt"); - } - - @Test - @TestMetadata("unaryMinusIndepWoExpType.kt") - public void testUnaryMinusIndepWoExpType() throws Exception { - runTest("compiler/testData/diagnostics/tests/evaluate/unaryMinusIndepWoExpType.kt"); - } - - @Test - @TestMetadata("unaryMinusIndependentExpType.kt") - public void testUnaryMinusIndependentExpType() throws Exception { - runTest("compiler/testData/diagnostics/tests/evaluate/unaryMinusIndependentExpType.kt"); - } - - @Test - @TestMetadata("wrongLongSuffix.kt") - public void testWrongLongSuffix() throws Exception { - runTest("compiler/testData/diagnostics/tests/evaluate/wrongLongSuffix.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/evaluate/inlineClasses") - @TestDataPath("$PROJECT_ROOT") - public class InlineClasses extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/evaluate/inlineClasses"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("constructorOfUnsignedType.kt") - public void testConstructorOfUnsignedType() throws Exception { - runTest("compiler/testData/diagnostics/tests/evaluate/inlineClasses/constructorOfUnsignedType.kt"); - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/exposed") - @TestDataPath("$PROJECT_ROOT") - public class Exposed extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInExposed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/exposed"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("delegate.kt") - public void testDelegate() throws Exception { - runTest("compiler/testData/diagnostics/tests/exposed/delegate.kt"); - } - - @Test - @TestMetadata("exceptionOnFakeInvisible.kt") - public void testExceptionOnFakeInvisible() throws Exception { - runTest("compiler/testData/diagnostics/tests/exposed/exceptionOnFakeInvisible.kt"); - } - - @Test - @TestMetadata("functional.kt") - public void testFunctional() throws Exception { - runTest("compiler/testData/diagnostics/tests/exposed/functional.kt"); - } - - @Test - @TestMetadata("implements.kt") - public void testImplements() throws Exception { - runTest("compiler/testData/diagnostics/tests/exposed/implements.kt"); - } - - @Test - @TestMetadata("inaccessibleType.kt") - public void testInaccessibleType() throws Exception { - runTest("compiler/testData/diagnostics/tests/exposed/inaccessibleType.kt"); - } - - @Test - @TestMetadata("internal.kt") - public void testInternal() throws Exception { - runTest("compiler/testData/diagnostics/tests/exposed/internal.kt"); - } - - @Test - @TestMetadata("internalAndProtected.kt") - public void testInternalAndProtected() throws Exception { - runTest("compiler/testData/diagnostics/tests/exposed/internalAndProtected.kt"); - } - - @Test - @TestMetadata("internalFromLocal.kt") - public void testInternalFromLocal() throws Exception { - runTest("compiler/testData/diagnostics/tests/exposed/internalFromLocal.kt"); - } - - @Test - @TestMetadata("local.kt") - public void testLocal() throws Exception { - runTest("compiler/testData/diagnostics/tests/exposed/local.kt"); - } - - @Test - @TestMetadata("localFromInternal.kt") - public void testLocalFromInternal() throws Exception { - runTest("compiler/testData/diagnostics/tests/exposed/localFromInternal.kt"); - } - - @Test - @TestMetadata("localFromPrivate.kt") - public void testLocalFromPrivate() throws Exception { - runTest("compiler/testData/diagnostics/tests/exposed/localFromPrivate.kt"); - } - - @Test - @TestMetadata("localInFunReturnType.kt") - public void testLocalInFunReturnType() throws Exception { - runTest("compiler/testData/diagnostics/tests/exposed/localInFunReturnType.kt"); - } - - @Test - @TestMetadata("localInMemberType.kt") - public void testLocalInMemberType() throws Exception { - runTest("compiler/testData/diagnostics/tests/exposed/localInMemberType.kt"); - } - - @Test - @TestMetadata("localInPropertyType.kt") - public void testLocalInPropertyType() throws Exception { - runTest("compiler/testData/diagnostics/tests/exposed/localInPropertyType.kt"); - } - - @Test - @TestMetadata("nested.kt") - public void testNested() throws Exception { - runTest("compiler/testData/diagnostics/tests/exposed/nested.kt"); - } - - @Test - @TestMetadata("object.kt") - public void testObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/exposed/object.kt"); - } - - @Test - @TestMetadata("packagePrivate.kt") - public void testPackagePrivate() throws Exception { - runTest("compiler/testData/diagnostics/tests/exposed/packagePrivate.kt"); - } - - @Test - @TestMetadata("privateFromLocal.kt") - public void testPrivateFromLocal() throws Exception { - runTest("compiler/testData/diagnostics/tests/exposed/privateFromLocal.kt"); - } - - @Test - @TestMetadata("privatePropertyInPrivateConstructor.kt") - public void testPrivatePropertyInPrivateConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/exposed/privatePropertyInPrivateConstructor.kt"); - } - - @Test - @TestMetadata("propertyInConstructorOfPrivateClass.kt") - public void testPropertyInConstructorOfPrivateClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/exposed/propertyInConstructorOfPrivateClass.kt"); - } - - @Test - @TestMetadata("propertyInPrivateConstructor.kt") - public void testPropertyInPrivateConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/exposed/propertyInPrivateConstructor.kt"); - } - - @Test - @TestMetadata("propertyInSimpleConstructor.kt") - public void testPropertyInSimpleConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/exposed/propertyInSimpleConstructor.kt"); - } - - @Test - @TestMetadata("protected.kt") - public void testProtected() throws Exception { - runTest("compiler/testData/diagnostics/tests/exposed/protected.kt"); - } - - @Test - @TestMetadata("protectedInProtected.kt") - public void testProtectedInProtected() throws Exception { - runTest("compiler/testData/diagnostics/tests/exposed/protectedInProtected.kt"); - } - - @Test - @TestMetadata("protectedJava.kt") - public void testProtectedJava() throws Exception { - runTest("compiler/testData/diagnostics/tests/exposed/protectedJava.kt"); - } - - @Test - @TestMetadata("protectedSameWay.kt") - public void testProtectedSameWay() throws Exception { - runTest("compiler/testData/diagnostics/tests/exposed/protectedSameWay.kt"); - } - - @Test - @TestMetadata("simple.kt") - public void testSimple() throws Exception { - runTest("compiler/testData/diagnostics/tests/exposed/simple.kt"); - } - - @Test - @TestMetadata("typeArgs.kt") - public void testTypeArgs() throws Exception { - runTest("compiler/testData/diagnostics/tests/exposed/typeArgs.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/extensions") - @TestDataPath("$PROJECT_ROOT") - public class Extensions extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInExtensions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/extensions"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("classObject.kt") - public void testClassObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/extensions/classObject.kt"); - } - - @Test - @TestMetadata("ExtensionFunctions.kt") - public void testExtensionFunctions() throws Exception { - runTest("compiler/testData/diagnostics/tests/extensions/ExtensionFunctions.kt"); - } - - @Test - @TestMetadata("extensionMemberInClassObject.kt") - public void testExtensionMemberInClassObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/extensions/extensionMemberInClassObject.kt"); - } - - @Test - @TestMetadata("extensionPropertyVsParameter.kt") - public void testExtensionPropertyVsParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/extensions/extensionPropertyVsParameter.kt"); - } - - @Test - @TestMetadata("ExtensionsCalledOnSuper.kt") - public void testExtensionsCalledOnSuper() throws Exception { - runTest("compiler/testData/diagnostics/tests/extensions/ExtensionsCalledOnSuper.kt"); - } - - @Test - @TestMetadata("GenericIterator.kt") - public void testGenericIterator() throws Exception { - runTest("compiler/testData/diagnostics/tests/extensions/GenericIterator.kt"); - } - - @Test - @TestMetadata("GenericIterator2.kt") - public void testGenericIterator2() throws Exception { - runTest("compiler/testData/diagnostics/tests/extensions/GenericIterator2.kt"); - } - - @Test - @TestMetadata("kt1875.kt") - public void testKt1875() throws Exception { - runTest("compiler/testData/diagnostics/tests/extensions/kt1875.kt"); - } - - @Test - @TestMetadata("kt2317.kt") - public void testKt2317() throws Exception { - runTest("compiler/testData/diagnostics/tests/extensions/kt2317.kt"); - } - - @Test - @TestMetadata("kt3470.kt") - public void testKt3470() throws Exception { - runTest("compiler/testData/diagnostics/tests/extensions/kt3470.kt"); - } - - @Test - @TestMetadata("kt3563.kt") - public void testKt3563() throws Exception { - runTest("compiler/testData/diagnostics/tests/extensions/kt3563.kt"); - } - - @Test - @TestMetadata("kt819ExtensionProperties.kt") - public void testKt819ExtensionProperties() throws Exception { - runTest("compiler/testData/diagnostics/tests/extensions/kt819ExtensionProperties.kt"); - } - - @Test - @TestMetadata("noClassObjectsInJava.kt") - public void testNoClassObjectsInJava() throws Exception { - runTest("compiler/testData/diagnostics/tests/extensions/noClassObjectsInJava.kt"); - } - - @Test - @TestMetadata("object.kt") - public void testObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/extensions/object.kt"); - } - - @Test - @TestMetadata("throwOutCandidatesByReceiver.kt") - public void testThrowOutCandidatesByReceiver() throws Exception { - runTest("compiler/testData/diagnostics/tests/extensions/throwOutCandidatesByReceiver.kt"); - } - - @Test - @TestMetadata("throwOutCandidatesByReceiver2.kt") - public void testThrowOutCandidatesByReceiver2() throws Exception { - runTest("compiler/testData/diagnostics/tests/extensions/throwOutCandidatesByReceiver2.kt"); - } - - @Test - @TestMetadata("variableInvoke.kt") - public void testVariableInvoke() throws Exception { - runTest("compiler/testData/diagnostics/tests/extensions/variableInvoke.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/funInterface") - @TestDataPath("$PROJECT_ROOT") - public class FunInterface extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInFunInterface() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/funInterface"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("basicFunInterface.kt") - public void testBasicFunInterface() throws Exception { - runTest("compiler/testData/diagnostics/tests/funInterface/basicFunInterface.kt"); - } - - @Test - @TestMetadata("basicFunInterfaceConversion.kt") - public void testBasicFunInterfaceConversion() throws Exception { - runTest("compiler/testData/diagnostics/tests/funInterface/basicFunInterfaceConversion.kt"); - } - - @Test - @TestMetadata("basicFunInterfaceDisabled.kt") - public void testBasicFunInterfaceDisabled() throws Exception { - runTest("compiler/testData/diagnostics/tests/funInterface/basicFunInterfaceDisabled.kt"); - } - - @Test - @TestMetadata("funInterfaceConversionOnReceiver.kt") - public void testFunInterfaceConversionOnReceiver() throws Exception { - runTest("compiler/testData/diagnostics/tests/funInterface/funInterfaceConversionOnReceiver.kt"); - } - - @Test - @TestMetadata("funInterfaceDeclarationCheck.kt") - public void testFunInterfaceDeclarationCheck() throws Exception { - runTest("compiler/testData/diagnostics/tests/funInterface/funInterfaceDeclarationCheck.kt"); - } - - @Test - @TestMetadata("funInterfaceSyntheticConstructors.kt") - public void testFunInterfaceSyntheticConstructors() throws Exception { - runTest("compiler/testData/diagnostics/tests/funInterface/funInterfaceSyntheticConstructors.kt"); - } - - @Test - @TestMetadata("funIsNotInheritedFromBaseInterface.kt") - public void testFunIsNotInheritedFromBaseInterface() throws Exception { - runTest("compiler/testData/diagnostics/tests/funInterface/funIsNotInheritedFromBaseInterface.kt"); - } - - @Test - @TestMetadata("functionDelegateClashOnJvm.kt") - public void testFunctionDelegateClashOnJvm() throws Exception { - runTest("compiler/testData/diagnostics/tests/funInterface/functionDelegateClashOnJvm.kt"); - } - - @Test - @TestMetadata("genericSubstitutionForFunInterface.kt") - public void testGenericSubstitutionForFunInterface() throws Exception { - runTest("compiler/testData/diagnostics/tests/funInterface/genericSubstitutionForFunInterface.kt"); - } - - @Test - @TestMetadata("noCompatibilityResolveForFunInterfaces.kt") - public void testNoCompatibilityResolveForFunInterfaces() throws Exception { - runTest("compiler/testData/diagnostics/tests/funInterface/noCompatibilityResolveForFunInterfaces.kt"); - } - - @Test - @TestMetadata("prohibitFunInterfaceConstructorReferences.kt") - public void testProhibitFunInterfaceConstructorReferences() throws Exception { - runTest("compiler/testData/diagnostics/tests/funInterface/prohibitFunInterfaceConstructorReferences.kt"); - } - - @Test - @TestMetadata("resolveFunInterfaceWithoutMainMethod.kt") - public void testResolveFunInterfaceWithoutMainMethod() throws Exception { - runTest("compiler/testData/diagnostics/tests/funInterface/resolveFunInterfaceWithoutMainMethod.kt"); - } - - @Test - @TestMetadata("severalConversionsForFunInterface.kt") - public void testSeveralConversionsForFunInterface() throws Exception { - runTest("compiler/testData/diagnostics/tests/funInterface/severalConversionsForFunInterface.kt"); - } - - @Test - @TestMetadata("suspendFunInterfaceConversion.kt") - public void testSuspendFunInterfaceConversion() throws Exception { - runTest("compiler/testData/diagnostics/tests/funInterface/suspendFunInterfaceConversion.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/functionAsExpression") - @TestDataPath("$PROJECT_ROOT") - public class FunctionAsExpression extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInFunctionAsExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/functionAsExpression"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("AutoLabels.kt") - public void testAutoLabels() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionAsExpression/AutoLabels.kt"); - } - - @Test - @TestMetadata("Common.kt") - public void testCommon() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionAsExpression/Common.kt"); - } - - @Test - @TestMetadata("DifficultInferenceForParameter.kt") - public void testDifficultInferenceForParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionAsExpression/DifficultInferenceForParameter.kt"); - } - - @Test - @TestMetadata("ForbiddenNonLocalReturn.kt") - public void testForbiddenNonLocalReturn() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionAsExpression/ForbiddenNonLocalReturn.kt"); - } - - @Test - @TestMetadata("FunctionType.kt") - public void testFunctionType() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionAsExpression/FunctionType.kt"); - } - - @Test - @TestMetadata("InferenceParametersTypes.kt") - public void testInferenceParametersTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionAsExpression/InferenceParametersTypes.kt"); - } - - @Test - @TestMetadata("MissingParameterTypes.kt") - public void testMissingParameterTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionAsExpression/MissingParameterTypes.kt"); - } - - @Test - @TestMetadata("NameDeprecation.kt") - public void testNameDeprecation() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionAsExpression/NameDeprecation.kt"); - } - - @Test - @TestMetadata("NoOverloadError.kt") - public void testNoOverloadError() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionAsExpression/NoOverloadError.kt"); - } - - @Test - @TestMetadata("Parameters.kt") - public void testParameters() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionAsExpression/Parameters.kt"); - } - - @Test - @TestMetadata("ReceiverByExpectedType.kt") - public void testReceiverByExpectedType() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionAsExpression/ReceiverByExpectedType.kt"); - } - - @Test - @TestMetadata("ReturnAndLabels.kt") - public void testReturnAndLabels() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionAsExpression/ReturnAndLabels.kt"); - } - - @Test - @TestMetadata("ReturnTypeCheck.kt") - public void testReturnTypeCheck() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionAsExpression/ReturnTypeCheck.kt"); - } - - @Test - @TestMetadata("ScopeCheck.kt") - public void testScopeCheck() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionAsExpression/ScopeCheck.kt"); - } - - @Test - @TestMetadata("WithGenericParameters.kt") - public void testWithGenericParameters() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionAsExpression/WithGenericParameters.kt"); - } - - @Test - @TestMetadata("WithOuterGeneric.kt") - public void testWithOuterGeneric() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionAsExpression/WithOuterGeneric.kt"); - } - - @Test - @TestMetadata("WithoutBody.kt") - public void testWithoutBody() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionAsExpression/WithoutBody.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/functionLiterals") - @TestDataPath("$PROJECT_ROOT") - public class FunctionLiterals extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInFunctionLiterals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/functionLiterals"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("assignmentOperationInLambda.kt") - public void testAssignmentOperationInLambda() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/assignmentOperationInLambda.kt"); - } - - @Test - @TestMetadata("assignmentOperationInLambdaWithExpectedType.kt") - public void testAssignmentOperationInLambdaWithExpectedType() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/assignmentOperationInLambdaWithExpectedType.kt"); - } - - @Test - @TestMetadata("DeprecatedSyntax.kt") - public void testDeprecatedSyntax() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/DeprecatedSyntax.kt"); - } - - @Test - @TestMetadata("ExpectedParameterTypeMismatchVariance.kt") - public void testExpectedParameterTypeMismatchVariance() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/ExpectedParameterTypeMismatchVariance.kt"); - } - - @Test - @TestMetadata("ExpectedParametersTypesMismatch.kt") - public void testExpectedParametersTypesMismatch() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/ExpectedParametersTypesMismatch.kt"); - } - - @Test - @TestMetadata("functionExpressionAsLastExpressionInBlock.kt") - public void testFunctionExpressionAsLastExpressionInBlock() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/functionExpressionAsLastExpressionInBlock.kt"); - } - - @Test - @TestMetadata("functionLIteralInBlockInIf.kt") - public void testFunctionLIteralInBlockInIf() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/functionLIteralInBlockInIf.kt"); - } - - @Test - @TestMetadata("functionLiteralAsArgumentForFunction.kt") - public void testFunctionLiteralAsArgumentForFunction() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/functionLiteralAsArgumentForFunction.kt"); - } - - @Test - @TestMetadata("functionLiteralInIf.kt") - public void testFunctionLiteralInIf() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/functionLiteralInIf.kt"); - } - - @Test - @TestMetadata("functionLiteralWithoutArgumentList.kt") - public void testFunctionLiteralWithoutArgumentList() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/functionLiteralWithoutArgumentList.kt"); - } - - @Test - @TestMetadata("genericFunctionalTypeOnRHSOfPlusAssign.kt") - public void testGenericFunctionalTypeOnRHSOfPlusAssign() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/genericFunctionalTypeOnRHSOfPlusAssign.kt"); - } - - @Test - @TestMetadata("higherOrderCallMissingParameters.kt") - public void testHigherOrderCallMissingParameters() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/higherOrderCallMissingParameters.kt"); - } - - @Test - @TestMetadata("kt11733.kt") - public void testKt11733() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/kt11733.kt"); - } - - @Test - @TestMetadata("kt11733_1.kt") - public void testKt11733_1() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/kt11733_1.kt"); - } - - @Test - @TestMetadata("kt16016.kt") - public void testKt16016() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/kt16016.kt"); - } - - @Test - @TestMetadata("kt2906.kt") - public void testKt2906() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/kt2906.kt"); - } - - @Test - @TestMetadata("kt3343.kt") - public void testKt3343() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/kt3343.kt"); - } - - @Test - @TestMetadata("kt4529.kt") - public void testKt4529() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/kt4529.kt"); - } - - @Test - @TestMetadata("kt6541_extensionForExtensionFunction.kt") - public void testKt6541_extensionForExtensionFunction() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/kt6541_extensionForExtensionFunction.kt"); - } - - @Test - @TestMetadata("kt6869.kt") - public void testKt6869() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/kt6869.kt"); - } - - @Test - @TestMetadata("kt7383_starProjectedFunction.kt") - public void testKt7383_starProjectedFunction() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/kt7383_starProjectedFunction.kt"); - } - - @Test - @TestMetadata("LabeledFunctionLiterals.kt") - public void testLabeledFunctionLiterals() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/LabeledFunctionLiterals.kt"); - } - - @Test - @TestMetadata("lambdaInLambda2.kt") - public void testLambdaInLambda2() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/lambdaInLambda2.kt"); - } - - @Test - @TestMetadata("missedTypeMismatch.kt") - public void testMissedTypeMismatch() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/missedTypeMismatch.kt"); - } - - @Test - @TestMetadata("prematurelyAnalyzingLambdaWhileFixingTypeVariableForAnotherArgument.kt") - public void testPrematurelyAnalyzingLambdaWhileFixingTypeVariableForAnotherArgument() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/prematurelyAnalyzingLambdaWhileFixingTypeVariableForAnotherArgument.kt"); - } - - @Test - @TestMetadata("returnNull.kt") - public void testReturnNull() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/returnNull.kt"); - } - - @Test - @TestMetadata("returnNullWithReturn.kt") - public void testReturnNullWithReturn() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/returnNullWithReturn.kt"); - } - - @Test - @TestMetadata("underscopeParameters.kt") - public void testUnderscopeParameters() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/underscopeParameters.kt"); - } - - @Test - @TestMetadata("unusedLiteral.kt") - public void testUnusedLiteral() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/unusedLiteral.kt"); - } - - @Test - @TestMetadata("unusedLiteralInsideUnitLiteral.kt") - public void testUnusedLiteralInsideUnitLiteral() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/unusedLiteralInsideUnitLiteral.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas") - @TestDataPath("$PROJECT_ROOT") - public class DestructuringInLambdas extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInDestructuringInLambdas() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("complexInference.kt") - public void testComplexInference() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/complexInference.kt"); - } - - @Test - @TestMetadata("extensionComponents.kt") - public void testExtensionComponents() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/extensionComponents.kt"); - } - - @Test - @TestMetadata("inferredFunctionalType.kt") - public void testInferredFunctionalType() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/inferredFunctionalType.kt"); - } - - @Test - @TestMetadata("modifiers.kt") - public void testModifiers() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/modifiers.kt"); - } - - @Test - @TestMetadata("noExpectedType.kt") - public void testNoExpectedType() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/noExpectedType.kt"); - } - - @Test - @TestMetadata("redeclaration.kt") - public void testRedeclaration() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/redeclaration.kt"); - } - - @Test - @TestMetadata("shadowing.kt") - public void testShadowing() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/shadowing.kt"); - } - - @Test - @TestMetadata("simple.kt") - public void testSimple() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/simple.kt"); - } - - @Test - @TestMetadata("underscore.kt") - public void testUnderscore() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/underscore.kt"); - } - - @Test - @TestMetadata("unsupportedFeature.kt") - public void testUnsupportedFeature() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/unsupportedFeature.kt"); - } - - @Test - @TestMetadata("unusedParameters.kt") - public void testUnusedParameters() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/unusedParameters.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/functionLiterals/return") - @TestDataPath("$PROJECT_ROOT") - public class Return extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInReturn() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/functionLiterals/return"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("AutoLabels.kt") - public void testAutoLabels() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/return/AutoLabels.kt"); - } - - @Test - @TestMetadata("AutoLabelsNonLocal.kt") - public void testAutoLabelsNonLocal() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/return/AutoLabelsNonLocal.kt"); - } - - @Test - @TestMetadata("ForbiddenNonLocalReturnNoType.kt") - public void testForbiddenNonLocalReturnNoType() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/return/ForbiddenNonLocalReturnNoType.kt"); - } - - @Test - @TestMetadata("IfInReturnedExpression.kt") - public void testIfInReturnedExpression() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/return/IfInReturnedExpression.kt"); - } - - @Test - @TestMetadata("IfWithoutElse.kt") - public void testIfWithoutElse() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/return/IfWithoutElse.kt"); - } - - @Test - @TestMetadata("IfWithoutElseWithExplicitType.kt") - public void testIfWithoutElseWithExplicitType() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/return/IfWithoutElseWithExplicitType.kt"); - } - - @Test - @TestMetadata("LambdaWithParameter.kt") - public void testLambdaWithParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/return/LambdaWithParameter.kt"); - } - - @Test - @TestMetadata("LocalAndNonLocalReturnInLambda.kt") - public void testLocalAndNonLocalReturnInLambda() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/return/LocalAndNonLocalReturnInLambda.kt"); - } - - @Test - @TestMetadata("LocalReturnExplicitLabelNoParens.kt") - public void testLocalReturnExplicitLabelNoParens() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnExplicitLabelNoParens.kt"); - } - - @Test - @TestMetadata("LocalReturnExplicitLabelParens.kt") - public void testLocalReturnExplicitLabelParens() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnExplicitLabelParens.kt"); - } - - @Test - @TestMetadata("LocalReturnHasTypeNothing.kt") - public void testLocalReturnHasTypeNothing() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnHasTypeNothing.kt"); - } - - @Test - @TestMetadata("LocalReturnInNestedFunction.kt") - public void testLocalReturnInNestedFunction() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnInNestedFunction.kt"); - } - - @Test - @TestMetadata("LocalReturnInNestedLambda.kt") - public void testLocalReturnInNestedLambda() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnInNestedLambda.kt"); - } - - @Test - @TestMetadata("LocalReturnNoCoercionToUnit.kt") - public void testLocalReturnNoCoercionToUnit() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnNoCoercionToUnit.kt"); - } - - @Test - @TestMetadata("LocalReturnNull.kt") - public void testLocalReturnNull() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnNull.kt"); - } - - @Test - @TestMetadata("LocalReturnSecondUnit.kt") - public void testLocalReturnSecondUnit() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnSecondUnit.kt"); - } - - @Test - @TestMetadata("LocalReturnUnit.kt") - public void testLocalReturnUnit() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnUnit.kt"); - } - - @Test - @TestMetadata("LocalReturnUnitAndDontCareType.kt") - public void testLocalReturnUnitAndDontCareType() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnUnitAndDontCareType.kt"); - } - - @Test - @TestMetadata("LocalReturnUnitWithBodyExpression.kt") - public void testLocalReturnUnitWithBodyExpression() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnUnitWithBodyExpression.kt"); - } - - @Test - @TestMetadata("LocalReturnWithExpectedType.kt") - public void testLocalReturnWithExpectedType() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnWithExpectedType.kt"); - } - - @Test - @TestMetadata("LocalReturnWithExplicitUnit.kt") - public void testLocalReturnWithExplicitUnit() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnWithExplicitUnit.kt"); - } - - @Test - @TestMetadata("LocalReturnsWithExplicitReturnType.kt") - public void testLocalReturnsWithExplicitReturnType() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/return/LocalReturnsWithExplicitReturnType.kt"); - } - - @Test - @TestMetadata("MixedReturnsFromLambda.kt") - public void testMixedReturnsFromLambda() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/return/MixedReturnsFromLambda.kt"); - } - - @Test - @TestMetadata("NoCommonSystem.kt") - public void testNoCommonSystem() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/return/NoCommonSystem.kt"); - } - - @Test - @TestMetadata("SmartCast.kt") - public void testSmartCast() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/return/SmartCast.kt"); - } - - @Test - @TestMetadata("SmartCastWithExplicitType.kt") - public void testSmartCastWithExplicitType() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/return/SmartCastWithExplicitType.kt"); - } - - @Test - @TestMetadata("unresolvedReferenceInReturnBlock.kt") - public void testUnresolvedReferenceInReturnBlock() throws Exception { - runTest("compiler/testData/diagnostics/tests/functionLiterals/return/unresolvedReferenceInReturnBlock.kt"); - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/generics") - @TestDataPath("$PROJECT_ROOT") - public class Generics extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInGenerics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("argumentsForT.kt") - public void testArgumentsForT() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/argumentsForT.kt"); - } - - @Test - @TestMetadata("bareTypesWithStarProjections.kt") - public void testBareTypesWithStarProjections() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/bareTypesWithStarProjections.kt"); - } - - @Test - @TestMetadata("commonSupertypeContravariant.kt") - public void testCommonSupertypeContravariant() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/commonSupertypeContravariant.kt"); - } - - @Test - @TestMetadata("commonSupertypeContravariant2.kt") - public void testCommonSupertypeContravariant2() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/commonSupertypeContravariant2.kt"); - } - - @Test - @TestMetadata("doNotCaptureSupertype.kt") - public void testDoNotCaptureSupertype() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/doNotCaptureSupertype.kt"); - } - - @Test - @TestMetadata("finalUpperBoundWithOverride.kt") - public void testFinalUpperBoundWithOverride() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/finalUpperBoundWithOverride.kt"); - } - - @Test - @TestMetadata("finalUpperBoundWithoutOverride.kt") - public void testFinalUpperBoundWithoutOverride() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/finalUpperBoundWithoutOverride.kt"); - } - - @Test - @TestMetadata("genericsInType.kt") - public void testGenericsInType() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/genericsInType.kt"); - } - - @Test - @TestMetadata("InconsistentTypeParameterBounds.kt") - public void testInconsistentTypeParameterBounds() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/InconsistentTypeParameterBounds.kt"); - } - - @Test - @TestMetadata("invalidArgumentsNumberInWhere.kt") - public void testInvalidArgumentsNumberInWhere() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/invalidArgumentsNumberInWhere.kt"); - } - - @Test - @TestMetadata("kt1575-Class.kt") - public void testKt1575_Class() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/kt1575-Class.kt"); - } - - @Test - @TestMetadata("kt1575-Function.kt") - public void testKt1575_Function() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/kt1575-Function.kt"); - } - - @Test - @TestMetadata("kt30590.kt") - public void testKt30590() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/kt30590.kt"); - } - - @Test - @TestMetadata("kt34729.kt") - public void testKt34729() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/kt34729.kt"); - } - - @Test - @TestMetadata("kt5508.kt") - public void testKt5508() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/kt5508.kt"); - } - - @Test - @TestMetadata("kt9203.kt") - public void testKt9203() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/kt9203.kt"); - } - - @Test - @TestMetadata("kt9203_1.kt") - public void testKt9203_1() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/kt9203_1.kt"); - } - - @Test - @TestMetadata("kt9985.kt") - public void testKt9985() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/kt9985.kt"); - } - - @Test - @TestMetadata("Projections.kt") - public void testProjections() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/Projections.kt"); - } - - @Test - @TestMetadata("protectedSuperCall.kt") - public void testProtectedSuperCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/protectedSuperCall.kt"); - } - - @Test - @TestMetadata("PseudoRawTypes.kt") - public void testPseudoRawTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/PseudoRawTypes.kt"); - } - - @Test - @TestMetadata("RawTypeInIsExpression.kt") - public void testRawTypeInIsExpression() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/RawTypeInIsExpression.kt"); - } - - @Test - @TestMetadata("RawTypeInIsPattern.kt") - public void testRawTypeInIsPattern() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/RawTypeInIsPattern.kt"); - } - - @Test - @TestMetadata("recursive.kt") - public void testRecursive() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/recursive.kt"); - } - - @Test - @TestMetadata("RecursiveUpperBoundCheck.kt") - public void testRecursiveUpperBoundCheck() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/RecursiveUpperBoundCheck.kt"); - } - - @Test - @TestMetadata("RecursiveUpperBoundWithTwoArguments.kt") - public void testRecursiveUpperBoundWithTwoArguments() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/RecursiveUpperBoundWithTwoArguments.kt"); - } - - @Test - @TestMetadata("resolveGenericBoundsBeforeSupertypes.kt") - public void testResolveGenericBoundsBeforeSupertypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/resolveGenericBoundsBeforeSupertypes.kt"); - } - - @Test - @TestMetadata("sameTypeParameterUse.kt") - public void testSameTypeParameterUse() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/sameTypeParameterUse.kt"); - } - - @Test - @TestMetadata("suppressVarianceConflict.kt") - public void testSuppressVarianceConflict() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/suppressVarianceConflict.kt"); - } - - @Test - @TestMetadata("TypeParameterBounds.kt") - public void testTypeParameterBounds() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/TypeParameterBounds.kt"); - } - - @Test - @TestMetadata("TypeParametersInTypeParameterBounds.kt") - public void testTypeParametersInTypeParameterBounds() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/TypeParametersInTypeParameterBounds.kt"); - } - - @Test - @TestMetadata("unresolvedClassifierInWhere.kt") - public void testUnresolvedClassifierInWhere() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/unresolvedClassifierInWhere.kt"); - } - - @Test - @TestMetadata("wildcardInValueParameter.kt") - public void testWildcardInValueParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/wildcardInValueParameter.kt"); - } - - @Test - @TestMetadata("wrongNumberOfTypeArgumentsDiagnostic.kt") - public void testWrongNumberOfTypeArgumentsDiagnostic() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/wrongNumberOfTypeArgumentsDiagnostic.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/generics/capturedParameters") - @TestDataPath("$PROJECT_ROOT") - public class CapturedParameters extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInCapturedParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/capturedParameters"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("captured.kt") - public void testCaptured() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/capturedParameters/captured.kt"); - } - - @Test - @TestMetadata("innerLocalClass.kt") - public void testInnerLocalClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/capturedParameters/innerLocalClass.kt"); - } - - @Test - @TestMetadata("localClass.kt") - public void testLocalClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/capturedParameters/localClass.kt"); - } - - @Test - @TestMetadata("localWithTypeParameter.kt") - public void testLocalWithTypeParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/capturedParameters/localWithTypeParameter.kt"); - } - - @Test - @TestMetadata("objectLiteral.kt") - public void testObjectLiteral() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/capturedParameters/objectLiteral.kt"); - } - - @Test - @TestMetadata("uncheckedCast.kt") - public void testUncheckedCast() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/capturedParameters/uncheckedCast.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/generics/cyclicBounds") - @TestDataPath("$PROJECT_ROOT") - public class CyclicBounds extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInCyclicBounds() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/cyclicBounds"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("functions.kt") - public void testFunctions() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/cyclicBounds/functions.kt"); - } - - @Test - @TestMetadata("inClass.kt") - public void testInClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/cyclicBounds/inClass.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/generics/innerClasses") - @TestDataPath("$PROJECT_ROOT") - public class InnerClasses extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInInnerClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/innerClasses"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("bareTypes.kt") - public void testBareTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/innerClasses/bareTypes.kt"); - } - - @Test - @TestMetadata("bareTypesComplex.kt") - public void testBareTypesComplex() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/innerClasses/bareTypesComplex.kt"); - } - - @Test - @TestMetadata("checkBoundsOuter.kt") - public void testCheckBoundsOuter() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/innerClasses/checkBoundsOuter.kt"); - } - - @Test - @TestMetadata("importedInner.kt") - public void testImportedInner() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/innerClasses/importedInner.kt"); - } - - @Test - @TestMetadata("innerSuperCall.kt") - public void testInnerSuperCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/innerClasses/innerSuperCall.kt"); - } - - @Test - @TestMetadata("innerSuperCallSecondary.kt") - public void testInnerSuperCallSecondary() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/innerClasses/innerSuperCallSecondary.kt"); - } - - @Test - @TestMetadata("innerTP.kt") - public void testInnerTP() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/innerClasses/innerTP.kt"); - } - - @Test - @TestMetadata("innerUncheckedCast.kt") - public void testInnerUncheckedCast() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/innerClasses/innerUncheckedCast.kt"); - } - - @Test - @TestMetadata("innerVariance.kt") - public void testInnerVariance() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/innerClasses/innerVariance.kt"); - } - - @Test - @TestMetadata("iterator.kt") - public void testIterator() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/innerClasses/iterator.kt"); - } - - @Test - @TestMetadata("j+k.kt") - public void testJ_k() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/innerClasses/j+k.kt"); - } - - @Test - @TestMetadata("j+k_complex.kt") - public void testJ_k_complex() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/innerClasses/j+k_complex.kt"); - } - - @Test - @TestMetadata("kt3357.kt") - public void testKt3357() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/innerClasses/kt3357.kt"); - } - - @Test - @TestMetadata("kt408.kt") - public void testKt408() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/innerClasses/kt408.kt"); - } - - @Test - @TestMetadata("kt6325.kt") - public void testKt6325() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/innerClasses/kt6325.kt"); - } - - @Test - @TestMetadata("outerArgumentsRequired.kt") - public void testOuterArgumentsRequired() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/innerClasses/outerArgumentsRequired.kt"); - } - - @Test - @TestMetadata("parameterShadowing.kt") - public void testParameterShadowing() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/innerClasses/parameterShadowing.kt"); - } - - @Test - @TestMetadata("qualifiedOuter.kt") - public void testQualifiedOuter() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/innerClasses/qualifiedOuter.kt"); - } - - @Test - @TestMetadata("qualifiedTypesResolution.kt") - public void testQualifiedTypesResolution() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/innerClasses/qualifiedTypesResolution.kt"); - } - - @Test - @TestMetadata("simple.kt") - public void testSimple() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/innerClasses/simple.kt"); - } - - @Test - @TestMetadata("simpleIn.kt") - public void testSimpleIn() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/innerClasses/simpleIn.kt"); - } - - @Test - @TestMetadata("simpleOut.kt") - public void testSimpleOut() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/innerClasses/simpleOut.kt"); - } - - @Test - @TestMetadata("simpleOutUseSite.kt") - public void testSimpleOutUseSite() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/innerClasses/simpleOutUseSite.kt"); - } - - @Test - @TestMetadata("substitutedMemberScope.kt") - public void testSubstitutedMemberScope() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/innerClasses/substitutedMemberScope.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments") - @TestDataPath("$PROJECT_ROOT") - public class ImplicitArguments extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInImplicitArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("fromCompanionObject_after.kt") - public void testFromCompanionObject_after() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromCompanionObject_after.kt"); - } - - @Test - @TestMetadata("fromCompanionObject_before.kt") - public void testFromCompanionObject_before() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromCompanionObject_before.kt"); - } - - @Test - @TestMetadata("fromOuterClassInObjectLiteral.kt") - public void testFromOuterClassInObjectLiteral() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromOuterClassInObjectLiteral.kt"); - } - - @Test - @TestMetadata("fromSuperClasses.kt") - public void testFromSuperClasses() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClasses.kt"); - } - - @Test - @TestMetadata("fromSuperClassesLocal.kt") - public void testFromSuperClassesLocal() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClassesLocal.kt"); - } - - @Test - @TestMetadata("fromSuperClassesLocalInsideInner.kt") - public void testFromSuperClassesLocalInsideInner() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClassesLocalInsideInner.kt"); - } - - @Test - @TestMetadata("fromSuperClassesTransitive.kt") - public void testFromSuperClassesTransitive() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClassesTransitive.kt"); - } - - @Test - @TestMetadata("inStaticScope.kt") - public void testInStaticScope() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/inStaticScope.kt"); - } - - @Test - @TestMetadata("secondLevelDepth.kt") - public void testSecondLevelDepth() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/secondLevelDepth.kt"); - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/generics/multipleBoundsMemberScope") - @TestDataPath("$PROJECT_ROOT") - public class MultipleBoundsMemberScope extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInMultipleBoundsMemberScope() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/multipleBoundsMemberScope"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("conflictingReturnType.kt") - public void testConflictingReturnType() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/multipleBoundsMemberScope/conflictingReturnType.kt"); - } - - @Test - @TestMetadata("flexibleTypes.kt") - public void testFlexibleTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/multipleBoundsMemberScope/flexibleTypes.kt"); - } - - @Test - @TestMetadata("mostSpecific.kt") - public void testMostSpecific() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/multipleBoundsMemberScope/mostSpecific.kt"); - } - - @Test - @TestMetadata("properties.kt") - public void testProperties() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/multipleBoundsMemberScope/properties.kt"); - } - - @Test - @TestMetadata("propertiesConflict.kt") - public void testPropertiesConflict() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/multipleBoundsMemberScope/propertiesConflict.kt"); - } - - @Test - @TestMetadata("simple.kt") - public void testSimple() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/multipleBoundsMemberScope/simple.kt"); - } - - @Test - @TestMetadata("validTypeParameters.kt") - public void testValidTypeParameters() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/multipleBoundsMemberScope/validTypeParameters.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/generics/nullability") - @TestDataPath("$PROJECT_ROOT") - public class Nullability extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInNullability() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/nullability"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("capturedTypeWithPlatformSupertype.kt") - public void testCapturedTypeWithPlatformSupertype() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/nullability/capturedTypeWithPlatformSupertype.kt"); - } - - @Test - @TestMetadata("considerTypeNotNullOnlyIfItHasNotNullBound.kt") - public void testConsiderTypeNotNullOnlyIfItHasNotNullBound() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/nullability/considerTypeNotNullOnlyIfItHasNotNullBound.kt"); - } - - @Test - @TestMetadata("correctSubstitutionForIncorporationConstraint.kt") - public void testCorrectSubstitutionForIncorporationConstraint() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/nullability/correctSubstitutionForIncorporationConstraint.kt"); - } - - @Test - @TestMetadata("declarationsBoundsViolation.kt") - public void testDeclarationsBoundsViolation() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/nullability/declarationsBoundsViolation.kt"); - } - - @Test - @TestMetadata("expressionsBoundsViolation.kt") - public void testExpressionsBoundsViolation() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/nullability/expressionsBoundsViolation.kt"); - } - - @Test - @TestMetadata("functionalBound.kt") - public void testFunctionalBound() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/nullability/functionalBound.kt"); - } - - @Test - @TestMetadata("inferNotNullTypeFromIntersectionOfNullableTypes.kt") - public void testInferNotNullTypeFromIntersectionOfNullableTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/nullability/inferNotNullTypeFromIntersectionOfNullableTypes.kt"); - } - - @Test - @TestMetadata("kt25182.kt") - public void testKt25182() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/nullability/kt25182.kt"); - } - - @Test - @TestMetadata("notNullSmartcastOnIntersectionOfNullables.kt") - public void testNotNullSmartcastOnIntersectionOfNullables() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/nullability/notNullSmartcastOnIntersectionOfNullables.kt"); - } - - @Test - @TestMetadata("nullToGeneric.kt") - public void testNullToGeneric() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/nullability/nullToGeneric.kt"); - } - - @Test - @TestMetadata("smartCastRefinedClass.kt") - public void testSmartCastRefinedClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/nullability/smartCastRefinedClass.kt"); - } - - @Test - @TestMetadata("smartCasts.kt") - public void testSmartCasts() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/nullability/smartCasts.kt"); - } - - @Test - @TestMetadata("smartCastsOnThis.kt") - public void testSmartCastsOnThis() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/nullability/smartCastsOnThis.kt"); - } - - @Test - @TestMetadata("smartCastsValueArgument.kt") - public void testSmartCastsValueArgument() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/nullability/smartCastsValueArgument.kt"); - } - - @Test - @TestMetadata("tpBoundsViolation.kt") - public void testTpBoundsViolation() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/nullability/tpBoundsViolation.kt"); - } - - @Test - @TestMetadata("tpBoundsViolationVariance.kt") - public void testTpBoundsViolationVariance() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/nullability/tpBoundsViolationVariance.kt"); - } - - @Test - @TestMetadata("tpInBounds.kt") - public void testTpInBounds() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/nullability/tpInBounds.kt"); - } - - @Test - @TestMetadata("useAsReceiver.kt") - public void testUseAsReceiver() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/nullability/useAsReceiver.kt"); - } - - @Test - @TestMetadata("useAsValueArgument.kt") - public void testUseAsValueArgument() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/nullability/useAsValueArgument.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/generics/projectionsScope") - @TestDataPath("$PROJECT_ROOT") - public class ProjectionsScope extends AbstractDiagnosticUsingJavacTest { - @Test - @TestMetadata("addAll.kt") - public void testAddAll() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/addAll.kt"); - } - - @Test - public void testAllFilesPresentInProjectionsScope() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/projectionsScope"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("approximateDispatchReceiver.kt") - public void testApproximateDispatchReceiver() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/approximateDispatchReceiver.kt"); - } - - @Test - @TestMetadata("extensionReceiverTypeMismatch.kt") - public void testExtensionReceiverTypeMismatch() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/extensionReceiverTypeMismatch.kt"); - } - - @Test - @TestMetadata("extensionResultSubstitution.kt") - public void testExtensionResultSubstitution() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/extensionResultSubstitution.kt"); - } - - @Test - @TestMetadata("flexibleProjectedScope.kt") - public void testFlexibleProjectedScope() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/flexibleProjectedScope.kt"); - } - - @Test - @TestMetadata("inValueParameter.kt") - public void testInValueParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/inValueParameter.kt"); - } - - @Test - @TestMetadata("iterateOnExtension.kt") - public void testIterateOnExtension() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/iterateOnExtension.kt"); - } - - @Test - @TestMetadata("kt7296.kt") - public void testKt7296() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/kt7296.kt"); - } - - @Test - @TestMetadata("kt8647.kt") - public void testKt8647() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/kt8647.kt"); - } - - @Test - @TestMetadata("lambdaArgument.kt") - public void testLambdaArgument() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/lambdaArgument.kt"); - } - - @Test - @TestMetadata("leakedApproximatedType.kt") - public void testLeakedApproximatedType() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/leakedApproximatedType.kt"); - } - - @Test - @TestMetadata("MLOut.kt") - public void testMLOut() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/MLOut.kt"); - } - - @Test - @TestMetadata("multipleArgumentProjectedOut.kt") - public void testMultipleArgumentProjectedOut() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/multipleArgumentProjectedOut.kt"); - } - - @Test - @TestMetadata("platformSuperClass.kt") - public void testPlatformSuperClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/platformSuperClass.kt"); - } - - @Test - @TestMetadata("projectedOutConventions.kt") - public void testProjectedOutConventions() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/projectedOutConventions.kt"); - } - - @Test - @TestMetadata("projectedOutSmartCast.kt") - public void testProjectedOutSmartCast() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/projectedOutSmartCast.kt"); - } - - @Test - @TestMetadata("recursiveUpperBoundStar.kt") - public void testRecursiveUpperBoundStar() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/recursiveUpperBoundStar.kt"); - } - - @Test - @TestMetadata("recursiveUpperBoundStarOut.kt") - public void testRecursiveUpperBoundStarOut() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/recursiveUpperBoundStarOut.kt"); - } - - @Test - @TestMetadata("starNullability.kt") - public void testStarNullability() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/starNullability.kt"); - } - - @Test - @TestMetadata("starNullabilityRecursive.kt") - public void testStarNullabilityRecursive() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/starNullabilityRecursive.kt"); - } - - @Test - @TestMetadata("superClass.kt") - public void testSuperClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/superClass.kt"); - } - - @Test - @TestMetadata("typeMismatchConventions.kt") - public void testTypeMismatchConventions() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/typeMismatchConventions.kt"); - } - - @Test - @TestMetadata("typeMismatchInLambda.kt") - public void testTypeMismatchInLambda() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/typeMismatchInLambda.kt"); - } - - @Test - @TestMetadata("typeParameterBounds.kt") - public void testTypeParameterBounds() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/typeParameterBounds.kt"); - } - - @Test - @TestMetadata("unsafeVarianceInAliasedFunctionalType.kt") - public void testUnsafeVarianceInAliasedFunctionalType() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/unsafeVarianceInAliasedFunctionalType.kt"); - } - - @Test - @TestMetadata("unsafeVarianceOnInputTypeOfFunctionalType.kt") - public void testUnsafeVarianceOnInputTypeOfFunctionalType() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/unsafeVarianceOnInputTypeOfFunctionalType.kt"); - } - - @Test - @TestMetadata("unsafeVarianceStar.kt") - public void testUnsafeVarianceStar() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/unsafeVarianceStar.kt"); - } - - @Test - @TestMetadata("unsafeVarianceWithRecursiveGenerics.kt") - public void testUnsafeVarianceWithRecursiveGenerics() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/unsafeVarianceWithRecursiveGenerics.kt"); - } - - @Test - @TestMetadata("varargs.kt") - public void testVarargs() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/projectionsScope/varargs.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/generics/starProjections") - @TestDataPath("$PROJECT_ROOT") - public class StarProjections extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInStarProjections() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/starProjections"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("checkBounds.kt") - public void testCheckBounds() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/starProjections/checkBounds.kt"); - } - - @Test - @TestMetadata("collectionInheritedFromJava.kt") - public void testCollectionInheritedFromJava() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/starProjections/collectionInheritedFromJava.kt"); - } - - @Test - @TestMetadata("foldRecursiveTypesToStarProjection.kt") - public void testFoldRecursiveTypesToStarProjection() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/starProjections/foldRecursiveTypesToStarProjection.kt"); - } - - @Test - @TestMetadata("inheritedFromJava.kt") - public void testInheritedFromJava() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/starProjections/inheritedFromJava.kt"); - } - - @Test - @TestMetadata("inheritedFromKotlin.kt") - public void testInheritedFromKotlin() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/starProjections/inheritedFromKotlin.kt"); - } - - @Test - @TestMetadata("invalid.kt") - public void testInvalid() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/starProjections/invalid.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/generics/tpAsReified") - @TestDataPath("$PROJECT_ROOT") - public class TpAsReified extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInTpAsReified() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/tpAsReified"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("CapturedAsReified.kt") - public void testCapturedAsReified() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/tpAsReified/CapturedAsReified.kt"); - } - - @Test - @TestMetadata("ClassDereference.kt") - public void testClassDereference() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/tpAsReified/ClassDereference.kt"); - } - - @Test - @TestMetadata("Conventions.kt") - public void testConventions() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/tpAsReified/Conventions.kt"); - } - - @Test - @TestMetadata("GenericArrayAsReifiedArgument.kt") - public void testGenericArrayAsReifiedArgument() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/tpAsReified/GenericArrayAsReifiedArgument.kt"); - } - - @Test - @TestMetadata("GenericArrayAsReifiedArgumentWarning.kt") - public void testGenericArrayAsReifiedArgumentWarning() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/tpAsReified/GenericArrayAsReifiedArgumentWarning.kt"); - } - - @Test - @TestMetadata("GenericAsReifiedArgument.kt") - public void testGenericAsReifiedArgument() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/tpAsReified/GenericAsReifiedArgument.kt"); - } - - @Test - @TestMetadata("InConstructor.kt") - public void testInConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/tpAsReified/InConstructor.kt"); - } - - @Test - @TestMetadata("InFunction.kt") - public void testInFunction() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/tpAsReified/InFunction.kt"); - } - - @Test - @TestMetadata("InProperty.kt") - public void testInProperty() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/tpAsReified/InProperty.kt"); - } - - @Test - @TestMetadata("InType.kt") - public void testInType() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/tpAsReified/InType.kt"); - } - - @Test - @TestMetadata("InlineableReified.kt") - public void testInlineableReified() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/tpAsReified/InlineableReified.kt"); - } - - @Test - @TestMetadata("LocalFun.kt") - public void testLocalFun() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/tpAsReified/LocalFun.kt"); - } - - @Test - @TestMetadata("NotInlineableReified.kt") - public void testNotInlineableReified() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/tpAsReified/NotInlineableReified.kt"); - } - - @Test - @TestMetadata("ReifiedClass.kt") - public void testReifiedClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/tpAsReified/ReifiedClass.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/generics/varProjection") - @TestDataPath("$PROJECT_ROOT") - public class VarProjection extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInVarProjection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/varProjection"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("setterNotProjectedOutAssign.kt") - public void testSetterNotProjectedOutAssign() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/varProjection/setterNotProjectedOutAssign.kt"); - } - - @Test - @TestMetadata("setterProjectedOutAssign.kt") - public void testSetterProjectedOutAssign() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/varProjection/setterProjectedOutAssign.kt"); - } - - @Test - @TestMetadata("setterProjectedOutNoPlusAssign.kt") - public void testSetterProjectedOutNoPlusAssign() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/varProjection/setterProjectedOutNoPlusAssign.kt"); - } - - @Test - @TestMetadata("setterProjectedOutPlusAssignDefined.kt") - public void testSetterProjectedOutPlusAssignDefined() throws Exception { - runTest("compiler/testData/diagnostics/tests/generics/varProjection/setterProjectedOutPlusAssignDefined.kt"); - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/imports") - @TestDataPath("$PROJECT_ROOT") - public class Imports extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInImports() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/imports"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("AllUnderImportsAmbiguity.kt") - public void testAllUnderImportsAmbiguity() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/AllUnderImportsAmbiguity.kt"); - } - - @Test - @TestMetadata("AllUnderImportsLessPriority.kt") - public void testAllUnderImportsLessPriority() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/AllUnderImportsLessPriority.kt"); - } - - @Test - @TestMetadata("AllUnderImportsSamePriorityForFunction.kt") - public void testAllUnderImportsSamePriorityForFunction() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/AllUnderImportsSamePriorityForFunction.kt"); - } - - @Test - @TestMetadata("AllUnderImportsSamePriorityForProperty.kt") - public void testAllUnderImportsSamePriorityForProperty() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/AllUnderImportsSamePriorityForProperty.kt"); - } - - @Test - @TestMetadata("CheckJavaVisibility.kt") - public void testCheckJavaVisibility() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/CheckJavaVisibility.kt"); - } - - @Test - @TestMetadata("CheckJavaVisibility2.kt") - public void testCheckJavaVisibility2() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/CheckJavaVisibility2.kt"); - } - - @Test - @TestMetadata("CheckVisibility.kt") - public void testCheckVisibility() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/CheckVisibility.kt"); - } - - @Test - @TestMetadata("ClassClash.kt") - public void testClassClash() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/ClassClash.kt"); - } - - @Test - @TestMetadata("ClassClashStarImport.kt") - public void testClassClashStarImport() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/ClassClashStarImport.kt"); - } - - @Test - @TestMetadata("ClassImportsConflicting.kt") - public void testClassImportsConflicting() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/ClassImportsConflicting.kt"); - } - - @Test - @TestMetadata("CurrentPackageAndAllUnderImport.kt") - public void testCurrentPackageAndAllUnderImport() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/CurrentPackageAndAllUnderImport.kt"); - } - - @Test - @TestMetadata("CurrentPackageAndExplicitImport.kt") - public void testCurrentPackageAndExplicitImport() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/CurrentPackageAndExplicitImport.kt"); - } - - @Test - @TestMetadata("DefaultImportsPriority.kt") - public void testDefaultImportsPriority() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/DefaultImportsPriority.kt"); - } - - @Test - @TestMetadata("ExplicitImportsAmbiguity.kt") - public void testExplicitImportsAmbiguity() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/ExplicitImportsAmbiguity.kt"); - } - - @Test - @TestMetadata("ExplicitImportsUnambiguityForFunction.kt") - public void testExplicitImportsUnambiguityForFunction() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/ExplicitImportsUnambiguityForFunction.kt"); - } - - @Test - @TestMetadata("ExplicitPackageImportsAmbiguity.kt") - public void testExplicitPackageImportsAmbiguity() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/ExplicitPackageImportsAmbiguity.kt"); - } - - @Test - @TestMetadata("ImportClassClash.kt") - public void testImportClassClash() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/ImportClassClash.kt"); - } - - @Test - @TestMetadata("ImportFromCompanionObject.kt") - public void testImportFromCompanionObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/ImportFromCompanionObject.kt"); - } - - @Test - @TestMetadata("ImportFromCurrentWithDifferentName.kt") - public void testImportFromCurrentWithDifferentName() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/ImportFromCurrentWithDifferentName.kt"); - } - - @Test - @TestMetadata("ImportFromObject.kt") - public void testImportFromObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/ImportFromObject.kt"); - } - - @Test - @TestMetadata("ImportFromRootPackage.kt") - public void testImportFromRootPackage() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/ImportFromRootPackage.kt"); - } - - @Test - @TestMetadata("importFunctionWithAllUnderImport.kt") - public void testImportFunctionWithAllUnderImport() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/importFunctionWithAllUnderImport.kt"); - } - - @Test - @TestMetadata("importFunctionWithAllUnderImportAfterNamedImport.kt") - public void testImportFunctionWithAllUnderImportAfterNamedImport() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/importFunctionWithAllUnderImportAfterNamedImport.kt"); - } - - @Test - @TestMetadata("ImportHidingDefinitionInTheSameFile.kt") - public void testImportHidingDefinitionInTheSameFile() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/ImportHidingDefinitionInTheSameFile.kt"); - } - - @Test - @TestMetadata("ImportNestedWithDifferentName.kt") - public void testImportNestedWithDifferentName() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/ImportNestedWithDifferentName.kt"); - } - - @Test - @TestMetadata("ImportObjectAndUseAsSupertype.kt") - public void testImportObjectAndUseAsSupertype() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/ImportObjectAndUseAsSupertype.kt"); - } - - @Test - @TestMetadata("ImportObjectHidesCurrentPackage.kt") - public void testImportObjectHidesCurrentPackage() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/ImportObjectHidesCurrentPackage.kt"); - } - - @Test - @TestMetadata("ImportOverloadFunctions.kt") - public void testImportOverloadFunctions() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/ImportOverloadFunctions.kt"); - } - - @Test - @TestMetadata("ImportPrivateMember.kt") - public void testImportPrivateMember() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/ImportPrivateMember.kt"); - } - - @Test - @TestMetadata("ImportPrivateMemberFromOtherFile.kt") - public void testImportPrivateMemberFromOtherFile() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/ImportPrivateMemberFromOtherFile.kt"); - } - - @Test - @TestMetadata("ImportPrivateMembersWithStar.kt") - public void testImportPrivateMembersWithStar() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/ImportPrivateMembersWithStar.kt"); - } - - @Test - @TestMetadata("ImportProtectedClass.kt") - public void testImportProtectedClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/ImportProtectedClass.kt"); - } - - @Test - @TestMetadata("ImportResolutionOrder.kt") - public void testImportResolutionOrder() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/ImportResolutionOrder.kt"); - } - - @Test - @TestMetadata("ImportTwoTimes.kt") - public void testImportTwoTimes() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/ImportTwoTimes.kt"); - } - - @Test - @TestMetadata("ImportTwoTimesStar.kt") - public void testImportTwoTimesStar() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/ImportTwoTimesStar.kt"); - } - - @Test - @TestMetadata("Imports.kt") - public void testImports() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/Imports.kt"); - } - - @Test - @TestMetadata("ImportsConflicting.kt") - public void testImportsConflicting() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/ImportsConflicting.kt"); - } - - @Test - @TestMetadata("InaccessiblePrivateClass.kt") - public void testInaccessiblePrivateClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/InaccessiblePrivateClass.kt"); - } - - @Test - @TestMetadata("invisibleFakeReferenceInImport.kt") - public void testInvisibleFakeReferenceInImport() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/invisibleFakeReferenceInImport.kt"); - } - - @Test - @TestMetadata("JavaPackageLocalClassNotImported.kt") - public void testJavaPackageLocalClassNotImported() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/JavaPackageLocalClassNotImported.kt"); - } - - @Test - @TestMetadata("kt13112.kt") - public void testKt13112() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/kt13112.kt"); - } - - @Test - @TestMetadata("MalformedImports.kt") - public void testMalformedImports() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/MalformedImports.kt"); - } - - @Test - @TestMetadata("NestedClassClash.kt") - public void testNestedClassClash() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/NestedClassClash.kt"); - } - - @Test - @TestMetadata("OperatorRenameOnImport.kt") - public void testOperatorRenameOnImport() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/OperatorRenameOnImport.kt"); - } - - @Test - @TestMetadata("PackageLocalClassNotImported.kt") - public void testPackageLocalClassNotImported() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/PackageLocalClassNotImported.kt"); - } - - @Test - @TestMetadata("PackageLocalClassReferencedError.kt") - public void testPackageLocalClassReferencedError() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/PackageLocalClassReferencedError.kt"); - } - - @Test - @TestMetadata("PackageVsClass.kt") - public void testPackageVsClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/PackageVsClass.kt"); - } - - @Test - @TestMetadata("PrivateClassNotImported.kt") - public void testPrivateClassNotImported() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/PrivateClassNotImported.kt"); - } - - @Test - @TestMetadata("PrivateClassReferencedError.kt") - public void testPrivateClassReferencedError() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/PrivateClassReferencedError.kt"); - } - - @Test - @TestMetadata("propertyClassFileDependencyRecursion.kt") - public void testPropertyClassFileDependencyRecursion() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/propertyClassFileDependencyRecursion.kt"); - } - - @Test - @TestMetadata("RenameOnImport.kt") - public void testRenameOnImport() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/RenameOnImport.kt"); - } - - @Test - @TestMetadata("StarImportFromObject.kt") - public void testStarImportFromObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/StarImportFromObject.kt"); - } - - @Test - @TestMetadata("SyntaxError.kt") - public void testSyntaxError() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/SyntaxError.kt"); - } - - @Test - @TestMetadata("TopLevelClassVsPackage.kt") - public void testTopLevelClassVsPackage() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/TopLevelClassVsPackage.kt"); - } - - @Test - @TestMetadata("twoImportLists.kt") - public void testTwoImportLists() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/twoImportLists.kt"); - } - - @Test - @TestMetadata("WrongImport.kt") - public void testWrongImport() throws Exception { - runTest("compiler/testData/diagnostics/tests/imports/WrongImport.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/incompleteCode") - @TestDataPath("$PROJECT_ROOT") - public class IncompleteCode extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInIncompleteCode() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/incompleteCode"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("arrayBracketsRange.kt") - public void testArrayBracketsRange() throws Exception { - runTest("compiler/testData/diagnostics/tests/incompleteCode/arrayBracketsRange.kt"); - } - - @Test - @TestMetadata("checkNothingIsSubtype.kt") - public void testCheckNothingIsSubtype() throws Exception { - runTest("compiler/testData/diagnostics/tests/incompleteCode/checkNothingIsSubtype.kt"); - } - - @Test - @TestMetadata("controlStructuresErrors.kt") - public void testControlStructuresErrors() throws Exception { - runTest("compiler/testData/diagnostics/tests/incompleteCode/controlStructuresErrors.kt"); - } - - @Test - @TestMetadata("illegalSelectorCallableReference.kt") - public void testIllegalSelectorCallableReference() throws Exception { - runTest("compiler/testData/diagnostics/tests/incompleteCode/illegalSelectorCallableReference.kt"); - } - - @Test - @TestMetadata("inExpr.kt") - public void testInExpr() throws Exception { - runTest("compiler/testData/diagnostics/tests/incompleteCode/inExpr.kt"); - } - - @Test - @TestMetadata("incompleteAssignment.kt") - public void testIncompleteAssignment() throws Exception { - runTest("compiler/testData/diagnostics/tests/incompleteCode/incompleteAssignment.kt"); - } - - @Test - @TestMetadata("incompleteEquals.kt") - public void testIncompleteEquals() throws Exception { - runTest("compiler/testData/diagnostics/tests/incompleteCode/incompleteEquals.kt"); - } - - @Test - @TestMetadata("incompleteTryCatchBlock.kt") - public void testIncompleteTryCatchBlock() throws Exception { - runTest("compiler/testData/diagnostics/tests/incompleteCode/incompleteTryCatchBlock.kt"); - } - - @Test - @TestMetadata("kt1955.kt") - public void testKt1955() throws Exception { - runTest("compiler/testData/diagnostics/tests/incompleteCode/kt1955.kt"); - } - - @Test - @TestMetadata("kt2014.kt") - public void testKt2014() throws Exception { - runTest("compiler/testData/diagnostics/tests/incompleteCode/kt2014.kt"); - } - - @Test - @TestMetadata("kt4866UnresolvedArrayAccess.kt") - public void testKt4866UnresolvedArrayAccess() throws Exception { - runTest("compiler/testData/diagnostics/tests/incompleteCode/kt4866UnresolvedArrayAccess.kt"); - } - - @Test - @TestMetadata("NoSenselessComparisonForErrorType.kt") - public void testNoSenselessComparisonForErrorType() throws Exception { - runTest("compiler/testData/diagnostics/tests/incompleteCode/NoSenselessComparisonForErrorType.kt"); - } - - @Test - @TestMetadata("plusOnTheRight.kt") - public void testPlusOnTheRight() throws Exception { - runTest("compiler/testData/diagnostics/tests/incompleteCode/plusOnTheRight.kt"); - } - - @Test - @TestMetadata("pseudocodeTraverseNextInstructions.kt") - public void testPseudocodeTraverseNextInstructions() throws Exception { - runTest("compiler/testData/diagnostics/tests/incompleteCode/pseudocodeTraverseNextInstructions.kt"); - } - - @Test - @TestMetadata("senselessComparisonWithNull.kt") - public void testSenselessComparisonWithNull() throws Exception { - runTest("compiler/testData/diagnostics/tests/incompleteCode/senselessComparisonWithNull.kt"); - } - - @Test - @TestMetadata("SupertypeOfErrorType.kt") - public void testSupertypeOfErrorType() throws Exception { - runTest("compiler/testData/diagnostics/tests/incompleteCode/SupertypeOfErrorType.kt"); - } - - @Test - @TestMetadata("typeParameterOnLhsOfDot.kt") - public void testTypeParameterOnLhsOfDot() throws Exception { - runTest("compiler/testData/diagnostics/tests/incompleteCode/typeParameterOnLhsOfDot.kt"); - } - - @Test - @TestMetadata("unresolvedArguments.kt") - public void testUnresolvedArguments() throws Exception { - runTest("compiler/testData/diagnostics/tests/incompleteCode/unresolvedArguments.kt"); - } - - @Test - @TestMetadata("unresolvedOperation.kt") - public void testUnresolvedOperation() throws Exception { - runTest("compiler/testData/diagnostics/tests/incompleteCode/unresolvedOperation.kt"); - } - - @Test - @TestMetadata("variableDeclarationInSelector.kt") - public void testVariableDeclarationInSelector() throws Exception { - runTest("compiler/testData/diagnostics/tests/incompleteCode/variableDeclarationInSelector.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError") - @TestDataPath("$PROJECT_ROOT") - public class DiagnosticWithSyntaxError extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInDiagnosticWithSyntaxError() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("arrayExpression.kt") - public void testArrayExpression() throws Exception { - runTest("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/arrayExpression.kt"); - } - - @Test - @TestMetadata("checkBackingFieldException.kt") - public void testCheckBackingFieldException() throws Exception { - runTest("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/checkBackingFieldException.kt"); - } - - @Test - @TestMetadata("completeFunctionArgumentsOfNestedCalls.kt") - public void testCompleteFunctionArgumentsOfNestedCalls() throws Exception { - runTest("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/completeFunctionArgumentsOfNestedCalls.kt"); - } - - @Test - @TestMetadata("declarationAfterDotSelectorExpected.kt") - public void testDeclarationAfterDotSelectorExpected() throws Exception { - runTest("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/declarationAfterDotSelectorExpected.kt"); - } - - @Test - @TestMetadata("declarationAfterIncompleteElvis.kt") - public void testDeclarationAfterIncompleteElvis() throws Exception { - runTest("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/declarationAfterIncompleteElvis.kt"); - } - - @Test - @TestMetadata("funEquals.kt") - public void testFunEquals() throws Exception { - runTest("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/funEquals.kt"); - } - - @Test - @TestMetadata("funKeyword.kt") - public void testFunKeyword() throws Exception { - runTest("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/funKeyword.kt"); - } - - @Test - @TestMetadata("funcitonTypes.kt") - public void testFuncitonTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/funcitonTypes.kt"); - } - - @Test - @TestMetadata("incompleteEnumReference.kt") - public void testIncompleteEnumReference() throws Exception { - runTest("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/incompleteEnumReference.kt"); - } - - @Test - @TestMetadata("incompleteVal.kt") - public void testIncompleteVal() throws Exception { - runTest("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/incompleteVal.kt"); - } - - @Test - @TestMetadata("incompleteValWithAccessor.kt") - public void testIncompleteValWithAccessor() throws Exception { - runTest("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/incompleteValWithAccessor.kt"); - } - - @Test - @TestMetadata("incompleteWhen.kt") - public void testIncompleteWhen() throws Exception { - runTest("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/incompleteWhen.kt"); - } - - @Test - @TestMetadata("namedFun.kt") - public void testNamedFun() throws Exception { - runTest("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/namedFun.kt"); - } - - @Test - @TestMetadata("noTypeParamsInReturnType.kt") - public void testNoTypeParamsInReturnType() throws Exception { - runTest("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/noTypeParamsInReturnType.kt"); - } - - @Test - @TestMetadata("typeReferenceError.kt") - public void testTypeReferenceError() throws Exception { - runTest("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/typeReferenceError.kt"); - } - - @Test - @TestMetadata("valNoName.kt") - public void testValNoName() throws Exception { - runTest("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/valNoName.kt"); - } - - @Test - @TestMetadata("valWithNoNameBeforeNextDeclarationWithModifiers.kt") - public void testValWithNoNameBeforeNextDeclarationWithModifiers() throws Exception { - runTest("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/valWithNoNameBeforeNextDeclarationWithModifiers.kt"); - } - - @Test - @TestMetadata("valWithNoNameInBlock.kt") - public void testValWithNoNameInBlock() throws Exception { - runTest("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/valWithNoNameInBlock.kt"); - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/inference") - @TestDataPath("$PROJECT_ROOT") - public class Inference extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInInference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("cannotCompleteResolveAmbiguity.kt") - public void testCannotCompleteResolveAmbiguity() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/cannotCompleteResolveAmbiguity.kt"); - } - - @Test - @TestMetadata("cannotCompleteResolveFunctionLiteralsNoUse.kt") - public void testCannotCompleteResolveFunctionLiteralsNoUse() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/cannotCompleteResolveFunctionLiteralsNoUse.kt"); - } - - @Test - @TestMetadata("cannotCompleteResolveNoInfoForParameter.kt") - public void testCannotCompleteResolveNoInfoForParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/cannotCompleteResolveNoInfoForParameter.kt"); - } - - @Test - @TestMetadata("cannotCompleteResolveNoneApplicable.kt") - public void testCannotCompleteResolveNoneApplicable() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/cannotCompleteResolveNoneApplicable.kt"); - } - - @Test - @TestMetadata("cannotCompleteResolveWithFunctionLiterals.kt") - public void testCannotCompleteResolveWithFunctionLiterals() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/cannotCompleteResolveWithFunctionLiterals.kt"); - } - - @Test - @TestMetadata("capturedInProjectedFlexibleType.kt") - public void testCapturedInProjectedFlexibleType() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/capturedInProjectedFlexibleType.kt"); - } - - @Test - @TestMetadata("coerceFunctionLiteralToSuspend.kt") - public void testCoerceFunctionLiteralToSuspend() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/coerceFunctionLiteralToSuspend.kt"); - } - - @Test - @TestMetadata("commonSuperTypeOfErrorTypes.kt") - public void testCommonSuperTypeOfErrorTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/commonSuperTypeOfErrorTypes.kt"); - } - - @Test - @TestMetadata("commonSuperTypeOfTypesWithErrorSupertypes.kt") - public void testCommonSuperTypeOfTypesWithErrorSupertypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/commonSuperTypeOfTypesWithErrorSupertypes.kt"); - } - - @Test - @TestMetadata("compatibilityResolveWhenVariableHasComplexIntersectionType.kt") - public void testCompatibilityResolveWhenVariableHasComplexIntersectionType() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/compatibilityResolveWhenVariableHasComplexIntersectionType.kt"); - } - - @Test - @TestMetadata("completeInferenceIfManyFailed.kt") - public void testCompleteInferenceIfManyFailed() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/completeInferenceIfManyFailed.kt"); - } - - @Test - @TestMetadata("completionOfMultipleLambdas.kt") - public void testCompletionOfMultipleLambdas() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/completionOfMultipleLambdas.kt"); - } - - @Test - @TestMetadata("conflictingSubstitutions.kt") - public void testConflictingSubstitutions() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/conflictingSubstitutions.kt"); - } - - @Test - @TestMetadata("cstFromErrorAndNonErrorTypes.kt") - public void testCstFromErrorAndNonErrorTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/cstFromErrorAndNonErrorTypes.kt"); - } - - @Test - @TestMetadata("dependOnExpectedType.kt") - public void testDependOnExpectedType() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/dependOnExpectedType.kt"); - } - - @Test - @TestMetadata("dependantOnVariance.kt") - public void testDependantOnVariance() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/dependantOnVariance.kt"); - } - - @Test - @TestMetadata("dependantOnVarianceNullable.kt") - public void testDependantOnVarianceNullable() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/dependantOnVarianceNullable.kt"); - } - - @Test - @TestMetadata("equalitySubstitutionInsideNonInvariantType.kt") - public void testEqualitySubstitutionInsideNonInvariantType() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/equalitySubstitutionInsideNonInvariantType.kt"); - } - - @Test - @TestMetadata("expectedTypeAdditionalTest.kt") - public void testExpectedTypeAdditionalTest() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/expectedTypeAdditionalTest.kt"); - } - - @Test - @TestMetadata("expectedTypeDoubleReceiver.kt") - public void testExpectedTypeDoubleReceiver() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/expectedTypeDoubleReceiver.kt"); - } - - @Test - @TestMetadata("expectedTypeFromCast.kt") - public void testExpectedTypeFromCast() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/expectedTypeFromCast.kt"); - } - - @Test - @TestMetadata("expectedTypeFromCastComplexExpression.kt") - public void testExpectedTypeFromCastComplexExpression() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/expectedTypeFromCastComplexExpression.kt"); - } - - @Test - @TestMetadata("expectedTypeFromCastParenthesized.kt") - public void testExpectedTypeFromCastParenthesized() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/expectedTypeFromCastParenthesized.kt"); - } - - @Test - @TestMetadata("expectedTypeWithGenerics.kt") - public void testExpectedTypeWithGenerics() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/expectedTypeWithGenerics.kt"); - } - - @Test - @TestMetadata("extensionLambdasAndArrow.kt") - public void testExtensionLambdasAndArrow() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/extensionLambdasAndArrow.kt"); - } - - @Test - @TestMetadata("findViewById.kt") - public void testFindViewById() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/findViewById.kt"); - } - - @Test - @TestMetadata("fixVariableToNothing.kt") - public void testFixVariableToNothing() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/fixVariableToNothing.kt"); - } - - @Test - @TestMetadata("fixationOrderForProperConstraints.kt") - public void testFixationOrderForProperConstraints() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/fixationOrderForProperConstraints.kt"); - } - - @Test - @TestMetadata("flexibleTypesAsUpperBound.kt") - public void testFlexibleTypesAsUpperBound() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/flexibleTypesAsUpperBound.kt"); - } - - @Test - @TestMetadata("functionPlaceholderError.kt") - public void testFunctionPlaceholderError() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/functionPlaceholderError.kt"); - } - - @Test - @TestMetadata("genericAssignmentOperator.kt") - public void testGenericAssignmentOperator() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/genericAssignmentOperator.kt"); - } - - @Test - @TestMetadata("hasErrorInConstrainingTypes.kt") - public void testHasErrorInConstrainingTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/hasErrorInConstrainingTypes.kt"); - } - - @Test - @TestMetadata("immutableArrayList.kt") - public void testImmutableArrayList() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/immutableArrayList.kt"); - } - - @Test - @TestMetadata("implicitInvokeExtensionWithFunctionalArgument.kt") - public void testImplicitInvokeExtensionWithFunctionalArgument() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/implicitInvokeExtensionWithFunctionalArgument.kt"); - } - - @Test - @TestMetadata("implicitInvokeInCompanionObjectWithFunctionalArgument.kt") - public void testImplicitInvokeInCompanionObjectWithFunctionalArgument() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/implicitInvokeInCompanionObjectWithFunctionalArgument.kt"); - } - - @Test - @TestMetadata("implicitInvokeInObjectWithFunctionalArgument.kt") - public void testImplicitInvokeInObjectWithFunctionalArgument() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/implicitInvokeInObjectWithFunctionalArgument.kt"); - } - - @Test - @TestMetadata("implicitInvokeWithFunctionLiteralArgument.kt") - public void testImplicitInvokeWithFunctionLiteralArgument() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/implicitInvokeWithFunctionLiteralArgument.kt"); - } - - @Test - @TestMetadata("inferInFunctionLiterals.kt") - public void testInferInFunctionLiterals() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/inferInFunctionLiterals.kt"); - } - - @Test - @TestMetadata("inferInFunctionLiteralsWithReturn.kt") - public void testInferInFunctionLiteralsWithReturn() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/inferInFunctionLiteralsWithReturn.kt"); - } - - @Test - @TestMetadata("intersectionTypeMultipleBoundsAsReceiver.kt") - public void testIntersectionTypeMultipleBoundsAsReceiver() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/intersectionTypeMultipleBoundsAsReceiver.kt"); - } - - @Test - @TestMetadata("intersectionTypesWithContravariantTypes.kt") - public void testIntersectionTypesWithContravariantTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/intersectionTypesWithContravariantTypes.kt"); - } - - @Test - @TestMetadata("intersectionWithEnum.kt") - public void testIntersectionWithEnum() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/intersectionWithEnum.kt"); - } - - @Test - @TestMetadata("invokeLambdaAsFunction.kt") - public void testInvokeLambdaAsFunction() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/invokeLambdaAsFunction.kt"); - } - - @Test - @TestMetadata("knownTypeParameters.kt") - public void testKnownTypeParameters() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/knownTypeParameters.kt"); - } - - @Test - @TestMetadata("kt11963.kt") - public void testKt11963() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/kt11963.kt"); - } - - @Test - @TestMetadata("kt12399.kt") - public void testKt12399() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/kt12399.kt"); - } - - @Test - @TestMetadata("kt1293.kt") - public void testKt1293() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/kt1293.kt"); - } - - @Test - @TestMetadata("kt28598.kt") - public void testKt28598() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/kt28598.kt"); - } - - @Test - @TestMetadata("kt28654.kt") - public void testKt28654() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/kt28654.kt"); - } - - @Test - @TestMetadata("kt30405.kt") - public void testKt30405() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/kt30405.kt"); - } - - @Test - @TestMetadata("kt3184.kt") - public void testKt3184() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/kt3184.kt"); - } - - @Test - @TestMetadata("kt32196.kt") - public void testKt32196() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/kt32196.kt"); - } - - @Test - @TestMetadata("kt32415.kt") - public void testKt32415() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/kt32415.kt"); - } - - @Test - @TestMetadata("kt32434.kt") - public void testKt32434() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/kt32434.kt"); - } - - @Test - @TestMetadata("kt32462.kt") - public void testKt32462() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/kt32462.kt"); - } - - @Test - @TestMetadata("kt33263.kt") - public void testKt33263() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/kt33263.kt"); - } - - @Test - @TestMetadata("kt35702.kt") - public void testKt35702() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/kt35702.kt"); - } - - @Test - @TestMetadata("kt36044.kt") - public void testKt36044() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/kt36044.kt"); - } - - @Test - @TestMetadata("kt36819.kt") - public void testKt36819() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/kt36819.kt"); - } - - @Test - @TestMetadata("kt37853.kt") - public void testKt37853() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/kt37853.kt"); - } - - @Test - @TestMetadata("kt39220.kt") - public void testKt39220() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/kt39220.kt"); - } - - @Test - @TestMetadata("kt6175.kt") - public void testKt6175() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/kt6175.kt"); - } - - @Test - @TestMetadata("kt619.kt") - public void testKt619() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/kt619.kt"); - } - - @Test - @TestMetadata("lambdaArgumentWithLabel.kt") - public void testLambdaArgumentWithLabel() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/lambdaArgumentWithLabel.kt"); - } - - @Test - @TestMetadata("lambdaInValInitializerWithAnonymousFunctions.kt") - public void testLambdaInValInitializerWithAnonymousFunctions() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/lambdaInValInitializerWithAnonymousFunctions.kt"); - } - - @Test - @TestMetadata("lambdaParameterTypeInElvis.kt") - public void testLambdaParameterTypeInElvis() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/lambdaParameterTypeInElvis.kt"); - } - - @Test - @TestMetadata("listConstructor.kt") - public void testListConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/listConstructor.kt"); - } - - @Test - @TestMetadata("localFunctionInsideIfBlock.kt") - public void testLocalFunctionInsideIfBlock() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/localFunctionInsideIfBlock.kt"); - } - - @Test - @TestMetadata("mapFunction.kt") - public void testMapFunction() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/mapFunction.kt"); - } - - @Test - @TestMetadata("mostSpecificAfterInference.kt") - public void testMostSpecificAfterInference() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/mostSpecificAfterInference.kt"); - } - - @Test - @TestMetadata("NoInferenceFromDeclaredBounds.kt") - public void testNoInferenceFromDeclaredBounds() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/NoInferenceFromDeclaredBounds.kt"); - } - - @Test - @TestMetadata("noInformationForParameter.kt") - public void testNoInformationForParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/noInformationForParameter.kt"); - } - - @Test - @TestMetadata("nonFunctionalExpectedTypeForLambdaArgument.kt") - public void testNonFunctionalExpectedTypeForLambdaArgument() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/nonFunctionalExpectedTypeForLambdaArgument.kt"); - } - - @Test - @TestMetadata("nullableTypeArgumentWithNotNullUpperBound.kt") - public void testNullableTypeArgumentWithNotNullUpperBound() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/nullableTypeArgumentWithNotNullUpperBound.kt"); - } - - @Test - @TestMetadata("nullableUpperBound.kt") - public void testNullableUpperBound() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/nullableUpperBound.kt"); - } - - @Test - @TestMetadata("opposite.kt") - public void testOpposite() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/opposite.kt"); - } - - @Test - @TestMetadata("possibleCycleOnConstraints.kt") - public void testPossibleCycleOnConstraints() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/possibleCycleOnConstraints.kt"); - } - - @Test - @TestMetadata("reportAboutUnresolvedReferenceAsUnresolved.kt") - public void testReportAboutUnresolvedReferenceAsUnresolved() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/reportAboutUnresolvedReferenceAsUnresolved.kt"); - } - - @Test - @TestMetadata("resolveWithUnknownLambdaParameterType.kt") - public void testResolveWithUnknownLambdaParameterType() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/resolveWithUnknownLambdaParameterType.kt"); - } - - @Test - @TestMetadata("returningLambdaInSuspendContext.kt") - public void testReturningLambdaInSuspendContext() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/returningLambdaInSuspendContext.kt"); - } - - @Test - @TestMetadata("simpleLambdaInCallWithAnotherLambdaWithBuilderInference.kt") - public void testSimpleLambdaInCallWithAnotherLambdaWithBuilderInference() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/simpleLambdaInCallWithAnotherLambdaWithBuilderInference.kt"); - } - - @Test - @TestMetadata("skipedUnresolvedInBuilderInferenceWithStubReceiverType.kt") - public void testSkipedUnresolvedInBuilderInferenceWithStubReceiverType() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/skipedUnresolvedInBuilderInferenceWithStubReceiverType.kt"); - } - - @Test - @TestMetadata("starApproximation.kt") - public void testStarApproximation() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/starApproximation.kt"); - } - - @Test - @TestMetadata("starApproximationBangBang.kt") - public void testStarApproximationBangBang() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/starApproximationBangBang.kt"); - } - - @Test - @TestMetadata("starApproximationFlexible.kt") - public void testStarApproximationFlexible() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/starApproximationFlexible.kt"); - } - - @Test - @TestMetadata("starApproximationFromDifferentTypeParameter.kt") - public void testStarApproximationFromDifferentTypeParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/starApproximationFromDifferentTypeParameter.kt"); - } - - @Test - @TestMetadata("tooEagerSmartcast.kt") - public void testTooEagerSmartcast() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/tooEagerSmartcast.kt"); - } - - @Test - @TestMetadata("topLevelIntersection.kt") - public void testTopLevelIntersection() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/topLevelIntersection.kt"); - } - - @Test - @TestMetadata("tryNumberLowerBoundsBeforeUpperBounds.kt") - public void testTryNumberLowerBoundsBeforeUpperBounds() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/tryNumberLowerBoundsBeforeUpperBounds.kt"); - } - - @Test - @TestMetadata("typeConstructorMismatch.kt") - public void testTypeConstructorMismatch() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/typeConstructorMismatch.kt"); - } - - @Test - @TestMetadata("typeInferenceExpectedTypeMismatch.kt") - public void testTypeInferenceExpectedTypeMismatch() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/typeInferenceExpectedTypeMismatch.kt"); - } - - @Test - @TestMetadata("typeParameterInConstructor.kt") - public void testTypeParameterInConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/typeParameterInConstructor.kt"); - } - - @Test - @TestMetadata("useFunctionLiteralsToInferType.kt") - public void testUseFunctionLiteralsToInferType() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/useFunctionLiteralsToInferType.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/inference/capturedTypes") - @TestDataPath("$PROJECT_ROOT") - public class CapturedTypes extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInCapturedTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/capturedTypes"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("approximateBeforeFixation.kt") - public void testApproximateBeforeFixation() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/approximateBeforeFixation.kt"); - } - - @Test - @TestMetadata("avoidCreatingUselessCapturedTypes.kt") - public void testAvoidCreatingUselessCapturedTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/avoidCreatingUselessCapturedTypes.kt"); - } - - @Test - @TestMetadata("cannotCaptureInProjection.kt") - public void testCannotCaptureInProjection() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/cannotCaptureInProjection.kt"); - } - - @Test - @TestMetadata("captureForNullableTypes.kt") - public void testCaptureForNullableTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/captureForNullableTypes.kt"); - } - - @Test - @TestMetadata("captureForPlatformTypes.kt") - public void testCaptureForPlatformTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/captureForPlatformTypes.kt"); - } - - @Test - @TestMetadata("captureFromNullableTypeVariable.kt") - public void testCaptureFromNullableTypeVariable() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/captureFromNullableTypeVariable.kt"); - } - - @Test - @TestMetadata("captureFromSubtyping.kt") - public void testCaptureFromSubtyping() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/captureFromSubtyping.kt"); - } - - @Test - @TestMetadata("captureFromTypeParameterUpperBound.kt") - public void testCaptureFromTypeParameterUpperBound() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/captureFromTypeParameterUpperBound.kt"); - } - - @Test - @TestMetadata("captureTypeOnlyOnTopLevel.kt") - public void testCaptureTypeOnlyOnTopLevel() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/captureTypeOnlyOnTopLevel.kt"); - } - - @Test - @TestMetadata("capturedFlexibleIntersectionTypesWithDifferentBounds.kt") - public void testCapturedFlexibleIntersectionTypesWithDifferentBounds() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/capturedFlexibleIntersectionTypesWithDifferentBounds.kt"); - } - - @Test - @TestMetadata("capturedFlexibleIntersectionTypesWithDifferentConstructors.kt") - public void testCapturedFlexibleIntersectionTypesWithDifferentConstructors() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/capturedFlexibleIntersectionTypesWithDifferentConstructors.kt"); - } - - @Test - @TestMetadata("capturedType.kt") - public void testCapturedType() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/capturedType.kt"); - } - - @Test - @TestMetadata("capturedTypeAndApproximation.kt") - public void testCapturedTypeAndApproximation() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/capturedTypeAndApproximation.kt"); - } - - @Test - @TestMetadata("capturedTypeSubstitutedIntoOppositeProjection.kt") - public void testCapturedTypeSubstitutedIntoOppositeProjection() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/capturedTypeSubstitutedIntoOppositeProjection.kt"); - } - - @Test - @TestMetadata("capturedTypeWithInnerTypealias.kt") - public void testCapturedTypeWithInnerTypealias() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/capturedTypeWithInnerTypealias.kt"); - } - - @Test - @TestMetadata("capturedTypeWithTypeVariableSubtyping.kt") - public void testCapturedTypeWithTypeVariableSubtyping() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/capturedTypeWithTypeVariableSubtyping.kt"); - } - - @Test - @TestMetadata("capturingFromArgumentOfFlexibleType.kt") - public void testCapturingFromArgumentOfFlexibleType() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/capturingFromArgumentOfFlexibleType.kt"); - } - - @Test - @TestMetadata("expectedTypeMismatchWithInVariance.kt") - public void testExpectedTypeMismatchWithInVariance() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/expectedTypeMismatchWithInVariance.kt"); - } - - @Test - @TestMetadata("invokeCallWithCapturedReceiver.kt") - public void testInvokeCallWithCapturedReceiver() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/invokeCallWithCapturedReceiver.kt"); - } - - @Test - @TestMetadata("kt25302.kt") - public void testKt25302() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/kt25302.kt"); - } - - @Test - @TestMetadata("kt2570.kt") - public void testKt2570() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/kt2570.kt"); - } - - @Test - @TestMetadata("kt2872.kt") - public void testKt2872() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/kt2872.kt"); - } - - @Test - @TestMetadata("memberScopeOfCaptured.kt") - public void testMemberScopeOfCaptured() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/memberScopeOfCaptured.kt"); - } - - @Test - @TestMetadata("noCaptureTypeErrorForNonTopLevel.kt") - public void testNoCaptureTypeErrorForNonTopLevel() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/noCaptureTypeErrorForNonTopLevel.kt"); - } - - @Test - @TestMetadata("notApproximateWhenCopyDescriptors.kt") - public void testNotApproximateWhenCopyDescriptors() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/notApproximateWhenCopyDescriptors.kt"); - } - - @Test - @TestMetadata("nullableCaptruredTypeAgainstNullableVariable.kt") - public void testNullableCaptruredTypeAgainstNullableVariable() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/nullableCaptruredTypeAgainstNullableVariable.kt"); - } - - @Test - @TestMetadata("nullableCaptruredTypeAgainstNullableVariableWithDisabledComplatibilityFlag.kt") - public void testNullableCaptruredTypeAgainstNullableVariableWithDisabledComplatibilityFlag() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/nullableCaptruredTypeAgainstNullableVariableWithDisabledComplatibilityFlag.kt"); - } - - @Test - @TestMetadata("overApproximationForInCaptured.kt") - public void testOverApproximationForInCaptured() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/overApproximationForInCaptured.kt"); - } - - @Test - @TestMetadata("overApproximationForOutCaptured.kt") - public void testOverApproximationForOutCaptured() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/overApproximationForOutCaptured.kt"); - } - - @Test - @TestMetadata("propagateNullailityOnSupertypesWhenCaptureTypes.kt") - public void testPropagateNullailityOnSupertypesWhenCaptureTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/propagateNullailityOnSupertypesWhenCaptureTypes.kt"); - } - - @Test - @TestMetadata("starProjectionRegression.kt") - public void testStarProjectionRegression() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/starProjectionRegression.kt"); - } - - @Test - @TestMetadata("topLevelCapturingInsideReturnType.kt") - public void testTopLevelCapturingInsideReturnType() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/capturedTypes/topLevelCapturingInsideReturnType.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/inference/coercionToUnit") - @TestDataPath("$PROJECT_ROOT") - public class CoercionToUnit extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInCoercionToUnit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/coercionToUnit"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("coercionToUnitForIfAsLastExpressionInLambda.kt") - public void testCoercionToUnitForIfAsLastExpressionInLambda() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionToUnitForIfAsLastExpressionInLambda.kt"); - } - - @Test - @TestMetadata("coercionToUnitForLastLambdaInLambda.kt") - public void testCoercionToUnitForLastLambdaInLambda() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionToUnitForLastLambdaInLambda.kt"); - } - - @Test - @TestMetadata("coercionToUnitReference.kt") - public void testCoercionToUnitReference() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionToUnitReference.kt"); - } - - @Test - @TestMetadata("coercionToUnitWithNothingType.kt") - public void testCoercionToUnitWithNothingType() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionToUnitWithNothingType.kt"); - } - - @Test - @TestMetadata("coercionWithExpectedType.kt") - public void testCoercionWithExpectedType() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithExpectedType.kt"); - } - - @Test - @TestMetadata("coercionWithExpectedTypeAndBound.kt") - public void testCoercionWithExpectedTypeAndBound() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithExpectedTypeAndBound.kt"); - } - - @Test - @TestMetadata("coercionWithExplicitTypeArgument.kt") - public void testCoercionWithExplicitTypeArgument() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithExplicitTypeArgument.kt"); - } - - @Test - @TestMetadata("coercionWithoutExpectedType.kt") - public void testCoercionWithoutExpectedType() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/coercionToUnit/coercionWithoutExpectedType.kt"); - } - - @Test - @TestMetadata("coerctionToUnitForATypeWithUpperBound.kt") - public void testCoerctionToUnitForATypeWithUpperBound() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/coercionToUnit/coerctionToUnitForATypeWithUpperBound.kt"); - } - - @Test - @TestMetadata("coersionWithAnonymousFunctionsAndUnresolved.kt") - public void testCoersionWithAnonymousFunctionsAndUnresolved() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/coercionToUnit/coersionWithAnonymousFunctionsAndUnresolved.kt"); - } - - @Test - @TestMetadata("indirectCoercionWithExpectedType.kt") - public void testIndirectCoercionWithExpectedType() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/coercionToUnit/indirectCoercionWithExpectedType.kt"); - } - - @Test - @TestMetadata("kt30242.kt") - public void testKt30242() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/coercionToUnit/kt30242.kt"); - } - - @Test - @TestMetadata("noCoercion.kt") - public void testNoCoercion() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/coercionToUnit/noCoercion.kt"); - } - - @Test - @TestMetadata("nonPropagationOfCoercionToUnitInsideNestedLambda.kt") - public void testNonPropagationOfCoercionToUnitInsideNestedLambda() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/coercionToUnit/nonPropagationOfCoercionToUnitInsideNestedLambda.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/inference/commonSystem") - @TestDataPath("$PROJECT_ROOT") - public class CommonSystem extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInCommonSystem() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/commonSystem"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("boundOnNullableVariable.kt") - public void testBoundOnNullableVariable() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/commonSystem/boundOnNullableVariable.kt"); - } - - @Test - @TestMetadata("castToSubtype.kt") - public void testCastToSubtype() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/commonSystem/castToSubtype.kt"); - } - - @Test - @TestMetadata("cstFromNullableChildAndNonParameterizedType.kt") - public void testCstFromNullableChildAndNonParameterizedType() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/commonSystem/cstFromNullableChildAndNonParameterizedType.kt"); - } - - @Test - @TestMetadata("cstWithTypeContainingNonFixedVariable.kt") - public void testCstWithTypeContainingNonFixedVariable() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/commonSystem/cstWithTypeContainingNonFixedVariable.kt"); - } - - @Test - @TestMetadata("dontCaptureTypeVariable.kt") - public void testDontCaptureTypeVariable() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/commonSystem/dontCaptureTypeVariable.kt"); - } - - @Test - @TestMetadata("fixVariablesInRightOrder.kt") - public void testFixVariablesInRightOrder() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/commonSystem/fixVariablesInRightOrder.kt"); - } - - @Test - @TestMetadata("genericCandidateInGenericClass.kt") - public void testGenericCandidateInGenericClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/commonSystem/genericCandidateInGenericClass.kt"); - } - - @Test - @TestMetadata("iltInsideSeveralCalls.kt") - public void testIltInsideSeveralCalls() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/commonSystem/iltInsideSeveralCalls.kt"); - } - - @Test - @TestMetadata("inferenceWithUpperBoundsInLambda.kt") - public void testInferenceWithUpperBoundsInLambda() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/commonSystem/inferenceWithUpperBoundsInLambda.kt"); - } - - @Test - @TestMetadata("kt30300.kt") - public void testKt30300() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/commonSystem/kt30300.kt"); - } - - @Test - @TestMetadata("kt31969.kt") - public void testKt31969() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/commonSystem/kt31969.kt"); - } - - @Test - @TestMetadata("kt32818.kt") - public void testKt32818() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/commonSystem/kt32818.kt"); - } - - @Test - @TestMetadata("kt33197.kt") - public void testKt33197() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/commonSystem/kt33197.kt"); - } - - @Test - @TestMetadata("kt3372toCollection.kt") - public void testKt3372toCollection() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/commonSystem/kt3372toCollection.kt"); - } - - @Test - @TestMetadata("lessSpecificTypeForArgumentCallWithExactAnnotation.kt") - public void testLessSpecificTypeForArgumentCallWithExactAnnotation() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/commonSystem/lessSpecificTypeForArgumentCallWithExactAnnotation.kt"); - } - - @Test - @TestMetadata("lessSpecificTypeForArgumentCallWithExactAnnotation_ni.kt") - public void testLessSpecificTypeForArgumentCallWithExactAnnotation_ni() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/commonSystem/lessSpecificTypeForArgumentCallWithExactAnnotation_ni.kt"); - } - - @Test - @TestMetadata("manyArgumentsForVararg.kt") - public void testManyArgumentsForVararg() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/commonSystem/manyArgumentsForVararg.kt"); - } - - @Test - @TestMetadata("nestedLambdas.kt") - public void testNestedLambdas() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/commonSystem/nestedLambdas.kt"); - } - - @Test - @TestMetadata("nonFixedVariableFromBothBranches.kt") - public void testNonFixedVariableFromBothBranches() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/commonSystem/nonFixedVariableFromBothBranches.kt"); - } - - @Test - @TestMetadata("nonFixedVariableInsideFlexibleType.kt") - public void testNonFixedVariableInsideFlexibleType() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/commonSystem/nonFixedVariableInsideFlexibleType.kt"); - } - - @Test - @TestMetadata("outProjectedTypeToOutProjected.kt") - public void testOutProjectedTypeToOutProjected() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/commonSystem/outProjectedTypeToOutProjected.kt"); - } - - @Test - @TestMetadata("postponedCompletionWithExactAnnotation.kt") - public void testPostponedCompletionWithExactAnnotation() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/commonSystem/postponedCompletionWithExactAnnotation.kt"); - } - - @Test - @TestMetadata("postponedCompletionWithExactAnnotation_ni.kt") - public void testPostponedCompletionWithExactAnnotation_ni() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/commonSystem/postponedCompletionWithExactAnnotation_ni.kt"); - } - - @Test - @TestMetadata("selectFromCovariantAndContravariantTypes.kt") - public void testSelectFromCovariantAndContravariantTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/commonSystem/selectFromCovariantAndContravariantTypes.kt"); - } - - @Test - @TestMetadata("selectFromTwoIncompatibleTypes.kt") - public void testSelectFromTwoIncompatibleTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/commonSystem/selectFromTwoIncompatibleTypes.kt"); - } - - @Test - @TestMetadata("selectIntegerValueTypeFromIf.kt") - public void testSelectIntegerValueTypeFromIf() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/commonSystem/selectIntegerValueTypeFromIf.kt"); - } - - @Test - @TestMetadata("theSameFunctionInArgs.kt") - public void testTheSameFunctionInArgs() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/commonSystem/theSameFunctionInArgs.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/inference/completion") - @TestDataPath("$PROJECT_ROOT") - public class Completion extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInCompletion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/completion"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("anonymousFunction.kt") - public void testAnonymousFunction() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/completion/anonymousFunction.kt"); - } - - @Test - @TestMetadata("basic.kt") - public void testBasic() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/completion/basic.kt"); - } - - @Test - @TestMetadata("definitelyNotNullType.kt") - public void testDefinitelyNotNullType() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/completion/definitelyNotNullType.kt"); - } - - @Test - @TestMetadata("equalityConstraintUpstairs.kt") - public void testEqualityConstraintUpstairs() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/completion/equalityConstraintUpstairs.kt"); - } - - @Test - @TestMetadata("flexibleType.kt") - public void testFlexibleType() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/completion/flexibleType.kt"); - } - - @Test - @TestMetadata("intersectionType.kt") - public void testIntersectionType() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/completion/intersectionType.kt"); - } - - @Test - @TestMetadata("kt33166.kt") - public void testKt33166() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/completion/kt33166.kt"); - } - - @Test - @TestMetadata("kt36233.kt") - public void testKt36233() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/completion/kt36233.kt"); - } - - @Test - @TestMetadata("lambdaWithVariableAndNothing.kt") - public void testLambdaWithVariableAndNothing() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/completion/lambdaWithVariableAndNothing.kt"); - } - - @Test - @TestMetadata("nestedVariance.kt") - public void testNestedVariance() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/completion/nestedVariance.kt"); - } - - @Test - @TestMetadata("nothingFromNestedCall.kt") - public void testNothingFromNestedCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/completion/nothingFromNestedCall.kt"); - } - - @Test - @TestMetadata("partialForIlt.kt") - public void testPartialForIlt() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/completion/partialForIlt.kt"); - } - - @Test - @TestMetadata("partialForIltWithNothing.kt") - public void testPartialForIltWithNothing() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/completion/partialForIltWithNothing.kt"); - } - - @Test - @TestMetadata("transitiveConstraint.kt") - public void testTransitiveConstraint() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/completion/transitiveConstraint.kt"); - } - - @Test - @TestMetadata("withExact.kt") - public void testWithExact() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/completion/withExact.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/inference/completion/postponedArgumentsAnalysis") - @TestDataPath("$PROJECT_ROOT") - public class PostponedArgumentsAnalysis extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInPostponedArgumentsAnalysis() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/completion/postponedArgumentsAnalysis"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("basic.kt") - public void testBasic() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/completion/postponedArgumentsAnalysis/basic.kt"); - } - - @Test - @TestMetadata("callableReferenceLambdaCombinationInsideCall.kt") - public void testCallableReferenceLambdaCombinationInsideCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/completion/postponedArgumentsAnalysis/callableReferenceLambdaCombinationInsideCall.kt"); - } - - @Test - @TestMetadata("callableReferences.kt") - public void testCallableReferences() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/completion/postponedArgumentsAnalysis/callableReferences.kt"); - } - - @Test - @TestMetadata("fixingVariableDuringAddingConstraintForFirstPosponedArgument.kt") - public void testFixingVariableDuringAddingConstraintForFirstPosponedArgument() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/completion/postponedArgumentsAnalysis/fixingVariableDuringAddingConstraintForFirstPosponedArgument.kt"); - } - - @Test - @TestMetadata("lackOfDeepIncorporation.kt") - public void testLackOfDeepIncorporation() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/completion/postponedArgumentsAnalysis/lackOfDeepIncorporation.kt"); - } - - @Test - @TestMetadata("lambdasInTryCatch.kt") - public void testLambdasInTryCatch() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/completion/postponedArgumentsAnalysis/lambdasInTryCatch.kt"); - } - - @Test - @TestMetadata("notInferableParameterOfAnonymousFunction.kt") - public void testNotInferableParameterOfAnonymousFunction() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/completion/postponedArgumentsAnalysis/notInferableParameterOfAnonymousFunction.kt"); - } - - @Test - @TestMetadata("takingExtensibilityFromDeclarationOfAnonymousFunction.kt") - public void testTakingExtensibilityFromDeclarationOfAnonymousFunction() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/completion/postponedArgumentsAnalysis/takingExtensibilityFromDeclarationOfAnonymousFunction.kt"); - } - - @Test - @TestMetadata("wrongVariableFixationOrder.kt") - public void testWrongVariableFixationOrder() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/completion/postponedArgumentsAnalysis/wrongVariableFixationOrder.kt"); - } - - @Test - @TestMetadata("wrongVariableFixationOrder2.kt") - public void testWrongVariableFixationOrder2() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/completion/postponedArgumentsAnalysis/wrongVariableFixationOrder2.kt"); - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/inference/constraints") - @TestDataPath("$PROJECT_ROOT") - public class Constraints extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInConstraints() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/constraints"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("approximationWithDefNotNullInInvPositionDuringInference.kt") - public void testApproximationWithDefNotNullInInvPositionDuringInference() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/constraints/approximationWithDefNotNullInInvPositionDuringInference.kt"); - } - - @Test - @TestMetadata("complexDependencyWihtoutProperConstraints.kt") - public void testComplexDependencyWihtoutProperConstraints() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/constraints/complexDependencyWihtoutProperConstraints.kt"); - } - - @Test - @TestMetadata("constraintFromVariantTypeWithNestedProjection.kt") - public void testConstraintFromVariantTypeWithNestedProjection() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/constraints/constraintFromVariantTypeWithNestedProjection.kt"); - } - - @Test - @TestMetadata("constraintOnFunctionLiteral.kt") - public void testConstraintOnFunctionLiteral() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/constraints/constraintOnFunctionLiteral.kt"); - } - - @Test - @TestMetadata("definitelyNotNullTypeInArguments.kt") - public void testDefinitelyNotNullTypeInArguments() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/constraints/definitelyNotNullTypeInArguments.kt"); - } - - @Test - @TestMetadata("definitelyNotNullTypeInReturnPosition.kt") - public void testDefinitelyNotNullTypeInReturnPosition() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/constraints/definitelyNotNullTypeInReturnPosition.kt"); - } - - @Test - @TestMetadata("definitelyNotNullTypeInvariantPosition.kt") - public void testDefinitelyNotNullTypeInvariantPosition() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/constraints/definitelyNotNullTypeInvariantPosition.kt"); - } - - @Test - @TestMetadata("earlyCompletionForCalls.kt") - public void testEarlyCompletionForCalls() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/constraints/earlyCompletionForCalls.kt"); - } - - @Test - @TestMetadata("equalityConstraintOnNullableType.kt") - public void testEqualityConstraintOnNullableType() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/constraints/equalityConstraintOnNullableType.kt"); - } - - @Test - @TestMetadata("errorUpperBoundConstraint.kt") - public void testErrorUpperBoundConstraint() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/constraints/errorUpperBoundConstraint.kt"); - } - - @Test - @TestMetadata("fixTypeVariableWithNothingConstraintEarlierThanComplexVariable.kt") - public void testFixTypeVariableWithNothingConstraintEarlierThanComplexVariable() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/constraints/fixTypeVariableWithNothingConstraintEarlierThanComplexVariable.kt"); - } - - @Test - @TestMetadata("ignoreConstraintFromImplicitInNothing.kt") - public void testIgnoreConstraintFromImplicitInNothing() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/constraints/ignoreConstraintFromImplicitInNothing.kt"); - } - - @Test - @TestMetadata("inferTypeFromCapturedStarProjection.kt") - public void testInferTypeFromCapturedStarProjection() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/constraints/inferTypeFromCapturedStarProjection.kt"); - } - - @Test - @TestMetadata("kt6320.kt") - public void testKt6320() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/constraints/kt6320.kt"); - } - - @Test - @TestMetadata("kt7351ConstraintFromUnitExpectedType.kt") - public void testKt7351ConstraintFromUnitExpectedType() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/constraints/kt7351ConstraintFromUnitExpectedType.kt"); - } - - @Test - @TestMetadata("kt7433.kt") - public void testKt7433() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/constraints/kt7433.kt"); - } - - @Test - @TestMetadata("kt8879.kt") - public void testKt8879() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/constraints/kt8879.kt"); - } - - @Test - @TestMetadata("manyConstraintsDueToFlexibleRawTypes.kt") - public void testManyConstraintsDueToFlexibleRawTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/constraints/manyConstraintsDueToFlexibleRawTypes.kt"); - } - - @Test - @TestMetadata("manyConstraintsDueToRecursiveFlexibleTypesWithWildcards.kt") - public void testManyConstraintsDueToRecursiveFlexibleTypesWithWildcards() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/constraints/manyConstraintsDueToRecursiveFlexibleTypesWithWildcards.kt"); - } - - @Test - @TestMetadata("notNullConstraintOnNullableType.kt") - public void testNotNullConstraintOnNullableType() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/constraints/notNullConstraintOnNullableType.kt"); - } - - @Test - @TestMetadata("operationsOnIntegerValueTypes.kt") - public void testOperationsOnIntegerValueTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/constraints/operationsOnIntegerValueTypes.kt"); - } - - @Test - @TestMetadata("recursiveJavaTypeWithStarProjection.kt") - public void testRecursiveJavaTypeWithStarProjection() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/constraints/recursiveJavaTypeWithStarProjection.kt"); - } - - @Test - @TestMetadata("remainConstraintContainingTypeWithoutProjection.kt") - public void testRemainConstraintContainingTypeWithoutProjection() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/constraints/remainConstraintContainingTypeWithoutProjection.kt"); - } - - @Test - @TestMetadata("returnLambdaFromLambda.kt") - public void testReturnLambdaFromLambda() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/constraints/returnLambdaFromLambda.kt"); - } - - @Test - @TestMetadata("subtypeConstraintOnNullableType.kt") - public void testSubtypeConstraintOnNullableType() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/constraints/subtypeConstraintOnNullableType.kt"); - } - - @Test - @TestMetadata("supertypeConstraintOnNullableType.kt") - public void testSupertypeConstraintOnNullableType() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/constraints/supertypeConstraintOnNullableType.kt"); - } - - @Test - @TestMetadata("wrongApproximationWithDefNotNullTypesAndDelegates.kt") - public void testWrongApproximationWithDefNotNullTypesAndDelegates() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/constraints/wrongApproximationWithDefNotNullTypesAndDelegates.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/inference/nestedCalls") - @TestDataPath("$PROJECT_ROOT") - public class NestedCalls extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInNestedCalls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/nestedCalls"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("arrayAccess.kt") - public void testArrayAccess() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/nestedCalls/arrayAccess.kt"); - } - - @Test - @TestMetadata("binaryExpressions.kt") - public void testBinaryExpressions() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/nestedCalls/binaryExpressions.kt"); - } - - @Test - @TestMetadata("checkTypesForQualifiedProperties.kt") - public void testCheckTypesForQualifiedProperties() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/nestedCalls/checkTypesForQualifiedProperties.kt"); - } - - @Test - @TestMetadata("completeNestedCallsForArraySetExpression.kt") - public void testCompleteNestedCallsForArraySetExpression() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/nestedCalls/completeNestedCallsForArraySetExpression.kt"); - } - - @Test - @TestMetadata("completeNestedCallsInference.kt") - public void testCompleteNestedCallsInference() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/nestedCalls/completeNestedCallsInference.kt"); - } - - @Test - @TestMetadata("completeNestedForVariableAsFunctionCall.kt") - public void testCompleteNestedForVariableAsFunctionCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/nestedCalls/completeNestedForVariableAsFunctionCall.kt"); - } - - @Test - @TestMetadata("externalTypeParameter.kt") - public void testExternalTypeParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/nestedCalls/externalTypeParameter.kt"); - } - - @Test - @TestMetadata("inferenceForNestedBinaryCall.kt") - public void testInferenceForNestedBinaryCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/nestedCalls/inferenceForNestedBinaryCall.kt"); - } - - @Test - @TestMetadata("kt3395.kt") - public void testKt3395() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/nestedCalls/kt3395.kt"); - } - - @Test - @TestMetadata("kt3461checkTypes.kt") - public void testKt3461checkTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/nestedCalls/kt3461checkTypes.kt"); - } - - @Test - @TestMetadata("makeNullableIfSafeCall.kt") - public void testMakeNullableIfSafeCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/nestedCalls/makeNullableIfSafeCall.kt"); - } - - @Test - @TestMetadata("nontrivialCallExpression.kt") - public void testNontrivialCallExpression() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/nestedCalls/nontrivialCallExpression.kt"); - } - - @Test - @TestMetadata("preferArgumentToNullability.kt") - public void testPreferArgumentToNullability() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/nestedCalls/preferArgumentToNullability.kt"); - } - - @Test - @TestMetadata("preferNothingToBound.kt") - public void testPreferNothingToBound() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/nestedCalls/preferNothingToBound.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/inference/nothingType") - @TestDataPath("$PROJECT_ROOT") - public class NothingType extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInNothingType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/nothingType"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("complexDependancyOnVariableWithTrivialConstraint.kt") - public void testComplexDependancyOnVariableWithTrivialConstraint() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/nothingType/complexDependancyOnVariableWithTrivialConstraint.kt"); - } - - @Test - @TestMetadata("discriminateNothingForReifiedParameter.kt") - public void testDiscriminateNothingForReifiedParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/nothingType/discriminateNothingForReifiedParameter.kt"); - } - - @Test - @TestMetadata("discriminatedNothingAndSmartCast.kt") - public void testDiscriminatedNothingAndSmartCast() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/nothingType/discriminatedNothingAndSmartCast.kt"); - } - - @Test - @TestMetadata("discriminatedNothingInsideComplexNestedCall.kt") - public void testDiscriminatedNothingInsideComplexNestedCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/nothingType/discriminatedNothingInsideComplexNestedCall.kt"); - } - - @Test - @TestMetadata("generateConstraintWithInnerNothingType.kt") - public void testGenerateConstraintWithInnerNothingType() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/nothingType/generateConstraintWithInnerNothingType.kt"); - } - - @Test - @TestMetadata("implicitInferenceTToFlexibleNothing.kt") - public void testImplicitInferenceTToFlexibleNothing() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/nothingType/implicitInferenceTToFlexibleNothing.kt"); - } - - @Test - @TestMetadata("implicitNothingConstraintFromReturn.kt") - public void testImplicitNothingConstraintFromReturn() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/nothingType/implicitNothingConstraintFromReturn.kt"); - } - - @Test - @TestMetadata("inferArgumentToNothingFromNullConstant.kt") - public void testInferArgumentToNothingFromNullConstant() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/nothingType/inferArgumentToNothingFromNullConstant.kt"); - } - - @Test - @TestMetadata("inferenceWithRecursiveGenericsAndNothing.kt") - public void testInferenceWithRecursiveGenericsAndNothing() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/nothingType/inferenceWithRecursiveGenericsAndNothing.kt"); - } - - @Test - @TestMetadata("kt24490.kt") - public void testKt24490() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/nothingType/kt24490.kt"); - } - - @Test - @TestMetadata("kt32051.kt") - public void testKt32051() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/nothingType/kt32051.kt"); - } - - @Test - @TestMetadata("kt32081.kt") - public void testKt32081() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/nothingType/kt32081.kt"); - } - - @Test - @TestMetadata("kt32207.kt") - public void testKt32207() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/nothingType/kt32207.kt"); - } - - @Test - @TestMetadata("kt32388.kt") - public void testKt32388() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/nothingType/kt32388.kt"); - } - - @Test - @TestMetadata("kt34335.kt") - public void testKt34335() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/nothingType/kt34335.kt"); - } - - @Test - @TestMetadata("lambdaNothingAndExpectedType.kt") - public void testLambdaNothingAndExpectedType() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/nothingType/lambdaNothingAndExpectedType.kt"); - } - - @Test - @TestMetadata("nestedLambdaInferenceWithIncorporationOfVariables.kt") - public void testNestedLambdaInferenceWithIncorporationOfVariables() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/nothingType/nestedLambdaInferenceWithIncorporationOfVariables.kt"); - } - - @Test - @TestMetadata("notEnoughInformationAndNothing.kt") - public void testNotEnoughInformationAndNothing() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/nothingType/notEnoughInformationAndNothing.kt"); - } - - @Test - @TestMetadata("notEnoughInformationFromNullabilityConstraint.kt") - public void testNotEnoughInformationFromNullabilityConstraint() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/nothingType/notEnoughInformationFromNullabilityConstraint.kt"); - } - - @Test - @TestMetadata("nothingWithCallableReference.kt") - public void testNothingWithCallableReference() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/nothingType/nothingWithCallableReference.kt"); - } - - @Test - @TestMetadata("nullableExpectedTypeFromVariable.kt") - public void testNullableExpectedTypeFromVariable() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/nothingType/nullableExpectedTypeFromVariable.kt"); - } - - @Test - @TestMetadata("platformNothingAsUsefulConstraint.kt") - public void testPlatformNothingAsUsefulConstraint() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/nothingType/platformNothingAsUsefulConstraint.kt"); - } - - @Test - @TestMetadata("reifiedParameterWithRecursiveBound.kt") - public void testReifiedParameterWithRecursiveBound() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/nothingType/reifiedParameterWithRecursiveBound.kt"); - } - - @Test - @TestMetadata("specialCallWithMaterializeAndExpectedType.kt") - public void testSpecialCallWithMaterializeAndExpectedType() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/nothingType/specialCallWithMaterializeAndExpectedType.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/inference/publicApproximation") - @TestDataPath("$PROJECT_ROOT") - public class PublicApproximation extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInPublicApproximation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/publicApproximation"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("approximatedIntersectionMorePreciseThanBound.kt") - public void testApproximatedIntersectionMorePreciseThanBound() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/publicApproximation/approximatedIntersectionMorePreciseThanBound.kt"); - } - - @Test - @TestMetadata("chainedLambdas.kt") - public void testChainedLambdas() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/publicApproximation/chainedLambdas.kt"); - } - - @Test - @TestMetadata("declarationTypes.kt") - public void testDeclarationTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/publicApproximation/declarationTypes.kt"); - } - - @Test - @TestMetadata("intersectionAfterSmartCastInLambdaReturn.kt") - public void testIntersectionAfterSmartCastInLambdaReturn() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/publicApproximation/intersectionAfterSmartCastInLambdaReturn.kt"); - } - - @Test - @TestMetadata("intersectionAlternative.kt") - public void testIntersectionAlternative() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/publicApproximation/intersectionAlternative.kt"); - } - - @Test - @TestMetadata("intersectionLocations.kt") - public void testIntersectionLocations() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/publicApproximation/intersectionLocations.kt"); - } - - @Test - @TestMetadata("lambdaReturnArgumentCall.kt") - public void testLambdaReturnArgumentCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/publicApproximation/lambdaReturnArgumentCall.kt"); - } - - @Test - @TestMetadata("lambdaReturnTypeApproximation.kt") - public void testLambdaReturnTypeApproximation() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/publicApproximation/lambdaReturnTypeApproximation.kt"); - } - - @Test - @TestMetadata("nonTrivialVariance.kt") - public void testNonTrivialVariance() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/publicApproximation/nonTrivialVariance.kt"); - } - - @Test - @TestMetadata("parameterInBound.kt") - public void testParameterInBound() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/publicApproximation/parameterInBound.kt"); - } - - @Test - @TestMetadata("projections.kt") - public void testProjections() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/publicApproximation/projections.kt"); - } - - @Test - @TestMetadata("smartCastInLambdaReturnAfterIntersection.kt") - public void testSmartCastInLambdaReturnAfterIntersection() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/publicApproximation/smartCastInLambdaReturnAfterIntersection.kt"); - } - - @Test - @TestMetadata("twoIntersections.kt") - public void testTwoIntersections() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/publicApproximation/twoIntersections.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/inference/recursiveCalls") - @TestDataPath("$PROJECT_ROOT") - public class RecursiveCalls extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInRecursiveCalls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/recursiveCalls"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("kt23531.kt") - public void testKt23531() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/recursiveCalls/kt23531.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/inference/recursiveLocalFuns") - @TestDataPath("$PROJECT_ROOT") - public class RecursiveLocalFuns extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInRecursiveLocalFuns() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/recursiveLocalFuns"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("localFactorial.kt") - public void testLocalFactorial() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/recursiveLocalFuns/localFactorial.kt"); - } - - @Test - @TestMetadata("recursiveFun.kt") - public void testRecursiveFun() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/recursiveLocalFuns/recursiveFun.kt"); - } - - @Test - @TestMetadata("recursiveLambda.kt") - public void testRecursiveLambda() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/recursiveLocalFuns/recursiveLambda.kt"); - } - - @Test - @TestMetadata("selfCall.kt") - public void testSelfCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/recursiveLocalFuns/selfCall.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/inference/recursiveTypes") - @TestDataPath("$PROJECT_ROOT") - public class RecursiveTypes extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInRecursiveTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/recursiveTypes"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("multirecursion.kt") - public void testMultirecursion() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/recursiveTypes/multirecursion.kt"); - } - - @Test - @TestMetadata("recursiveInIn.kt") - public void testRecursiveInIn() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/recursiveTypes/recursiveInIn.kt"); - } - - @Test - @TestMetadata("recursiveInInv.kt") - public void testRecursiveInInv() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/recursiveTypes/recursiveInInv.kt"); - } - - @Test - @TestMetadata("recursiveInOut.kt") - public void testRecursiveInOut() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/recursiveTypes/recursiveInOut.kt"); - } - - @Test - @TestMetadata("recursiveInvIn.kt") - public void testRecursiveInvIn() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/recursiveTypes/recursiveInvIn.kt"); - } - - @Test - @TestMetadata("recursiveInvOut.kt") - public void testRecursiveInvOut() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/recursiveTypes/recursiveInvOut.kt"); - } - - @Test - @TestMetadata("recursiveOutIn.kt") - public void testRecursiveOutIn() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/recursiveTypes/recursiveOutIn.kt"); - } - - @Test - @TestMetadata("recursiveOutInv.kt") - public void testRecursiveOutInv() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/recursiveTypes/recursiveOutInv.kt"); - } - - @Test - @TestMetadata("recursiveOutOut.kt") - public void testRecursiveOutOut() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/recursiveTypes/recursiveOutOut.kt"); - } - - @Test - @TestMetadata("recursiveTypeWithNonStarResult.kt") - public void testRecursiveTypeWithNonStarResult() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/recursiveTypes/recursiveTypeWithNonStarResult.kt"); - } - - @Test - @TestMetadata("recursiveTypes.kt") - public void testRecursiveTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/recursiveTypes/recursiveTypes.kt"); - } - - @Test - @TestMetadata("twoTypeConstructors.kt") - public void testTwoTypeConstructors() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/recursiveTypes/twoTypeConstructors.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/inference/regressions") - @TestDataPath("$PROJECT_ROOT") - public class Regressions extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInRegressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/regressions"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("compareBy.kt") - public void testCompareBy() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/compareBy.kt"); - } - - @Test - @TestMetadata("kt1029.kt") - public void testKt1029() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt1029.kt"); - } - - @Test - @TestMetadata("kt1031.kt") - public void testKt1031() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt1031.kt"); - } - - @Test - @TestMetadata("kt1127.kt") - public void testKt1127() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt1127.kt"); - } - - @Test - @TestMetadata("kt1145.kt") - public void testKt1145() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt1145.kt"); - } - - @Test - @TestMetadata("kt1358.kt") - public void testKt1358() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt1358.kt"); - } - - @Test - @TestMetadata("kt1410.kt") - public void testKt1410() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt1410.kt"); - } - - @Test - @TestMetadata("kt1718.kt") - public void testKt1718() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt1718.kt"); - } - - @Test - @TestMetadata("kt1944.kt") - public void testKt1944() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt1944.kt"); - } - - @Test - @TestMetadata("kt2057.kt") - public void testKt2057() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt2057.kt"); - } - - @Test - @TestMetadata("kt2179.kt") - public void testKt2179() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt2179.kt"); - } - - @Test - @TestMetadata("kt2200.kt") - public void testKt2200() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt2200.kt"); - } - - @Test - @TestMetadata("kt2283.kt") - public void testKt2283() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt2283.kt"); - } - - @Test - @TestMetadata("kt2286.kt") - public void testKt2286() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt2286.kt"); - } - - @Test - @TestMetadata("kt2294.kt") - public void testKt2294() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt2294.kt"); - } - - @Test - @TestMetadata("kt2320.kt") - public void testKt2320() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt2320.kt"); - } - - @Test - @TestMetadata("kt2324.kt") - public void testKt2324() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt2324.kt"); - } - - @Test - @TestMetadata("kt2407.kt") - public void testKt2407() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt2407.kt"); - } - - @Test - @TestMetadata("kt2445.kt") - public void testKt2445() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt2445.kt"); - } - - @Test - @TestMetadata("kt2459.kt") - public void testKt2459() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt2459.kt"); - } - - @Test - @TestMetadata("kt2484.kt") - public void testKt2484() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt2484.kt"); - } - - @Test - @TestMetadata("kt2505.kt") - public void testKt2505() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt2505.kt"); - } - - @Test - @TestMetadata("kt2514.kt") - public void testKt2514() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt2514.kt"); - } - - @Test - @TestMetadata("kt2588.kt") - public void testKt2588() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt2588.kt"); - } - - @Test - @TestMetadata("kt2741.kt") - public void testKt2741() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt2741.kt"); - } - - @Test - @TestMetadata("kt2754.kt") - public void testKt2754() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt2754.kt"); - } - - @Test - @TestMetadata("kt2838.kt") - public void testKt2838() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt2838.kt"); - } - - @Test - @TestMetadata("kt2841.kt") - public void testKt2841() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt2841.kt"); - } - - @Test - @TestMetadata("kt2841_it.kt") - public void testKt2841_it() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt2841_it.kt"); - } - - @Test - @TestMetadata("kt2841_it_this.kt") - public void testKt2841_it_this() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt2841_it_this.kt"); - } - - @Test - @TestMetadata("kt2841_this.kt") - public void testKt2841_this() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt2841_this.kt"); - } - - @Test - @TestMetadata("kt2842.kt") - public void testKt2842() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt2842.kt"); - } - - @Test - @TestMetadata("kt2883.kt") - public void testKt2883() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt2883.kt"); - } - - @Test - @TestMetadata("kt3007.kt") - public void testKt3007() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt3007.kt"); - } - - @Test - @TestMetadata("kt3038.kt") - public void testKt3038() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt3038.kt"); - } - - @Test - @TestMetadata("kt3150.kt") - public void testKt3150() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt3150.kt"); - } - - @Test - @TestMetadata("kt3174.kt") - public void testKt3174() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt3174.kt"); - } - - @Test - @TestMetadata("kt32106.kt") - public void testKt32106() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt32106.kt"); - } - - @Test - @TestMetadata("kt32250.kt") - public void testKt32250() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt32250.kt"); - } - - @Test - @TestMetadata("kt32862_both.kt") - public void testKt32862_both() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt32862_both.kt"); - } - - @Test - @TestMetadata("kt32862_none.kt") - public void testKt32862_none() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt32862_none.kt"); - } - - @Test - @TestMetadata("kt3301.kt") - public void testKt3301() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt3301.kt"); - } - - @Test - @TestMetadata("kt3344.kt") - public void testKt3344() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt3344.kt"); - } - - @Test - @TestMetadata("kt33629.kt") - public void testKt33629() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt33629.kt"); - } - - @Test - @TestMetadata("kt34029.kt") - public void testKt34029() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt34029.kt"); - } - - @Test - @TestMetadata("kt34282.kt") - public void testKt34282() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt34282.kt"); - } - - @Test - @TestMetadata("kt3496.kt") - public void testKt3496() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt3496.kt"); - } - - @Test - @TestMetadata("kt3496_2.kt") - public void testKt3496_2() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt3496_2.kt"); - } - - @Test - @TestMetadata("kt3559.kt") - public void testKt3559() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt3559.kt"); - } - - @Test - @TestMetadata("kt35844.kt") - public void testKt35844() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt35844.kt"); - } - - @Test - @TestMetadata("kt35943.kt") - public void testKt35943() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt35943.kt"); - } - - @Test - @TestMetadata("kt36342.kt") - public void testKt36342() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt36342.kt"); - } - - @Test - @TestMetadata("kt36342_2.kt") - public void testKt36342_2() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt36342_2.kt"); - } - - @Test - @TestMetadata("kt37043.kt") - public void testKt37043() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt37043.kt"); - } - - @Test - @TestMetadata("kt37043_2.kt") - public void testKt37043_2() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt37043_2.kt"); - } - - @Test - @TestMetadata("kt37419.kt") - public void testKt37419() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt37419.kt"); - } - - @Test - @TestMetadata("kt37650.kt") - public void testKt37650() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt37650.kt"); - } - - @Test - @TestMetadata("kt38549.kt") - public void testKt38549() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt38549.kt"); - } - - @Test - @TestMetadata("kt38691.kt") - public void testKt38691() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt38691.kt"); - } - - @Test - @TestMetadata("kt41386.kt") - public void testKt41386() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt41386.kt"); - } - - @Test - @TestMetadata("kt41394.kt") - public void testKt41394() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt41394.kt"); - } - - @Test - @TestMetadata("kt4420.kt") - public void testKt4420() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt4420.kt"); - } - - @Test - @TestMetadata("kt702.kt") - public void testKt702() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt702.kt"); - } - - @Test - @TestMetadata("kt731.kt") - public void testKt731() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt731.kt"); - } - - @Test - @TestMetadata("kt742.kt") - public void testKt742() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt742.kt"); - } - - @Test - @TestMetadata("kt8132.kt") - public void testKt8132() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt8132.kt"); - } - - @Test - @TestMetadata("kt832.kt") - public void testKt832() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt832.kt"); - } - - @Test - @TestMetadata("kt943.kt") - public void testKt943() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt943.kt"); - } - - @Test - @TestMetadata("kt9461.kt") - public void testKt9461() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt9461.kt"); - } - - @Test - @TestMetadata("kt948.kt") - public void testKt948() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/kt948.kt"); - } - - @Test - @TestMetadata("noRecursionOnCallingPureKotlinFunctionAsSyntheticJavaAccessor.kt") - public void testNoRecursionOnCallingPureKotlinFunctionAsSyntheticJavaAccessor() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/regressions/noRecursionOnCallingPureKotlinFunctionAsSyntheticJavaAccessor.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/inference/reportingImprovements") - @TestDataPath("$PROJECT_ROOT") - public class ReportingImprovements extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInReportingImprovements() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/reportingImprovements"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("cannotInferParameterTypeWithInference.kt") - public void testCannotInferParameterTypeWithInference() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/reportingImprovements/cannotInferParameterTypeWithInference.kt"); - } - - @Test - @TestMetadata("ErrorTypeAsGenericParameter.kt") - public void testErrorTypeAsGenericParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/reportingImprovements/ErrorTypeAsGenericParameter.kt"); - } - - @Test - @TestMetadata("FunctionPlaceholder.kt") - public void testFunctionPlaceholder() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/reportingImprovements/FunctionPlaceholder.kt"); - } - - @Test - @TestMetadata("inferTypeFromUnresolvedArgument.kt") - public void testInferTypeFromUnresolvedArgument() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/reportingImprovements/inferTypeFromUnresolvedArgument.kt"); - } - - @Test - @TestMetadata("kt42620.kt") - public void testKt42620() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/reportingImprovements/kt42620.kt"); - } - - @Test - @TestMetadata("NoAmbiguityForDifferentFunctionTypes.kt") - public void testNoAmbiguityForDifferentFunctionTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/reportingImprovements/NoAmbiguityForDifferentFunctionTypes.kt"); - } - - @Test - @TestMetadata("reportUnresolvedReferenceWrongReceiverForManyCandidates.kt") - public void testReportUnresolvedReferenceWrongReceiverForManyCandidates() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/reportingImprovements/reportUnresolvedReferenceWrongReceiverForManyCandidates.kt"); - } - - @Test - @TestMetadata("subtypeForInvariantWithErrorGenerics.kt") - public void testSubtypeForInvariantWithErrorGenerics() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/reportingImprovements/subtypeForInvariantWithErrorGenerics.kt"); - } - - @Test - @TestMetadata("typeInferenceFailedOnComponentN.kt") - public void testTypeInferenceFailedOnComponentN() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/reportingImprovements/typeInferenceFailedOnComponentN.kt"); - } - - @Test - @TestMetadata("typeInferenceFailedOnIteratorCall.kt") - public void testTypeInferenceFailedOnIteratorCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/reportingImprovements/typeInferenceFailedOnIteratorCall.kt"); - } - - @Test - @TestMetadata("wrongArgumentExtensionFunction.kt") - public void testWrongArgumentExtensionFunction() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/reportingImprovements/wrongArgumentExtensionFunction.kt"); - } - - @Test - @TestMetadata("wrongArgumentPassedToLocalExtensionFunction.kt") - public void testWrongArgumentPassedToLocalExtensionFunction() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/reportingImprovements/wrongArgumentPassedToLocalExtensionFunction.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/inference/substitutions") - @TestDataPath("$PROJECT_ROOT") - public class Substitutions extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInSubstitutions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/substitutions"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("delegationAndInference.kt") - public void testDelegationAndInference() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/substitutions/delegationAndInference.kt"); - } - - @Test - @TestMetadata("kt32189returnTypeWithTypealiasSubtitution.kt") - public void testKt32189returnTypeWithTypealiasSubtitution() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/substitutions/kt32189returnTypeWithTypealiasSubtitution.kt"); - } - - @Test - @TestMetadata("kt32189returnTypeWithTypealiasSubtitutionOldInference.kt") - public void testKt32189returnTypeWithTypealiasSubtitutionOldInference() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/substitutions/kt32189returnTypeWithTypealiasSubtitutionOldInference.kt"); - } - - @Test - @TestMetadata("kt6081SubstituteIntoClassCorrectly.kt") - public void testKt6081SubstituteIntoClassCorrectly() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/substitutions/kt6081SubstituteIntoClassCorrectly.kt"); - } - - @Test - @TestMetadata("simpleSubstitutionCheckTypeArgumentsNotTypeParameters.kt") - public void testSimpleSubstitutionCheckTypeArgumentsNotTypeParameters() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/substitutions/simpleSubstitutionCheckTypeArgumentsNotTypeParameters.kt"); - } - - @Test - @TestMetadata("substitutionIntoAnonymousClass.kt") - public void testSubstitutionIntoAnonymousClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/substitutions/substitutionIntoAnonymousClass.kt"); - } - - @Test - @TestMetadata("substitutionIntoInnerClass.kt") - public void testSubstitutionIntoInnerClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/substitutions/substitutionIntoInnerClass.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/inference/upperBounds") - @TestDataPath("$PROJECT_ROOT") - public class UpperBounds extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInUpperBounds() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/upperBounds"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("conflictingSubstitutionsFromUpperBound.kt") - public void testConflictingSubstitutionsFromUpperBound() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/upperBounds/conflictingSubstitutionsFromUpperBound.kt"); - } - - @Test - @TestMetadata("doNotInferFromBoundsOnly.kt") - public void testDoNotInferFromBoundsOnly() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/upperBounds/doNotInferFromBoundsOnly.kt"); - } - - @Test - @TestMetadata("flexibilityInCommonSuperTypeCalculation.kt") - public void testFlexibilityInCommonSuperTypeCalculation() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/upperBounds/flexibilityInCommonSuperTypeCalculation.kt"); - } - - @Test - @TestMetadata("flexibilityInCommonSuperTypeCalculation.ni.kt") - public void testFlexibilityInCommonSuperTypeCalculation_ni() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/upperBounds/flexibilityInCommonSuperTypeCalculation.ni.kt"); - } - - @Test - @TestMetadata("inferringVariableByMaterializeAndUpperBound.kt") - public void testInferringVariableByMaterializeAndUpperBound() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/upperBounds/inferringVariableByMaterializeAndUpperBound.kt"); - } - - @Test - @TestMetadata("intersectUpperBounds.kt") - public void testIntersectUpperBounds() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/upperBounds/intersectUpperBounds.kt"); - } - - @Test - @TestMetadata("kt2856.kt") - public void testKt2856() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/upperBounds/kt2856.kt"); - } - - @Test - @TestMetadata("nonNullUpperBound.kt") - public void testNonNullUpperBound() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/upperBounds/nonNullUpperBound.kt"); - } - - @Test - @TestMetadata("typeParameterAsUpperBound.kt") - public void testTypeParameterAsUpperBound() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/upperBounds/typeParameterAsUpperBound.kt"); - } - - @Test - @TestMetadata("useBoundsIfUnknownParameters.kt") - public void testUseBoundsIfUnknownParameters() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/upperBounds/useBoundsIfUnknownParameters.kt"); - } - - @Test - @TestMetadata("useBoundsToInferTypeParamsSimple.kt") - public void testUseBoundsToInferTypeParamsSimple() throws Exception { - runTest("compiler/testData/diagnostics/tests/inference/upperBounds/useBoundsToInferTypeParamsSimple.kt"); - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/infos") - @TestDataPath("$PROJECT_ROOT") - public class Infos extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInInfos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/infos"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("PropertiesWithBackingFields.kt") - public void testPropertiesWithBackingFields() throws Exception { - runTest("compiler/testData/diagnostics/tests/infos/PropertiesWithBackingFields.kt"); - } - - @Test - @TestMetadata("SmartCasts.kt") - public void testSmartCasts() throws Exception { - runTest("compiler/testData/diagnostics/tests/infos/SmartCasts.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/inline") - @TestDataPath("$PROJECT_ROOT") - public class Inline extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inline"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("anonymousObjects.kt") - public void testAnonymousObjects() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/anonymousObjects.kt"); - } - - @Test - @TestMetadata("assignment.kt") - public void testAssignment() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/assignment.kt"); - } - - @Test - @TestMetadata("capture.kt") - public void testCapture() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/capture.kt"); - } - - @Test - @TestMetadata("constructor.kt") - public void testConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/constructor.kt"); - } - - @Test - @TestMetadata("default.kt") - public void testDefault() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/default.kt"); - } - - @Test - @TestMetadata("defaultLambdaInlineDisable.kt") - public void testDefaultLambdaInlineDisable() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/defaultLambdaInlineDisable.kt"); - } - - @Test - @TestMetadata("defaultLambdaInlineSuspend.kt") - public void testDefaultLambdaInlineSuspend() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/defaultLambdaInlineSuspend.kt"); - } - - @Test - @TestMetadata("defaultLambdaInlining.kt") - public void testDefaultLambdaInlining() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/defaultLambdaInlining.kt"); - } - - @Test - @TestMetadata("extensionOnFunction.kt") - public void testExtensionOnFunction() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/extensionOnFunction.kt"); - } - - @Test - @TestMetadata("fromInlineToNoInline.kt") - public void testFromInlineToNoInline() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/fromInlineToNoInline.kt"); - } - - @Test - @TestMetadata("functions.kt") - public void testFunctions() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/functions.kt"); - } - - @Test - @TestMetadata("inlineLambdaInDefaultInlineParameter.kt") - public void testInlineLambdaInDefaultInlineParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/inlineLambdaInDefaultInlineParameter.kt"); - } - - @Test - @TestMetadata("inlineLambdaInDefaultInlineParameterDisabled.kt") - public void testInlineLambdaInDefaultInlineParameterDisabled() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/inlineLambdaInDefaultInlineParameterDisabled.kt"); - } - - @Test - @TestMetadata("inlineReified.kt") - public void testInlineReified() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/inlineReified.kt"); - } - - @Test - @TestMetadata("invoke.kt") - public void testInvoke() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/invoke.kt"); - } - - @Test - @TestMetadata("isCheck.kt") - public void testIsCheck() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/isCheck.kt"); - } - - @Test - @TestMetadata("kt15410.kt") - public void testKt15410() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/kt15410.kt"); - } - - @Test - @TestMetadata("kt19679.kt") - public void testKt19679() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/kt19679.kt"); - } - - @Test - @TestMetadata("kt21177.kt") - public void testKt21177() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/kt21177.kt"); - } - - @Test - @TestMetadata("kt4869.kt") - public void testKt4869() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/kt4869.kt"); - } - - @Test - @TestMetadata("labeled.kt") - public void testLabeled() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/labeled.kt"); - } - - @Test - @TestMetadata("lambdaCast.kt") - public void testLambdaCast() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/lambdaCast.kt"); - } - - @Test - @TestMetadata("localFun.kt") - public void testLocalFun() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/localFun.kt"); - } - - @Test - @TestMetadata("messagesForUnsupportedInInline.kt") - public void testMessagesForUnsupportedInInline() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/messagesForUnsupportedInInline.kt"); - } - - @Test - @TestMetadata("nonVirtualMembersWithInline.kt") - public void testNonVirtualMembersWithInline() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/nonVirtualMembersWithInline.kt"); - } - - @Test - @TestMetadata("nothingToInline.kt") - public void testNothingToInline() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/nothingToInline.kt"); - } - - @Test - @TestMetadata("nullabilityOperations.kt") - public void testNullabilityOperations() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/nullabilityOperations.kt"); - } - - @Test - @TestMetadata("nullableFunction.kt") - public void testNullableFunction() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/nullableFunction.kt"); - } - - @Test - @TestMetadata("overrideWithInline.kt") - public void testOverrideWithInline() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/overrideWithInline.kt"); - } - - @Test - @TestMetadata("parenthesized.kt") - public void testParenthesized() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/parenthesized.kt"); - } - - @Test - @TestMetadata("privateClass.kt") - public void testPrivateClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/privateClass.kt"); - } - - @Test - @TestMetadata("propagation.kt") - public void testPropagation() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/propagation.kt"); - } - - @Test - @TestMetadata("protectedCallDepecation.kt") - public void testProtectedCallDepecation() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/protectedCallDepecation.kt"); - } - - @Test - @TestMetadata("protectedCallError.kt") - public void testProtectedCallError() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/protectedCallError.kt"); - } - - @Test - @TestMetadata("publishedApi.kt") - public void testPublishedApi() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/publishedApi.kt"); - } - - @Test - @TestMetadata("recursion.kt") - public void testRecursion() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/recursion.kt"); - } - - @Test - @TestMetadata("returnedAnonymousObjects.kt") - public void testReturnedAnonymousObjects() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/returnedAnonymousObjects.kt"); - } - - @Test - @TestMetadata("returns.kt") - public void testReturns() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/returns.kt"); - } - - @Test - @TestMetadata("sam.kt") - public void testSam() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/sam.kt"); - } - - @Test - @TestMetadata("stringTemplate.kt") - public void testStringTemplate() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/stringTemplate.kt"); - } - - @Test - @TestMetadata("unsupportedConstruction.kt") - public void testUnsupportedConstruction() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/unsupportedConstruction.kt"); - } - - @Test - @TestMetadata("vararg.kt") - public void testVararg() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/vararg.kt"); - } - - @Test - @TestMetadata("when.kt") - public void testWhen() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/when.kt"); - } - - @Test - @TestMetadata("wrongUsage.kt") - public void testWrongUsage() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/wrongUsage.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/inline/binaryExpressions") - @TestDataPath("$PROJECT_ROOT") - public class BinaryExpressions extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInBinaryExpressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inline/binaryExpressions"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("andOr.kt") - public void testAndOr() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/binaryExpressions/andOr.kt"); - } - - @Test - @TestMetadata("arrayAccess.kt") - public void testArrayAccess() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/binaryExpressions/arrayAccess.kt"); - } - - @Test - @TestMetadata("assignment.kt") - public void testAssignment() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/binaryExpressions/assignment.kt"); - } - - @Test - @TestMetadata("comparison.kt") - public void testComparison() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/binaryExpressions/comparison.kt"); - } - - @Test - @TestMetadata("componentAccess.kt") - public void testComponentAccess() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/binaryExpressions/componentAccess.kt"); - } - - @Test - @TestMetadata("contains.kt") - public void testContains() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/binaryExpressions/contains.kt"); - } - - @Test - @TestMetadata("mathOperations.kt") - public void testMathOperations() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/binaryExpressions/mathOperations.kt"); - } - - @Test - @TestMetadata("rangeTo.kt") - public void testRangeTo() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/binaryExpressions/rangeTo.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/inline/nonLocalReturns") - @TestDataPath("$PROJECT_ROOT") - public class NonLocalReturns extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInNonLocalReturns() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inline/nonLocalReturns"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("anonymousObjects.kt") - public void testAnonymousObjects() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/nonLocalReturns/anonymousObjects.kt"); - } - - @Test - @TestMetadata("anonymousObjectsNested.kt") - public void testAnonymousObjectsNested() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/nonLocalReturns/anonymousObjectsNested.kt"); - } - - @Test - @TestMetadata("explicitReturnType.kt") - public void testExplicitReturnType() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/nonLocalReturns/explicitReturnType.kt"); - } - - @Test - @TestMetadata("fromOnlyLocal.kt") - public void testFromOnlyLocal() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/nonLocalReturns/fromOnlyLocal.kt"); - } - - @Test - @TestMetadata("inlineLambda.kt") - public void testInlineLambda() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/nonLocalReturns/inlineLambda.kt"); - } - - @Test - @TestMetadata("labeledReturn.kt") - public void testLabeledReturn() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/nonLocalReturns/labeledReturn.kt"); - } - - @Test - @TestMetadata("lambdaAsGeneric.kt") - public void testLambdaAsGeneric() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/nonLocalReturns/lambdaAsGeneric.kt"); - } - - @Test - @TestMetadata("lambdaAsNonFunction.kt") - public void testLambdaAsNonFunction() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/nonLocalReturns/lambdaAsNonFunction.kt"); - } - - @Test - @TestMetadata("lambdaWithGlobalReturnsInsideOnlyLocalOne.kt") - public void testLambdaWithGlobalReturnsInsideOnlyLocalOne() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/nonLocalReturns/lambdaWithGlobalReturnsInsideOnlyLocalOne.kt"); - } - - @Test - @TestMetadata("localFun.kt") - public void testLocalFun() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/nonLocalReturns/localFun.kt"); - } - - @Test - @TestMetadata("nestedNonLocals.kt") - public void testNestedNonLocals() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/nonLocalReturns/nestedNonLocals.kt"); - } - - @Test - @TestMetadata("noInlineAnnotation.kt") - public void testNoInlineAnnotation() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/nonLocalReturns/noInlineAnnotation.kt"); - } - - @Test - @TestMetadata("noInlineLambda.kt") - public void testNoInlineLambda() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/nonLocalReturns/noInlineLambda.kt"); - } - - @Test - @TestMetadata("nonInlinedClass.kt") - public void testNonInlinedClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/nonLocalReturns/nonInlinedClass.kt"); - } - - @Test - @TestMetadata("onlyLocalReturnLambda.kt") - public void testOnlyLocalReturnLambda() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/nonLocalReturns/onlyLocalReturnLambda.kt"); - } - - @Test - @TestMetadata("onlyLocalReturnLambdaBinaryExpr.kt") - public void testOnlyLocalReturnLambdaBinaryExpr() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/nonLocalReturns/onlyLocalReturnLambdaBinaryExpr.kt"); - } - - @Test - @TestMetadata("propertyAccessorsAndConstructor.kt") - public void testPropertyAccessorsAndConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/nonLocalReturns/propertyAccessorsAndConstructor.kt"); - } - - @Test - @TestMetadata("toOnlyLocal.kt") - public void testToOnlyLocal() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/nonLocalReturns/toOnlyLocal.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/inline/nonPublicMember") - @TestDataPath("$PROJECT_ROOT") - public class NonPublicMember extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInNonPublicMember() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inline/nonPublicMember"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("inNonPublicClass.kt") - public void testInNonPublicClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/nonPublicMember/inNonPublicClass.kt"); - } - - @Test - @TestMetadata("inNonPublicInnerClass.kt") - public void testInNonPublicInnerClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/nonPublicMember/inNonPublicInnerClass.kt"); - } - - @Test - @TestMetadata("inPackage.kt") - public void testInPackage() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/nonPublicMember/inPackage.kt"); - } - - @Test - @TestMetadata("inPublicClass.kt") - public void testInPublicClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/nonPublicMember/inPublicClass.kt"); - } - - @Test - @TestMetadata("kt14887.kt") - public void testKt14887() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/nonPublicMember/kt14887.kt"); - } - - @Test - @TestMetadata("localClass.kt") - public void testLocalClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/nonPublicMember/localClass.kt"); - } - - @Test - @TestMetadata("localClass2.kt") - public void testLocalClass2() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/nonPublicMember/localClass2.kt"); - } - - @Test - @TestMetadata("localFun.kt") - public void testLocalFun() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/nonPublicMember/localFun.kt"); - } - - @Test - @TestMetadata("publishedApi.kt") - public void testPublishedApi() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/nonPublicMember/publishedApi.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/inline/property") - @TestDataPath("$PROJECT_ROOT") - public class Property extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inline/property"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("invoke.kt") - public void testInvoke() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/property/invoke.kt"); - } - - @Test - @TestMetadata("propertyWithBackingField.kt") - public void testPropertyWithBackingField() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/property/propertyWithBackingField.kt"); - } - - @Test - @TestMetadata("unsupportedConstruction.kt") - public void testUnsupportedConstruction() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/property/unsupportedConstruction.kt"); - } - - @Test - @TestMetadata("virtualProperty.kt") - public void testVirtualProperty() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/property/virtualProperty.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/inline/regressions") - @TestDataPath("$PROJECT_ROOT") - public class Regressions extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInRegressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inline/regressions"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("kt4341.kt") - public void testKt4341() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/regressions/kt4341.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/inline/unaryExpressions") - @TestDataPath("$PROJECT_ROOT") - public class UnaryExpressions extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInUnaryExpressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inline/unaryExpressions"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("mathOperation.kt") - public void testMathOperation() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/unaryExpressions/mathOperation.kt"); - } - - @Test - @TestMetadata("notOnCall.kt") - public void testNotOnCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/unaryExpressions/notOnCall.kt"); - } - - @Test - @TestMetadata("notOperation.kt") - public void testNotOperation() throws Exception { - runTest("compiler/testData/diagnostics/tests/inline/unaryExpressions/notOperation.kt"); - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/inlineClasses") - @TestDataPath("$PROJECT_ROOT") - public class InlineClasses extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inlineClasses"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("basicInlineClassDeclaration.kt") - public void testBasicInlineClassDeclaration() throws Exception { - runTest("compiler/testData/diagnostics/tests/inlineClasses/basicInlineClassDeclaration.kt"); - } - - @Test - @TestMetadata("basicInlineClassDeclarationDisabled.kt") - public void testBasicInlineClassDeclarationDisabled() throws Exception { - runTest("compiler/testData/diagnostics/tests/inlineClasses/basicInlineClassDeclarationDisabled.kt"); - } - - @Test - @TestMetadata("changingNullabilityOfOrdinaryClassIsBinaryCompatibleChange.kt") - public void testChangingNullabilityOfOrdinaryClassIsBinaryCompatibleChange() throws Exception { - runTest("compiler/testData/diagnostics/tests/inlineClasses/changingNullabilityOfOrdinaryClassIsBinaryCompatibleChange.kt"); - } - - @Test - @TestMetadata("constructorsJvmSignaturesClash.kt") - public void testConstructorsJvmSignaturesClash() throws Exception { - runTest("compiler/testData/diagnostics/tests/inlineClasses/constructorsJvmSignaturesClash.kt"); - } - - @Test - @TestMetadata("delegatedPropertyInInlineClass.kt") - public void testDelegatedPropertyInInlineClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/inlineClasses/delegatedPropertyInInlineClass.kt"); - } - - @Test - @TestMetadata("functionsJvmSignaturesClash.kt") - public void testFunctionsJvmSignaturesClash() throws Exception { - runTest("compiler/testData/diagnostics/tests/inlineClasses/functionsJvmSignaturesClash.kt"); - } - - @Test - @TestMetadata("functionsJvmSignaturesConflictOnInheritance.kt") - public void testFunctionsJvmSignaturesConflictOnInheritance() throws Exception { - runTest("compiler/testData/diagnostics/tests/inlineClasses/functionsJvmSignaturesConflictOnInheritance.kt"); - } - - @Test - @TestMetadata("identityComparisonWithInlineClasses.kt") - public void testIdentityComparisonWithInlineClasses() throws Exception { - runTest("compiler/testData/diagnostics/tests/inlineClasses/identityComparisonWithInlineClasses.kt"); - } - - @Test - @TestMetadata("inlineClassCanOnlyImplementInterfaces.kt") - public void testInlineClassCanOnlyImplementInterfaces() throws Exception { - runTest("compiler/testData/diagnostics/tests/inlineClasses/inlineClassCanOnlyImplementInterfaces.kt"); - } - - @Test - @TestMetadata("inlineClassCannotImplementInterfaceByDelegation.kt") - public void testInlineClassCannotImplementInterfaceByDelegation() throws Exception { - runTest("compiler/testData/diagnostics/tests/inlineClasses/inlineClassCannotImplementInterfaceByDelegation.kt"); - } - - @Test - @TestMetadata("inlineClassConstructorParameterWithDefaultValue.kt") - public void testInlineClassConstructorParameterWithDefaultValue() throws Exception { - runTest("compiler/testData/diagnostics/tests/inlineClasses/inlineClassConstructorParameterWithDefaultValue.kt"); - } - - @Test - @TestMetadata("inlineClassDeclarationCheck.kt") - public void testInlineClassDeclarationCheck() throws Exception { - runTest("compiler/testData/diagnostics/tests/inlineClasses/inlineClassDeclarationCheck.kt"); - } - - @Test - @TestMetadata("inlineClassImplementsCollection.kt") - public void testInlineClassImplementsCollection() throws Exception { - runTest("compiler/testData/diagnostics/tests/inlineClasses/inlineClassImplementsCollection.kt"); - } - - @Test - @TestMetadata("inlineClassWithForbiddenUnderlyingType.kt") - public void testInlineClassWithForbiddenUnderlyingType() throws Exception { - runTest("compiler/testData/diagnostics/tests/inlineClasses/inlineClassWithForbiddenUnderlyingType.kt"); - } - - @Test - @TestMetadata("inlineClassesInsideAnnotations.kt") - public void testInlineClassesInsideAnnotations() throws Exception { - runTest("compiler/testData/diagnostics/tests/inlineClasses/inlineClassesInsideAnnotations.kt"); - } - - @Test - @TestMetadata("innerClassInsideInlineClass.kt") - public void testInnerClassInsideInlineClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/inlineClasses/innerClassInsideInlineClass.kt"); - } - - @Test - @TestMetadata("lateinitInlineClasses.kt") - public void testLateinitInlineClasses() throws Exception { - runTest("compiler/testData/diagnostics/tests/inlineClasses/lateinitInlineClasses.kt"); - } - - @Test - @TestMetadata("presenceOfInitializerBlockInsideInlineClass.kt") - public void testPresenceOfInitializerBlockInsideInlineClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/inlineClasses/presenceOfInitializerBlockInsideInlineClass.kt"); - } - - @Test - @TestMetadata("presenceOfPublicPrimaryConstructorForInlineClass.kt") - public void testPresenceOfPublicPrimaryConstructorForInlineClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/inlineClasses/presenceOfPublicPrimaryConstructorForInlineClass.kt"); - } - - @Test - @TestMetadata("propertiesWithBackingFieldsInsideInlineClass.kt") - public void testPropertiesWithBackingFieldsInsideInlineClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/inlineClasses/propertiesWithBackingFieldsInsideInlineClass.kt"); - } - - @Test - @TestMetadata("recursiveInlineClasses.kt") - public void testRecursiveInlineClasses() throws Exception { - runTest("compiler/testData/diagnostics/tests/inlineClasses/recursiveInlineClasses.kt"); - } - - @Test - @TestMetadata("reservedMembersAndConstructsInsideInlineClass.kt") - public void testReservedMembersAndConstructsInsideInlineClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/inlineClasses/reservedMembersAndConstructsInsideInlineClass.kt"); - } - - @Test - @TestMetadata("unsignedLiteralsWithoutArtifactOnClasspath.kt") - public void testUnsignedLiteralsWithoutArtifactOnClasspath() throws Exception { - runTest("compiler/testData/diagnostics/tests/inlineClasses/unsignedLiteralsWithoutArtifactOnClasspath.kt"); - } - - @Test - @TestMetadata("varPropertyWithInlineClassReceiver.kt") - public void testVarPropertyWithInlineClassReceiver() throws Exception { - runTest("compiler/testData/diagnostics/tests/inlineClasses/varPropertyWithInlineClassReceiver.kt"); - } - - @Test - @TestMetadata("varargsOnParametersOfInlineClassType.kt") - public void testVarargsOnParametersOfInlineClassType() throws Exception { - runTest("compiler/testData/diagnostics/tests/inlineClasses/varargsOnParametersOfInlineClassType.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/inner") - @TestDataPath("$PROJECT_ROOT") - public class Inner extends AbstractDiagnosticUsingJavacTest { - @Test - @TestMetadata("accessingToJavaNestedClass.kt") - public void testAccessingToJavaNestedClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/accessingToJavaNestedClass.kt"); - } - - @Test - @TestMetadata("accessingToKotlinNestedClass.kt") - public void testAccessingToKotlinNestedClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/accessingToKotlinNestedClass.kt"); - } - - @Test - public void testAllFilesPresentInInner() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inner"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("annotationInInnerClass.kt") - public void testAnnotationInInnerClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/annotationInInnerClass.kt"); - } - - @Test - @TestMetadata("classesInClassObjectHeader.kt") - public void testClassesInClassObjectHeader() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/classesInClassObjectHeader.kt"); - } - - @Test - @TestMetadata("constructorAccess.kt") - public void testConstructorAccess() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/constructorAccess.kt"); - } - - @Test - @TestMetadata("deepInnerClass.kt") - public void testDeepInnerClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/deepInnerClass.kt"); - } - - @Test - @TestMetadata("enumEntries.kt") - public void testEnumEntries() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/enumEntries.kt"); - } - - @Test - @TestMetadata("enumInInnerClass.kt") - public void testEnumInInnerClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/enumInInnerClass.kt"); - } - - @Test - @TestMetadata("extensionFun.kt") - public void testExtensionFun() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/extensionFun.kt"); - } - - @Test - @TestMetadata("extensionLambdaInsideNestedClass.kt") - public void testExtensionLambdaInsideNestedClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/extensionLambdaInsideNestedClass.kt"); - } - - @Test - @TestMetadata("illegalModifier.kt") - public void testIllegalModifier() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/illegalModifier.kt"); - } - - @Test - @TestMetadata("illegalModifier_lv12.kt") - public void testIllegalModifier_lv12() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/illegalModifier_lv12.kt"); - } - - @Test - @TestMetadata("innerClassInEnumEntryClassMemberResolve.kt") - public void testInnerClassInEnumEntryClassMemberResolve() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/innerClassInEnumEntryClassMemberResolve.kt"); - } - - @Test - @TestMetadata("innerClassInEnumEntryClass_lv11.kt") - public void testInnerClassInEnumEntryClass_lv11() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/innerClassInEnumEntryClass_lv11.kt"); - } - - @Test - @TestMetadata("innerClassInEnumEntryClass_lv12.kt") - public void testInnerClassInEnumEntryClass_lv12() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/innerClassInEnumEntryClass_lv12.kt"); - } - - @Test - @TestMetadata("innerClassInEnumEntryClass_lv13.kt") - public void testInnerClassInEnumEntryClass_lv13() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/innerClassInEnumEntryClass_lv13.kt"); - } - - @Test - @TestMetadata("InnerClassNameClash.kt") - public void testInnerClassNameClash() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/InnerClassNameClash.kt"); - } - - @Test - @TestMetadata("innerClassesInStaticParameters.kt") - public void testInnerClassesInStaticParameters() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/innerClassesInStaticParameters.kt"); - } - - @Test - @TestMetadata("innerConstructorsFromQualifiers.kt") - public void testInnerConstructorsFromQualifiers() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/innerConstructorsFromQualifiers.kt"); - } - - @Test - @TestMetadata("innerConstructorsFromQualifiersWithIrrelevantCandidate.kt") - public void testInnerConstructorsFromQualifiersWithIrrelevantCandidate() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/innerConstructorsFromQualifiersWithIrrelevantCandidate.kt"); - } - - @Test - @TestMetadata("innerErrorForClassObjects.kt") - public void testInnerErrorForClassObjects() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/innerErrorForClassObjects.kt"); - } - - @Test - @TestMetadata("innerErrorForObjects.kt") - public void testInnerErrorForObjects() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/innerErrorForObjects.kt"); - } - - @Test - @TestMetadata("innerThisSuper.kt") - public void testInnerThisSuper() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/innerThisSuper.kt"); - } - - @Test - @TestMetadata("interfaceInInnerClass.kt") - public void testInterfaceInInnerClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/interfaceInInnerClass.kt"); - } - - @Test - @TestMetadata("kt5854.kt") - public void testKt5854() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/kt5854.kt"); - } - - @Test - @TestMetadata("kt6026.kt") - public void testKt6026() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/kt6026.kt"); - } - - @Test - @TestMetadata("localClass.kt") - public void testLocalClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/localClass.kt"); - } - - @Test - @TestMetadata("localClassInsideNested.kt") - public void testLocalClassInsideNested() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/localClassInsideNested.kt"); - } - - @Test - @TestMetadata("localThisSuper.kt") - public void testLocalThisSuper() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/localThisSuper.kt"); - } - - @Test - @TestMetadata("modality.kt") - public void testModality() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/modality.kt"); - } - - @Test - @TestMetadata("nestedClassAccessedViaInstanceReference.kt") - public void testNestedClassAccessedViaInstanceReference() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/nestedClassAccessedViaInstanceReference.kt"); - } - - @Test - @TestMetadata("nestedClassExtendsOuter.kt") - public void testNestedClassExtendsOuter() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/nestedClassExtendsOuter.kt"); - } - - @Test - @TestMetadata("nestedClassExtendsOuterGeneric.kt") - public void testNestedClassExtendsOuterGeneric() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/nestedClassExtendsOuterGeneric.kt"); - } - - @Test - @TestMetadata("nestedClassInObject.kt") - public void testNestedClassInObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/nestedClassInObject.kt"); - } - - @Test - @TestMetadata("nestedClassNotAllowed_after.kt") - public void testNestedClassNotAllowed_after() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/nestedClassNotAllowed_after.kt"); - } - - @Test - @TestMetadata("nestedClassNotAllowed_before.kt") - public void testNestedClassNotAllowed_before() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/nestedClassNotAllowed_before.kt"); - } - - @Test - @TestMetadata("nestedObject.kt") - public void testNestedObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/nestedObject.kt"); - } - - @Test - @TestMetadata("nestedVsInnerAccessOuterMember.kt") - public void testNestedVsInnerAccessOuterMember() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/nestedVsInnerAccessOuterMember.kt"); - } - - @Test - @TestMetadata("outerGenericParam.kt") - public void testOuterGenericParam() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/outerGenericParam.kt"); - } - - @Test - @TestMetadata("outerProtectedMember.kt") - public void testOuterProtectedMember() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/outerProtectedMember.kt"); - } - - @Test - @TestMetadata("outerSuperClassMember.kt") - public void testOuterSuperClassMember() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/outerSuperClassMember.kt"); - } - - @Test - @TestMetadata("referenceToSelfInLocal.kt") - public void testReferenceToSelfInLocal() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/referenceToSelfInLocal.kt"); - } - - @Test - @TestMetadata("resolvePackageClassInObjects.kt") - public void testResolvePackageClassInObjects() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/resolvePackageClassInObjects.kt"); - } - - @Test - @TestMetadata("selfAnnotationForClassObject.kt") - public void testSelfAnnotationForClassObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/selfAnnotationForClassObject.kt"); - } - - @Test - @TestMetadata("traits.kt") - public void testTraits() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/traits.kt"); - } - - @Test - @TestMetadata("visibility.kt") - public void testVisibility() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/visibility.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/inner/qualifiedExpression") - @TestDataPath("$PROJECT_ROOT") - public class QualifiedExpression extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInQualifiedExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inner/qualifiedExpression"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("classObjectOfNestedClass.kt") - public void testClassObjectOfNestedClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/qualifiedExpression/classObjectOfNestedClass.kt"); - } - - @Test - @TestMetadata("constructNestedClass.kt") - public void testConstructNestedClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/qualifiedExpression/constructNestedClass.kt"); - } - - @Test - @TestMetadata("dataLocalVariable.kt") - public void testDataLocalVariable() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/qualifiedExpression/dataLocalVariable.kt"); - } - - @Test - @TestMetadata("enumConstant.kt") - public void testEnumConstant() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/qualifiedExpression/enumConstant.kt"); - } - - @Test - @TestMetadata("genericNestedClass.kt") - public void testGenericNestedClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/qualifiedExpression/genericNestedClass.kt"); - } - - @Test - @TestMetadata("importNestedClass.kt") - public void testImportNestedClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/qualifiedExpression/importNestedClass.kt"); - } - - @Test - @TestMetadata("nestedClassInPackage.kt") - public void testNestedClassInPackage() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/qualifiedExpression/nestedClassInPackage.kt"); - } - - @Test - @TestMetadata("nestedEnumConstant.kt") - public void testNestedEnumConstant() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/qualifiedExpression/nestedEnumConstant.kt"); - } - - @Test - @TestMetadata("nestedObjects.kt") - public void testNestedObjects() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/qualifiedExpression/nestedObjects.kt"); - } - - @Test - @TestMetadata("typePosition.kt") - public void testTypePosition() throws Exception { - runTest("compiler/testData/diagnostics/tests/inner/qualifiedExpression/typePosition.kt"); - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/j+k") - @TestDataPath("$PROJECT_ROOT") - public class J_k extends AbstractDiagnosticUsingJavacTest { - @Test - @TestMetadata("accessClassObjectFromJava.kt") - public void testAccessClassObjectFromJava() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/accessClassObjectFromJava.kt"); - } - - @Test - public void testAllFilesPresentInJ_k() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("ambiguousSamAdapters.kt") - public void testAmbiguousSamAdapters() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/ambiguousSamAdapters.kt"); - } - - @Test - @TestMetadata("annotationWithArgumentsMissingDependencies.kt") - public void testAnnotationWithArgumentsMissingDependencies() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/annotationWithArgumentsMissingDependencies.kt"); - } - - @Test - @TestMetadata("annotationsInheritance.kt") - public void testAnnotationsInheritance() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/annotationsInheritance.kt"); - } - - @Test - @TestMetadata("arrayOfStarParametrized.kt") - public void testArrayOfStarParametrized() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/arrayOfStarParametrized.kt"); - } - - @Test - @TestMetadata("callableReferencesStaticMemberClash.kt") - public void testCallableReferencesStaticMemberClash() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/callableReferencesStaticMemberClash.kt"); - } - - @Test - @TestMetadata("canDeclareIfSamAdapterIsInherited.kt") - public void testCanDeclareIfSamAdapterIsInherited() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/canDeclareIfSamAdapterIsInherited.kt"); - } - - @Test - @TestMetadata("collectorInference.kt") - public void testCollectorInference() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/collectorInference.kt"); - } - - @Test - @TestMetadata("computeIfAbsentConcurrent.kt") - public void testComputeIfAbsentConcurrent() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/computeIfAbsentConcurrent.kt"); - } - - @Test - @TestMetadata("contravariantIterable.kt") - public void testContravariantIterable() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/contravariantIterable.kt"); - } - - @Test - @TestMetadata("defaultMethods.kt") - public void testDefaultMethods() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/defaultMethods.kt"); - } - - @Test - @TestMetadata("defaultMethodsIndirectInheritance.kt") - public void testDefaultMethodsIndirectInheritance() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/defaultMethodsIndirectInheritance.kt"); - } - - @Test - @TestMetadata("defaultMethods_warning.kt") - public void testDefaultMethods_warning() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/defaultMethods_warning.kt"); - } - - @Test - @TestMetadata("differentFilename.kt") - public void testDifferentFilename() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/differentFilename.kt"); - } - - @Test - @TestMetadata("enumGetOrdinal.kt") - public void testEnumGetOrdinal() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/enumGetOrdinal.kt"); - } - - @Test - @TestMetadata("exceptionMessage.kt") - public void testExceptionMessage() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/exceptionMessage.kt"); - } - - @Test - @TestMetadata("fieldOverridesField.kt") - public void testFieldOverridesField() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/fieldOverridesField.kt"); - } - - @Test - @TestMetadata("fieldOverridesFieldOfDifferentType.kt") - public void testFieldOverridesFieldOfDifferentType() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/fieldOverridesFieldOfDifferentType.kt"); - } - - @Test - @TestMetadata("fieldOverridesNothing.kt") - public void testFieldOverridesNothing() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/fieldOverridesNothing.kt"); - } - - @Test - @TestMetadata("finalCollectionSize.kt") - public void testFinalCollectionSize() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/finalCollectionSize.kt"); - } - - @Test - @TestMetadata("flexibleNothing.kt") - public void testFlexibleNothing() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/flexibleNothing.kt"); - } - - @Test - @TestMetadata("genericConstructorWithMultipleBounds.kt") - public void testGenericConstructorWithMultipleBounds() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/genericConstructorWithMultipleBounds.kt"); - } - - @Test - @TestMetadata("GenericsInSupertypes.kt") - public void testGenericsInSupertypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/GenericsInSupertypes.kt"); - } - - @Test - @TestMetadata("inheritAbstractSamAdapter.kt") - public void testInheritAbstractSamAdapter() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/inheritAbstractSamAdapter.kt"); - } - - @Test - @TestMetadata("inheritanceStaticMethodFromInterface.kt") - public void testInheritanceStaticMethodFromInterface() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/inheritanceStaticMethodFromInterface.kt"); - } - - @Test - @TestMetadata("InheritedGenericFunction.kt") - public void testInheritedGenericFunction() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/InheritedGenericFunction.kt"); - } - - @Test - @TestMetadata("InnerClassFromJava.kt") - public void testInnerClassFromJava() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/InnerClassFromJava.kt"); - } - - @Test - @TestMetadata("innerNestedClassFromJava.kt") - public void testInnerNestedClassFromJava() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/innerNestedClassFromJava.kt"); - } - - @Test - @TestMetadata("invisiblePackagePrivateInheritedMember.kt") - public void testInvisiblePackagePrivateInheritedMember() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/invisiblePackagePrivateInheritedMember.kt"); - } - - @Test - @TestMetadata("javaStaticImport.kt") - public void testJavaStaticImport() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/javaStaticImport.kt"); - } - - @Test - @TestMetadata("KJKInheritance.kt") - public void testKJKInheritance() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/KJKInheritance.kt"); - } - - @Test - @TestMetadata("KJKInheritanceGeneric.kt") - public void testKJKInheritanceGeneric() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/KJKInheritanceGeneric.kt"); - } - - @Test - @TestMetadata("kt1402.kt") - public void testKt1402() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/kt1402.kt"); - } - - @Test - @TestMetadata("kt1431.kt") - public void testKt1431() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/kt1431.kt"); - } - - @Test - @TestMetadata("kt1730_implementCharSequence.kt") - public void testKt1730_implementCharSequence() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/kt1730_implementCharSequence.kt"); - } - - @Test - @TestMetadata("kt2152.kt") - public void testKt2152() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/kt2152.kt"); - } - - @Test - @TestMetadata("kt2394.kt") - public void testKt2394() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/kt2394.kt"); - } - - @Test - @TestMetadata("kt2606.kt") - public void testKt2606() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/kt2606.kt"); - } - - @Test - @TestMetadata("kt2619.kt") - public void testKt2619() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/kt2619.kt"); - } - - @Test - @TestMetadata("kt2641.kt") - public void testKt2641() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/kt2641.kt"); - } - - @Test - @TestMetadata("kt2890.kt") - public void testKt2890() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/kt2890.kt"); - } - - @Test - @TestMetadata("kt3307.kt") - public void testKt3307() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/kt3307.kt"); - } - - @Test - @TestMetadata("kt3311.kt") - public void testKt3311() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/kt3311.kt"); - } - - @Test - @TestMetadata("kt36856.kt") - public void testKt36856() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/kt36856.kt"); - } - - @Test - @TestMetadata("kt6720_abstractProperty.kt") - public void testKt6720_abstractProperty() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/kt6720_abstractProperty.kt"); - } - - @Test - @TestMetadata("kt7523.kt") - public void testKt7523() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/kt7523.kt"); - } - - @Test - @TestMetadata("matchers.kt") - public void testMatchers() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/matchers.kt"); - } - - @Test - @TestMetadata("mutableIterator.kt") - public void testMutableIterator() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/mutableIterator.kt"); - } - - @Test - @TestMetadata("nullForOptionalOrElse.kt") - public void testNullForOptionalOrElse() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/nullForOptionalOrElse.kt"); - } - - @Test - @TestMetadata("overrideRawType.kt") - public void testOverrideRawType() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/overrideRawType.kt"); - } - - @Test - @TestMetadata("OverrideVararg.kt") - public void testOverrideVararg() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/OverrideVararg.kt"); - } - - @Test - @TestMetadata("overrideWithSamAndTypeParameter.kt") - public void testOverrideWithSamAndTypeParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/overrideWithSamAndTypeParameter.kt"); - } - - @Test - @TestMetadata("packagePrivateClassStaticMember.kt") - public void testPackagePrivateClassStaticMember() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/packagePrivateClassStaticMember.kt"); - } - - @Test - @TestMetadata("packageVisibility.kt") - public void testPackageVisibility() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/packageVisibility.kt"); - } - - @Test - @TestMetadata("privateFieldOverridesNothing.kt") - public void testPrivateFieldOverridesNothing() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/privateFieldOverridesNothing.kt"); - } - - @Test - @TestMetadata("privateNestedClassStaticMember.kt") - public void testPrivateNestedClassStaticMember() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/privateNestedClassStaticMember.kt"); - } - - @Test - @TestMetadata("protectedStaticSamePackage.kt") - public void testProtectedStaticSamePackage() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/protectedStaticSamePackage.kt"); - } - - @Test - @TestMetadata("recursionWithJavaSyntheticProperty.kt") - public void testRecursionWithJavaSyntheticProperty() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/recursionWithJavaSyntheticProperty.kt"); - } - - @Test - @TestMetadata("recursiveRawUpperBound.kt") - public void testRecursiveRawUpperBound() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/recursiveRawUpperBound.kt"); - } - - @Test - @TestMetadata("recursiveRawUpperBound2.kt") - public void testRecursiveRawUpperBound2() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/recursiveRawUpperBound2.kt"); - } - - @Test - @TestMetadata("recursiveRawUpperBound3.kt") - public void testRecursiveRawUpperBound3() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/recursiveRawUpperBound3.kt"); - } - - @Test - @TestMetadata("samInConstructorWithGenerics.kt") - public void testSamInConstructorWithGenerics() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/samInConstructorWithGenerics.kt"); - } - - @Test - @TestMetadata("samWithConsumer.kt") - public void testSamWithConsumer() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/samWithConsumer.kt"); - } - - @Test - @TestMetadata("selectMoreSpecific.kt") - public void testSelectMoreSpecific() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/selectMoreSpecific.kt"); - } - - @Test - @TestMetadata("serializable.kt") - public void testSerializable() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/serializable.kt"); - } - - @Test - @TestMetadata("shadowingPrimitiveStaticField.kt") - public void testShadowingPrimitiveStaticField() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/shadowingPrimitiveStaticField.kt"); - } - - @Test - @TestMetadata("Simple.kt") - public void testSimple() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/Simple.kt"); - } - - @Test - @TestMetadata("specialBridges.kt") - public void testSpecialBridges() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/specialBridges.kt"); - } - - @Test - @TestMetadata("StaticMembersFromSuperclasses.kt") - public void testStaticMembersFromSuperclasses() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/StaticMembersFromSuperclasses.kt"); - } - - @Test - @TestMetadata("staticMethodInClass.kt") - public void testStaticMethodInClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/staticMethodInClass.kt"); - } - - @Test - @TestMetadata("SupertypeArgumentsNullability-NotNull-SpecialTypes.kt") - public void testSupertypeArgumentsNullability_NotNull_SpecialTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-NotNull-SpecialTypes.kt"); - } - - @Test - @TestMetadata("SupertypeArgumentsNullability-NotNull-UserTypes.kt") - public void testSupertypeArgumentsNullability_NotNull_UserTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-NotNull-UserTypes.kt"); - } - - @Test - @TestMetadata("SupertypeArgumentsNullability-SpecialTypes.kt") - public void testSupertypeArgumentsNullability_SpecialTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-SpecialTypes.kt"); - } - - @Test - @TestMetadata("SupertypeArgumentsNullability-UserTypes.kt") - public void testSupertypeArgumentsNullability_UserTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/SupertypeArgumentsNullability-UserTypes.kt"); - } - - @Test - @TestMetadata("traitDefaultCall.kt") - public void testTraitDefaultCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/traitDefaultCall.kt"); - } - - @Test - @TestMetadata("typeAliasWithSamConstructor.kt") - public void testTypeAliasWithSamConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/typeAliasWithSamConstructor.kt"); - } - - @Test - @TestMetadata("UnboxingNulls.kt") - public void testUnboxingNulls() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/UnboxingNulls.kt"); - } - - @Test - @TestMetadata("wrongVarianceInJava.kt") - public void testWrongVarianceInJava() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/wrongVarianceInJava.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/j+k/brokenCode") - @TestDataPath("$PROJECT_ROOT") - public class BrokenCode extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInBrokenCode() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/brokenCode"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("classDuplicates.kt") - public void testClassDuplicates() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/brokenCode/classDuplicates.kt"); - } - - @Test - @TestMetadata("fieldDuplicates.kt") - public void testFieldDuplicates() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/brokenCode/fieldDuplicates.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/j+k/collectionOverrides") - @TestDataPath("$PROJECT_ROOT") - public class CollectionOverrides extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInCollectionOverrides() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/collectionOverrides"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("charBuffer.kt") - public void testCharBuffer() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/collectionOverrides/charBuffer.kt"); - } - - @Test - @TestMetadata("collectionStringImpl.kt") - public void testCollectionStringImpl() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/collectionOverrides/collectionStringImpl.kt"); - } - - @Test - @TestMetadata("commonCollections.kt") - public void testCommonCollections() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/collectionOverrides/commonCollections.kt"); - } - - @Test - @TestMetadata("contains.kt") - public void testContains() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/collectionOverrides/contains.kt"); - } - - @Test - @TestMetadata("containsAll.kt") - public void testContainsAll() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/collectionOverrides/containsAll.kt"); - } - - @Test - @TestMetadata("containsAndOverload.kt") - public void testContainsAndOverload() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/collectionOverrides/containsAndOverload.kt"); - } - - @Test - @TestMetadata("getCharSequence.kt") - public void testGetCharSequence() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/collectionOverrides/getCharSequence.kt"); - } - - @Test - @TestMetadata("irrelevantCharAtAbstract.kt") - public void testIrrelevantCharAtAbstract() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/collectionOverrides/irrelevantCharAtAbstract.kt"); - } - - @Test - @TestMetadata("irrelevantImplCharSequence.kt") - public void testIrrelevantImplCharSequence() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/collectionOverrides/irrelevantImplCharSequence.kt"); - } - - @Test - @TestMetadata("irrelevantImplCharSequenceKotlin.kt") - public void testIrrelevantImplCharSequenceKotlin() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/collectionOverrides/irrelevantImplCharSequenceKotlin.kt"); - } - - @Test - @TestMetadata("irrelevantImplMutableList.kt") - public void testIrrelevantImplMutableList() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/collectionOverrides/irrelevantImplMutableList.kt"); - } - - @Test - @TestMetadata("irrelevantImplMutableListKotlin.kt") - public void testIrrelevantImplMutableListKotlin() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/collectionOverrides/irrelevantImplMutableListKotlin.kt"); - } - - @Test - @TestMetadata("irrelevantMapGetAbstract.kt") - public void testIrrelevantMapGetAbstract() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/collectionOverrides/irrelevantMapGetAbstract.kt"); - } - - @Test - @TestMetadata("mapGetOverride.kt") - public void testMapGetOverride() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/collectionOverrides/mapGetOverride.kt"); - } - - @Test - @TestMetadata("overridesBuiltinNoMagic.kt") - public void testOverridesBuiltinNoMagic() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/collectionOverrides/overridesBuiltinNoMagic.kt"); - } - - @Test - @TestMetadata("removeAt.kt") - public void testRemoveAt() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/collectionOverrides/removeAt.kt"); - } - - @Test - @TestMetadata("removeAtInt.kt") - public void testRemoveAtInt() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/collectionOverrides/removeAtInt.kt"); - } - - @Test - @TestMetadata("sizeFromKotlinOverriddenInJava.kt") - public void testSizeFromKotlinOverriddenInJava() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/collectionOverrides/sizeFromKotlinOverriddenInJava.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/j+k/deprecations") - @TestDataPath("$PROJECT_ROOT") - public class Deprecations extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInDeprecations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/deprecations"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("forFakeOverrides.kt") - public void testForFakeOverrides() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/deprecations/forFakeOverrides.kt"); - } - - @Test - @TestMetadata("forMixedOverride.kt") - public void testForMixedOverride() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/deprecations/forMixedOverride.kt"); - } - - @Test - @TestMetadata("forOverrides.kt") - public void testForOverrides() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/deprecations/forOverrides.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/j+k/genericConstructor") - @TestDataPath("$PROJECT_ROOT") - public class GenericConstructor extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInGenericConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/genericConstructor"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("classTypeParameterInferredFromArgument.kt") - public void testClassTypeParameterInferredFromArgument() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/genericConstructor/classTypeParameterInferredFromArgument.kt"); - } - - @Test - @TestMetadata("innerClass.kt") - public void testInnerClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/genericConstructor/innerClass.kt"); - } - - @Test - @TestMetadata("noClassTypeParameters.kt") - public void testNoClassTypeParameters() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/genericConstructor/noClassTypeParameters.kt"); - } - - @Test - @TestMetadata("noClassTypeParametersInvParameter.kt") - public void testNoClassTypeParametersInvParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/genericConstructor/noClassTypeParametersInvParameter.kt"); - } - - @Test - @TestMetadata("recursive.kt") - public void testRecursive() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/genericConstructor/recursive.kt"); - } - - @Test - @TestMetadata("selfTypes.kt") - public void testSelfTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/genericConstructor/selfTypes.kt"); - } - - @Test - @TestMetadata("superCall.kt") - public void testSuperCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/genericConstructor/superCall.kt"); - } - - @Test - @TestMetadata("superCallImpossibleToInfer.kt") - public void testSuperCallImpossibleToInfer() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/genericConstructor/superCallImpossibleToInfer.kt"); - } - - @Test - @TestMetadata("withClassTypeParameters.kt") - public void testWithClassTypeParameters() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/genericConstructor/withClassTypeParameters.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/j+k/polymorphicSignature") - @TestDataPath("$PROJECT_ROOT") - public class PolymorphicSignature extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInPolymorphicSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/polymorphicSignature"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("spreadOperator_after.kt") - public void testSpreadOperator_after() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/polymorphicSignature/spreadOperator_after.kt"); - } - - @Test - @TestMetadata("spreadOperator_before.kt") - public void testSpreadOperator_before() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/polymorphicSignature/spreadOperator_before.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/j+k/primitiveOverrides") - @TestDataPath("$PROJECT_ROOT") - public class PrimitiveOverrides extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInPrimitiveOverrides() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/primitiveOverrides"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("kt11140.kt") - public void testKt11140() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/primitiveOverrides/kt11140.kt"); - } - - @Test - @TestMetadata("notNullAnnotated.kt") - public void testNotNullAnnotated() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/primitiveOverrides/notNullAnnotated.kt"); - } - - @Test - @TestMetadata("specializedMap.kt") - public void testSpecializedMap() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/primitiveOverrides/specializedMap.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/j+k/primitiveOverridesWithInlineClass") - @TestDataPath("$PROJECT_ROOT") - public class PrimitiveOverridesWithInlineClass extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInPrimitiveOverridesWithInlineClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/primitiveOverridesWithInlineClass"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("inlineClassErasedToPrimitiveInt.kt") - public void testInlineClassErasedToPrimitiveInt() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/primitiveOverridesWithInlineClass/inlineClassErasedToPrimitiveInt.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/j+k/properties") - @TestDataPath("$PROJECT_ROOT") - public class Properties extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/properties"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("fieldPropertyOverloads.kt") - public void testFieldPropertyOverloads() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/properties/fieldPropertyOverloads.kt"); - } - - @Test - @TestMetadata("fieldPropertyOverloadsDisabled.kt") - public void testFieldPropertyOverloadsDisabled() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/properties/fieldPropertyOverloadsDisabled.kt"); - } - - @Test - @TestMetadata("fieldPropertyOverloadsNI.kt") - public void testFieldPropertyOverloadsNI() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/properties/fieldPropertyOverloadsNI.kt"); - } - - @Test - @TestMetadata("interface.kt") - public void testInterface() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/properties/interface.kt"); - } - - @Test - @TestMetadata("isName.kt") - public void testIsName() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/properties/isName.kt"); - } - - @Test - @TestMetadata("staticFieldPropertyOverloads.kt") - public void testStaticFieldPropertyOverloads() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/properties/staticFieldPropertyOverloads.kt"); - } - - @Test - @TestMetadata("val.kt") - public void testVal() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/properties/val.kt"); - } - - @Test - @TestMetadata("var.kt") - public void testVar() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/properties/var.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/j+k/sam") - @TestDataPath("$PROJECT_ROOT") - public class Sam extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInSam() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/sam"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("compatibilityResolveToOuterScopeForKotlinFunctions.kt") - public void testCompatibilityResolveToOuterScopeForKotlinFunctions() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/sam/compatibilityResolveToOuterScopeForKotlinFunctions.kt"); - } - - @Test - @TestMetadata("conversionForDerivedGenericClass.kt") - public void testConversionForDerivedGenericClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/sam/conversionForDerivedGenericClass.kt"); - } - - @Test - @TestMetadata("conversionsWithNestedGenerics.kt") - public void testConversionsWithNestedGenerics() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/sam/conversionsWithNestedGenerics.kt"); - } - - @Test - @TestMetadata("enhancedSamConstructor.kt") - public void testEnhancedSamConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/sam/enhancedSamConstructor.kt"); - } - - @Test - @TestMetadata("fakeOverrideFunctionForStaticSam.kt") - public void testFakeOverrideFunctionForStaticSam() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/sam/fakeOverrideFunctionForStaticSam.kt"); - } - - @Test - @TestMetadata("inheritedStaticSam.kt") - public void testInheritedStaticSam() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/sam/inheritedStaticSam.kt"); - } - - @Test - @TestMetadata("kt37920.kt") - public void testKt37920() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/sam/kt37920.kt"); - } - - @Test - @TestMetadata("kt39630.kt") - public void testKt39630() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/sam/kt39630.kt"); - } - - @Test - @TestMetadata("privateCandidatesWithWrongArguments.kt") - public void testPrivateCandidatesWithWrongArguments() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/sam/privateCandidatesWithWrongArguments.kt"); - } - - @Test - @TestMetadata("recursiveSamsAndInvoke.kt") - public void testRecursiveSamsAndInvoke() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/sam/recursiveSamsAndInvoke.kt"); - } - - @Test - @TestMetadata("referenceToSamFunctionAgainstExpectedType.kt") - public void testReferenceToSamFunctionAgainstExpectedType() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/sam/referenceToSamFunctionAgainstExpectedType.kt"); - } - - @Test - @TestMetadata("samOnTypeParameter.kt") - public void testSamOnTypeParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/sam/samOnTypeParameter.kt"); - } - - @Test - @TestMetadata("staticSamFromImportWithStar.kt") - public void testStaticSamFromImportWithStar() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/sam/staticSamFromImportWithStar.kt"); - } - - @Test - @TestMetadata("staticSamWithExplicitImport.kt") - public void testStaticSamWithExplicitImport() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/sam/staticSamWithExplicitImport.kt"); - } - - @Test - @TestMetadata("typeInferenceOnSamAdapters.kt") - public void testTypeInferenceOnSamAdapters() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/sam/typeInferenceOnSamAdapters.kt"); - } - - @Test - @TestMetadata("withDefaultMethods.kt") - public void testWithDefaultMethods() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/sam/withDefaultMethods.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/j+k/samByProjectedType") - @TestDataPath("$PROJECT_ROOT") - public class SamByProjectedType extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInSamByProjectedType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/samByProjectedType"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("genericInReturnType.kt") - public void testGenericInReturnType() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/samByProjectedType/genericInReturnType.kt"); - } - - @Test - @TestMetadata("genericInValueParameter.kt") - public void testGenericInValueParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/samByProjectedType/genericInValueParameter.kt"); - } - - @Test - @TestMetadata("genericSuperWildcard.kt") - public void testGenericSuperWildcard() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/samByProjectedType/genericSuperWildcard.kt"); - } - - @Test - @TestMetadata("noAdapterBecuaseOfRecursiveUpperBound.kt") - public void testNoAdapterBecuaseOfRecursiveUpperBound() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/samByProjectedType/noAdapterBecuaseOfRecursiveUpperBound.kt"); - } - - @Test - @TestMetadata("starProjectionComplexUpperBound.kt") - public void testStarProjectionComplexUpperBound() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/samByProjectedType/starProjectionComplexUpperBound.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/j+k/signatureAnnotations") - @TestDataPath("$PROJECT_ROOT") - public class SignatureAnnotations extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInSignatureAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/signatureAnnotations"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("defaultEnum.kt") - public void testDefaultEnum() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/signatureAnnotations/defaultEnum.kt"); - } - - @Test - @TestMetadata("defaultLongLiteral.kt") - public void testDefaultLongLiteral() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/signatureAnnotations/defaultLongLiteral.kt"); - } - - @Test - @TestMetadata("defaultNull.kt") - public void testDefaultNull() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/signatureAnnotations/defaultNull.kt"); - } - - @Test - @TestMetadata("defaultNullAndParameter.kt") - public void testDefaultNullAndParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/signatureAnnotations/defaultNullAndParameter.kt"); - } - - @Test - @TestMetadata("defaultParameter.kt") - public void testDefaultParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/signatureAnnotations/defaultParameter.kt"); - } - - @Test - @TestMetadata("emptyParameterName.kt") - public void testEmptyParameterName() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/signatureAnnotations/emptyParameterName.kt"); - } - - @Test - @TestMetadata("notNullVarargOverride.kt") - public void testNotNullVarargOverride() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/signatureAnnotations/notNullVarargOverride.kt"); - } - - @Test - @TestMetadata("nullableVarargOverride.kt") - public void testNullableVarargOverride() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/signatureAnnotations/nullableVarargOverride.kt"); - } - - @Test - @TestMetadata("overridesDefaultValue.kt") - public void testOverridesDefaultValue() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/signatureAnnotations/overridesDefaultValue.kt"); - } - - @Test - @TestMetadata("overridesParameterName.kt") - public void testOverridesParameterName() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/signatureAnnotations/overridesParameterName.kt"); - } - - @Test - @TestMetadata("reorderedParameterNames.kt") - public void testReorderedParameterNames() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/signatureAnnotations/reorderedParameterNames.kt"); - } - - @Test - @TestMetadata("sameParameterName.kt") - public void testSameParameterName() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/signatureAnnotations/sameParameterName.kt"); - } - - @Test - @TestMetadata("specialCharsParameterName.kt") - public void testSpecialCharsParameterName() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/signatureAnnotations/specialCharsParameterName.kt"); - } - - @Test - @TestMetadata("stableParameterName.kt") - public void testStableParameterName() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/signatureAnnotations/stableParameterName.kt"); - } - - @Test - @TestMetadata("staticMethodWithDefaultValue.kt") - public void testStaticMethodWithDefaultValue() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/signatureAnnotations/staticMethodWithDefaultValue.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/j+k/specialBuiltIns") - @TestDataPath("$PROJECT_ROOT") - public class SpecialBuiltIns extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInSpecialBuiltIns() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/specialBuiltIns"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("hashtableInheritance.kt") - public void testHashtableInheritance() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/specialBuiltIns/hashtableInheritance.kt"); - } - - @Test - @TestMetadata("securityProvider.kt") - public void testSecurityProvider() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/specialBuiltIns/securityProvider.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/j+k/types") - @TestDataPath("$PROJECT_ROOT") - public class Types extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/types"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("arrayList.kt") - public void testArrayList() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/types/arrayList.kt"); - } - - @Test - @TestMetadata("notNullTypeParameterWithKotlinNullable.kt") - public void testNotNullTypeParameterWithKotlinNullable() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/types/notNullTypeParameterWithKotlinNullable.kt"); - } - - @Test - @TestMetadata("notNullTypeParameterWithKotlinNullableWarnings.kt") - public void testNotNullTypeParameterWithKotlinNullableWarnings() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/types/notNullTypeParameterWithKotlinNullableWarnings.kt"); - } - - @Test - @TestMetadata("returnCollection.kt") - public void testReturnCollection() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/types/returnCollection.kt"); - } - - @Test - @TestMetadata("shapeMismatchInCovariantPosition.kt") - public void testShapeMismatchInCovariantPosition() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/types/shapeMismatchInCovariantPosition.kt"); - } - - @Test - @TestMetadata("shapeMismatchInCovariantPositionGeneric.kt") - public void testShapeMismatchInCovariantPositionGeneric() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/types/shapeMismatchInCovariantPositionGeneric.kt"); - } - - @Test - @TestMetadata("typeParameter.kt") - public void testTypeParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/j+k/types/typeParameter.kt"); - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/java8Overrides") - @TestDataPath("$PROJECT_ROOT") - public class Java8Overrides extends AbstractDiagnosticUsingJavacTest { - @Test - @TestMetadata("abstractBaseClassMemberNotImplemented.kt") - public void testAbstractBaseClassMemberNotImplemented() throws Exception { - runTest("compiler/testData/diagnostics/tests/java8Overrides/abstractBaseClassMemberNotImplemented.kt"); - } - - @Test - @TestMetadata("abstractVsAbstract.kt") - public void testAbstractVsAbstract() throws Exception { - runTest("compiler/testData/diagnostics/tests/java8Overrides/abstractVsAbstract.kt"); - } - - @Test - public void testAllFilesPresentInJava8Overrides() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/java8Overrides"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("defaultVsAbstract.kt") - public void testDefaultVsAbstract() throws Exception { - runTest("compiler/testData/diagnostics/tests/java8Overrides/defaultVsAbstract.kt"); - } - - @Test - @TestMetadata("hidingMethodOfAny.kt") - public void testHidingMethodOfAny() throws Exception { - runTest("compiler/testData/diagnostics/tests/java8Overrides/hidingMethodOfAny.kt"); - } - - @Test - @TestMetadata("implementingMethodOfAny.kt") - public void testImplementingMethodOfAny() throws Exception { - runTest("compiler/testData/diagnostics/tests/java8Overrides/implementingMethodOfAny.kt"); - } - - @Test - @TestMetadata("notAMethodOfAny.kt") - public void testNotAMethodOfAny() throws Exception { - runTest("compiler/testData/diagnostics/tests/java8Overrides/notAMethodOfAny.kt"); - } - - @Test - @TestMetadata("overridingMethodOfAnyChain.kt") - public void testOverridingMethodOfAnyChain() throws Exception { - runTest("compiler/testData/diagnostics/tests/java8Overrides/overridingMethodOfAnyChain.kt"); - } - - @Test - @TestMetadata("overridingMethodOfAnyDiamond.kt") - public void testOverridingMethodOfAnyDiamond() throws Exception { - runTest("compiler/testData/diagnostics/tests/java8Overrides/overridingMethodOfAnyDiamond.kt"); - } - - @Test - @TestMetadata("singleRelevantDefault.kt") - public void testSingleRelevantDefault() throws Exception { - runTest("compiler/testData/diagnostics/tests/java8Overrides/singleRelevantDefault.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/labels") - @TestDataPath("$PROJECT_ROOT") - public class Labels extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInLabels() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/labels"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("automaticLabelFromInfixOperator.kt") - public void testAutomaticLabelFromInfixOperator() throws Exception { - runTest("compiler/testData/diagnostics/tests/labels/automaticLabelFromInfixOperator.kt"); - } - - @Test - @TestMetadata("kt1703.kt") - public void testKt1703() throws Exception { - runTest("compiler/testData/diagnostics/tests/labels/kt1703.kt"); - } - - @Test - @TestMetadata("kt361.kt") - public void testKt361() throws Exception { - runTest("compiler/testData/diagnostics/tests/labels/kt361.kt"); - } - - @Test - @TestMetadata("kt3920.kt") - public void testKt3920() throws Exception { - runTest("compiler/testData/diagnostics/tests/labels/kt3920.kt"); - } - - @Test - @TestMetadata("kt3988.kt") - public void testKt3988() throws Exception { - runTest("compiler/testData/diagnostics/tests/labels/kt3988.kt"); - } - - @Test - @TestMetadata("kt4247.kt") - public void testKt4247() throws Exception { - runTest("compiler/testData/diagnostics/tests/labels/kt4247.kt"); - } - - @Test - @TestMetadata("kt4586.kt") - public void testKt4586() throws Exception { - runTest("compiler/testData/diagnostics/tests/labels/kt4586.kt"); - } - - @Test - @TestMetadata("kt4603.kt") - public void testKt4603() throws Exception { - runTest("compiler/testData/diagnostics/tests/labels/kt4603.kt"); - } - - @Test - @TestMetadata("kt591.kt") - public void testKt591() throws Exception { - runTest("compiler/testData/diagnostics/tests/labels/kt591.kt"); - } - - @Test - @TestMetadata("labelReferencesInsideObjectExpressions.kt") - public void testLabelReferencesInsideObjectExpressions() throws Exception { - runTest("compiler/testData/diagnostics/tests/labels/labelReferencesInsideObjectExpressions.kt"); - } - - @Test - @TestMetadata("labeledFunctionLiteral.kt") - public void testLabeledFunctionLiteral() throws Exception { - runTest("compiler/testData/diagnostics/tests/labels/labeledFunctionLiteral.kt"); - } - - @Test - @TestMetadata("labelsMustBeNamed.kt") - public void testLabelsMustBeNamed() throws Exception { - runTest("compiler/testData/diagnostics/tests/labels/labelsMustBeNamed.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/lateinit") - @TestDataPath("$PROJECT_ROOT") - public class Lateinit extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInLateinit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/lateinit"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("modifierApplicability.kt") - public void testModifierApplicability() throws Exception { - runTest("compiler/testData/diagnostics/tests/lateinit/modifierApplicability.kt"); - } - - @Test - @TestMetadata("modifierApplicability_lv12.kt") - public void testModifierApplicability_lv12() throws Exception { - runTest("compiler/testData/diagnostics/tests/lateinit/modifierApplicability_lv12.kt"); - } - - @Test - @TestMetadata("setter.kt") - public void testSetter() throws Exception { - runTest("compiler/testData/diagnostics/tests/lateinit/setter.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/lateinit/local") - @TestDataPath("$PROJECT_ROOT") - public class Local extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInLocal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/lateinit/local"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("inapplicableLateinitModifier.kt") - public void testInapplicableLateinitModifier() throws Exception { - runTest("compiler/testData/diagnostics/tests/lateinit/local/inapplicableLateinitModifier.kt"); - } - - @Test - @TestMetadata("localLateinit.kt") - public void testLocalLateinit() throws Exception { - runTest("compiler/testData/diagnostics/tests/lateinit/local/localLateinit.kt"); - } - - @Test - @TestMetadata("uninitialized.kt") - public void testUninitialized() throws Exception { - runTest("compiler/testData/diagnostics/tests/lateinit/local/uninitialized.kt"); - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/library") - @TestDataPath("$PROJECT_ROOT") - public class Library extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInLibrary() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/library"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("Collections.kt") - public void testCollections() throws Exception { - runTest("compiler/testData/diagnostics/tests/library/Collections.kt"); - } - - @Test - @TestMetadata("kt828.kt") - public void testKt828() throws Exception { - runTest("compiler/testData/diagnostics/tests/library/kt828.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/localClasses") - @TestDataPath("$PROJECT_ROOT") - public class LocalClasses extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInLocalClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/localClasses"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("localAnnotationClass.kt") - public void testLocalAnnotationClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/localClasses/localAnnotationClass.kt"); - } - - @Test - @TestMetadata("localAnnotationClassError.kt") - public void testLocalAnnotationClassError() throws Exception { - runTest("compiler/testData/diagnostics/tests/localClasses/localAnnotationClassError.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/modifiers") - @TestDataPath("$PROJECT_ROOT") - public class Modifiers extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInModifiers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/modifiers"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("annotations.kt") - public void testAnnotations() throws Exception { - runTest("compiler/testData/diagnostics/tests/modifiers/annotations.kt"); - } - - @Test - @TestMetadata("defaultModifier.kt") - public void testDefaultModifier() throws Exception { - runTest("compiler/testData/diagnostics/tests/modifiers/defaultModifier.kt"); - } - - @Test - @TestMetadata("IllegalModifiers.kt") - public void testIllegalModifiers() throws Exception { - runTest("compiler/testData/diagnostics/tests/modifiers/IllegalModifiers.kt"); - } - - @Test - @TestMetadata("incompatibleVarianceModifiers.kt") - public void testIncompatibleVarianceModifiers() throws Exception { - runTest("compiler/testData/diagnostics/tests/modifiers/incompatibleVarianceModifiers.kt"); - } - - @Test - @TestMetadata("inlineParameters.kt") - public void testInlineParameters() throws Exception { - runTest("compiler/testData/diagnostics/tests/modifiers/inlineParameters.kt"); - } - - @Test - @TestMetadata("internalInInterface.kt") - public void testInternalInInterface() throws Exception { - runTest("compiler/testData/diagnostics/tests/modifiers/internalInInterface.kt"); - } - - @Test - @TestMetadata("modifierOnParameterInFunctionType.kt") - public void testModifierOnParameterInFunctionType() throws Exception { - runTest("compiler/testData/diagnostics/tests/modifiers/modifierOnParameterInFunctionType.kt"); - } - - @Test - @TestMetadata("NoLocalVisibility.kt") - public void testNoLocalVisibility() throws Exception { - runTest("compiler/testData/diagnostics/tests/modifiers/NoLocalVisibility.kt"); - } - - @Test - @TestMetadata("openInExpectInterface.kt") - public void testOpenInExpectInterface() throws Exception { - runTest("compiler/testData/diagnostics/tests/modifiers/openInExpectInterface.kt"); - } - - @Test - @TestMetadata("openInInterface.kt") - public void testOpenInInterface() throws Exception { - runTest("compiler/testData/diagnostics/tests/modifiers/openInInterface.kt"); - } - - @Test - @TestMetadata("primaryConstructorMissingBrackets.kt") - public void testPrimaryConstructorMissingBrackets() throws Exception { - runTest("compiler/testData/diagnostics/tests/modifiers/primaryConstructorMissingBrackets.kt"); - } - - @Test - @TestMetadata("primaryConstructorMissingKeyword.kt") - public void testPrimaryConstructorMissingKeyword() throws Exception { - runTest("compiler/testData/diagnostics/tests/modifiers/primaryConstructorMissingKeyword.kt"); - } - - @Test - @TestMetadata("privateInInterface.kt") - public void testPrivateInInterface() throws Exception { - runTest("compiler/testData/diagnostics/tests/modifiers/privateInInterface.kt"); - } - - @Test - @TestMetadata("protected.kt") - public void testProtected() throws Exception { - runTest("compiler/testData/diagnostics/tests/modifiers/protected.kt"); - } - - @Test - @TestMetadata("redundantTargets.kt") - public void testRedundantTargets() throws Exception { - runTest("compiler/testData/diagnostics/tests/modifiers/redundantTargets.kt"); - } - - @Test - @TestMetadata("repeatedModifiers.kt") - public void testRepeatedModifiers() throws Exception { - runTest("compiler/testData/diagnostics/tests/modifiers/repeatedModifiers.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/modifiers/const") - @TestDataPath("$PROJECT_ROOT") - public class Const extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInConst() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/modifiers/const"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("applicability.kt") - public void testApplicability() throws Exception { - runTest("compiler/testData/diagnostics/tests/modifiers/const/applicability.kt"); - } - - @Test - @TestMetadata("arrayInAnnotationArgumentType.kt") - public void testArrayInAnnotationArgumentType() throws Exception { - runTest("compiler/testData/diagnostics/tests/modifiers/const/arrayInAnnotationArgumentType.kt"); - } - - @Test - @TestMetadata("constInteraction.kt") - public void testConstInteraction() throws Exception { - runTest("compiler/testData/diagnostics/tests/modifiers/const/constInteraction.kt"); - } - - @Test - @TestMetadata("fromJava.kt") - public void testFromJava() throws Exception { - runTest("compiler/testData/diagnostics/tests/modifiers/const/fromJava.kt"); - } - - @Test - @TestMetadata("fromJavaSubclass.kt") - public void testFromJavaSubclass() throws Exception { - runTest("compiler/testData/diagnostics/tests/modifiers/const/fromJavaSubclass.kt"); - } - - @Test - @TestMetadata("kt12248.kt") - public void testKt12248() throws Exception { - runTest("compiler/testData/diagnostics/tests/modifiers/const/kt12248.kt"); - } - - @Test - @TestMetadata("kt15913.kt") - public void testKt15913() throws Exception { - runTest("compiler/testData/diagnostics/tests/modifiers/const/kt15913.kt"); - } - - @Test - @TestMetadata("noDivisionByZeroFeature.kt") - public void testNoDivisionByZeroFeature() throws Exception { - runTest("compiler/testData/diagnostics/tests/modifiers/const/noDivisionByZeroFeature.kt"); - } - - @Test - @TestMetadata("types.kt") - public void testTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/modifiers/const/types.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/modifiers/operatorInfix") - @TestDataPath("$PROJECT_ROOT") - public class OperatorInfix extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInOperatorInfix() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/modifiers/operatorInfix"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("LocalFunctions.kt") - public void testLocalFunctions() throws Exception { - runTest("compiler/testData/diagnostics/tests/modifiers/operatorInfix/LocalFunctions.kt"); - } - - @Test - @TestMetadata("MemberFunctions.kt") - public void testMemberFunctions() throws Exception { - runTest("compiler/testData/diagnostics/tests/modifiers/operatorInfix/MemberFunctions.kt"); - } - - @Test - @TestMetadata("Simple.kt") - public void testSimple() throws Exception { - runTest("compiler/testData/diagnostics/tests/modifiers/operatorInfix/Simple.kt"); - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/multimodule") - @TestDataPath("$PROJECT_ROOT") - public class Multimodule extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInMultimodule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multimodule"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("internal.kt") - public void testInternal() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/internal.kt"); - } - - @Test - @TestMetadata("kt14249.kt") - public void testKt14249() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/kt14249.kt"); - } - - @Test - @TestMetadata("packagePrivate.kt") - public void testPackagePrivate() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/packagePrivate.kt"); - } - - @Test - @TestMetadata("publishedApiInternal.kt") - public void testPublishedApiInternal() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/publishedApiInternal.kt"); - } - - @Test - @TestMetadata("redundantElseInWhen.kt") - public void testRedundantElseInWhen() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/redundantElseInWhen.kt"); - } - - @Test - @TestMetadata("varargConflict.kt") - public void testVarargConflict() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/varargConflict.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateClass") - @TestDataPath("$PROJECT_ROOT") - public class DuplicateClass extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInDuplicateClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multimodule/duplicateClass"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("collectionMethodStub.kt") - public void testCollectionMethodStub() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/duplicateClass/collectionMethodStub.kt"); - } - - @Test - @TestMetadata("differentGenericArguments.kt") - public void testDifferentGenericArguments() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/duplicateClass/differentGenericArguments.kt"); - } - - @Test - @TestMetadata("differentGenericArgumentsReversed.kt") - public void testDifferentGenericArgumentsReversed() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/duplicateClass/differentGenericArgumentsReversed.kt"); - } - - @Test - @TestMetadata("duplicateClass.kt") - public void testDuplicateClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/duplicateClass/duplicateClass.kt"); - } - - @Test - @TestMetadata("duplicateNestedClasses.kt") - public void testDuplicateNestedClasses() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/duplicateClass/duplicateNestedClasses.kt"); - } - - @Test - @TestMetadata("duplicateSuperClass.kt") - public void testDuplicateSuperClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/duplicateClass/duplicateSuperClass.kt"); - } - - @Test - @TestMetadata("genericArgumentNumberMismatch.kt") - public void testGenericArgumentNumberMismatch() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/duplicateClass/genericArgumentNumberMismatch.kt"); - } - - @Test - @TestMetadata("genericSuperClass.kt") - public void testGenericSuperClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/duplicateClass/genericSuperClass.kt"); - } - - @Test - @TestMetadata("inTheSameModuleWithUsage.kt") - public void testInTheSameModuleWithUsage() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/duplicateClass/inTheSameModuleWithUsage.kt"); - } - - @Test - @TestMetadata("inTheSameModuleWithUsageNoTypeAnnotation.kt") - public void testInTheSameModuleWithUsageNoTypeAnnotation() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/duplicateClass/inTheSameModuleWithUsageNoTypeAnnotation.kt"); - } - - @Test - @TestMetadata("members.kt") - public void testMembers() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/duplicateClass/members.kt"); - } - - @Test - @TestMetadata("sameClassNameDifferentPackages.kt") - public void testSameClassNameDifferentPackages() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/duplicateClass/sameClassNameDifferentPackages.kt"); - } - - @Test - @TestMetadata("sameGenericArguments.kt") - public void testSameGenericArguments() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/duplicateClass/sameGenericArguments.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateMethod") - @TestDataPath("$PROJECT_ROOT") - public class DuplicateMethod extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInDuplicateMethod() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multimodule/duplicateMethod"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("classGenericsInParams.kt") - public void testClassGenericsInParams() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classGenericsInParams.kt"); - } - - @Test - @TestMetadata("classGenericsInParamsBoundMismatch.kt") - public void testClassGenericsInParamsBoundMismatch() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classGenericsInParamsBoundMismatch.kt"); - } - - @Test - @TestMetadata("classGenericsInParamsIndexMismatch.kt") - public void testClassGenericsInParamsIndexMismatch() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classGenericsInParamsIndexMismatch.kt"); - } - - @Test - @TestMetadata("classGenericsInParamsNameMismatch.kt") - public void testClassGenericsInParamsNameMismatch() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classGenericsInParamsNameMismatch.kt"); - } - - @Test - @TestMetadata("classGenericsInReturnType.kt") - public void testClassGenericsInReturnType() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classGenericsInReturnType.kt"); - } - - @Test - @TestMetadata("classVsFunctionGenericsInParamsMismatch.kt") - public void testClassVsFunctionGenericsInParamsMismatch() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/classVsFunctionGenericsInParamsMismatch.kt"); - } - - @Test - @TestMetadata("covariantReturnTypes.kt") - public void testCovariantReturnTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/covariantReturnTypes.kt"); - } - - @Test - @TestMetadata("differenceInParamNames.kt") - public void testDifferenceInParamNames() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/differenceInParamNames.kt"); - } - - @Test - @TestMetadata("differentGenericsInParams.kt") - public void testDifferentGenericsInParams() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/differentGenericsInParams.kt"); - } - - @Test - @TestMetadata("differentNumberOfParams.kt") - public void testDifferentNumberOfParams() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/differentNumberOfParams.kt"); - } - - @Test - @TestMetadata("differentReturnTypes.kt") - public void testDifferentReturnTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/differentReturnTypes.kt"); - } - - @Test - @TestMetadata("extensionMatch.kt") - public void testExtensionMatch() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/extensionMatch.kt"); - } - - @Test - @TestMetadata("functionGenericsInParams.kt") - public void testFunctionGenericsInParams() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/functionGenericsInParams.kt"); - } - - @Test - @TestMetadata("functionGenericsInParamsBoundsMismatch.kt") - public void testFunctionGenericsInParamsBoundsMismatch() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/functionGenericsInParamsBoundsMismatch.kt"); - } - - @Test - @TestMetadata("functionGenericsInParamsEqNull.kt") - public void testFunctionGenericsInParamsEqNull() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/functionGenericsInParamsEqNull.kt"); - } - - @Test - @TestMetadata("functionGenericsInParamsNotIs.kt") - public void testFunctionGenericsInParamsNotIs() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/functionGenericsInParamsNotIs.kt"); - } - - @Test - @TestMetadata("functionGenericsInParamsReturnFooT.kt") - public void testFunctionGenericsInParamsReturnFooT() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/functionGenericsInParamsReturnFooT.kt"); - } - - @Test - @TestMetadata("functionGenericsInParamsReturnT.kt") - public void testFunctionGenericsInParamsReturnT() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/functionGenericsInParamsReturnT.kt"); - } - - @Test - @TestMetadata("incompleteCodeNoNoneApplicable.kt") - public void testIncompleteCodeNoNoneApplicable() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/incompleteCodeNoNoneApplicable.kt"); - } - - @Test - @TestMetadata("noGenericsInParams.kt") - public void testNoGenericsInParams() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/noGenericsInParams.kt"); - } - - @Test - @TestMetadata("noParams.kt") - public void testNoParams() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/noParams.kt"); - } - - @Test - @TestMetadata("sameGenericsInParams.kt") - public void testSameGenericsInParams() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/sameGenericsInParams.kt"); - } - - @Test - @TestMetadata("simpleWithInheritance.kt") - public void testSimpleWithInheritance() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/simpleWithInheritance.kt"); - } - - @Test - @TestMetadata("sinceKotlin.kt") - public void testSinceKotlin() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/sinceKotlin.kt"); - } - - @Test - @TestMetadata("substitutedGenericInParams.kt") - public void testSubstitutedGenericInParams() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/duplicateMethod/substitutedGenericInParams.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/multimodule/duplicateSuper") - @TestDataPath("$PROJECT_ROOT") - public class DuplicateSuper extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInDuplicateSuper() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multimodule/duplicateSuper"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("differentSuperTraits.kt") - public void testDifferentSuperTraits() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/duplicateSuper/differentSuperTraits.kt"); - } - - @Test - @TestMetadata("sameSuperTrait.kt") - public void testSameSuperTrait() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/duplicateSuper/sameSuperTrait.kt"); - } - - @Test - @TestMetadata("sameSuperTraitDifferentBounds.kt") - public void testSameSuperTraitDifferentBounds() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/duplicateSuper/sameSuperTraitDifferentBounds.kt"); - } - - @Test - @TestMetadata("sameSuperTraitGenerics.kt") - public void testSameSuperTraitGenerics() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/duplicateSuper/sameSuperTraitGenerics.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/multimodule/hiddenClass") - @TestDataPath("$PROJECT_ROOT") - public class HiddenClass extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInHiddenClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multimodule/hiddenClass"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("deprecatedHiddenImportPriority.kt") - public void testDeprecatedHiddenImportPriority() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/hiddenClass/deprecatedHiddenImportPriority.kt"); - } - - @Test - @TestMetadata("deprecatedHiddenMultipleClasses.kt") - public void testDeprecatedHiddenMultipleClasses() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/hiddenClass/deprecatedHiddenMultipleClasses.kt"); - } - - @Test - @TestMetadata("sinceKotlinImportPriority.kt") - public void testSinceKotlinImportPriority() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/hiddenClass/sinceKotlinImportPriority.kt"); - } - - @Test - @TestMetadata("sinceKotlinMultipleClasses.kt") - public void testSinceKotlinMultipleClasses() throws Exception { - runTest("compiler/testData/diagnostics/tests/multimodule/hiddenClass/sinceKotlinMultipleClasses.kt"); - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/multiplatform") - @TestDataPath("$PROJECT_ROOT") - public class Multiplatform extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInMultiplatform() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("expectInterfaceApplicability.kt") - public void testExpectInterfaceApplicability() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/expectInterfaceApplicability.kt"); - } - - @Test - @TestMetadata("headerFunInNonHeaderClass.kt") - public void testHeaderFunInNonHeaderClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/headerFunInNonHeaderClass.kt"); - } - - @Test - @TestMetadata("implDelegatedMember.kt") - public void testImplDelegatedMember() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/implDelegatedMember.kt"); - } - - @Test - @TestMetadata("implDynamic.kt") - public void testImplDynamic() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/implDynamic.kt"); - } - - @Test - @TestMetadata("implFakeOverride.kt") - public void testImplFakeOverride() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/implFakeOverride.kt"); - } - - @Test - @TestMetadata("incompatibles.kt") - public void testIncompatibles() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/incompatibles.kt"); - } - - @Test - @TestMetadata("modifierApplicability.kt") - public void testModifierApplicability() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/modifierApplicability.kt"); - } - - @Test - @TestMetadata("namedArguments.kt") - public void testNamedArguments() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/namedArguments.kt"); - } - - @Test - @TestMetadata("privateTopLevelDeclarations.kt") - public void testPrivateTopLevelDeclarations() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/privateTopLevelDeclarations.kt"); - } - - @Test - @TestMetadata("sealedTypeAlias.kt") - public void testSealedTypeAlias() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/sealedTypeAlias.kt"); - } - - @Test - @TestMetadata("sealedTypeAliasTopLevel.kt") - public void testSealedTypeAliasTopLevel() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/sealedTypeAliasTopLevel.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/multiplatform/defaultArguments") - @TestDataPath("$PROJECT_ROOT") - public class DefaultArguments extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInDefaultArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/defaultArguments"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("annotationArgumentEquality.kt") - public void testAnnotationArgumentEquality() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/defaultArguments/annotationArgumentEquality.kt"); - } - - @Test - @TestMetadata("annotations.kt") - public void testAnnotations() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/defaultArguments/annotations.kt"); - } - - @Test - @TestMetadata("annotationsViaActualTypeAlias.kt") - public void testAnnotationsViaActualTypeAlias() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/defaultArguments/annotationsViaActualTypeAlias.kt"); - } - - @Test - @TestMetadata("annotationsViaActualTypeAlias2.kt") - public void testAnnotationsViaActualTypeAlias2() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/defaultArguments/annotationsViaActualTypeAlias2.kt"); - } - - @Test - @TestMetadata("constructor.kt") - public void testConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/defaultArguments/constructor.kt"); - } - - @Test - @TestMetadata("expectedDeclaresDefaultArguments.kt") - public void testExpectedDeclaresDefaultArguments() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/defaultArguments/expectedDeclaresDefaultArguments.kt"); - } - - @Test - @TestMetadata("expectedInheritsDefaultArguments.kt") - public void testExpectedInheritsDefaultArguments() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/defaultArguments/expectedInheritsDefaultArguments.kt"); - } - - @Test - @TestMetadata("expectedVsNonExpectedWithDefaults.kt") - public void testExpectedVsNonExpectedWithDefaults() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/defaultArguments/expectedVsNonExpectedWithDefaults.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/multiplatform/deprecated") - @TestDataPath("$PROJECT_ROOT") - public class Deprecated extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInDeprecated() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/deprecated"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("header.kt") - public void testHeader() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/deprecated/header.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/multiplatform/enum") - @TestDataPath("$PROJECT_ROOT") - public class Enum extends AbstractDiagnosticUsingJavacTest { - @Test - @TestMetadata("additionalEntriesInImpl.kt") - public void testAdditionalEntriesInImpl() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/enum/additionalEntriesInImpl.kt"); - } - - @Test - public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/enum"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("constructorInHeaderEnum.kt") - public void testConstructorInHeaderEnum() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/enum/constructorInHeaderEnum.kt"); - } - - @Test - @TestMetadata("differentEntryOrder.kt") - public void testDifferentEntryOrder() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/enum/differentEntryOrder.kt"); - } - - @Test - @TestMetadata("enumEntryWithBody.kt") - public void testEnumEntryWithBody() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/enum/enumEntryWithBody.kt"); - } - - @Test - @TestMetadata("javaEnum.kt") - public void testJavaEnum() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/enum/javaEnum.kt"); - } - - @Test - @TestMetadata("simpleEnum.kt") - public void testSimpleEnum() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/enum/simpleEnum.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/multiplatform/generic") - @TestDataPath("$PROJECT_ROOT") - public class Generic extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInGeneric() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/generic"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("functionTypeParameterBounds.kt") - public void testFunctionTypeParameterBounds() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/generic/functionTypeParameterBounds.kt"); - } - - @Test - @TestMetadata("genericMemberBounds.kt") - public void testGenericMemberBounds() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/generic/genericMemberBounds.kt"); - } - - @Test - @TestMetadata("membersInGenericClass.kt") - public void testMembersInGenericClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/generic/membersInGenericClass.kt"); - } - - @Test - @TestMetadata("typeParameterBoundsDifferentOrderActualMissing.kt") - public void testTypeParameterBoundsDifferentOrderActualMissing() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/generic/typeParameterBoundsDifferentOrderActualMissing.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/multiplatform/headerClass") - @TestDataPath("$PROJECT_ROOT") - public class HeaderClass extends AbstractDiagnosticUsingJavacTest { - @Test - @TestMetadata("actualClassWithDefaultValuesInAnnotationViaTypealias.kt") - public void testActualClassWithDefaultValuesInAnnotationViaTypealias() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/headerClass/actualClassWithDefaultValuesInAnnotationViaTypealias.kt"); - } - - @Test - @TestMetadata("actualClassWithDifferentConstructors.kt") - public void testActualClassWithDifferentConstructors() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/headerClass/actualClassWithDifferentConstructors.kt"); - } - - @Test - @TestMetadata("actualMissing.kt") - public void testActualMissing() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/headerClass/actualMissing.kt"); - } - - @Test - public void testAllFilesPresentInHeaderClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/headerClass"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("baseExpectClassWithoutConstructor.kt") - public void testBaseExpectClassWithoutConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/headerClass/baseExpectClassWithoutConstructor.kt"); - } - - @Test - @TestMetadata("classKinds.kt") - public void testClassKinds() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/headerClass/classKinds.kt"); - } - - @Test - @TestMetadata("dontOverrideMethodsFromInterfaceInCommonCode.kt") - public void testDontOverrideMethodsFromInterfaceInCommonCode() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/headerClass/dontOverrideMethodsFromInterfaceInCommonCode.kt"); - } - - @Test - @TestMetadata("expectClassWithExplicitAbstractMember.kt") - public void testExpectClassWithExplicitAbstractMember() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/headerClass/expectClassWithExplicitAbstractMember.kt"); - } - - @Test - @TestMetadata("expectClassWithoutConstructor.kt") - public void testExpectClassWithoutConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/headerClass/expectClassWithoutConstructor.kt"); - } - - @Test - @TestMetadata("expectDeclarationWithStrongIncompatibilities.kt") - public void testExpectDeclarationWithStrongIncompatibilities() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/headerClass/expectDeclarationWithStrongIncompatibilities.kt"); - } - - @Test - @TestMetadata("expectDeclarationWithWeakIncompatibilities.kt") - public void testExpectDeclarationWithWeakIncompatibilities() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/headerClass/expectDeclarationWithWeakIncompatibilities.kt"); - } - - @Test - @TestMetadata("expectFinalActualOpen.kt") - public void testExpectFinalActualOpen() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/headerClass/expectFinalActualOpen.kt"); - } - - @Test - @TestMetadata("explicitConstructorDelegation.kt") - public void testExplicitConstructorDelegation() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/headerClass/explicitConstructorDelegation.kt"); - } - - @Test - @TestMetadata("extendExpectedClassWithAbstractMember.kt") - public void testExtendExpectedClassWithAbstractMember() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/headerClass/extendExpectedClassWithAbstractMember.kt"); - } - - @Test - @TestMetadata("extendExpectedClassWithoutExplicitOverrideOfMethod.kt") - public void testExtendExpectedClassWithoutExplicitOverrideOfMethod() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/headerClass/extendExpectedClassWithoutExplicitOverrideOfMethod.kt"); - } - - @Test - @TestMetadata("extraHeaderOnMembers.kt") - public void testExtraHeaderOnMembers() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/headerClass/extraHeaderOnMembers.kt"); - } - - @Test - @TestMetadata("functionAndPropertyWithSameName.kt") - public void testFunctionAndPropertyWithSameName() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/headerClass/functionAndPropertyWithSameName.kt"); - } - - @Test - @TestMetadata("genericClassImplTypeAlias.kt") - public void testGenericClassImplTypeAlias() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/headerClass/genericClassImplTypeAlias.kt"); - } - - @Test - @TestMetadata("headerClassMember.kt") - public void testHeaderClassMember() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/headerClass/headerClassMember.kt"); - } - - @Test - @TestMetadata("headerClassWithFunctionBody.kt") - public void testHeaderClassWithFunctionBody() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/headerClass/headerClassWithFunctionBody.kt"); - } - - @Test - @TestMetadata("implDataClass.kt") - public void testImplDataClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/headerClass/implDataClass.kt"); - } - - @Test - @TestMetadata("implOpenClass.kt") - public void testImplOpenClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/headerClass/implOpenClass.kt"); - } - - @Test - @TestMetadata("inheritanceByDelegationInExpectClass.kt") - public void testInheritanceByDelegationInExpectClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/headerClass/inheritanceByDelegationInExpectClass.kt"); - } - - @Test - @TestMetadata("memberPropertyKinds.kt") - public void testMemberPropertyKinds() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/headerClass/memberPropertyKinds.kt"); - } - - @Test - @TestMetadata("modalityCheckForExplicitAndImplicitOverride.kt") - public void testModalityCheckForExplicitAndImplicitOverride() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/headerClass/modalityCheckForExplicitAndImplicitOverride.kt"); - } - - @Test - @TestMetadata("morePermissiveVisibilityOnActual.kt") - public void testMorePermissiveVisibilityOnActual() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/headerClass/morePermissiveVisibilityOnActual.kt"); - } - - @Test - @TestMetadata("morePermissiveVisibilityOnActualViaTypeAlias.kt") - public void testMorePermissiveVisibilityOnActualViaTypeAlias() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/headerClass/morePermissiveVisibilityOnActualViaTypeAlias.kt"); - } - - @Test - @TestMetadata("nestedClasses.kt") - public void testNestedClasses() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/headerClass/nestedClasses.kt"); - } - - @Test - @TestMetadata("nestedClassesWithErrors.kt") - public void testNestedClassesWithErrors() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/headerClass/nestedClassesWithErrors.kt"); - } - - @Test - @TestMetadata("noImplKeywordOnMember.kt") - public void testNoImplKeywordOnMember() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/headerClass/noImplKeywordOnMember.kt"); - } - - @Test - @TestMetadata("privateMembers.kt") - public void testPrivateMembers() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/headerClass/privateMembers.kt"); - } - - @Test - @TestMetadata("simpleHeaderClass.kt") - public void testSimpleHeaderClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/headerClass/simpleHeaderClass.kt"); - } - - @Test - @TestMetadata("smartCastOnExpectClass.kt") - public void testSmartCastOnExpectClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/headerClass/smartCastOnExpectClass.kt"); - } - - @Test - @TestMetadata("superClass.kt") - public void testSuperClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/headerClass/superClass.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/multiplatform/inlineClasses") - @TestDataPath("$PROJECT_ROOT") - public class InlineClasses extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/inlineClasses"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("expectActualInlineClass.kt") - public void testExpectActualInlineClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/inlineClasses/expectActualInlineClass.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/multiplatform/java") - @TestDataPath("$PROJECT_ROOT") - public class Java extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/java"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("flexibleTypes.kt") - public void testFlexibleTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/java/flexibleTypes.kt"); - } - - @Test - @TestMetadata("parameterNames.kt") - public void testParameterNames() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/java/parameterNames.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/multiplatform/topLevelFun") - @TestDataPath("$PROJECT_ROOT") - public class TopLevelFun extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInTopLevelFun() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/topLevelFun"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("callHeaderFun.kt") - public void testCallHeaderFun() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/topLevelFun/callHeaderFun.kt"); - } - - @Test - @TestMetadata("callableReferenceOnExpectFun.kt") - public void testCallableReferenceOnExpectFun() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/topLevelFun/callableReferenceOnExpectFun.kt"); - } - - @Test - @TestMetadata("conflictingHeaderDeclarations.kt") - public void testConflictingHeaderDeclarations() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/topLevelFun/conflictingHeaderDeclarations.kt"); - } - - @Test - @TestMetadata("conflictingImplDeclarations.kt") - public void testConflictingImplDeclarations() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/topLevelFun/conflictingImplDeclarations.kt"); - } - - @Test - @TestMetadata("functionModifiers.kt") - public void testFunctionModifiers() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/topLevelFun/functionModifiers.kt"); - } - - @Test - @TestMetadata("headerAndImplInDIfferentPackages.kt") - public void testHeaderAndImplInDIfferentPackages() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/topLevelFun/headerAndImplInDIfferentPackages.kt"); - } - - @Test - @TestMetadata("headerDeclarationWithBody.kt") - public void testHeaderDeclarationWithBody() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/topLevelFun/headerDeclarationWithBody.kt"); - } - - @Test - @TestMetadata("headerWithoutImpl.kt") - public void testHeaderWithoutImpl() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/topLevelFun/headerWithoutImpl.kt"); - } - - @Test - @TestMetadata("implDeclarationWithoutBody.kt") - public void testImplDeclarationWithoutBody() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/topLevelFun/implDeclarationWithoutBody.kt"); - } - - @Test - @TestMetadata("implWithoutHeader.kt") - public void testImplWithoutHeader() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/topLevelFun/implWithoutHeader.kt"); - } - - @Test - @TestMetadata("inlineFun.kt") - public void testInlineFun() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/topLevelFun/inlineFun.kt"); - } - - @Test - @TestMetadata("simpleHeaderFun.kt") - public void testSimpleHeaderFun() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/topLevelFun/simpleHeaderFun.kt"); - } - - @Test - @TestMetadata("valueParameterModifiers.kt") - public void testValueParameterModifiers() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/topLevelFun/valueParameterModifiers.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/multiplatform/topLevelProperty") - @TestDataPath("$PROJECT_ROOT") - public class TopLevelProperty extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInTopLevelProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/topLevelProperty"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("differentKindsOfProperties.kt") - public void testDifferentKindsOfProperties() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/topLevelProperty/differentKindsOfProperties.kt"); - } - - @Test - @TestMetadata("simpleHeaderVar.kt") - public void testSimpleHeaderVar() throws Exception { - runTest("compiler/testData/diagnostics/tests/multiplatform/topLevelProperty/simpleHeaderVar.kt"); - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/namedArguments") - @TestDataPath("$PROJECT_ROOT") - public class NamedArguments extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInNamedArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/namedArguments"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("allowForJavaAnnotation.kt") - public void testAllowForJavaAnnotation() throws Exception { - runTest("compiler/testData/diagnostics/tests/namedArguments/allowForJavaAnnotation.kt"); - } - - @Test - @TestMetadata("ambiguousNamedArguments1.kt") - public void testAmbiguousNamedArguments1() throws Exception { - runTest("compiler/testData/diagnostics/tests/namedArguments/ambiguousNamedArguments1.kt"); - } - - @Test - @TestMetadata("ambiguousNamedArguments2.kt") - public void testAmbiguousNamedArguments2() throws Exception { - runTest("compiler/testData/diagnostics/tests/namedArguments/ambiguousNamedArguments2.kt"); - } - - @Test - @TestMetadata("ambiguousNamedArgumentsWithGenerics1.kt") - public void testAmbiguousNamedArgumentsWithGenerics1() throws Exception { - runTest("compiler/testData/diagnostics/tests/namedArguments/ambiguousNamedArgumentsWithGenerics1.kt"); - } - - @Test - @TestMetadata("ambiguousNamedArgumentsWithGenerics2.kt") - public void testAmbiguousNamedArgumentsWithGenerics2() throws Exception { - runTest("compiler/testData/diagnostics/tests/namedArguments/ambiguousNamedArgumentsWithGenerics2.kt"); - } - - @Test - @TestMetadata("ambiguousNamedArgumentsWithGenerics3.kt") - public void testAmbiguousNamedArgumentsWithGenerics3() throws Exception { - runTest("compiler/testData/diagnostics/tests/namedArguments/ambiguousNamedArgumentsWithGenerics3.kt"); - } - - @Test - @TestMetadata("disallowForJavaConstructor.kt") - public void testDisallowForJavaConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/namedArguments/disallowForJavaConstructor.kt"); - } - - @Test - @TestMetadata("disallowForJavaMethods.kt") - public void testDisallowForJavaMethods() throws Exception { - runTest("compiler/testData/diagnostics/tests/namedArguments/disallowForJavaMethods.kt"); - } - - @Test - @TestMetadata("disallowForSamAdapterConstructor.kt") - public void testDisallowForSamAdapterConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/namedArguments/disallowForSamAdapterConstructor.kt"); - } - - @Test - @TestMetadata("disallowForSamAdapterFunction.kt") - public void testDisallowForSamAdapterFunction() throws Exception { - runTest("compiler/testData/diagnostics/tests/namedArguments/disallowForSamAdapterFunction.kt"); - } - - @Test - @TestMetadata("namedArgumentsAndDefaultValues.kt") - public void testNamedArgumentsAndDefaultValues() throws Exception { - runTest("compiler/testData/diagnostics/tests/namedArguments/namedArgumentsAndDefaultValues.kt"); - } - - @Test - @TestMetadata("namedArgumentsInOverloads.kt") - public void testNamedArgumentsInOverloads() throws Exception { - runTest("compiler/testData/diagnostics/tests/namedArguments/namedArgumentsInOverloads.kt"); - } - - @Test - @TestMetadata("namedArgumentsInOverrides.kt") - public void testNamedArgumentsInOverrides() throws Exception { - runTest("compiler/testData/diagnostics/tests/namedArguments/namedArgumentsInOverrides.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/namedArguments/mixedNamedPosition") - @TestDataPath("$PROJECT_ROOT") - public class MixedNamedPosition extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInMixedNamedPosition() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/namedArguments/mixedNamedPosition"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("defaults.kt") - public void testDefaults() throws Exception { - runTest("compiler/testData/diagnostics/tests/namedArguments/mixedNamedPosition/defaults.kt"); - } - - @Test - @TestMetadata("disabledFeature.kt") - public void testDisabledFeature() throws Exception { - runTest("compiler/testData/diagnostics/tests/namedArguments/mixedNamedPosition/disabledFeature.kt"); - } - - @Test - @TestMetadata("oldInference.kt") - public void testOldInference() throws Exception { - runTest("compiler/testData/diagnostics/tests/namedArguments/mixedNamedPosition/oldInference.kt"); - } - - @Test - @TestMetadata("secondNamed.kt") - public void testSecondNamed() throws Exception { - runTest("compiler/testData/diagnostics/tests/namedArguments/mixedNamedPosition/secondNamed.kt"); - } - - @Test - @TestMetadata("simple.kt") - public void testSimple() throws Exception { - runTest("compiler/testData/diagnostics/tests/namedArguments/mixedNamedPosition/simple.kt"); - } - - @Test - @TestMetadata("varargs.kt") - public void testVarargs() throws Exception { - runTest("compiler/testData/diagnostics/tests/namedArguments/mixedNamedPosition/varargs.kt"); - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts") - @TestDataPath("$PROJECT_ROOT") - public class NullabilityAndSmartCasts extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInNullabilityAndSmartCasts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("AssertNotNull.kt") - public void testAssertNotNull() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/AssertNotNull.kt"); - } - - @Test - @TestMetadata("dataFlowInfoAfterExclExcl.kt") - public void testDataFlowInfoAfterExclExcl() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/dataFlowInfoAfterExclExcl.kt"); - } - - @Test - @TestMetadata("equalityUnderNotNullCheck.kt") - public void testEqualityUnderNotNullCheck() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/equalityUnderNotNullCheck.kt"); - } - - @Test - @TestMetadata("funcLiteralArgsInsideAmbiguity.kt") - public void testFuncLiteralArgsInsideAmbiguity() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/funcLiteralArgsInsideAmbiguity.kt"); - } - - @Test - @TestMetadata("funcLiteralArgsInsideUnresolvedFunction.kt") - public void testFuncLiteralArgsInsideUnresolvedFunction() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/funcLiteralArgsInsideUnresolvedFunction.kt"); - } - - @Test - @TestMetadata("InfixCallNullability.kt") - public void testInfixCallNullability() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/InfixCallNullability.kt"); - } - - @Test - @TestMetadata("kt1270.kt") - public void testKt1270() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt1270.kt"); - } - - @Test - @TestMetadata("kt1680.kt") - public void testKt1680() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt1680.kt"); - } - - @Test - @TestMetadata("kt1778.kt") - public void testKt1778() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt1778.kt"); - } - - @Test - @TestMetadata("kt2109.kt") - public void testKt2109() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2109.kt"); - } - - @Test - @TestMetadata("kt2125.kt") - public void testKt2125() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2125.kt"); - } - - @Test - @TestMetadata("kt2146.kt") - public void testKt2146() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2146.kt"); - } - - @Test - @TestMetadata("kt2164.kt") - public void testKt2164() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2164.kt"); - } - - @Test - @TestMetadata("kt2176.kt") - public void testKt2176() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2176.kt"); - } - - @Test - @TestMetadata("kt2195.kt") - public void testKt2195() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2195.kt"); - } - - @Test - @TestMetadata("kt2212.kt") - public void testKt2212() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2212.kt"); - } - - @Test - @TestMetadata("kt2216.kt") - public void testKt2216() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2216.kt"); - } - - @Test - @TestMetadata("kt2223.kt") - public void testKt2223() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2223.kt"); - } - - @Test - @TestMetadata("kt2234.kt") - public void testKt2234() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2234.kt"); - } - - @Test - @TestMetadata("kt2336.kt") - public void testKt2336() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt2336.kt"); - } - - @Test - @TestMetadata("kt244.kt") - public void testKt244() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt244.kt"); - } - - @Test - @TestMetadata("kt30734.kt") - public void testKt30734() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt30734.kt"); - } - - @Test - @TestMetadata("kt362.kt") - public void testKt362() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt362.kt"); - } - - @Test - @TestMetadata("noSenselessNullOnNullableType.kt") - public void testNoSenselessNullOnNullableType() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/noSenselessNullOnNullableType.kt"); - } - - @Test - @TestMetadata("noUnnecessaryNotNullAssertionOnErrorType.kt") - public void testNoUnnecessaryNotNullAssertionOnErrorType() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/noUnnecessaryNotNullAssertionOnErrorType.kt"); - } - - @Test - @TestMetadata("notnullTypesFromJavaWithSmartcast.kt") - public void testNotnullTypesFromJavaWithSmartcast() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/notnullTypesFromJavaWithSmartcast.kt"); - } - - @Test - @TestMetadata("NullableNothingIsExactlyNull.kt") - public void testNullableNothingIsExactlyNull() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/NullableNothingIsExactlyNull.kt"); - } - - @Test - @TestMetadata("nullableReceiverWithOverloadedMethod.kt") - public void testNullableReceiverWithOverloadedMethod() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/nullableReceiverWithOverloadedMethod.kt"); - } - - @Test - @TestMetadata("PreferExtensionsOnNullableReceiver.kt") - public void testPreferExtensionsOnNullableReceiver() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/PreferExtensionsOnNullableReceiver.kt"); - } - - @Test - @TestMetadata("QualifiedExpressionNullability.kt") - public void testQualifiedExpressionNullability() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/QualifiedExpressionNullability.kt"); - } - - @Test - @TestMetadata("ReceiverNullability.kt") - public void testReceiverNullability() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/ReceiverNullability.kt"); - } - - @Test - @TestMetadata("SenselessNullInWhen.kt") - public void testSenselessNullInWhen() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/SenselessNullInWhen.kt"); - } - - @Test - @TestMetadata("senslessComparisonWithNullOnTypeParameters.kt") - public void testSenslessComparisonWithNullOnTypeParameters() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/senslessComparisonWithNullOnTypeParameters.kt"); - } - - @Test - @TestMetadata("smartCastReceiverWithGenerics.kt") - public void testSmartCastReceiverWithGenerics() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/smartCastReceiverWithGenerics.kt"); - } - - @Test - @TestMetadata("smartCastsAndBooleanExpressions.kt") - public void testSmartCastsAndBooleanExpressions() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/smartCastsAndBooleanExpressions.kt"); - } - - @Test - @TestMetadata("unnecessaryNotNullAssertion.kt") - public void testUnnecessaryNotNullAssertion() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/unnecessaryNotNullAssertion.kt"); - } - - @Test - @TestMetadata("unstableSmartcastWhenOpenGetterWithOverloading.kt") - public void testUnstableSmartcastWhenOpenGetterWithOverloading() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/unstableSmartcastWhenOpenGetterWithOverloading.kt"); - } - - @Test - @TestMetadata("unstableSmartcastWithOverloadedExtensions.kt") - public void testUnstableSmartcastWithOverloadedExtensions() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/unstableSmartcastWithOverloadedExtensions.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/nullableTypes") - @TestDataPath("$PROJECT_ROOT") - public class NullableTypes extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInNullableTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/nullableTypes"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("baseWithNullableUpperBound.kt") - public void testBaseWithNullableUpperBound() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullableTypes/baseWithNullableUpperBound.kt"); - } - - @Test - @TestMetadata("definitelyNotNullWithNullableBound.kt") - public void testDefinitelyNotNullWithNullableBound() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullableTypes/definitelyNotNullWithNullableBound.kt"); - } - - @Test - @TestMetadata("elvisOnUnit.kt") - public void testElvisOnUnit() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullableTypes/elvisOnUnit.kt"); - } - - @Test - @TestMetadata("inferenceFlexibleTToNullable.kt") - public void testInferenceFlexibleTToNullable() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullableTypes/inferenceFlexibleTToNullable.kt"); - } - - @Test - @TestMetadata("nullAssertOnTypeWithNullableUpperBound.kt") - public void testNullAssertOnTypeWithNullableUpperBound() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullableTypes/nullAssertOnTypeWithNullableUpperBound.kt"); - } - - @Test - @TestMetadata("nullableArgumentForIn.kt") - public void testNullableArgumentForIn() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullableTypes/nullableArgumentForIn.kt"); - } - - @Test - @TestMetadata("nullableArgumentToNonNullParameterPlatform.kt") - public void testNullableArgumentToNonNullParameterPlatform() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullableTypes/nullableArgumentToNonNullParameterPlatform.kt"); - } - - @Test - @TestMetadata("nullableArgumentToNonNullParameterSimple.kt") - public void testNullableArgumentToNonNullParameterSimple() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullableTypes/nullableArgumentToNonNullParameterSimple.kt"); - } - - @Test - @TestMetadata("redundantNullable.kt") - public void testRedundantNullable() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullableTypes/redundantNullable.kt"); - } - - @Test - @TestMetadata("redundantNullableInSupertype.kt") - public void testRedundantNullableInSupertype() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullableTypes/redundantNullableInSupertype.kt"); - } - - @Test - @TestMetadata("safeAccessOnUnit.kt") - public void testSafeAccessOnUnit() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullableTypes/safeAccessOnUnit.kt"); - } - - @Test - @TestMetadata("safeCallOnTypeWithNullableUpperBound.kt") - public void testSafeCallOnTypeWithNullableUpperBound() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullableTypes/safeCallOnTypeWithNullableUpperBound.kt"); - } - - @Test - @TestMetadata("safeCallOperators.kt") - public void testSafeCallOperators() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullableTypes/safeCallOperators.kt"); - } - - @Test - @TestMetadata("safeCallWithInvoke.kt") - public void testSafeCallWithInvoke() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullableTypes/safeCallWithInvoke.kt"); - } - - @Test - @TestMetadata("takingNullabilityFromExplicitTypeArgmentsInsteadOfUsingFlexibleTypes.kt") - public void testTakingNullabilityFromExplicitTypeArgmentsInsteadOfUsingFlexibleTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullableTypes/takingNullabilityFromExplicitTypeArgmentsInsteadOfUsingFlexibleTypes.kt"); - } - - @Test - @TestMetadata("uselessElvis.kt") - public void testUselessElvis() throws Exception { - runTest("compiler/testData/diagnostics/tests/nullableTypes/uselessElvis.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/numbers") - @TestDataPath("$PROJECT_ROOT") - public class Numbers extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInNumbers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/numbers"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("characterIsNotANumber.kt") - public void testCharacterIsNotANumber() throws Exception { - runTest("compiler/testData/diagnostics/tests/numbers/characterIsNotANumber.kt"); - } - - @Test - @TestMetadata("doublesInSimpleConstraints.kt") - public void testDoublesInSimpleConstraints() throws Exception { - runTest("compiler/testData/diagnostics/tests/numbers/doublesInSimpleConstraints.kt"); - } - - @Test - @TestMetadata("intValuesOutOfRange.kt") - public void testIntValuesOutOfRange() throws Exception { - runTest("compiler/testData/diagnostics/tests/numbers/intValuesOutOfRange.kt"); - } - - @Test - @TestMetadata("numberAsUnionAndIntersection.kt") - public void testNumberAsUnionAndIntersection() throws Exception { - runTest("compiler/testData/diagnostics/tests/numbers/numberAsUnionAndIntersection.kt"); - } - - @Test - @TestMetadata("numbersInSimpleConstraints.kt") - public void testNumbersInSimpleConstraints() throws Exception { - runTest("compiler/testData/diagnostics/tests/numbers/numbersInSimpleConstraints.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/objects") - @TestDataPath("$PROJECT_ROOT") - public class Objects extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInObjects() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/objects"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("invokeOnInnerObject.kt") - public void testInvokeOnInnerObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/objects/invokeOnInnerObject.kt"); - } - - @Test - @TestMetadata("kt2240.kt") - public void testKt2240() throws Exception { - runTest("compiler/testData/diagnostics/tests/objects/kt2240.kt"); - } - - @Test - @TestMetadata("kt5527.kt") - public void testKt5527() throws Exception { - runTest("compiler/testData/diagnostics/tests/objects/kt5527.kt"); - } - - @Test - @TestMetadata("localObjectInsideObject.kt") - public void testLocalObjectInsideObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/objects/localObjectInsideObject.kt"); - } - - @Test - @TestMetadata("localObjects.kt") - public void testLocalObjects() throws Exception { - runTest("compiler/testData/diagnostics/tests/objects/localObjects.kt"); - } - - @Test - @TestMetadata("nestedClassInAnonymousObject.kt") - public void testNestedClassInAnonymousObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/objects/nestedClassInAnonymousObject.kt"); - } - - @Test - @TestMetadata("objectInsideFun.kt") - public void testObjectInsideFun() throws Exception { - runTest("compiler/testData/diagnostics/tests/objects/objectInsideFun.kt"); - } - - @Test - @TestMetadata("objectLiteralExpressionTypeMismatch.kt") - public void testObjectLiteralExpressionTypeMismatch() throws Exception { - runTest("compiler/testData/diagnostics/tests/objects/objectLiteralExpressionTypeMismatch.kt"); - } - - @Test - @TestMetadata("Objects.kt") - public void testObjects() throws Exception { - runTest("compiler/testData/diagnostics/tests/objects/Objects.kt"); - } - - @Test - @TestMetadata("ObjectsInheritance.kt") - public void testObjectsInheritance() throws Exception { - runTest("compiler/testData/diagnostics/tests/objects/ObjectsInheritance.kt"); - } - - @Test - @TestMetadata("ObjectsLocal.kt") - public void testObjectsLocal() throws Exception { - runTest("compiler/testData/diagnostics/tests/objects/ObjectsLocal.kt"); - } - - @Test - @TestMetadata("ObjectsNested.kt") - public void testObjectsNested() throws Exception { - runTest("compiler/testData/diagnostics/tests/objects/ObjectsNested.kt"); - } - - @Test - @TestMetadata("OpenInObject.kt") - public void testOpenInObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/objects/OpenInObject.kt"); - } - - @Test - @TestMetadata("upperBoundViolated.kt") - public void testUpperBoundViolated() throws Exception { - runTest("compiler/testData/diagnostics/tests/objects/upperBoundViolated.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/objects/kt21515") - @TestDataPath("$PROJECT_ROOT") - public class Kt21515 extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInKt21515() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/objects/kt21515"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("annotationConstructor.kt") - public void testAnnotationConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/objects/kt21515/annotationConstructor.kt"); - } - - @Test - @TestMetadata("callableReferenceComplexCasesWithImportsOld.kt") - public void testCallableReferenceComplexCasesWithImportsOld() throws Exception { - runTest("compiler/testData/diagnostics/tests/objects/kt21515/callableReferenceComplexCasesWithImportsOld.kt"); - } - - @Test - @TestMetadata("callableReferencesComplexCasesWithQualificationOld.kt") - public void testCallableReferencesComplexCasesWithQualificationOld() throws Exception { - runTest("compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesComplexCasesWithQualificationOld.kt"); - } - - @Test - @TestMetadata("callableReferencesNew.kt") - public void testCallableReferencesNew() throws Exception { - runTest("compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesNew.kt"); - } - - @Test - @TestMetadata("callableReferencesOld.kt") - public void testCallableReferencesOld() throws Exception { - runTest("compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesOld.kt"); - } - - @Test - @TestMetadata("callableReferencesOldComplexCases.kt") - public void testCallableReferencesOldComplexCases() throws Exception { - runTest("compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesOldComplexCases.kt"); - } - - @Test - @TestMetadata("callableReferencesWithQualificationNew.kt") - public void testCallableReferencesWithQualificationNew() throws Exception { - runTest("compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesWithQualificationNew.kt"); - } - - @Test - @TestMetadata("callableReferencesWithQualificationOld.kt") - public void testCallableReferencesWithQualificationOld() throws Exception { - runTest("compiler/testData/diagnostics/tests/objects/kt21515/callableReferencesWithQualificationOld.kt"); - } - - @Test - @TestMetadata("classifierFromCompanionObjectNew.kt") - public void testClassifierFromCompanionObjectNew() throws Exception { - runTest("compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectNew.kt"); - } - - @Test - @TestMetadata("classifierFromCompanionObjectOld.kt") - public void testClassifierFromCompanionObjectOld() throws Exception { - runTest("compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectOld.kt"); - } - - @Test - @TestMetadata("classifierFromCompanionObjectWithQualificationNew.kt") - public void testClassifierFromCompanionObjectWithQualificationNew() throws Exception { - runTest("compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectWithQualificationNew.kt"); - } - - @Test - @TestMetadata("classifierFromCompanionObjectWithQualificationOld.kt") - public void testClassifierFromCompanionObjectWithQualificationOld() throws Exception { - runTest("compiler/testData/diagnostics/tests/objects/kt21515/classifierFromCompanionObjectWithQualificationOld.kt"); - } - - @Test - @TestMetadata("classifierIsVisibleByTwoPaths.kt") - public void testClassifierIsVisibleByTwoPaths() throws Exception { - runTest("compiler/testData/diagnostics/tests/objects/kt21515/classifierIsVisibleByTwoPaths.kt"); - } - - @Test - @TestMetadata("inheritedFromDeprecatedNew.kt") - public void testInheritedFromDeprecatedNew() throws Exception { - runTest("compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedNew.kt"); - } - - @Test - @TestMetadata("inheritedFromDeprecatedOld.kt") - public void testInheritedFromDeprecatedOld() throws Exception { - runTest("compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedOld.kt"); - } - - @Test - @TestMetadata("inheritedFromDeprecatedWithQualificationNew.kt") - public void testInheritedFromDeprecatedWithQualificationNew() throws Exception { - runTest("compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedWithQualificationNew.kt"); - } - - @Test - @TestMetadata("inheritedFromDeprecatedWithQualificationOld.kt") - public void testInheritedFromDeprecatedWithQualificationOld() throws Exception { - runTest("compiler/testData/diagnostics/tests/objects/kt21515/inheritedFromDeprecatedWithQualificationOld.kt"); - } - - @Test - @TestMetadata("staticsFromJavaNew.kt") - public void testStaticsFromJavaNew() throws Exception { - runTest("compiler/testData/diagnostics/tests/objects/kt21515/staticsFromJavaNew.kt"); - } - - @Test - @TestMetadata("staticsFromJavaOld.kt") - public void testStaticsFromJavaOld() throws Exception { - runTest("compiler/testData/diagnostics/tests/objects/kt21515/staticsFromJavaOld.kt"); - } - - @Test - @TestMetadata("staticsFromJavaWithQualificationNew.kt") - public void testStaticsFromJavaWithQualificationNew() throws Exception { - runTest("compiler/testData/diagnostics/tests/objects/kt21515/staticsFromJavaWithQualificationNew.kt"); - } - - @Test - @TestMetadata("staticsFromJavaWithQualificationOld.kt") - public void testStaticsFromJavaWithQualificationOld() throws Exception { - runTest("compiler/testData/diagnostics/tests/objects/kt21515/staticsFromJavaWithQualificationOld.kt"); - } - - @Test - @TestMetadata("useDeprecatedConstructorNew.kt") - public void testUseDeprecatedConstructorNew() throws Exception { - runTest("compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorNew.kt"); - } - - @Test - @TestMetadata("useDeprecatedConstructorOld.kt") - public void testUseDeprecatedConstructorOld() throws Exception { - runTest("compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorOld.kt"); - } - - @Test - @TestMetadata("useDeprecatedConstructorWithQualificationNew.kt") - public void testUseDeprecatedConstructorWithQualificationNew() throws Exception { - runTest("compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorWithQualificationNew.kt"); - } - - @Test - @TestMetadata("useDeprecatedConstructorWithQualificationOld.kt") - public void testUseDeprecatedConstructorWithQualificationOld() throws Exception { - runTest("compiler/testData/diagnostics/tests/objects/kt21515/useDeprecatedConstructorWithQualificationOld.kt"); - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/operatorRem") - @TestDataPath("$PROJECT_ROOT") - public class OperatorRem extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInOperatorRem() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/operatorRem"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("DeprecatedModAssignOperatorConventions.kt") - public void testDeprecatedModAssignOperatorConventions() throws Exception { - runTest("compiler/testData/diagnostics/tests/operatorRem/DeprecatedModAssignOperatorConventions.kt"); - } - - @Test - @TestMetadata("deprecatedModConvention.kt") - public void testDeprecatedModConvention() throws Exception { - runTest("compiler/testData/diagnostics/tests/operatorRem/deprecatedModConvention.kt"); - } - - @Test - @TestMetadata("DeprecatedModOperatorConventions.kt") - public void testDeprecatedModOperatorConventions() throws Exception { - runTest("compiler/testData/diagnostics/tests/operatorRem/DeprecatedModOperatorConventions.kt"); - } - - @Test - @TestMetadata("doNotResolveToInapplicableRem.kt") - public void testDoNotResolveToInapplicableRem() throws Exception { - runTest("compiler/testData/diagnostics/tests/operatorRem/doNotResolveToInapplicableRem.kt"); - } - - @Test - @TestMetadata("forbiddenModOperatorConvention.kt") - public void testForbiddenModOperatorConvention() throws Exception { - runTest("compiler/testData/diagnostics/tests/operatorRem/forbiddenModOperatorConvention.kt"); - } - - @Test - @TestMetadata("modWithRemAssign.kt") - public void testModWithRemAssign() throws Exception { - runTest("compiler/testData/diagnostics/tests/operatorRem/modWithRemAssign.kt"); - } - - @Test - @TestMetadata("noDeprecatedModConventionWithoutFeature.kt") - public void testNoDeprecatedModConventionWithoutFeature() throws Exception { - runTest("compiler/testData/diagnostics/tests/operatorRem/noDeprecatedModConventionWithoutFeature.kt"); - } - - @Test - @TestMetadata("noOperatorRemFeature.kt") - public void testNoOperatorRemFeature() throws Exception { - runTest("compiler/testData/diagnostics/tests/operatorRem/noOperatorRemFeature.kt"); - } - - @Test - @TestMetadata("numberRemConversions.kt") - public void testNumberRemConversions() throws Exception { - runTest("compiler/testData/diagnostics/tests/operatorRem/numberRemConversions.kt"); - } - - @Test - @TestMetadata("operatorRem.kt") - public void testOperatorRem() throws Exception { - runTest("compiler/testData/diagnostics/tests/operatorRem/operatorRem.kt"); - } - - @Test - @TestMetadata("preferRemAsExtentionOverMod.kt") - public void testPreferRemAsExtentionOverMod() throws Exception { - runTest("compiler/testData/diagnostics/tests/operatorRem/preferRemAsExtentionOverMod.kt"); - } - - @Test - @TestMetadata("preferRemAsMemberOverMod.kt") - public void testPreferRemAsMemberOverMod() throws Exception { - runTest("compiler/testData/diagnostics/tests/operatorRem/preferRemAsMemberOverMod.kt"); - } - - @Test - @TestMetadata("preferRemFromCompanionObjectOverRem.kt") - public void testPreferRemFromCompanionObjectOverRem() throws Exception { - runTest("compiler/testData/diagnostics/tests/operatorRem/preferRemFromCompanionObjectOverRem.kt"); - } - - @Test - @TestMetadata("preferRemOverModInLocalFunctions.kt") - public void testPreferRemOverModInLocalFunctions() throws Exception { - runTest("compiler/testData/diagnostics/tests/operatorRem/preferRemOverModInLocalFunctions.kt"); - } - - @Test - @TestMetadata("preferRemWithImplicitReceivers.kt") - public void testPreferRemWithImplicitReceivers() throws Exception { - runTest("compiler/testData/diagnostics/tests/operatorRem/preferRemWithImplicitReceivers.kt"); - } - - @Test - @TestMetadata("prefereRemAsExtensionOverMemberMod.kt") - public void testPrefereRemAsExtensionOverMemberMod() throws Exception { - runTest("compiler/testData/diagnostics/tests/operatorRem/prefereRemAsExtensionOverMemberMod.kt"); - } - - @Test - @TestMetadata("remAndRemAssignAmbiguity.kt") - public void testRemAndRemAssignAmbiguity() throws Exception { - runTest("compiler/testData/diagnostics/tests/operatorRem/remAndRemAssignAmbiguity.kt"); - } - - @Test - @TestMetadata("remWithModAndModAssign.kt") - public void testRemWithModAndModAssign() throws Exception { - runTest("compiler/testData/diagnostics/tests/operatorRem/remWithModAndModAssign.kt"); - } - - @Test - @TestMetadata("remWithModAssign.kt") - public void testRemWithModAssign() throws Exception { - runTest("compiler/testData/diagnostics/tests/operatorRem/remWithModAssign.kt"); - } - - @Test - @TestMetadata("resolveModIfRemIsHidden.kt") - public void testResolveModIfRemIsHidden() throws Exception { - runTest("compiler/testData/diagnostics/tests/operatorRem/resolveModIfRemIsHidden.kt"); - } - - @Test - @TestMetadata("resolveToModWhenNoOperatorRemFeature.kt") - public void testResolveToModWhenNoOperatorRemFeature() throws Exception { - runTest("compiler/testData/diagnostics/tests/operatorRem/resolveToModWhenNoOperatorRemFeature.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/operatorsOverloading") - @TestDataPath("$PROJECT_ROOT") - public class OperatorsOverloading extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInOperatorsOverloading() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/operatorsOverloading"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("AssignOperatorAmbiguity.kt") - public void testAssignOperatorAmbiguity() throws Exception { - runTest("compiler/testData/diagnostics/tests/operatorsOverloading/AssignOperatorAmbiguity.kt"); - } - - @Test - @TestMetadata("AssignmentOperations.kt") - public void testAssignmentOperations() throws Exception { - runTest("compiler/testData/diagnostics/tests/operatorsOverloading/AssignmentOperations.kt"); - } - - @Test - @TestMetadata("assignmentOperationsCheckReturnType.kt") - public void testAssignmentOperationsCheckReturnType() throws Exception { - runTest("compiler/testData/diagnostics/tests/operatorsOverloading/assignmentOperationsCheckReturnType.kt"); - } - - @Test - @TestMetadata("compareToNullable.kt") - public void testCompareToNullable() throws Exception { - runTest("compiler/testData/diagnostics/tests/operatorsOverloading/compareToNullable.kt"); - } - - @Test - @TestMetadata("InconsistentGetSet.kt") - public void testInconsistentGetSet() throws Exception { - runTest("compiler/testData/diagnostics/tests/operatorsOverloading/InconsistentGetSet.kt"); - } - - @Test - @TestMetadata("IteratorAmbiguity.kt") - public void testIteratorAmbiguity() throws Exception { - runTest("compiler/testData/diagnostics/tests/operatorsOverloading/IteratorAmbiguity.kt"); - } - - @Test - @TestMetadata("kt1028.kt") - public void testKt1028() throws Exception { - runTest("compiler/testData/diagnostics/tests/operatorsOverloading/kt1028.kt"); - } - - @Test - @TestMetadata("kt11300.kt") - public void testKt11300() throws Exception { - runTest("compiler/testData/diagnostics/tests/operatorsOverloading/kt11300.kt"); - } - - @Test - @TestMetadata("kt13330.kt") - public void testKt13330() throws Exception { - runTest("compiler/testData/diagnostics/tests/operatorsOverloading/kt13330.kt"); - } - - @Test - @TestMetadata("kt13349.kt") - public void testKt13349() throws Exception { - runTest("compiler/testData/diagnostics/tests/operatorsOverloading/kt13349.kt"); - } - - @Test - @TestMetadata("kt3450.kt") - public void testKt3450() throws Exception { - runTest("compiler/testData/diagnostics/tests/operatorsOverloading/kt3450.kt"); - } - - @Test - @TestMetadata("plusAssignOnArray.kt") - public void testPlusAssignOnArray() throws Exception { - runTest("compiler/testData/diagnostics/tests/operatorsOverloading/plusAssignOnArray.kt"); - } - - @Test - @TestMetadata("plusAssignOnLocal.kt") - public void testPlusAssignOnLocal() throws Exception { - runTest("compiler/testData/diagnostics/tests/operatorsOverloading/plusAssignOnLocal.kt"); - } - - @Test - @TestMetadata("plusAssignOnProperty.kt") - public void testPlusAssignOnProperty() throws Exception { - runTest("compiler/testData/diagnostics/tests/operatorsOverloading/plusAssignOnProperty.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/overload") - @TestDataPath("$PROJECT_ROOT") - public class Overload extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInOverload() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/overload"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("ConflictingOlverloadsGenericFunctions.kt") - public void testConflictingOlverloadsGenericFunctions() throws Exception { - runTest("compiler/testData/diagnostics/tests/overload/ConflictingOlverloadsGenericFunctions.kt"); - } - - @Test - @TestMetadata("ConflictingOverloadsFunsDifferentReturnInClass.kt") - public void testConflictingOverloadsFunsDifferentReturnInClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/overload/ConflictingOverloadsFunsDifferentReturnInClass.kt"); - } - - @Test - @TestMetadata("ConflictingOverloadsFunsDifferentReturnInPackage.kt") - public void testConflictingOverloadsFunsDifferentReturnInPackage() throws Exception { - runTest("compiler/testData/diagnostics/tests/overload/ConflictingOverloadsFunsDifferentReturnInPackage.kt"); - } - - @Test - @TestMetadata("ConflictingOverloadsIdenticalExtFunsInPackage.kt") - public void testConflictingOverloadsIdenticalExtFunsInPackage() throws Exception { - runTest("compiler/testData/diagnostics/tests/overload/ConflictingOverloadsIdenticalExtFunsInPackage.kt"); - } - - @Test - @TestMetadata("ConflictingOverloadsIdenticalFunsInClass.kt") - public void testConflictingOverloadsIdenticalFunsInClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/overload/ConflictingOverloadsIdenticalFunsInClass.kt"); - } - - @Test - @TestMetadata("ConflictingOverloadsIdenticalFunsTPInClass.kt") - public void testConflictingOverloadsIdenticalFunsTPInClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/overload/ConflictingOverloadsIdenticalFunsTPInClass.kt"); - } - - @Test - @TestMetadata("ConflictingOverloadsIdenticalValsInClass.kt") - public void testConflictingOverloadsIdenticalValsInClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/overload/ConflictingOverloadsIdenticalValsInClass.kt"); - } - - @Test - @TestMetadata("ConflictingOverloadsValsDifferentTypeInClass.kt") - public void testConflictingOverloadsValsDifferentTypeInClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/overload/ConflictingOverloadsValsDifferentTypeInClass.kt"); - } - - @Test - @TestMetadata("ConstructorVsFunOverload.kt") - public void testConstructorVsFunOverload() throws Exception { - runTest("compiler/testData/diagnostics/tests/overload/ConstructorVsFunOverload.kt"); - } - - @Test - @TestMetadata("defaultParameters.kt") - public void testDefaultParameters() throws Exception { - runTest("compiler/testData/diagnostics/tests/overload/defaultParameters.kt"); - } - - @Test - @TestMetadata("disambiguateByFailedAbstractClassCheck.kt") - public void testDisambiguateByFailedAbstractClassCheck() throws Exception { - runTest("compiler/testData/diagnostics/tests/overload/disambiguateByFailedAbstractClassCheck.kt"); - } - - @Test - @TestMetadata("EmptyArgumentListInLambda.kt") - public void testEmptyArgumentListInLambda() throws Exception { - runTest("compiler/testData/diagnostics/tests/overload/EmptyArgumentListInLambda.kt"); - } - - @Test - @TestMetadata("ExtFunDifferentReceiver.kt") - public void testExtFunDifferentReceiver() throws Exception { - runTest("compiler/testData/diagnostics/tests/overload/ExtFunDifferentReceiver.kt"); - } - - @Test - @TestMetadata("FunNoConflictInDifferentPackages.kt") - public void testFunNoConflictInDifferentPackages() throws Exception { - runTest("compiler/testData/diagnostics/tests/overload/FunNoConflictInDifferentPackages.kt"); - } - - @Test - @TestMetadata("kt10939.kt") - public void testKt10939() throws Exception { - runTest("compiler/testData/diagnostics/tests/overload/kt10939.kt"); - } - - @Test - @TestMetadata("kt1998.kt") - public void testKt1998() throws Exception { - runTest("compiler/testData/diagnostics/tests/overload/kt1998.kt"); - } - - @Test - @TestMetadata("kt2493.kt") - public void testKt2493() throws Exception { - runTest("compiler/testData/diagnostics/tests/overload/kt2493.kt"); - } - - @Test - @TestMetadata("kt7068.kt") - public void testKt7068() throws Exception { - runTest("compiler/testData/diagnostics/tests/overload/kt7068.kt"); - } - - @Test - @TestMetadata("kt7068_2.kt") - public void testKt7068_2() throws Exception { - runTest("compiler/testData/diagnostics/tests/overload/kt7068_2.kt"); - } - - @Test - @TestMetadata("kt7440.kt") - public void testKt7440() throws Exception { - runTest("compiler/testData/diagnostics/tests/overload/kt7440.kt"); - } - - @Test - @TestMetadata("LocalFunctions.kt") - public void testLocalFunctions() throws Exception { - runTest("compiler/testData/diagnostics/tests/overload/LocalFunctions.kt"); - } - - @Test - @TestMetadata("onlyPrivateOverloadsDiagnostic.kt") - public void testOnlyPrivateOverloadsDiagnostic() throws Exception { - runTest("compiler/testData/diagnostics/tests/overload/onlyPrivateOverloadsDiagnostic.kt"); - } - - @Test - @TestMetadata("OverloadFunRegularAndExt.kt") - public void testOverloadFunRegularAndExt() throws Exception { - runTest("compiler/testData/diagnostics/tests/overload/OverloadFunRegularAndExt.kt"); - } - - @Test - @TestMetadata("OverloadVarAndFunInClass.kt") - public void testOverloadVarAndFunInClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/overload/OverloadVarAndFunInClass.kt"); - } - - @Test - @TestMetadata("SyntheticAndNotSynthetic.kt") - public void testSyntheticAndNotSynthetic() throws Exception { - runTest("compiler/testData/diagnostics/tests/overload/SyntheticAndNotSynthetic.kt"); - } - - @Test - @TestMetadata("TypeParameterMultipleBounds.kt") - public void testTypeParameterMultipleBounds() throws Exception { - runTest("compiler/testData/diagnostics/tests/overload/TypeParameterMultipleBounds.kt"); - } - - @Test - @TestMetadata("UnsubstitutedJavaGenetics.kt") - public void testUnsubstitutedJavaGenetics() throws Exception { - runTest("compiler/testData/diagnostics/tests/overload/UnsubstitutedJavaGenetics.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/override") - @TestDataPath("$PROJECT_ROOT") - public class Override extends AbstractDiagnosticUsingJavacTest { - @Test - @TestMetadata("AbstractFunImplemented.kt") - public void testAbstractFunImplemented() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/AbstractFunImplemented.kt"); - } - - @Test - @TestMetadata("AbstractFunNotImplemented.kt") - public void testAbstractFunNotImplemented() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/AbstractFunNotImplemented.kt"); - } - - @Test - @TestMetadata("AbstractValImplemented.kt") - public void testAbstractValImplemented() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/AbstractValImplemented.kt"); - } - - @Test - @TestMetadata("AbstractValNotImplemented.kt") - public void testAbstractValNotImplemented() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/AbstractValNotImplemented.kt"); - } - - @Test - @TestMetadata("AbstractVarImplemented.kt") - public void testAbstractVarImplemented() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/AbstractVarImplemented.kt"); - } - - @Test - @TestMetadata("AbstractVarNotImplemented.kt") - public void testAbstractVarNotImplemented() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/AbstractVarNotImplemented.kt"); - } - - @Test - public void testAllFilesPresentInOverride() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/override"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("AllPrivateFromSuperTypes.kt") - public void testAllPrivateFromSuperTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/AllPrivateFromSuperTypes.kt"); - } - - @Test - @TestMetadata("ComplexValRedeclaration.kt") - public void testComplexValRedeclaration() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/ComplexValRedeclaration.kt"); - } - - @Test - @TestMetadata("ConflictingFunctionSignatureFromSuperclass.kt") - public void testConflictingFunctionSignatureFromSuperclass() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/ConflictingFunctionSignatureFromSuperclass.kt"); - } - - @Test - @TestMetadata("ConflictingPropertySignatureFromSuperclass.kt") - public void testConflictingPropertySignatureFromSuperclass() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/ConflictingPropertySignatureFromSuperclass.kt"); - } - - @Test - @TestMetadata("DefaultParameterValueInOverride.kt") - public void testDefaultParameterValueInOverride() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/DefaultParameterValueInOverride.kt"); - } - - @Test - @TestMetadata("DefaultParameterValues-NoErrorsWhenInheritingFromOneTypeTwice.kt") - public void testDefaultParameterValues_NoErrorsWhenInheritingFromOneTypeTwice() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/DefaultParameterValues-NoErrorsWhenInheritingFromOneTypeTwice.kt"); - } - - @Test - @TestMetadata("Delegation.kt") - public void testDelegation() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/Delegation.kt"); - } - - @Test - @TestMetadata("DelegationFun.kt") - public void testDelegationFun() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/DelegationFun.kt"); - } - - @Test - @TestMetadata("DelegationVal.kt") - public void testDelegationVal() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/DelegationVal.kt"); - } - - @Test - @TestMetadata("DelegationVar.kt") - public void testDelegationVar() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/DelegationVar.kt"); - } - - @Test - @TestMetadata("DuplicateMethod.kt") - public void testDuplicateMethod() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/DuplicateMethod.kt"); - } - - @Test - @TestMetadata("EqualityOfIntersectionTypes.kt") - public void testEqualityOfIntersectionTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/EqualityOfIntersectionTypes.kt"); - } - - @Test - @TestMetadata("ExtendFunctionClass.kt") - public void testExtendFunctionClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/ExtendFunctionClass.kt"); - } - - @Test - @TestMetadata("fakeEquals.kt") - public void testFakeEquals() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/fakeEquals.kt"); - } - - @Test - @TestMetadata("FakeOverrideAbstractAndNonAbstractFun.kt") - public void testFakeOverrideAbstractAndNonAbstractFun() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/FakeOverrideAbstractAndNonAbstractFun.kt"); - } - - @Test - @TestMetadata("FakeOverrideDifferentDeclarationSignatures.kt") - public void testFakeOverrideDifferentDeclarationSignatures() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/FakeOverrideDifferentDeclarationSignatures.kt"); - } - - @Test - @TestMetadata("FakeOverrideModality1.kt") - public void testFakeOverrideModality1() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/FakeOverrideModality1.kt"); - } - - @Test - @TestMetadata("FakeOverrideModality2.kt") - public void testFakeOverrideModality2() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/FakeOverrideModality2.kt"); - } - - @Test - @TestMetadata("FakeOverrideModality3.kt") - public void testFakeOverrideModality3() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/FakeOverrideModality3.kt"); - } - - @Test - @TestMetadata("Generics.kt") - public void testGenerics() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/Generics.kt"); - } - - @Test - @TestMetadata("InvisiblePotentialOverride.kt") - public void testInvisiblePotentialOverride() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/InvisiblePotentialOverride.kt"); - } - - @Test - @TestMetadata("kt12358.kt") - public void testKt12358() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/kt12358.kt"); - } - - @Test - @TestMetadata("kt12467.kt") - public void testKt12467() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/kt12467.kt"); - } - - @Test - @TestMetadata("kt12482.kt") - public void testKt12482() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/kt12482.kt"); - } - - @Test - @TestMetadata("kt1862.kt") - public void testKt1862() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/kt1862.kt"); - } - - @Test - @TestMetadata("kt2052.kt") - public void testKt2052() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/kt2052.kt"); - } - - @Test - @TestMetadata("kt2491.kt") - public void testKt2491() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/kt2491.kt"); - } - - @Test - @TestMetadata("kt4763.kt") - public void testKt4763() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/kt4763.kt"); - } - - @Test - @TestMetadata("kt4763property.kt") - public void testKt4763property() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/kt4763property.kt"); - } - - @Test - @TestMetadata("kt4785.kt") - public void testKt4785() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/kt4785.kt"); - } - - @Test - @TestMetadata("kt6014.kt") - public void testKt6014() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/kt6014.kt"); - } - - @Test - @TestMetadata("kt880.kt") - public void testKt880() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/kt880.kt"); - } - - @Test - @TestMetadata("kt8990.kt") - public void testKt8990() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/kt8990.kt"); - } - - @Test - @TestMetadata("MissingDelegate.kt") - public void testMissingDelegate() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/MissingDelegate.kt"); - } - - @Test - @TestMetadata("MultipleDefaultParametersInSupertypes.kt") - public void testMultipleDefaultParametersInSupertypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/MultipleDefaultParametersInSupertypes.kt"); - } - - @Test - @TestMetadata("MultipleDefaultParametersInSupertypesNoOverride.kt") - public void testMultipleDefaultParametersInSupertypesNoOverride() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/MultipleDefaultParametersInSupertypesNoOverride.kt"); - } - - @Test - @TestMetadata("MultipleDefaultsAndNamesInSupertypes.kt") - public void testMultipleDefaultsAndNamesInSupertypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/MultipleDefaultsAndNamesInSupertypes.kt"); - } - - @Test - @TestMetadata("MultipleDefaultsInSupertypesNoExplicitOverride.kt") - public void testMultipleDefaultsInSupertypesNoExplicitOverride() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/MultipleDefaultsInSupertypesNoExplicitOverride.kt"); - } - - @Test - @TestMetadata("NonGenerics.kt") - public void testNonGenerics() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/NonGenerics.kt"); - } - - @Test - @TestMetadata("ObjectDelegationManyImpl.kt") - public void testObjectDelegationManyImpl() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/ObjectDelegationManyImpl.kt"); - } - - @Test - @TestMetadata("overrideMemberFromFinalClass.kt") - public void testOverrideMemberFromFinalClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/overrideMemberFromFinalClass.kt"); - } - - @Test - @TestMetadata("OverrideWithErrors.kt") - public void testOverrideWithErrors() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/OverrideWithErrors.kt"); - } - - @Test - @TestMetadata("OverridingFinalMember.kt") - public void testOverridingFinalMember() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/OverridingFinalMember.kt"); - } - - @Test - @TestMetadata("ParameterDefaultValues-DefaultValueFromOnlyOneSupertype.kt") - public void testParameterDefaultValues_DefaultValueFromOnlyOneSupertype() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/ParameterDefaultValues-DefaultValueFromOnlyOneSupertype.kt"); - } - - @Test - @TestMetadata("ParentInheritsManyImplementations.kt") - public void testParentInheritsManyImplementations() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/ParentInheritsManyImplementations.kt"); - } - - @Test - @TestMetadata("PropertyInConstructor.kt") - public void testPropertyInConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/PropertyInConstructor.kt"); - } - - @Test - @TestMetadata("ProtectedAndPrivateFromSupertypes.kt") - public void testProtectedAndPrivateFromSupertypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/ProtectedAndPrivateFromSupertypes.kt"); - } - - @Test - @TestMetadata("SuspiciousCase1.kt") - public void testSuspiciousCase1() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/SuspiciousCase1.kt"); - } - - @Test - @TestMetadata("ToAbstractMembersFromSuper-kt1996.kt") - public void testToAbstractMembersFromSuper_kt1996() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/ToAbstractMembersFromSuper-kt1996.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/override/clashesOnInheritance") - @TestDataPath("$PROJECT_ROOT") - public class ClashesOnInheritance extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInClashesOnInheritance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/override/clashesOnInheritance"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("covariantOverrides.kt") - public void testCovariantOverrides() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/clashesOnInheritance/covariantOverrides.kt"); - } - - @Test - @TestMetadata("flexibleReturnType.kt") - public void testFlexibleReturnType() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/clashesOnInheritance/flexibleReturnType.kt"); - } - - @Test - @TestMetadata("flexibleReturnTypeIn.kt") - public void testFlexibleReturnTypeIn() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/clashesOnInheritance/flexibleReturnTypeIn.kt"); - } - - @Test - @TestMetadata("flexibleReturnTypeList.kt") - public void testFlexibleReturnTypeList() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/clashesOnInheritance/flexibleReturnTypeList.kt"); - } - - @Test - @TestMetadata("genericWithUpperBound.kt") - public void testGenericWithUpperBound() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/clashesOnInheritance/genericWithUpperBound.kt"); - } - - @Test - @TestMetadata("kt13355.kt") - public void testKt13355() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/clashesOnInheritance/kt13355.kt"); - } - - @Test - @TestMetadata("kt13355viaJava.kt") - public void testKt13355viaJava() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/clashesOnInheritance/kt13355viaJava.kt"); - } - - @Test - @TestMetadata("kt9550.kt") - public void testKt9550() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/clashesOnInheritance/kt9550.kt"); - } - - @Test - @TestMetadata("returnTypeMismatch.kt") - public void testReturnTypeMismatch() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/clashesOnInheritance/returnTypeMismatch.kt"); - } - - @Test - @TestMetadata("unrelatedInherited.kt") - public void testUnrelatedInherited() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/clashesOnInheritance/unrelatedInherited.kt"); - } - - @Test - @TestMetadata("valTypeMismatch.kt") - public void testValTypeMismatch() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/clashesOnInheritance/valTypeMismatch.kt"); - } - - @Test - @TestMetadata("varTypeMismatch.kt") - public void testVarTypeMismatch() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/clashesOnInheritance/varTypeMismatch.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/override/parameterNames") - @TestDataPath("$PROJECT_ROOT") - public class ParameterNames extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInParameterNames() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/override/parameterNames"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("changeOnOverrideDiagnostic.kt") - public void testChangeOnOverrideDiagnostic() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/parameterNames/changeOnOverrideDiagnostic.kt"); - } - - @Test - @TestMetadata("differentNamesInSupertypesDiagnostic.kt") - public void testDifferentNamesInSupertypesDiagnostic() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/parameterNames/differentNamesInSupertypesDiagnostic.kt"); - } - - @Test - @TestMetadata("invokeInFunctionClass.kt") - public void testInvokeInFunctionClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/parameterNames/invokeInFunctionClass.kt"); - } - - @Test - @TestMetadata("jjkHierarchy.kt") - public void testJjkHierarchy() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/parameterNames/jjkHierarchy.kt"); - } - - @Test - @TestMetadata("kjkHierarchy.kt") - public void testKjkHierarchy() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/parameterNames/kjkHierarchy.kt"); - } - - @Test - @TestMetadata("kjkWithSeveralSupers.kt") - public void testKjkWithSeveralSupers() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/parameterNames/kjkWithSeveralSupers.kt"); - } - - @Test - @TestMetadata("kotlinInheritsBothJavaAndKotlin.kt") - public void testKotlinInheritsBothJavaAndKotlin() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/parameterNames/kotlinInheritsBothJavaAndKotlin.kt"); - } - - @Test - @TestMetadata("kotlinInheritsJava.kt") - public void testKotlinInheritsJava() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/parameterNames/kotlinInheritsJava.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/override/typeParameters") - @TestDataPath("$PROJECT_ROOT") - public class TypeParameters extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInTypeParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/override/typeParameters"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("classAndTwoInterfaceBounds.kt") - public void testClassAndTwoInterfaceBounds() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/typeParameters/classAndTwoInterfaceBounds.kt"); - } - - @Test - @TestMetadata("differentSetsOfBounds.kt") - public void testDifferentSetsOfBounds() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/typeParameters/differentSetsOfBounds.kt"); - } - - @Test - @TestMetadata("kt9850.kt") - public void testKt9850() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/typeParameters/kt9850.kt"); - } - - @Test - @TestMetadata("simpleVisitorTwoAccepts.kt") - public void testSimpleVisitorTwoAccepts() throws Exception { - runTest("compiler/testData/diagnostics/tests/override/typeParameters/simpleVisitorTwoAccepts.kt"); - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/parenthesizedTypes") - @TestDataPath("$PROJECT_ROOT") - public class ParenthesizedTypes extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInParenthesizedTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/parenthesizedTypes"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("annotationsOnNullableParenthesizedTypes.kt") - public void testAnnotationsOnNullableParenthesizedTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/parenthesizedTypes/annotationsOnNullableParenthesizedTypes.kt"); - } - - @Test - @TestMetadata("annotationsOnParenthesizedTypes.kt") - public void testAnnotationsOnParenthesizedTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/parenthesizedTypes/annotationsOnParenthesizedTypes.kt"); - } - - @Test - @TestMetadata("splitModifierList.kt") - public void testSplitModifierList() throws Exception { - runTest("compiler/testData/diagnostics/tests/parenthesizedTypes/splitModifierList.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/platformTypes") - @TestDataPath("$PROJECT_ROOT") - public class PlatformTypes extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInPlatformTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("delegateByComplexInheritance.kt") - public void testDelegateByComplexInheritance() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/delegateByComplexInheritance.kt"); - } - - @Test - @TestMetadata("dereference.kt") - public void testDereference() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/dereference.kt"); - } - - @Test - @TestMetadata("elvis.kt") - public void testElvis() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/elvis.kt"); - } - - @Test - @TestMetadata("explicitFlexibleNoPackage.kt") - public void testExplicitFlexibleNoPackage() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/explicitFlexibleNoPackage.kt"); - } - - @Test - @TestMetadata("explicitFlexibleWithPackage.kt") - public void testExplicitFlexibleWithPackage() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/explicitFlexibleWithPackage.kt"); - } - - @Test - @TestMetadata("getParentOfType.kt") - public void testGetParentOfType() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/getParentOfType.kt"); - } - - @Test - @TestMetadata("inference.kt") - public void testInference() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/inference.kt"); - } - - @Test - @TestMetadata("intVsIntegerAmbiguity.kt") - public void testIntVsIntegerAmbiguity() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/intVsIntegerAmbiguity.kt"); - } - - @Test - @TestMetadata("javaEmptyList.kt") - public void testJavaEmptyList() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/javaEmptyList.kt"); - } - - @Test - @TestMetadata("methodTypeParameterDefaultBound.kt") - public void testMethodTypeParameterDefaultBound() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/methodTypeParameterDefaultBound.kt"); - } - - @Test - @TestMetadata("noAnnotationInClassPath.kt") - public void testNoAnnotationInClassPath() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/noAnnotationInClassPath.kt"); - } - - @Test - @TestMetadata("nullableTypeArgument.kt") - public void testNullableTypeArgument() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/nullableTypeArgument.kt"); - } - - @Test - @TestMetadata("override.kt") - public void testOverride() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/override.kt"); - } - - @Test - @TestMetadata("rawOverrides.kt") - public void testRawOverrides() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/rawOverrides.kt"); - } - - @Test - @TestMetadata("rawSamOverrides.kt") - public void testRawSamOverrides() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/rawSamOverrides.kt"); - } - - @Test - @TestMetadata("safeCall.kt") - public void testSafeCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/safeCall.kt"); - } - - @Test - @TestMetadata("samAdapterInConstructor.kt") - public void testSamAdapterInConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/samAdapterInConstructor.kt"); - } - - @Test - @TestMetadata("samConstructor.kt") - public void testSamConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/samConstructor.kt"); - } - - @Test - @TestMetadata("supertypeArgumentsExplicit.kt") - public void testSupertypeArgumentsExplicit() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/supertypeArgumentsExplicit.kt"); - } - - @Test - @TestMetadata("supertypeTypeArguments.kt") - public void testSupertypeTypeArguments() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/supertypeTypeArguments.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/platformTypes/commonSupertype") - @TestDataPath("$PROJECT_ROOT") - public class CommonSupertype extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInCommonSupertype() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/commonSupertype"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("collectionOrNull.kt") - public void testCollectionOrNull() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/commonSupertype/collectionOrNull.kt"); - } - - @Test - @TestMetadata("inferenceWithBound.kt") - public void testInferenceWithBound() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/commonSupertype/inferenceWithBound.kt"); - } - - @Test - @TestMetadata("mixedElvis.kt") - public void testMixedElvis() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/commonSupertype/mixedElvis.kt"); - } - - @Test - @TestMetadata("mixedIf.kt") - public void testMixedIf() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/commonSupertype/mixedIf.kt"); - } - - @Test - @TestMetadata("recursiveGeneric.kt") - public void testRecursiveGeneric() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/commonSupertype/recursiveGeneric.kt"); - } - - @Test - @TestMetadata("stringOrNull.kt") - public void testStringOrNull() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/commonSupertype/stringOrNull.kt"); - } - - @Test - @TestMetadata("typeOfElvis.kt") - public void testTypeOfElvis() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/commonSupertype/typeOfElvis.kt"); - } - - @Test - @TestMetadata("withNothing.kt") - public void testWithNothing() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/commonSupertype/withNothing.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/platformTypes/genericVarianceViolation") - @TestDataPath("$PROJECT_ROOT") - public class GenericVarianceViolation extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInGenericVarianceViolation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/genericVarianceViolation"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("listSuperType.kt") - public void testListSuperType() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/genericVarianceViolation/listSuperType.kt"); - } - - @Test - @TestMetadata("rawTypes.kt") - public void testRawTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/genericVarianceViolation/rawTypes.kt"); - } - - @Test - @TestMetadata("simple.kt") - public void testSimple() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/genericVarianceViolation/simple.kt"); - } - - @Test - @TestMetadata("smartCast.kt") - public void testSmartCast() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/genericVarianceViolation/smartCast.kt"); - } - - @Test - @TestMetadata("strangeVariance.kt") - public void testStrangeVariance() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/genericVarianceViolation/strangeVariance.kt"); - } - - @Test - @TestMetadata("userDefinedOut.kt") - public void testUserDefinedOut() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/genericVarianceViolation/userDefinedOut.kt"); - } - - @Test - @TestMetadata("valueFromJava.kt") - public void testValueFromJava() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/genericVarianceViolation/valueFromJava.kt"); - } - - @Test - @TestMetadata("wildcards.kt") - public void testWildcards() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/genericVarianceViolation/wildcards.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/platformTypes/intersection") - @TestDataPath("$PROJECT_ROOT") - public class Intersection extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInIntersection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/intersection"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("map.kt") - public void testMap() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/intersection/map.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/platformTypes/methodCall") - @TestDataPath("$PROJECT_ROOT") - public class MethodCall extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInMethodCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/methodCall"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("entrySet.kt") - public void testEntrySet() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/methodCall/entrySet.kt"); - } - - @Test - @TestMetadata("flexibilityThroughTypeVariable.kt") - public void testFlexibilityThroughTypeVariable() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/methodCall/flexibilityThroughTypeVariable.kt"); - } - - @Test - @TestMetadata("flexibilityThroughTypeVariableOut.kt") - public void testFlexibilityThroughTypeVariableOut() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/methodCall/flexibilityThroughTypeVariableOut.kt"); - } - - @Test - @TestMetadata("genericsAndArrays.kt") - public void testGenericsAndArrays() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/methodCall/genericsAndArrays.kt"); - } - - @Test - @TestMetadata("int.kt") - public void testInt() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/methodCall/int.kt"); - } - - @Test - @TestMetadata("intArray.kt") - public void testIntArray() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/methodCall/intArray.kt"); - } - - @Test - @TestMetadata("javaCollectionToKotlin.kt") - public void testJavaCollectionToKotlin() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/methodCall/javaCollectionToKotlin.kt"); - } - - @Test - @TestMetadata("javaToJava.kt") - public void testJavaToJava() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/methodCall/javaToJava.kt"); - } - - @Test - @TestMetadata("javaToKotlin.kt") - public void testJavaToKotlin() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/methodCall/javaToKotlin.kt"); - } - - @Test - @TestMetadata("kotlinCollectionToJava.kt") - public void testKotlinCollectionToJava() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/methodCall/kotlinCollectionToJava.kt"); - } - - @Test - @TestMetadata("kt27565.kt") - public void testKt27565() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/methodCall/kt27565.kt"); - } - - @Test - @TestMetadata("list.kt") - public void testList() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/methodCall/list.kt"); - } - - @Test - @TestMetadata("multipleExactBounds.kt") - public void testMultipleExactBounds() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/methodCall/multipleExactBounds.kt"); - } - - @Test - @TestMetadata("multipleExactBoundsNullable.kt") - public void testMultipleExactBoundsNullable() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/methodCall/multipleExactBoundsNullable.kt"); - } - - @Test - @TestMetadata("objectArray.kt") - public void testObjectArray() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/methodCall/objectArray.kt"); - } - - @Test - @TestMetadata("overloadingForSubclass.kt") - public void testOverloadingForSubclass() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/methodCall/overloadingForSubclass.kt"); - } - - @Test - @TestMetadata("sam.kt") - public void testSam() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/methodCall/sam.kt"); - } - - @Test - @TestMetadata("singleton.kt") - public void testSingleton() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/methodCall/singleton.kt"); - } - - @Test - @TestMetadata("string.kt") - public void testString() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/methodCall/string.kt"); - } - - @Test - @TestMetadata("visitor.kt") - public void testVisitor() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/methodCall/visitor.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/platformTypes/notNullTypeParameter") - @TestDataPath("$PROJECT_ROOT") - public class NotNullTypeParameter extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInNotNullTypeParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/notNullTypeParameter"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("enhancementFromAnnotation.kt") - public void testEnhancementFromAnnotation() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/notNullTypeParameter/enhancementFromAnnotation.kt"); - } - - @Test - @TestMetadata("enhancementFromKotlin.kt") - public void testEnhancementFromKotlin() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/notNullTypeParameter/enhancementFromKotlin.kt"); - } - - @Test - @TestMetadata("methodTypeParameter.kt") - public void testMethodTypeParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/notNullTypeParameter/methodTypeParameter.kt"); - } - - @Test - @TestMetadata("noInheritanceReturnType.kt") - public void testNoInheritanceReturnType() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/notNullTypeParameter/noInheritanceReturnType.kt"); - } - - @Test - @TestMetadata("noInheritanceValueParameter.kt") - public void testNoInheritanceValueParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/notNullTypeParameter/noInheritanceValueParameter.kt"); - } - - @Test - @TestMetadata("onTypeProjection.kt") - public void testOnTypeProjection() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/notNullTypeParameter/onTypeProjection.kt"); - } - - @Test - @TestMetadata("substitutionInSuperType.kt") - public void testSubstitutionInSuperType() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/notNullTypeParameter/substitutionInSuperType.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings") - @TestDataPath("$PROJECT_ROOT") - public class NullabilityWarnings extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInNullabilityWarnings() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("arithmetic.kt") - public void testArithmetic() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/arithmetic.kt"); - } - - @Test - @TestMetadata("array.kt") - public void testArray() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/array.kt"); - } - - @Test - @TestMetadata("assignToVar.kt") - public void testAssignToVar() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/assignToVar.kt"); - } - - @Test - @TestMetadata("conditions.kt") - public void testConditions() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/conditions.kt"); - } - - @Test - @TestMetadata("dataFlowInfo.kt") - public void testDataFlowInfo() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/dataFlowInfo.kt"); - } - - @Test - @TestMetadata("defaultParameters.kt") - public void testDefaultParameters() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/defaultParameters.kt"); - } - - @Test - @TestMetadata("delegatedProperties.kt") - public void testDelegatedProperties() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/delegatedProperties.kt"); - } - - @Test - @TestMetadata("delegation.kt") - public void testDelegation() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/delegation.kt"); - } - - @Test - @TestMetadata("derefenceExtension.kt") - public void testDerefenceExtension() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/derefenceExtension.kt"); - } - - @Test - @TestMetadata("derefenceMember.kt") - public void testDerefenceMember() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/derefenceMember.kt"); - } - - @Test - @TestMetadata("elvis.kt") - public void testElvis() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/elvis.kt"); - } - - @Test - @TestMetadata("expectedType.kt") - public void testExpectedType() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/expectedType.kt"); - } - - @Test - @TestMetadata("for.kt") - public void testFor() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/for.kt"); - } - - @Test - @TestMetadata("functionArguments.kt") - public void testFunctionArguments() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/functionArguments.kt"); - } - - @Test - @TestMetadata("inferenceInConditionals.kt") - public void testInferenceInConditionals() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/inferenceInConditionals.kt"); - } - - @Test - @TestMetadata("invoke.kt") - public void testInvoke() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/invoke.kt"); - } - - @Test - @TestMetadata("kt6829.kt") - public void testKt6829() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/kt6829.kt"); - } - - @Test - @TestMetadata("multiDeclaration.kt") - public void testMultiDeclaration() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/multiDeclaration.kt"); - } - - @Test - @TestMetadata("noWarningOnDoubleElvis.kt") - public void testNoWarningOnDoubleElvis() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/noWarningOnDoubleElvis.kt"); - } - - @Test - @TestMetadata("notNullAfterSafeCall.kt") - public void testNotNullAfterSafeCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/notNullAfterSafeCall.kt"); - } - - @Test - @TestMetadata("notNullAssertion.kt") - public void testNotNullAssertion() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/notNullAssertion.kt"); - } - - @Test - @TestMetadata("notNullAssertionInCall.kt") - public void testNotNullAssertionInCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/notNullAssertionInCall.kt"); - } - - @Test - @TestMetadata("notNullTypeMarkedWithNullableAnnotation.kt") - public void testNotNullTypeMarkedWithNullableAnnotation() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/notNullTypeMarkedWithNullableAnnotation.kt"); - } - - @Test - @TestMetadata("passToJava.kt") - public void testPassToJava() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/passToJava.kt"); - } - - @Test - @TestMetadata("primitiveArray.kt") - public void testPrimitiveArray() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/primitiveArray.kt"); - } - - @Test - @TestMetadata("safeCall.kt") - public void testSafeCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/safeCall.kt"); - } - - @Test - @TestMetadata("senselessComparisonEquals.kt") - public void testSenselessComparisonEquals() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/senselessComparisonEquals.kt"); - } - - @Test - @TestMetadata("senselessComparisonIdentityEquals.kt") - public void testSenselessComparisonIdentityEquals() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/senselessComparisonIdentityEquals.kt"); - } - - @Test - @TestMetadata("throw.kt") - public void testThrow() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/throw.kt"); - } - - @Test - @TestMetadata("uselessElvisInCall.kt") - public void testUselessElvisInCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/uselessElvisInCall.kt"); - } - - @Test - @TestMetadata("uselessElvisRightIsNull.kt") - public void testUselessElvisRightIsNull() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/uselessElvisRightIsNull.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/platformTypes/rawTypes") - @TestDataPath("$PROJECT_ROOT") - public class RawTypes extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInRawTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/rawTypes"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("arrays.kt") - public void testArrays() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/arrays.kt"); - } - - @Test - @TestMetadata("errorType.kt") - public void testErrorType() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/errorType.kt"); - } - - @Test - @TestMetadata("genericInnerClass.kt") - public void testGenericInnerClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/genericInnerClass.kt"); - } - - @Test - @TestMetadata("interClassesRecursion.kt") - public void testInterClassesRecursion() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/interClassesRecursion.kt"); - } - - @Test - @TestMetadata("nonGenericRawMember.kt") - public void testNonGenericRawMember() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/nonGenericRawMember.kt"); - } - - @Test - @TestMetadata("nonTrivialErasure.kt") - public void testNonTrivialErasure() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/nonTrivialErasure.kt"); - } - - @Test - @TestMetadata("rawEnhancment.kt") - public void testRawEnhancment() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/rawEnhancment.kt"); - } - - @Test - @TestMetadata("rawSupertype.kt") - public void testRawSupertype() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/rawSupertype.kt"); - } - - @Test - @TestMetadata("rawSupertypeOverride.kt") - public void testRawSupertypeOverride() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/rawSupertypeOverride.kt"); - } - - @Test - @TestMetadata("rawTypeInUpperBound.kt") - public void testRawTypeInUpperBound() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/rawTypeInUpperBound.kt"); - } - - @Test - @TestMetadata("rawWithInProjection.kt") - public void testRawWithInProjection() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/rawWithInProjection.kt"); - } - - @Test - @TestMetadata("recursiveBound.kt") - public void testRecursiveBound() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/recursiveBound.kt"); - } - - @Test - @TestMetadata("samRaw.kt") - public void testSamRaw() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/samRaw.kt"); - } - - @Test - @TestMetadata("saveRawCapabilitiesAfterSubtitution.kt") - public void testSaveRawCapabilitiesAfterSubtitution() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/saveRawCapabilitiesAfterSubtitution.kt"); - } - - @Test - @TestMetadata("simple.kt") - public void testSimple() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/simple.kt"); - } - - @Test - @TestMetadata("starProjectionToRaw.kt") - public void testStarProjectionToRaw() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/starProjectionToRaw.kt"); - } - - @Test - @TestMetadata("typeEnhancement.kt") - public void testTypeEnhancement() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/rawTypes/typeEnhancement.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/platformTypes/typeEnhancement") - @TestDataPath("$PROJECT_ROOT") - public class TypeEnhancement extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInTypeEnhancement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/typeEnhancement"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("overriddenExtensions.kt") - public void testOverriddenExtensions() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/overriddenExtensions.kt"); - } - - @Test - @TestMetadata("saveAnnotationAfterSubstitution.kt") - public void testSaveAnnotationAfterSubstitution() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/saveAnnotationAfterSubstitution.kt"); - } - - @Test - @TestMetadata("supertypeDifferentParameterNullability.kt") - public void testSupertypeDifferentParameterNullability() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/supertypeDifferentParameterNullability.kt"); - } - - @Test - @TestMetadata("supertypeDifferentReturnNullability.kt") - public void testSupertypeDifferentReturnNullability() throws Exception { - runTest("compiler/testData/diagnostics/tests/platformTypes/typeEnhancement/supertypeDifferentReturnNullability.kt"); - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/privateInFile") - @TestDataPath("$PROJECT_ROOT") - public class PrivateInFile extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInPrivateInFile() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/privateInFile"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("kt12429.kt") - public void testKt12429() throws Exception { - runTest("compiler/testData/diagnostics/tests/privateInFile/kt12429.kt"); - } - - @Test - @TestMetadata("topLevelAnnotationCall.kt") - public void testTopLevelAnnotationCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/privateInFile/topLevelAnnotationCall.kt"); - } - - @Test - @TestMetadata("visibility.kt") - public void testVisibility() throws Exception { - runTest("compiler/testData/diagnostics/tests/privateInFile/visibility.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/properties") - @TestDataPath("$PROJECT_ROOT") - public class Properties extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/properties"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("extensionPropertyMustHaveAccessorsOrBeAbstract.kt") - public void testExtensionPropertyMustHaveAccessorsOrBeAbstract() throws Exception { - runTest("compiler/testData/diagnostics/tests/properties/extensionPropertyMustHaveAccessorsOrBeAbstract.kt"); - } - - @Test - @TestMetadata("lateinitOnTopLevel.kt") - public void testLateinitOnTopLevel() throws Exception { - runTest("compiler/testData/diagnostics/tests/properties/lateinitOnTopLevel.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/properties/inferenceFromGetters") - @TestDataPath("$PROJECT_ROOT") - public class InferenceFromGetters extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInInferenceFromGetters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/properties/inferenceFromGetters"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("blockBodyGetter.kt") - public void testBlockBodyGetter() throws Exception { - runTest("compiler/testData/diagnostics/tests/properties/inferenceFromGetters/blockBodyGetter.kt"); - } - - @Test - @TestMetadata("cantBeInferred.kt") - public void testCantBeInferred() throws Exception { - runTest("compiler/testData/diagnostics/tests/properties/inferenceFromGetters/cantBeInferred.kt"); - } - - @Test - @TestMetadata("explicitGetterType.kt") - public void testExplicitGetterType() throws Exception { - runTest("compiler/testData/diagnostics/tests/properties/inferenceFromGetters/explicitGetterType.kt"); - } - - @Test - @TestMetadata("members.kt") - public void testMembers() throws Exception { - runTest("compiler/testData/diagnostics/tests/properties/inferenceFromGetters/members.kt"); - } - - @Test - @TestMetadata("nullAsNothing.kt") - public void testNullAsNothing() throws Exception { - runTest("compiler/testData/diagnostics/tests/properties/inferenceFromGetters/nullAsNothing.kt"); - } - - @Test - @TestMetadata("objectExpression.kt") - public void testObjectExpression() throws Exception { - runTest("compiler/testData/diagnostics/tests/properties/inferenceFromGetters/objectExpression.kt"); - } - - @Test - @TestMetadata("overrides.kt") - public void testOverrides() throws Exception { - runTest("compiler/testData/diagnostics/tests/properties/inferenceFromGetters/overrides.kt"); - } - - @Test - @TestMetadata("primaryConstructorParameter.kt") - public void testPrimaryConstructorParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/properties/inferenceFromGetters/primaryConstructorParameter.kt"); - } - - @Test - @TestMetadata("recursiveGetter.kt") - public void testRecursiveGetter() throws Exception { - runTest("compiler/testData/diagnostics/tests/properties/inferenceFromGetters/recursiveGetter.kt"); - } - - @Test - @TestMetadata("topLevel.kt") - public void testTopLevel() throws Exception { - runTest("compiler/testData/diagnostics/tests/properties/inferenceFromGetters/topLevel.kt"); - } - - @Test - @TestMetadata("unsupportedInferenceFromGetters.kt") - public void testUnsupportedInferenceFromGetters() throws Exception { - runTest("compiler/testData/diagnostics/tests/properties/inferenceFromGetters/unsupportedInferenceFromGetters.kt"); - } - - @Test - @TestMetadata("vars.kt") - public void testVars() throws Exception { - runTest("compiler/testData/diagnostics/tests/properties/inferenceFromGetters/vars.kt"); - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/qualifiedExpression") - @TestDataPath("$PROJECT_ROOT") - public class QualifiedExpression extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInQualifiedExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/qualifiedExpression"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("calleeExpressionAsCallExpression.kt") - public void testCalleeExpressionAsCallExpression() throws Exception { - runTest("compiler/testData/diagnostics/tests/qualifiedExpression/calleeExpressionAsCallExpression.kt"); - } - - @Test - @TestMetadata("GenericClassVsPackage.kt") - public void testGenericClassVsPackage() throws Exception { - runTest("compiler/testData/diagnostics/tests/qualifiedExpression/GenericClassVsPackage.kt"); - } - - @Test - @TestMetadata("JavaQualifier.kt") - public void testJavaQualifier() throws Exception { - runTest("compiler/testData/diagnostics/tests/qualifiedExpression/JavaQualifier.kt"); - } - - @Test - @TestMetadata("nullCalleeExpression.kt") - public void testNullCalleeExpression() throws Exception { - runTest("compiler/testData/diagnostics/tests/qualifiedExpression/nullCalleeExpression.kt"); - } - - @Test - @TestMetadata("PackageVsClass.kt") - public void testPackageVsClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/qualifiedExpression/PackageVsClass.kt"); - } - - @Test - @TestMetadata("PackageVsClass2.kt") - public void testPackageVsClass2() throws Exception { - runTest("compiler/testData/diagnostics/tests/qualifiedExpression/PackageVsClass2.kt"); - } - - @Test - @TestMetadata("PackageVsRootClass.kt") - public void testPackageVsRootClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/qualifiedExpression/PackageVsRootClass.kt"); - } - - @Test - @TestMetadata("TypeWithError.kt") - public void testTypeWithError() throws Exception { - runTest("compiler/testData/diagnostics/tests/qualifiedExpression/TypeWithError.kt"); - } - - @Test - @TestMetadata("visibleClassVsQualifiedClass.kt") - public void testVisibleClassVsQualifiedClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/qualifiedExpression/visibleClassVsQualifiedClass.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/reassignment") - @TestDataPath("$PROJECT_ROOT") - public class Reassignment extends AbstractDiagnosticUsingJavacTest { - @Test - @TestMetadata("afterfor.kt") - public void testAfterfor() throws Exception { - runTest("compiler/testData/diagnostics/tests/reassignment/afterfor.kt"); - } - - @Test - public void testAllFilesPresentInReassignment() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/reassignment"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("dowhile.kt") - public void testDowhile() throws Exception { - runTest("compiler/testData/diagnostics/tests/reassignment/dowhile.kt"); - } - - @Test - @TestMetadata("else.kt") - public void testElse() throws Exception { - runTest("compiler/testData/diagnostics/tests/reassignment/else.kt"); - } - - @Test - @TestMetadata("foronly.kt") - public void testForonly() throws Exception { - runTest("compiler/testData/diagnostics/tests/reassignment/foronly.kt"); - } - - @Test - @TestMetadata("if.kt") - public void testIf() throws Exception { - runTest("compiler/testData/diagnostics/tests/reassignment/if.kt"); - } - - @Test - @TestMetadata("ifelse.kt") - public void testIfelse() throws Exception { - runTest("compiler/testData/diagnostics/tests/reassignment/ifelse.kt"); - } - - @Test - @TestMetadata("noifelse.kt") - public void testNoifelse() throws Exception { - runTest("compiler/testData/diagnostics/tests/reassignment/noifelse.kt"); - } - - @Test - @TestMetadata("when.kt") - public void testWhen() throws Exception { - runTest("compiler/testData/diagnostics/tests/reassignment/when.kt"); - } - - @Test - @TestMetadata("whiletrue.kt") - public void testWhiletrue() throws Exception { - runTest("compiler/testData/diagnostics/tests/reassignment/whiletrue.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/recovery") - @TestDataPath("$PROJECT_ROOT") - public class Recovery extends AbstractDiagnosticUsingJavacTest { - @Test - @TestMetadata("absentLeftHandSide.kt") - public void testAbsentLeftHandSide() throws Exception { - runTest("compiler/testData/diagnostics/tests/recovery/absentLeftHandSide.kt"); - } - - @Test - public void testAllFilesPresentInRecovery() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/recovery"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("emptyTypeArgs.kt") - public void testEmptyTypeArgs() throws Exception { - runTest("compiler/testData/diagnostics/tests/recovery/emptyTypeArgs.kt"); - } - - @Test - @TestMetadata("namelessInJava.kt") - public void testNamelessInJava() throws Exception { - runTest("compiler/testData/diagnostics/tests/recovery/namelessInJava.kt"); - } - - @Test - @TestMetadata("namelessMembers.kt") - public void testNamelessMembers() throws Exception { - runTest("compiler/testData/diagnostics/tests/recovery/namelessMembers.kt"); - } - - @Test - @TestMetadata("namelessToplevelDeclarations.kt") - public void testNamelessToplevelDeclarations() throws Exception { - runTest("compiler/testData/diagnostics/tests/recovery/namelessToplevelDeclarations.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/redeclarations") - @TestDataPath("$PROJECT_ROOT") - public class Redeclarations extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInRedeclarations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/redeclarations"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("ClassRedeclarationInDifferentFiles.kt") - public void testClassRedeclarationInDifferentFiles() throws Exception { - runTest("compiler/testData/diagnostics/tests/redeclarations/ClassRedeclarationInDifferentFiles.kt"); - } - - @Test - @TestMetadata("ConflictingExtensionProperties.kt") - public void testConflictingExtensionProperties() throws Exception { - runTest("compiler/testData/diagnostics/tests/redeclarations/ConflictingExtensionProperties.kt"); - } - - @Test - @TestMetadata("DuplicateParameterNamesInFunctionType.kt") - public void testDuplicateParameterNamesInFunctionType() throws Exception { - runTest("compiler/testData/diagnostics/tests/redeclarations/DuplicateParameterNamesInFunctionType.kt"); - } - - @Test - @TestMetadata("EnumName.kt") - public void testEnumName() throws Exception { - runTest("compiler/testData/diagnostics/tests/redeclarations/EnumName.kt"); - } - - @Test - @TestMetadata("FunVsCtorInDifferentFiles.kt") - public void testFunVsCtorInDifferentFiles() throws Exception { - runTest("compiler/testData/diagnostics/tests/redeclarations/FunVsCtorInDifferentFiles.kt"); - } - - @Test - @TestMetadata("interfaceTypeParameters.kt") - public void testInterfaceTypeParameters() throws Exception { - runTest("compiler/testData/diagnostics/tests/redeclarations/interfaceTypeParameters.kt"); - } - - @Test - @TestMetadata("kt2418.kt") - public void testKt2418() throws Exception { - runTest("compiler/testData/diagnostics/tests/redeclarations/kt2418.kt"); - } - - @Test - @TestMetadata("kt2438.kt") - public void testKt2438() throws Exception { - runTest("compiler/testData/diagnostics/tests/redeclarations/kt2438.kt"); - } - - @Test - @TestMetadata("kt470.kt") - public void testKt470() throws Exception { - runTest("compiler/testData/diagnostics/tests/redeclarations/kt470.kt"); - } - - @Test - @TestMetadata("MultiFilePackageRedeclaration.kt") - public void testMultiFilePackageRedeclaration() throws Exception { - runTest("compiler/testData/diagnostics/tests/redeclarations/MultiFilePackageRedeclaration.kt"); - } - - @Test - @TestMetadata("NoRedeclarationForClassesInDefaultObject.kt") - public void testNoRedeclarationForClassesInDefaultObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/redeclarations/NoRedeclarationForClassesInDefaultObject.kt"); - } - - @Test - @TestMetadata("NoRedeclarationForEnumEntriesAndDefaultObjectMembers.kt") - public void testNoRedeclarationForEnumEntriesAndDefaultObjectMembers() throws Exception { - runTest("compiler/testData/diagnostics/tests/redeclarations/NoRedeclarationForEnumEntriesAndDefaultObjectMembers.kt"); - } - - @Test - @TestMetadata("PropertyAndFunInClass.kt") - public void testPropertyAndFunInClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/redeclarations/PropertyAndFunInClass.kt"); - } - - @Test - @TestMetadata("PropertyAndInnerClass.kt") - public void testPropertyAndInnerClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/redeclarations/PropertyAndInnerClass.kt"); - } - - @Test - @TestMetadata("RedeclarationInDefaultObject.kt") - public void testRedeclarationInDefaultObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/redeclarations/RedeclarationInDefaultObject.kt"); - } - - @Test - @TestMetadata("RedeclarationInMultiFile.kt") - public void testRedeclarationInMultiFile() throws Exception { - runTest("compiler/testData/diagnostics/tests/redeclarations/RedeclarationInMultiFile.kt"); - } - - @Test - @TestMetadata("RedeclarationMainInFile.kt") - public void testRedeclarationMainInFile() throws Exception { - runTest("compiler/testData/diagnostics/tests/redeclarations/RedeclarationMainInFile.kt"); - } - - @Test - @TestMetadata("RedeclarationMainInMultiFile.kt") - public void testRedeclarationMainInMultiFile() throws Exception { - runTest("compiler/testData/diagnostics/tests/redeclarations/RedeclarationMainInMultiFile.kt"); - } - - @Test - @TestMetadata("RedeclarationParameterlessMain.kt") - public void testRedeclarationParameterlessMain() throws Exception { - runTest("compiler/testData/diagnostics/tests/redeclarations/RedeclarationParameterlessMain.kt"); - } - - @Test - @TestMetadata("RedeclarationParameterlessMainInvalid.kt") - public void testRedeclarationParameterlessMainInvalid() throws Exception { - runTest("compiler/testData/diagnostics/tests/redeclarations/RedeclarationParameterlessMainInvalid.kt"); - } - - @Test - @TestMetadata("RedeclarationParameterlessMain_before.kt") - public void testRedeclarationParameterlessMain_before() throws Exception { - runTest("compiler/testData/diagnostics/tests/redeclarations/RedeclarationParameterlessMain_before.kt"); - } - - @Test - @TestMetadata("RedeclarationSuspendMainInMultiFile.kt") - public void testRedeclarationSuspendMainInMultiFile() throws Exception { - runTest("compiler/testData/diagnostics/tests/redeclarations/RedeclarationSuspendMainInMultiFile.kt"); - } - - @Test - @TestMetadata("RedeclarationSuspendMainInMultiFile_before.kt") - public void testRedeclarationSuspendMainInMultiFile_before() throws Exception { - runTest("compiler/testData/diagnostics/tests/redeclarations/RedeclarationSuspendMainInMultiFile_before.kt"); - } - - @Test - @TestMetadata("Redeclarations.kt") - public void testRedeclarations() throws Exception { - runTest("compiler/testData/diagnostics/tests/redeclarations/Redeclarations.kt"); - } - - @Test - @TestMetadata("RedeclarationsInObjects.kt") - public void testRedeclarationsInObjects() throws Exception { - runTest("compiler/testData/diagnostics/tests/redeclarations/RedeclarationsInObjects.kt"); - } - - @Test - @TestMetadata("RedeclaredTypeParameters.kt") - public void testRedeclaredTypeParameters() throws Exception { - runTest("compiler/testData/diagnostics/tests/redeclarations/RedeclaredTypeParameters.kt"); - } - - @Test - @TestMetadata("RedeclaringPrivateToFile.kt") - public void testRedeclaringPrivateToFile() throws Exception { - runTest("compiler/testData/diagnostics/tests/redeclarations/RedeclaringPrivateToFile.kt"); - } - - @Test - @TestMetadata("ScriptAndClassConflict.kts") - public void testScriptAndClassConflict() throws Exception { - runTest("compiler/testData/diagnostics/tests/redeclarations/ScriptAndClassConflict.kts"); - } - - @Test - @TestMetadata("SingletonAndFunctionSameName.kt") - public void testSingletonAndFunctionSameName() throws Exception { - runTest("compiler/testData/diagnostics/tests/redeclarations/SingletonAndFunctionSameName.kt"); - } - - @Test - @TestMetadata("TopLevelPropertyVsClassifier.kt") - public void testTopLevelPropertyVsClassifier() throws Exception { - runTest("compiler/testData/diagnostics/tests/redeclarations/TopLevelPropertyVsClassifier.kt"); - } - - @Test - @TestMetadata("TypeAliasCtorVsFun.kt") - public void testTypeAliasCtorVsFun() throws Exception { - runTest("compiler/testData/diagnostics/tests/redeclarations/TypeAliasCtorVsFun.kt"); - } - - @Test - @TestMetadata("TypeAliasVsClass.kt") - public void testTypeAliasVsClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/redeclarations/TypeAliasVsClass.kt"); - } - - @Test - @TestMetadata("TypeAliasVsProperty.kt") - public void testTypeAliasVsProperty() throws Exception { - runTest("compiler/testData/diagnostics/tests/redeclarations/TypeAliasVsProperty.kt"); - } - - @Test - @TestMetadata("typeParameterWithTwoBounds.kt") - public void testTypeParameterWithTwoBounds() throws Exception { - runTest("compiler/testData/diagnostics/tests/redeclarations/typeParameterWithTwoBounds.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension") - @TestDataPath("$PROJECT_ROOT") - public class ShadowedExtension extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInShadowedExtension() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("extensionFunShadowedByInnerClassConstructor.kt") - public void testExtensionFunShadowedByInnerClassConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension/extensionFunShadowedByInnerClassConstructor.kt"); - } - - @Test - @TestMetadata("extensionFunShadowedByMemberFun.kt") - public void testExtensionFunShadowedByMemberFun() throws Exception { - runTest("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension/extensionFunShadowedByMemberFun.kt"); - } - - @Test - @TestMetadata("extensionFunShadowedByMemberPropertyWithInvoke.kt") - public void testExtensionFunShadowedByMemberPropertyWithInvoke() throws Exception { - runTest("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension/extensionFunShadowedByMemberPropertyWithInvoke.kt"); - } - - @Test - @TestMetadata("extensionFunShadowedBySynthesizedMemberFun.kt") - public void testExtensionFunShadowedBySynthesizedMemberFun() throws Exception { - runTest("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension/extensionFunShadowedBySynthesizedMemberFun.kt"); - } - - @Test - @TestMetadata("extensionFunVsMemberExtensionFun.kt") - public void testExtensionFunVsMemberExtensionFun() throws Exception { - runTest("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension/extensionFunVsMemberExtensionFun.kt"); - } - - @Test - @TestMetadata("extensionOnErrorType.kt") - public void testExtensionOnErrorType() throws Exception { - runTest("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension/extensionOnErrorType.kt"); - } - - @Test - @TestMetadata("extensionOnNullableReceiver.kt") - public void testExtensionOnNullableReceiver() throws Exception { - runTest("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension/extensionOnNullableReceiver.kt"); - } - - @Test - @TestMetadata("extensionPropertyShadowedByMemberProperty.kt") - public void testExtensionPropertyShadowedByMemberProperty() throws Exception { - runTest("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension/extensionPropertyShadowedByMemberProperty.kt"); - } - - @Test - @TestMetadata("extensionShadowedByDelegatedMember.kt") - public void testExtensionShadowedByDelegatedMember() throws Exception { - runTest("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension/extensionShadowedByDelegatedMember.kt"); - } - - @Test - @TestMetadata("extensionVsNonPublicMember.kt") - public void testExtensionVsNonPublicMember() throws Exception { - runTest("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension/extensionVsNonPublicMember.kt"); - } - - @Test - @TestMetadata("infixExtensionVsNonInfixMember.kt") - public void testInfixExtensionVsNonInfixMember() throws Exception { - runTest("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension/infixExtensionVsNonInfixMember.kt"); - } - - @Test - @TestMetadata("localExtensionShadowedByMember.kt") - public void testLocalExtensionShadowedByMember() throws Exception { - runTest("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension/localExtensionShadowedByMember.kt"); - } - - @Test - @TestMetadata("memberExtensionShadowedByMember.kt") - public void testMemberExtensionShadowedByMember() throws Exception { - runTest("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension/memberExtensionShadowedByMember.kt"); - } - - @Test - @TestMetadata("operatorExtensionVsNonOperatorMember.kt") - public void testOperatorExtensionVsNonOperatorMember() throws Exception { - runTest("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension/operatorExtensionVsNonOperatorMember.kt"); - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/regressions") - @TestDataPath("$PROJECT_ROOT") - public class Regressions extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInRegressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/regressions"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("AmbiguityOnLazyTypeComputation.kt") - public void testAmbiguityOnLazyTypeComputation() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/AmbiguityOnLazyTypeComputation.kt"); - } - - @Test - @TestMetadata("AssignmentsUnderOperators.kt") - public void testAssignmentsUnderOperators() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/AssignmentsUnderOperators.kt"); - } - - @Test - @TestMetadata("CoercionToUnit.kt") - public void testCoercionToUnit() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/CoercionToUnit.kt"); - } - - @Test - @TestMetadata("correctResultSubstitutorForErrorCandidate.kt") - public void testCorrectResultSubstitutorForErrorCandidate() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/correctResultSubstitutorForErrorCandidate.kt"); - } - - @Test - @TestMetadata("delegationWithReceiver.kt") - public void testDelegationWithReceiver() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/delegationWithReceiver.kt"); - } - - @Test - @TestMetadata("DoubleDefine.kt") - public void testDoubleDefine() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/DoubleDefine.kt"); - } - - @Test - @TestMetadata("ea40964.kt") - public void testEa40964() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/ea40964.kt"); - } - - @Test - @TestMetadata("ea43298.kt") - public void testEa43298() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/ea43298.kt"); - } - - @Test - @TestMetadata("ea53340.kt") - public void testEa53340() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/ea53340.kt"); - } - - @Test - @TestMetadata("ea65509.kt") - public void testEa65509() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/ea65509.kt"); - } - - @Test - @TestMetadata("ea66984.kt") - public void testEa66984() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/ea66984.kt"); - } - - @Test - @TestMetadata("ea69735.kt") - public void testEa69735() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/ea69735.kt"); - } - - @Test - @TestMetadata("ea72837.kt") - public void testEa72837() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/ea72837.kt"); - } - - @Test - @TestMetadata("ea76264.kt") - public void testEa76264() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/ea76264.kt"); - } - - @Test - @TestMetadata("ErrorsOnIbjectExpressionsAsParameters.kt") - public void testErrorsOnIbjectExpressionsAsParameters() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/ErrorsOnIbjectExpressionsAsParameters.kt"); - } - - @Test - @TestMetadata("intchar.kt") - public void testIntchar() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/intchar.kt"); - } - - @Test - @TestMetadata("itselfAsUpperBound.kt") - public void testItselfAsUpperBound() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/itselfAsUpperBound.kt"); - } - - @Test - @TestMetadata("itselfAsUpperBoundInClass.kt") - public void testItselfAsUpperBoundInClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/itselfAsUpperBoundInClass.kt"); - } - - @Test - @TestMetadata("itselfAsUpperBoundInClassNotNull.kt") - public void testItselfAsUpperBoundInClassNotNull() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/itselfAsUpperBoundInClassNotNull.kt"); - } - - @Test - @TestMetadata("itselfAsUpperBoundLocal.kt") - public void testItselfAsUpperBoundLocal() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/itselfAsUpperBoundLocal.kt"); - } - - @Test - @TestMetadata("itselfAsUpperBoundMember.kt") - public void testItselfAsUpperBoundMember() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/itselfAsUpperBoundMember.kt"); - } - - @Test - @TestMetadata("itselfAsUpperBoundNotNull.kt") - public void testItselfAsUpperBoundNotNull() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/itselfAsUpperBoundNotNull.kt"); - } - - @Test - @TestMetadata("Jet11.kt") - public void testJet11() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/Jet11.kt"); - } - - @Test - @TestMetadata("Jet121.kt") - public void testJet121() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/Jet121.kt"); - } - - @Test - @TestMetadata("Jet124.kt") - public void testJet124() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/Jet124.kt"); - } - - @Test - @TestMetadata("Jet169.kt") - public void testJet169() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/Jet169.kt"); - } - - @Test - @TestMetadata("Jet17.kt") - public void testJet17() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/Jet17.kt"); - } - - @Test - @TestMetadata("Jet183.kt") - public void testJet183() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/Jet183.kt"); - } - - @Test - @TestMetadata("Jet183-1.kt") - public void testJet183_1() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/Jet183-1.kt"); - } - - @Test - @TestMetadata("Jet53.kt") - public void testJet53() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/Jet53.kt"); - } - - @Test - @TestMetadata("Jet67.kt") - public void testJet67() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/Jet67.kt"); - } - - @Test - @TestMetadata("Jet68.kt") - public void testJet68() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/Jet68.kt"); - } - - @Test - @TestMetadata("Jet69.kt") - public void testJet69() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/Jet69.kt"); - } - - @Test - @TestMetadata("Jet72.kt") - public void testJet72() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/Jet72.kt"); - } - - @Test - @TestMetadata("Jet81.kt") - public void testJet81() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/Jet81.kt"); - } - - @Test - @TestMetadata("kt10243.kt") - public void testKt10243() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt10243.kt"); - } - - @Test - @TestMetadata("kt10243a.kt") - public void testKt10243a() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt10243a.kt"); - } - - @Test - @TestMetadata("kt10633.kt") - public void testKt10633() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt10633.kt"); - } - - @Test - @TestMetadata("kt10824.kt") - public void testKt10824() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt10824.kt"); - } - - @Test - @TestMetadata("kt10843.kt") - public void testKt10843() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt10843.kt"); - } - - @Test - @TestMetadata("kt11979.kt") - public void testKt11979() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt11979.kt"); - } - - @Test - @TestMetadata("kt127.kt") - public void testKt127() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt127.kt"); - } - - @Test - @TestMetadata("kt128.kt") - public void testKt128() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt128.kt"); - } - - @Test - @TestMetadata("kt12898.kt") - public void testKt12898() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt12898.kt"); - } - - @Test - @TestMetadata("kt13685.kt") - public void testKt13685() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt13685.kt"); - } - - @Test - @TestMetadata("kt13954.kt") - public void testKt13954() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt13954.kt"); - } - - @Test - @TestMetadata("kt14740.kt") - public void testKt14740() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt14740.kt"); - } - - @Test - @TestMetadata("kt1489_1728.kt") - public void testKt1489_1728() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt1489_1728.kt"); - } - - @Test - @TestMetadata("kt1550.kt") - public void testKt1550() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt1550.kt"); - } - - @Test - @TestMetadata("kt16086.kt") - public void testKt16086() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt16086.kt"); - } - - @Test - @TestMetadata("kt16086_2.kt") - public void testKt16086_2() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt16086_2.kt"); - } - - @Test - @TestMetadata("kt1639-JFrame.kt") - public void testKt1639_JFrame() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt1639-JFrame.kt"); - } - - @Test - @TestMetadata("kt1647.kt") - public void testKt1647() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt1647.kt"); - } - - @Test - @TestMetadata("kt1736.kt") - public void testKt1736() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt1736.kt"); - } - - @Test - @TestMetadata("kt174.kt") - public void testKt174() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt174.kt"); - } - - @Test - @TestMetadata("kt201.kt") - public void testKt201() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt201.kt"); - } - - @Test - @TestMetadata("kt235.kt") - public void testKt235() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt235.kt"); - } - - @Test - @TestMetadata("kt2376.kt") - public void testKt2376() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt2376.kt"); - } - - @Test - @TestMetadata("kt24488.kt") - public void testKt24488() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt24488.kt"); - } - - @Test - @TestMetadata("kt251.kt") - public void testKt251() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt251.kt"); - } - - @Test - @TestMetadata("kt258.kt") - public void testKt258() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt258.kt"); - } - - @Test - @TestMetadata("kt26.kt") - public void testKt26() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt26.kt"); - } - - @Test - @TestMetadata("kt26303.kt") - public void testKt26303() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt26303.kt"); - } - - @Test - @TestMetadata("kt26-1.kt") - public void testKt26_1() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt26-1.kt"); - } - - @Test - @TestMetadata("kt2768.kt") - public void testKt2768() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt2768.kt"); - } - - @Test - @TestMetadata("kt28001.kt") - public void testKt28001() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt28001.kt"); - } - - @Test - @TestMetadata("kt282.kt") - public void testKt282() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt282.kt"); - } - - @Test - @TestMetadata("kt287.kt") - public void testKt287() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt287.kt"); - } - - @Test - @TestMetadata("kt2956.kt") - public void testKt2956() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt2956.kt"); - } - - @Test - @TestMetadata("kt302.kt") - public void testKt302() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt302.kt"); - } - - @Test - @TestMetadata("kt30245.kt") - public void testKt30245() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt30245.kt"); - } - - @Test - @TestMetadata("kt306.kt") - public void testKt306() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt306.kt"); - } - - @Test - @TestMetadata("kt307.kt") - public void testKt307() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt307.kt"); - } - - @Test - @TestMetadata("kt312.kt") - public void testKt312() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt312.kt"); - } - - @Test - @TestMetadata("kt313.kt") - public void testKt313() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt313.kt"); - } - - @Test - @TestMetadata("kt316.kt") - public void testKt316() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt316.kt"); - } - - @Test - @TestMetadata("kt31975.kt") - public void testKt31975() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt31975.kt"); - } - - @Test - @TestMetadata("kt32205.kt") - public void testKt32205() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt32205.kt"); - } - - @Test - @TestMetadata("kt32507.kt") - public void testKt32507() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt32507.kt"); - } - - @Test - @TestMetadata("kt32792.kt") - public void testKt32792() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt32792.kt"); - } - - @Test - @TestMetadata("kt328.kt") - public void testKt328() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt328.kt"); - } - - @Test - @TestMetadata("kt32836.kt") - public void testKt32836() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt32836.kt"); - } - - @Test - @TestMetadata("kt334.kt") - public void testKt334() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt334.kt"); - } - - @Test - @TestMetadata("kt335.336.kt") - public void testKt335_336() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt335.336.kt"); - } - - @Test - @TestMetadata("kt337.kt") - public void testKt337() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt337.kt"); - } - - @Test - @TestMetadata("kt352.kt") - public void testKt352() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt352.kt"); - } - - @Test - @TestMetadata("kt353.kt") - public void testKt353() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt353.kt"); - } - - @Test - @TestMetadata("kt3535.kt") - public void testKt3535() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt3535.kt"); - } - - @Test - @TestMetadata("kt35626.kt") - public void testKt35626() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt35626.kt"); - } - - @Test - @TestMetadata("kt35626small.kt") - public void testKt35626small() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt35626small.kt"); - } - - @Test - @TestMetadata("kt35668.kt") - public void testKt35668() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt35668.kt"); - } - - @Test - @TestMetadata("kt36222.kt") - public void testKt36222() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt36222.kt"); - } - - @Test - @TestMetadata("kt3647.kt") - public void testKt3647() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt3647.kt"); - } - - @Test - @TestMetadata("kt3731.kt") - public void testKt3731() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt3731.kt"); - } - - @Test - @TestMetadata("kt3810.kt") - public void testKt3810() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt3810.kt"); - } - - @Test - @TestMetadata("kt385.109.441.kt") - public void testKt385_109_441() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt385.109.441.kt"); - } - - @Test - @TestMetadata("kt394.kt") - public void testKt394() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt394.kt"); - } - - @Test - @TestMetadata("kt398.kt") - public void testKt398() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt398.kt"); - } - - @Test - @TestMetadata("kt399.kt") - public void testKt399() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt399.kt"); - } - - @Test - @TestMetadata("kt402.kt") - public void testKt402() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt402.kt"); - } - - @Test - @TestMetadata("kt41.kt") - public void testKt41() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt41.kt"); - } - - @Test - @TestMetadata("kt411.kt") - public void testKt411() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt411.kt"); - } - - @Test - @TestMetadata("kt439.kt") - public void testKt439() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt439.kt"); - } - - @Test - @TestMetadata("kt442.kt") - public void testKt442() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt442.kt"); - } - - @Test - @TestMetadata("kt443.kt") - public void testKt443() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt443.kt"); - } - - @Test - @TestMetadata("kt455.kt") - public void testKt455() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt455.kt"); - } - - @Test - @TestMetadata("kt456.kt") - public void testKt456() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt456.kt"); - } - - @Test - @TestMetadata("kt459.kt") - public void testKt459() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt459.kt"); - } - - @Test - @TestMetadata("kt469.kt") - public void testKt469() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt469.kt"); - } - - @Test - @TestMetadata("kt4693.kt") - public void testKt4693() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt4693.kt"); - } - - @Test - @TestMetadata("kt4827.kt") - public void testKt4827() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt4827.kt"); - } - - @Test - @TestMetadata("kt498.kt") - public void testKt498() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt498.kt"); - } - - @Test - @TestMetadata("kt524.kt") - public void testKt524() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt524.kt"); - } - - @Test - @TestMetadata("kt526UnresolvedReferenceInnerStatic.kt") - public void testKt526UnresolvedReferenceInnerStatic() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt526UnresolvedReferenceInnerStatic.kt"); - } - - @Test - @TestMetadata("kt5326.kt") - public void testKt5326() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt5326.kt"); - } - - @Test - @TestMetadata("kt5362.kt") - public void testKt5362() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt5362.kt"); - } - - @Test - @TestMetadata("kt549.kt") - public void testKt549() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt549.kt"); - } - - @Test - @TestMetadata("kt557.kt") - public void testKt557() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt557.kt"); - } - - @Test - @TestMetadata("kt571.kt") - public void testKt571() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt571.kt"); - } - - @Test - @TestMetadata("kt575.kt") - public void testKt575() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt575.kt"); - } - - @Test - @TestMetadata("kt58.kt") - public void testKt58() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt58.kt"); - } - - @Test - @TestMetadata("kt580.kt") - public void testKt580() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt580.kt"); - } - - @Test - @TestMetadata("kt588.kt") - public void testKt588() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt588.kt"); - } - - @Test - @TestMetadata("kt597.kt") - public void testKt597() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt597.kt"); - } - - @Test - @TestMetadata("kt600.kt") - public void testKt600() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt600.kt"); - } - - @Test - @TestMetadata("kt604.kt") - public void testKt604() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt604.kt"); - } - - @Test - @TestMetadata("kt618.kt") - public void testKt618() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt618.kt"); - } - - @Test - @TestMetadata("kt629.kt") - public void testKt629() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt629.kt"); - } - - @Test - @TestMetadata("kt630.kt") - public void testKt630() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt630.kt"); - } - - @Test - @TestMetadata("kt6508.kt") - public void testKt6508() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt6508.kt"); - } - - @Test - @TestMetadata("kt688.kt") - public void testKt688() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt688.kt"); - } - - @Test - @TestMetadata("kt691.kt") - public void testKt691() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt691.kt"); - } - - @Test - @TestMetadata("kt701.kt") - public void testKt701() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt701.kt"); - } - - @Test - @TestMetadata("kt716.kt") - public void testKt716() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt716.kt"); - } - - @Test - @TestMetadata("kt743.kt") - public void testKt743() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt743.kt"); - } - - @Test - @TestMetadata("kt750.kt") - public void testKt750() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt750.kt"); - } - - @Test - @TestMetadata("kt762.kt") - public void testKt762() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt762.kt"); - } - - @Test - @TestMetadata("kt7804.kt") - public void testKt7804() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt7804.kt"); - } - - @Test - @TestMetadata("kt847.kt") - public void testKt847() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt847.kt"); - } - - @Test - @TestMetadata("kt860.kt") - public void testKt860() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt860.kt"); - } - - @Test - @TestMetadata("kt9384.kt") - public void testKt9384() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt9384.kt"); - } - - @Test - @TestMetadata("kt9620.kt") - public void testKt9620() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt9620.kt"); - } - - @Test - @TestMetadata("kt9633.kt") - public void testKt9633() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt9633.kt"); - } - - @Test - @TestMetadata("kt9682.kt") - public void testKt9682() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt9682.kt"); - } - - @Test - @TestMetadata("kt9808.kt") - public void testKt9808() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt9808.kt"); - } - - @Test - @TestMetadata("noThis.kt") - public void testNoThis() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/noThis.kt"); - } - - @Test - @TestMetadata("OrphanStarProjection.kt") - public void testOrphanStarProjection() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/OrphanStarProjection.kt"); - } - - @Test - @TestMetadata("OutProjections.kt") - public void testOutProjections() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/OutProjections.kt"); - } - - @Test - @TestMetadata("OverrideResolution.kt") - public void testOverrideResolution() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/OverrideResolution.kt"); - } - - @Test - @TestMetadata("propertyWithExtensionTypeInvoke.kt") - public void testPropertyWithExtensionTypeInvoke() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/propertyWithExtensionTypeInvoke.kt"); - } - - @Test - @TestMetadata("resolveCollectionLiteralInsideLambda.kt") - public void testResolveCollectionLiteralInsideLambda() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/resolveCollectionLiteralInsideLambda.kt"); - } - - @Test - @TestMetadata("resolveSubclassOfList.kt") - public void testResolveSubclassOfList() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/resolveSubclassOfList.kt"); - } - - @Test - @TestMetadata("SpecififcityByReceiver.kt") - public void testSpecififcityByReceiver() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/SpecififcityByReceiver.kt"); - } - - @Test - @TestMetadata("testNestedSpecialCalls.kt") - public void testTestNestedSpecialCalls() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/testNestedSpecialCalls.kt"); - } - - @Test - @TestMetadata("TypeMismatchOnUnaryOperations.kt") - public void testTypeMismatchOnUnaryOperations() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/TypeMismatchOnUnaryOperations.kt"); - } - - @Test - @TestMetadata("TypeParameterAsASupertype.kt") - public void testTypeParameterAsASupertype() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/TypeParameterAsASupertype.kt"); - } - - @Test - @TestMetadata("UnavaliableQualifiedThis.kt") - public void testUnavaliableQualifiedThis() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/UnavaliableQualifiedThis.kt"); - } - - @Test - @TestMetadata("WrongTraceInCallResolver.kt") - public void testWrongTraceInCallResolver() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/WrongTraceInCallResolver.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/regressions/kt7585") - @TestDataPath("$PROJECT_ROOT") - public class Kt7585 extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInKt7585() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/regressions/kt7585"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("base.kt") - public void testBase() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt7585/base.kt"); - } - - @Test - @TestMetadata("java.kt") - public void testJava() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt7585/java.kt"); - } - - @Test - @TestMetadata("twoparents.kt") - public void testTwoparents() throws Exception { - runTest("compiler/testData/diagnostics/tests/regressions/kt7585/twoparents.kt"); - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/resolve") - @TestDataPath("$PROJECT_ROOT") - public class Resolve extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInResolve() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("ambiguityOnPropertiesWithTheSamePackageName.kt") - public void testAmbiguityOnPropertiesWithTheSamePackageName() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/ambiguityOnPropertiesWithTheSamePackageName.kt"); - } - - @Test - @TestMetadata("ambiguityWithTwoCorrespondingFunctionTypes.kt") - public void testAmbiguityWithTwoCorrespondingFunctionTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/ambiguityWithTwoCorrespondingFunctionTypes.kt"); - } - - @Test - @TestMetadata("anonymousObjectFromTopLevelMember.kt") - public void testAnonymousObjectFromTopLevelMember() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/anonymousObjectFromTopLevelMember.kt"); - } - - @Test - @TestMetadata("callableReferenceInCST.kt") - public void testCallableReferenceInCST() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/callableReferenceInCST.kt"); - } - - @Test - @TestMetadata("capturedTypesInLambdaParameter.kt") - public void testCapturedTypesInLambdaParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/capturedTypesInLambdaParameter.kt"); - } - - @Test - @TestMetadata("constructorVsCompanion.kt") - public void testConstructorVsCompanion() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/constructorVsCompanion.kt"); - } - - @Test - @TestMetadata("CycleInTypeArgs.kt") - public void testCycleInTypeArgs() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/CycleInTypeArgs.kt"); - } - - @Test - @TestMetadata("HiddenDeclarations.kt") - public void testHiddenDeclarations() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/HiddenDeclarations.kt"); - } - - @Test - @TestMetadata("implicitReceiverProperty.kt") - public void testImplicitReceiverProperty() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/implicitReceiverProperty.kt"); - } - - @Test - @TestMetadata("incompleteConstructorInvocation.kt") - public void testIncompleteConstructorInvocation() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/incompleteConstructorInvocation.kt"); - } - - @Test - @TestMetadata("inferenceInLinkedLambdas.kt") - public void testInferenceInLinkedLambdas() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/inferenceInLinkedLambdas.kt"); - } - - @Test - @TestMetadata("inferenceInLinkedLambdasDependentOnExpectedType.kt") - public void testInferenceInLinkedLambdasDependentOnExpectedType() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/inferenceInLinkedLambdasDependentOnExpectedType.kt"); - } - - @Test - @TestMetadata("kt36264.kt") - public void testKt36264() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/kt36264.kt"); - } - - @Test - @TestMetadata("localObject.kt") - public void testLocalObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/localObject.kt"); - } - - @Test - @TestMetadata("newLineLambda.kt") - public void testNewLineLambda() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/newLineLambda.kt"); - } - - @Test - @TestMetadata("noStopOnReceiverUnstableSmartCast.kt") - public void testNoStopOnReceiverUnstableSmartCast() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/noStopOnReceiverUnstableSmartCast.kt"); - } - - @Test - @TestMetadata("objectLiteralAsArgument.kt") - public void testObjectLiteralAsArgument() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/objectLiteralAsArgument.kt"); - } - - @Test - @TestMetadata("parameterAsDefaultValueInLocalFunction.kt") - public void testParameterAsDefaultValueInLocalFunction() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/parameterAsDefaultValueInLocalFunction.kt"); - } - - @Test - @TestMetadata("resolveAnnotatedLambdaArgument.kt") - public void testResolveAnnotatedLambdaArgument() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/resolveAnnotatedLambdaArgument.kt"); - } - - @Test - @TestMetadata("resolveTypeArgsForUnresolvedCall.kt") - public void testResolveTypeArgsForUnresolvedCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/resolveTypeArgsForUnresolvedCall.kt"); - } - - @Test - @TestMetadata("resolveWithFunctionLiteralWithId.kt") - public void testResolveWithFunctionLiteralWithId() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/resolveWithFunctionLiteralWithId.kt"); - } - - @Test - @TestMetadata("resolveWithFunctionLiterals.kt") - public void testResolveWithFunctionLiterals() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/resolveWithFunctionLiterals.kt"); - } - - @Test - @TestMetadata("resolveWithFunctionLiteralsOverload.kt") - public void testResolveWithFunctionLiteralsOverload() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/resolveWithFunctionLiteralsOverload.kt"); - } - - @Test - @TestMetadata("resolveWithGenerics.kt") - public void testResolveWithGenerics() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/resolveWithGenerics.kt"); - } - - @Test - @TestMetadata("resolveWithRedeclarationError.kt") - public void testResolveWithRedeclarationError() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/resolveWithRedeclarationError.kt"); - } - - @Test - @TestMetadata("resolveWithSpecifiedFunctionLiteralWithId.kt") - public void testResolveWithSpecifiedFunctionLiteralWithId() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/resolveWithSpecifiedFunctionLiteralWithId.kt"); - } - - @Test - @TestMetadata("resolveWithoutGenerics.kt") - public void testResolveWithoutGenerics() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/resolveWithoutGenerics.kt"); - } - - @Test - @TestMetadata("typeParameterInDefaultValueInLocalFunction.kt") - public void testTypeParameterInDefaultValueInLocalFunction() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/typeParameterInDefaultValueInLocalFunction.kt"); - } - - @Test - @TestMetadata("underscoreInCatchBlock.kt") - public void testUnderscoreInCatchBlock() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/underscoreInCatchBlock.kt"); - } - - @Test - @TestMetadata("underscoreInCatchBlockWithEnabledFeature.kt") - public void testUnderscoreInCatchBlockWithEnabledFeature() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/underscoreInCatchBlockWithEnabledFeature.kt"); - } - - @Test - @TestMetadata("wrongNumberOfTypeArguments.kt") - public void testWrongNumberOfTypeArguments() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/wrongNumberOfTypeArguments.kt"); - } - - @Test - @TestMetadata("wrongReceiver.kt") - public void testWrongReceiver() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/wrongReceiver.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/resolve/dslMarker") - @TestDataPath("$PROJECT_ROOT") - public class DslMarker extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInDslMarker() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/dslMarker"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("annotatedFunctionType.kt") - public void testAnnotatedFunctionType() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/annotatedFunctionType.kt"); - } - - @Test - @TestMetadata("annotatedFunctionType_1_4.kt") - public void testAnnotatedFunctionType_1_4() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/annotatedFunctionType_1_4.kt"); - } - - @Test - @TestMetadata("annotatedTypeArgument.kt") - public void testAnnotatedTypeArgument() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/annotatedTypeArgument.kt"); - } - - @Test - @TestMetadata("dslMarkerOnTypealias.kt") - public void testDslMarkerOnTypealias() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/dslMarkerOnTypealias.kt"); - } - - @Test - @TestMetadata("dslMarkerWithTypealiasRecursion.kt") - public void testDslMarkerWithTypealiasRecursion() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/dslMarkerWithTypealiasRecursion.kt"); - } - - @Test - @TestMetadata("inheritedMarker.kt") - public void testInheritedMarker() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/inheritedMarker.kt"); - } - - @Test - @TestMetadata("insideTopLevelExtension.kt") - public void testInsideTopLevelExtension() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/insideTopLevelExtension.kt"); - } - - @Test - @TestMetadata("insideTopLevelExtensionAnnotatedType.kt") - public void testInsideTopLevelExtensionAnnotatedType() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/insideTopLevelExtensionAnnotatedType.kt"); - } - - @Test - @TestMetadata("kt29948.kt") - public void testKt29948() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/kt29948.kt"); - } - - @Test - @TestMetadata("kt31360.kt") - public void testKt31360() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/kt31360.kt"); - } - - @Test - @TestMetadata("markedReceiverWithCapturedTypeArgument.kt") - public void testMarkedReceiverWithCapturedTypeArgument() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/markedReceiverWithCapturedTypeArgument.kt"); - } - - @Test - @TestMetadata("markersIntersection.kt") - public void testMarkersIntersection() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/markersIntersection.kt"); - } - - @Test - @TestMetadata("nestedWithSameReceiver.kt") - public void testNestedWithSameReceiver() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/nestedWithSameReceiver.kt"); - } - - @Test - @TestMetadata("properties.kt") - public void testProperties() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/properties.kt"); - } - - @Test - @TestMetadata("simpleAnnotatedClasses.kt") - public void testSimpleAnnotatedClasses() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/simpleAnnotatedClasses.kt"); - } - - @Test - @TestMetadata("simpleAnnotatedTypes.kt") - public void testSimpleAnnotatedTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/simpleAnnotatedTypes.kt"); - } - - @Test - @TestMetadata("substitutedReceiverAnnotatedClasses.kt") - public void testSubstitutedReceiverAnnotatedClasses() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/substitutedReceiverAnnotatedClasses.kt"); - } - - @Test - @TestMetadata("substitutedReceiverAnnotatedType.kt") - public void testSubstitutedReceiverAnnotatedType() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/substitutedReceiverAnnotatedType.kt"); - } - - @Test - @TestMetadata("threeImplicitReceivers.kt") - public void testThreeImplicitReceivers() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/threeImplicitReceivers.kt"); - } - - @Test - @TestMetadata("threeImplicitReceivers2.kt") - public void testThreeImplicitReceivers2() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/threeImplicitReceivers2.kt"); - } - - @Test - @TestMetadata("twoImplicitReceivers.kt") - public void testTwoImplicitReceivers() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/twoImplicitReceivers.kt"); - } - - @Test - @TestMetadata("twoLanguages.kt") - public void testTwoLanguages() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/twoLanguages.kt"); - } - - @Test - @TestMetadata("unsupportedFeature.kt") - public void testUnsupportedFeature() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/unsupportedFeature.kt"); - } - - @Test - @TestMetadata("useOfExtensions.kt") - public void testUseOfExtensions() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/useOfExtensions.kt"); - } - - @Test - @TestMetadata("usingWith.kt") - public void testUsingWith() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/usingWith.kt"); - } - - @Test - @TestMetadata("usingWithThis.kt") - public void testUsingWithThis() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/dslMarker/usingWithThis.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/resolve/invoke") - @TestDataPath("$PROJECT_ROOT") - public class Invoke extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInInvoke() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/invoke"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("extensionValueAsNonExtension.kt") - public void testExtensionValueAsNonExtension() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/invoke/extensionValueAsNonExtension.kt"); - } - - @Test - @TestMetadata("functionExpectedWhenSeveralInvokesExist.kt") - public void testFunctionExpectedWhenSeveralInvokesExist() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/invoke/functionExpectedWhenSeveralInvokesExist.kt"); - } - - @Test - @TestMetadata("implicitInvoke.kt") - public void testImplicitInvoke() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/invoke/implicitInvoke.kt"); - } - - @Test - @TestMetadata("implicitInvokeAfterSafeCall.kt") - public void testImplicitInvokeAfterSafeCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/invoke/implicitInvokeAfterSafeCall.kt"); - } - - @Test - @TestMetadata("invokeAndSmartCast.kt") - public void testInvokeAndSmartCast() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/invoke/invokeAndSmartCast.kt"); - } - - @Test - @TestMetadata("invokeAsExtension.kt") - public void testInvokeAsExtension() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/invoke/invokeAsExtension.kt"); - } - - @Test - @TestMetadata("invokeAsMember.kt") - public void testInvokeAsMember() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/invoke/invokeAsMember.kt"); - } - - @Test - @TestMetadata("invokeAsMemberExtension.kt") - public void testInvokeAsMemberExtension() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/invoke/invokeAsMemberExtension.kt"); - } - - @Test - @TestMetadata("invokeAsMemberExtensionToExplicitReceiver.kt") - public void testInvokeAsMemberExtensionToExplicitReceiver() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/invoke/invokeAsMemberExtensionToExplicitReceiver.kt"); - } - - @Test - @TestMetadata("invokeNonExtensionLambdaInContext.kt") - public void testInvokeNonExtensionLambdaInContext() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/invoke/invokeNonExtensionLambdaInContext.kt"); - } - - @Test - @TestMetadata("invokeOnVariableWithExtensionFunctionType.kt") - public void testInvokeOnVariableWithExtensionFunctionType() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/invoke/invokeOnVariableWithExtensionFunctionType.kt"); - } - - @Test - @TestMetadata("KT-4372.kt") - public void testKT_4372() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/invoke/KT-4372.kt"); - } - - @Test - @TestMetadata("kt30695.kt") - public void testKt30695() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/invoke/kt30695.kt"); - } - - @Test - @TestMetadata("kt30695_2.kt") - public void testKt30695_2() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/invoke/kt30695_2.kt"); - } - - @Test - @TestMetadata("kt3772.kt") - public void testKt3772() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/invoke/kt3772.kt"); - } - - @Test - @TestMetadata("kt3833-invokeInsideNestedClass.kt") - public void testKt3833_invokeInsideNestedClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/invoke/kt3833-invokeInsideNestedClass.kt"); - } - - @Test - @TestMetadata("kt4204-completeNestedCallsForInvoke.kt") - public void testKt4204_completeNestedCallsForInvoke() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/invoke/kt4204-completeNestedCallsForInvoke.kt"); - } - - @Test - @TestMetadata("kt4321InvokeOnEnum.kt") - public void testKt4321InvokeOnEnum() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/invoke/kt4321InvokeOnEnum.kt"); - } - - @Test - @TestMetadata("kt9517.kt") - public void testKt9517() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/invoke/kt9517.kt"); - } - - @Test - @TestMetadata("kt9805.kt") - public void testKt9805() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/invoke/kt9805.kt"); - } - - @Test - @TestMetadata("reportFunctionExpectedWhenOneInvokeExist.kt") - public void testReportFunctionExpectedWhenOneInvokeExist() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/invoke/reportFunctionExpectedWhenOneInvokeExist.kt"); - } - - @Test - @TestMetadata("valNamedInvoke.kt") - public void testValNamedInvoke() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/invoke/valNamedInvoke.kt"); - } - - @Test - @TestMetadata("wrongInvokeExtension.kt") - public void testWrongInvokeExtension() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/invoke/wrongInvokeExtension.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/resolve/invoke/errors") - @TestDataPath("$PROJECT_ROOT") - public class Errors extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInErrors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/invoke/errors"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("ambiguityForInvoke.kt") - public void testAmbiguityForInvoke() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/invoke/errors/ambiguityForInvoke.kt"); - } - - @Test - @TestMetadata("invisibleInvoke.kt") - public void testInvisibleInvoke() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/invoke/errors/invisibleInvoke.kt"); - } - - @Test - @TestMetadata("receiverPresenceErrorForInvoke.kt") - public void testReceiverPresenceErrorForInvoke() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/invoke/errors/receiverPresenceErrorForInvoke.kt"); - } - - @Test - @TestMetadata("typeInferenceErrorForInvoke.kt") - public void testTypeInferenceErrorForInvoke() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/invoke/errors/typeInferenceErrorForInvoke.kt"); - } - - @Test - @TestMetadata("unresolvedInvoke.kt") - public void testUnresolvedInvoke() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/invoke/errors/unresolvedInvoke.kt"); - } - - @Test - @TestMetadata("unsafeCallWithInvoke.kt") - public void testUnsafeCallWithInvoke() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/invoke/errors/unsafeCallWithInvoke.kt"); - } - - @Test - @TestMetadata("wrongReceiverForInvokeOnExpression.kt") - public void testWrongReceiverForInvokeOnExpression() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/invoke/errors/wrongReceiverForInvokeOnExpression.kt"); - } - - @Test - @TestMetadata("wrongReceiverTypeForInvoke.kt") - public void testWrongReceiverTypeForInvoke() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/invoke/errors/wrongReceiverTypeForInvoke.kt"); - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/resolve/nestedCalls") - @TestDataPath("$PROJECT_ROOT") - public class NestedCalls extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInNestedCalls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/nestedCalls"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("analyzeArgsInFreeExpressionPosition.kt") - public void testAnalyzeArgsInFreeExpressionPosition() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/nestedCalls/analyzeArgsInFreeExpressionPosition.kt"); - } - - @Test - @TestMetadata("analyzeUnmappedArguments.kt") - public void testAnalyzeUnmappedArguments() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/nestedCalls/analyzeUnmappedArguments.kt"); - } - - @Test - @TestMetadata("argumentsInParentheses.kt") - public void testArgumentsInParentheses() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/nestedCalls/argumentsInParentheses.kt"); - } - - @Test - @TestMetadata("completeTypeInferenceForNestedInNoneApplicable.kt") - public void testCompleteTypeInferenceForNestedInNoneApplicable() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/nestedCalls/completeTypeInferenceForNestedInNoneApplicable.kt"); - } - - @Test - @TestMetadata("completeUnmappedArguments.kt") - public void testCompleteUnmappedArguments() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/nestedCalls/completeUnmappedArguments.kt"); - } - - @Test - @TestMetadata("kt5971NestedSafeCall.kt") - public void testKt5971NestedSafeCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/nestedCalls/kt5971NestedSafeCall.kt"); - } - - @Test - @TestMetadata("kt7597.kt") - public void testKt7597() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/nestedCalls/kt7597.kt"); - } - - @Test - @TestMetadata("manyInapplicableCandidatesWithLambdas.kt") - public void testManyInapplicableCandidatesWithLambdas() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/nestedCalls/manyInapplicableCandidatesWithLambdas.kt"); - } - - @Test - @TestMetadata("twoTypeParameters.kt") - public void testTwoTypeParameters() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/nestedCalls/twoTypeParameters.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/resolve/noCandidates") - @TestDataPath("$PROJECT_ROOT") - public class NoCandidates extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInNoCandidates() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/noCandidates"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("kt2787.kt") - public void testKt2787() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/noCandidates/kt2787.kt"); - } - - @Test - @TestMetadata("resolvedToClassifier.kt") - public void testResolvedToClassifier() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/noCandidates/resolvedToClassifier.kt"); - } - - @Test - @TestMetadata("resolvedToClassifierWithReceiver.kt") - public void testResolvedToClassifierWithReceiver() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/noCandidates/resolvedToClassifierWithReceiver.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/resolve/overloadConflicts") - @TestDataPath("$PROJECT_ROOT") - public class OverloadConflicts extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInOverloadConflicts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/overloadConflicts"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("allLambdas.kt") - public void testAllLambdas() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/overloadConflicts/allLambdas.kt"); - } - - @Test - @TestMetadata("extensionReceiverAndVarargs.kt") - public void testExtensionReceiverAndVarargs() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/overloadConflicts/extensionReceiverAndVarargs.kt"); - } - - @Test - @TestMetadata("genericClash.kt") - public void testGenericClash() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/overloadConflicts/genericClash.kt"); - } - - @Test - @TestMetadata("genericWithProjection.kt") - public void testGenericWithProjection() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/overloadConflicts/genericWithProjection.kt"); - } - - @Test - @TestMetadata("kt10472.kt") - public void testKt10472() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt10472.kt"); - } - - @Test - @TestMetadata("kt10640.kt") - public void testKt10640() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt10640.kt"); - } - - @Test - @TestMetadata("kt31670.kt") - public void testKt31670() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt31670.kt"); - } - - @Test - @TestMetadata("kt31670_compat.kt") - public void testKt31670_compat() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt31670_compat.kt"); - } - - @Test - @TestMetadata("kt31758.kt") - public void testKt31758() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt31758.kt"); - } - - @Test - @TestMetadata("kt31758_compat.kt") - public void testKt31758_compat() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt31758_compat.kt"); - } - - @Test - @TestMetadata("kt37692.kt") - public void testKt37692() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt37692.kt"); - } - - @Test - @TestMetadata("numberOfDefaults.kt") - public void testNumberOfDefaults() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/overloadConflicts/numberOfDefaults.kt"); - } - - @Test - @TestMetadata("originalExamples.kt") - public void testOriginalExamples() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/overloadConflicts/originalExamples.kt"); - } - - @Test - @TestMetadata("overloadResolutionOnNullableContravariantParameter.kt") - public void testOverloadResolutionOnNullableContravariantParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/overloadConflicts/overloadResolutionOnNullableContravariantParameter.kt"); - } - - @Test - @TestMetadata("overloadResolutionOnNullableContravariantParameter_compat.kt") - public void testOverloadResolutionOnNullableContravariantParameter_compat() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/overloadConflicts/overloadResolutionOnNullableContravariantParameter_compat.kt"); - } - - @Test - @TestMetadata("varargWithMoreSpecificSignature.kt") - public void testVarargWithMoreSpecificSignature() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/overloadConflicts/varargWithMoreSpecificSignature.kt"); - } - - @Test - @TestMetadata("varargs.kt") - public void testVarargs() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/overloadConflicts/varargs.kt"); - } - - @Test - @TestMetadata("varargsInDifferentPositions.kt") - public void testVarargsInDifferentPositions() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/overloadConflicts/varargsInDifferentPositions.kt"); - } - - @Test - @TestMetadata("varargsMixed.kt") - public void testVarargsMixed() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/overloadConflicts/varargsMixed.kt"); - } - - @Test - @TestMetadata("varargsWithRecursiveGenerics.kt") - public void testVarargsWithRecursiveGenerics() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/overloadConflicts/varargsWithRecursiveGenerics.kt"); - } - - @Test - @TestMetadata("withVariance.kt") - public void testWithVariance() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/overloadConflicts/withVariance.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/resolve/priority") - @TestDataPath("$PROJECT_ROOT") - public class Priority extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInPriority() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/priority"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("invokeExtensionVsOther.kt") - public void testInvokeExtensionVsOther() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/priority/invokeExtensionVsOther.kt"); - } - - @Test - @TestMetadata("invokeExtensionVsOther2.kt") - public void testInvokeExtensionVsOther2() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/priority/invokeExtensionVsOther2.kt"); - } - - @Test - @TestMetadata("kt10219.kt") - public void testKt10219() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/priority/kt10219.kt"); - } - - @Test - @TestMetadata("kt10510.kt") - public void testKt10510() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/priority/kt10510.kt"); - } - - @Test - @TestMetadata("kt9810.kt") - public void testKt9810() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/priority/kt9810.kt"); - } - - @Test - @TestMetadata("kt9965.kt") - public void testKt9965() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/priority/kt9965.kt"); - } - - @Test - @TestMetadata("localExtVsNonLocalExt.kt") - public void testLocalExtVsNonLocalExt() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/priority/localExtVsNonLocalExt.kt"); - } - - @Test - @TestMetadata("memberVsLocalExt.kt") - public void testMemberVsLocalExt() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/priority/memberVsLocalExt.kt"); - } - - @Test - @TestMetadata("staticVsImplicitReceiverMember.kt") - public void testStaticVsImplicitReceiverMember() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/priority/staticVsImplicitReceiverMember.kt"); - } - - @Test - @TestMetadata("synthesizedMembersVsExtension.kt") - public void testSynthesizedMembersVsExtension() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/priority/synthesizedMembersVsExtension.kt"); - } - - @Test - @TestMetadata("syntheticPropertiesVsExtensions.kt") - public void testSyntheticPropertiesVsExtensions() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/priority/syntheticPropertiesVsExtensions.kt"); - } - - @Test - @TestMetadata("syntheticPropertiesVsMembers.kt") - public void testSyntheticPropertiesVsMembers() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/priority/syntheticPropertiesVsMembers.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/resolve/specialConstructions") - @TestDataPath("$PROJECT_ROOT") - public class SpecialConstructions extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInSpecialConstructions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/specialConstructions"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("constantsInIf.kt") - public void testConstantsInIf() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/specialConstructions/constantsInIf.kt"); - } - - @Test - @TestMetadata("elvisAsCall.kt") - public void testElvisAsCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/specialConstructions/elvisAsCall.kt"); - } - - @Test - @TestMetadata("exclExclAsCall.kt") - public void testExclExclAsCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/specialConstructions/exclExclAsCall.kt"); - } - - @Test - @TestMetadata("inferenceForElvis.kt") - public void testInferenceForElvis() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/specialConstructions/inferenceForElvis.kt"); - } - - @Test - @TestMetadata("multipleSuperClasses.kt") - public void testMultipleSuperClasses() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/specialConstructions/multipleSuperClasses.kt"); - } - - @Test - @TestMetadata("reportTypeMismatchDeeplyOnBranches.kt") - public void testReportTypeMismatchDeeplyOnBranches() throws Exception { - runTest("compiler/testData/diagnostics/tests/resolve/specialConstructions/reportTypeMismatchDeeplyOnBranches.kt"); - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/samConversions") - @TestDataPath("$PROJECT_ROOT") - public class SamConversions extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInSamConversions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/samConversions"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("arrayAsVarargAfterSamArgument.kt") - public void testArrayAsVarargAfterSamArgument() throws Exception { - runTest("compiler/testData/diagnostics/tests/samConversions/arrayAsVarargAfterSamArgument.kt"); - } - - @Test - @TestMetadata("arrayAsVarargAfterSamArgumentProhibited.kt") - public void testArrayAsVarargAfterSamArgumentProhibited() throws Exception { - runTest("compiler/testData/diagnostics/tests/samConversions/arrayAsVarargAfterSamArgumentProhibited.kt"); - } - - @Test - @TestMetadata("arrayAsVarargAfterSamArgumentWithoutSamConversionsPerArgument.kt") - public void testArrayAsVarargAfterSamArgumentWithoutSamConversionsPerArgument() throws Exception { - runTest("compiler/testData/diagnostics/tests/samConversions/arrayAsVarargAfterSamArgumentWithoutSamConversionsPerArgument.kt"); - } - - @Test - @TestMetadata("checkSamConversionsAreDisabledByDefault.kt") - public void testCheckSamConversionsAreDisabledByDefault() throws Exception { - runTest("compiler/testData/diagnostics/tests/samConversions/checkSamConversionsAreDisabledByDefault.kt"); - } - - @Test - @TestMetadata("conversionOnLambdaAsLastExpression.kt") - public void testConversionOnLambdaAsLastExpression() throws Exception { - runTest("compiler/testData/diagnostics/tests/samConversions/conversionOnLambdaAsLastExpression.kt"); - } - - @Test - @TestMetadata("DisabledForKTSimple.kt") - public void testDisabledForKTSimple() throws Exception { - runTest("compiler/testData/diagnostics/tests/samConversions/DisabledForKTSimple.kt"); - } - - @Test - @TestMetadata("GenericSubstitution.kt") - public void testGenericSubstitution() throws Exception { - runTest("compiler/testData/diagnostics/tests/samConversions/GenericSubstitution.kt"); - } - - @Test - @TestMetadata("GenericSubstitutionKT.kt") - public void testGenericSubstitutionKT() throws Exception { - runTest("compiler/testData/diagnostics/tests/samConversions/GenericSubstitutionKT.kt"); - } - - @Test - @TestMetadata("javaMemberAgainstExtension.kt") - public void testJavaMemberAgainstExtension() throws Exception { - runTest("compiler/testData/diagnostics/tests/samConversions/javaMemberAgainstExtension.kt"); - } - - @Test - @TestMetadata("OverloadPriority.kt") - public void testOverloadPriority() throws Exception { - runTest("compiler/testData/diagnostics/tests/samConversions/OverloadPriority.kt"); - } - - @Test - @TestMetadata("OverloadPriorityKT.kt") - public void testOverloadPriorityKT() throws Exception { - runTest("compiler/testData/diagnostics/tests/samConversions/OverloadPriorityKT.kt"); - } - - @Test - @TestMetadata("SAMAfterSubstitution.kt") - public void testSAMAfterSubstitution() throws Exception { - runTest("compiler/testData/diagnostics/tests/samConversions/SAMAfterSubstitution.kt"); - } - - @Test - @TestMetadata("SAMAfterSubstitutionKT.kt") - public void testSAMAfterSubstitutionKT() throws Exception { - runTest("compiler/testData/diagnostics/tests/samConversions/SAMAfterSubstitutionKT.kt"); - } - - @Test - @TestMetadata("samConversionToGeneric.kt") - public void testSamConversionToGeneric() throws Exception { - runTest("compiler/testData/diagnostics/tests/samConversions/samConversionToGeneric.kt"); - } - - @Test - @TestMetadata("samConversionsWithSmartCasts.kt") - public void testSamConversionsWithSmartCasts() throws Exception { - runTest("compiler/testData/diagnostics/tests/samConversions/samConversionsWithSmartCasts.kt"); - } - - @Test - @TestMetadata("sameCandidatesFromKotlinAndJavaInOneScope.kt") - public void testSameCandidatesFromKotlinAndJavaInOneScope() throws Exception { - runTest("compiler/testData/diagnostics/tests/samConversions/sameCandidatesFromKotlinAndJavaInOneScope.kt"); - } - - @Test - @TestMetadata("SimpleCorrect.kt") - public void testSimpleCorrect() throws Exception { - runTest("compiler/testData/diagnostics/tests/samConversions/SimpleCorrect.kt"); - } - - @Test - @TestMetadata("SimpleCorrectKT.kt") - public void testSimpleCorrectKT() throws Exception { - runTest("compiler/testData/diagnostics/tests/samConversions/SimpleCorrectKT.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/scopes") - @TestDataPath("$PROJECT_ROOT") - public class Scopes extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInScopes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/scopes"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("AmbiguityBetweenRootAndPackage.kt") - public void testAmbiguityBetweenRootAndPackage() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/AmbiguityBetweenRootAndPackage.kt"); - } - - @Test - @TestMetadata("AmbiguousNonExtensions.kt") - public void testAmbiguousNonExtensions() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/AmbiguousNonExtensions.kt"); - } - - @Test - @TestMetadata("genericVsNested.kt") - public void testGenericVsNested() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/genericVsNested.kt"); - } - - @Test - @TestMetadata("implicitReceiverMemberVsParameter.kt") - public void testImplicitReceiverMemberVsParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/implicitReceiverMemberVsParameter.kt"); - } - - @Test - @TestMetadata("initializerScopeOfExtensionProperty.kt") - public void testInitializerScopeOfExtensionProperty() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/initializerScopeOfExtensionProperty.kt"); - } - - @Test - @TestMetadata("invisibleSetter.kt") - public void testInvisibleSetter() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/invisibleSetter.kt"); - } - - @Test - @TestMetadata("kt1078.kt") - public void testKt1078() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/kt1078.kt"); - } - - @Test - @TestMetadata("kt1080.kt") - public void testKt1080() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/kt1080.kt"); - } - - @Test - @TestMetadata("kt1244.kt") - public void testKt1244() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/kt1244.kt"); - } - - @Test - @TestMetadata("kt1248.kt") - public void testKt1248() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/kt1248.kt"); - } - - @Test - @TestMetadata("kt151.kt") - public void testKt151() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/kt151.kt"); - } - - @Test - @TestMetadata("kt1579.kt") - public void testKt1579() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/kt1579.kt"); - } - - @Test - @TestMetadata("kt1579_map_entry.kt") - public void testKt1579_map_entry() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/kt1579_map_entry.kt"); - } - - @Test - @TestMetadata("kt1580.kt") - public void testKt1580() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/kt1580.kt"); - } - - @Test - @TestMetadata("kt1642.kt") - public void testKt1642() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/kt1642.kt"); - } - - @Test - @TestMetadata("kt1738.kt") - public void testKt1738() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/kt1738.kt"); - } - - @Test - @TestMetadata("kt1805.kt") - public void testKt1805() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/kt1805.kt"); - } - - @Test - @TestMetadata("kt1806.kt") - public void testKt1806() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/kt1806.kt"); - } - - @Test - @TestMetadata("kt1822.kt") - public void testKt1822() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/kt1822.kt"); - } - - @Test - @TestMetadata("kt1942.kt") - public void testKt1942() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/kt1942.kt"); - } - - @Test - @TestMetadata("kt2262.kt") - public void testKt2262() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/kt2262.kt"); - } - - @Test - @TestMetadata("kt250.617.10.kt") - public void testKt250_617_10() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/kt250.617.10.kt"); - } - - @Test - @TestMetadata("kt323.kt") - public void testKt323() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/kt323.kt"); - } - - @Test - @TestMetadata("kt37.kt") - public void testKt37() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/kt37.kt"); - } - - @Test - @TestMetadata("kt587.kt") - public void testKt587() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/kt587.kt"); - } - - @Test - @TestMetadata("kt900.kt") - public void testKt900() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/kt900.kt"); - } - - @Test - @TestMetadata("kt900-1.kt") - public void testKt900_1() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/kt900-1.kt"); - } - - @Test - @TestMetadata("kt900-2.kt") - public void testKt900_2() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/kt900-2.kt"); - } - - @Test - @TestMetadata("kt939.kt") - public void testKt939() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/kt939.kt"); - } - - @Test - @TestMetadata("kt9430.kt") - public void testKt9430() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/kt9430.kt"); - } - - @Test - @TestMetadata("NoAmbiguityBetweenRootAndPackage.kt") - public void testNoAmbiguityBetweenRootAndPackage() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/NoAmbiguityBetweenRootAndPackage.kt"); - } - - @Test - @TestMetadata("sameClassNameResolve.kt") - public void testSameClassNameResolve() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/sameClassNameResolve.kt"); - } - - @Test - @TestMetadata("stopResolutionOnAmbiguity.kt") - public void testStopResolutionOnAmbiguity() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/stopResolutionOnAmbiguity.kt"); - } - - @Test - @TestMetadata("visibility.kt") - public void testVisibility() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/visibility.kt"); - } - - @Test - @TestMetadata("visibility2.kt") - public void testVisibility2() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/visibility2.kt"); - } - - @Test - @TestMetadata("visibility3.kt") - public void testVisibility3() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/visibility3.kt"); - } - - @Test - @TestMetadata("VisibilityInClassObject.kt") - public void testVisibilityInClassObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/VisibilityInClassObject.kt"); - } - - @Test - @TestMetadata("VisibilityInheritModifier.kt") - public void testVisibilityInheritModifier() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/VisibilityInheritModifier.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/scopes/classHeader") - @TestDataPath("$PROJECT_ROOT") - public class ClassHeader extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInClassHeader() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/scopes/classHeader"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("annotationOnClass.kt") - public void testAnnotationOnClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/classHeader/annotationOnClass.kt"); - } - - @Test - @TestMetadata("annotationOnConstructors.kt") - public void testAnnotationOnConstructors() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/classHeader/annotationOnConstructors.kt"); - } - - @Test - @TestMetadata("classGenericParameters.kt") - public void testClassGenericParameters() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/classHeader/classGenericParameters.kt"); - } - - @Test - @TestMetadata("classParents.kt") - public void testClassParents() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/classHeader/classParents.kt"); - } - - @Test - @TestMetadata("companionObjectParents.kt") - public void testCompanionObjectParents() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/classHeader/companionObjectParents.kt"); - } - - @Test - @TestMetadata("companionObjectSuperConstructorArguments.kt") - public void testCompanionObjectSuperConstructorArguments() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/classHeader/companionObjectSuperConstructorArguments.kt"); - } - - @Test - @TestMetadata("constructors.kt") - public void testConstructors() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/classHeader/constructors.kt"); - } - - @Test - @TestMetadata("delegation.kt") - public void testDelegation() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/classHeader/delegation.kt"); - } - - @Test - @TestMetadata("objectParents.kt") - public void testObjectParents() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/classHeader/objectParents.kt"); - } - - @Test - @TestMetadata("objectSuperConstructorArguments.kt") - public void testObjectSuperConstructorArguments() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/classHeader/objectSuperConstructorArguments.kt"); - } - - @Test - @TestMetadata("simpleDelegation.kt") - public void testSimpleDelegation() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/classHeader/simpleDelegation.kt"); - } - - @Test - @TestMetadata("superConstructorArguments.kt") - public void testSuperConstructorArguments() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/classHeader/superConstructorArguments.kt"); - } - - @Test - @TestMetadata("superConstructorArgumentsInSecondaryConstructor.kt") - public void testSuperConstructorArgumentsInSecondaryConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/classHeader/superConstructorArgumentsInSecondaryConstructor.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/scopes/inheritance") - @TestDataPath("$PROJECT_ROOT") - public class Inheritance extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInInheritance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/scopes/inheritance"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("companionObject.kt") - public void testCompanionObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/inheritance/companionObject.kt"); - } - - @Test - @TestMetadata("companionObjectAfterJava.kt") - public void testCompanionObjectAfterJava() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/inheritance/companionObjectAfterJava.kt"); - } - - @Test - @TestMetadata("companionObjectsOrder.kt") - public void testCompanionObjectsOrder() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/inheritance/companionObjectsOrder.kt"); - } - - @Test - @TestMetadata("innerClasses.kt") - public void testInnerClasses() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/inheritance/innerClasses.kt"); - } - - @Test - @TestMetadata("kt3856.kt") - public void testKt3856() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/inheritance/kt3856.kt"); - } - - @Test - @TestMetadata("methodsPriority.kt") - public void testMethodsPriority() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/inheritance/methodsPriority.kt"); - } - - @Test - @TestMetadata("nestedClassesFromInterface.kt") - public void testNestedClassesFromInterface() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/inheritance/nestedClassesFromInterface.kt"); - } - - @Test - @TestMetadata("nestedCompanionClass.kt") - public void testNestedCompanionClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClass.kt"); - } - - @Test - @TestMetadata("nestedCompanionClassVsNested.kt") - public void testNestedCompanionClassVsNested() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClassVsNested.kt"); - } - - @Test - @TestMetadata("nestedCompanionClassVsNestedJava.kt") - public void testNestedCompanionClassVsNestedJava() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/inheritance/nestedCompanionClassVsNestedJava.kt"); - } - - @Test - @TestMetadata("nestedFromJava.kt") - public void testNestedFromJava() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/inheritance/nestedFromJava.kt"); - } - - @Test - @TestMetadata("nestedFromJavaAfterKotlin.kt") - public void testNestedFromJavaAfterKotlin() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/inheritance/nestedFromJavaAfterKotlin.kt"); - } - - @Test - @TestMetadata("nestedVsToplevelClass.kt") - public void testNestedVsToplevelClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/inheritance/nestedVsToplevelClass.kt"); - } - - @Test - @TestMetadata("severalCompanions.kt") - public void testSeveralCompanions() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/inheritance/severalCompanions.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/scopes/inheritance/statics") - @TestDataPath("$PROJECT_ROOT") - public class Statics extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInStatics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/scopes/inheritance/statics"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("hidePrivateByPublic.kt") - public void testHidePrivateByPublic() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/hidePrivateByPublic.kt"); - } - - @Test - @TestMetadata("jjkj.kt") - public void testJjkj() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/jjkj.kt"); - } - - @Test - @TestMetadata("kjk.kt") - public void testKjk() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/kjk.kt"); - } - - @Test - @TestMetadata("localVsStatic.kt") - public void testLocalVsStatic() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/localVsStatic.kt"); - } - - @Test - @TestMetadata("nameClash0.kt") - public void testNameClash0() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/nameClash0.kt"); - } - - @Test - @TestMetadata("nameClash1.kt") - public void testNameClash1() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/nameClash1.kt"); - } - - @Test - @TestMetadata("nameClash2.kt") - public void testNameClash2() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/nameClash2.kt"); - } - - @Test - @TestMetadata("oneInterfaceManyTimes.kt") - public void testOneInterfaceManyTimes() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/oneInterfaceManyTimes.kt"); - } - - @Test - @TestMetadata("overloadStatic.kt") - public void testOverloadStatic() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/overloadStatic.kt"); - } - - @Test - @TestMetadata("staticFunVsImport.kt") - public void testStaticFunVsImport() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticFunVsImport.kt"); - } - - @Test - @TestMetadata("staticPropertyVsImport.kt") - public void testStaticPropertyVsImport() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticPropertyVsImport.kt"); - } - - @Test - @TestMetadata("staticVsCompanion.kt") - public void testStaticVsCompanion() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticVsCompanion.kt"); - } - - @Test - @TestMetadata("staticVsMember.kt") - public void testStaticVsMember() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticVsMember.kt"); - } - - @Test - @TestMetadata("staticVsOuter.kt") - public void testStaticVsOuter() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticVsOuter.kt"); - } - - @Test - @TestMetadata("staticsFromjava.kt") - public void testStaticsFromjava() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticsFromjava.kt"); - } - - @Test - @TestMetadata("staticsFromjavaAfterKotlin.kt") - public void testStaticsFromjavaAfterKotlin() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/staticsFromjavaAfterKotlin.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject") - @TestDataPath("$PROJECT_ROOT") - public class CompanionObject extends AbstractDiagnosticUsingJavacTest { - @Test - @TestMetadata("accessToStaticMembersOfParentClassJKJ_after.kt") - public void testAccessToStaticMembersOfParentClassJKJ_after() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/accessToStaticMembersOfParentClassJKJ_after.kt"); - } - - @Test - @TestMetadata("accessToStaticMembersOfParentClassJKJ_before.kt") - public void testAccessToStaticMembersOfParentClassJKJ_before() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/accessToStaticMembersOfParentClassJKJ_before.kt"); - } - - @Test - @TestMetadata("accessToStaticMembersOfParentClass_after.kt") - public void testAccessToStaticMembersOfParentClass_after() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/accessToStaticMembersOfParentClass_after.kt"); - } - - @Test - @TestMetadata("accessToStaticMembersOfParentClass_before.kt") - public void testAccessToStaticMembersOfParentClass_before() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/accessToStaticMembersOfParentClass_before.kt"); - } - - @Test - public void testAllFilesPresentInCompanionObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("inheritFromContainingClass_after.kt") - public void testInheritFromContainingClass_after() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromContainingClass_after.kt"); - } - - @Test - @TestMetadata("inheritFromContainingClass_before.kt") - public void testInheritFromContainingClass_before() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromContainingClass_before.kt"); - } - - @Test - @TestMetadata("inheritFromJavaAfterKotlin_after.kt") - public void testInheritFromJavaAfterKotlin_after() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromJavaAfterKotlin_after.kt"); - } - - @Test - @TestMetadata("inheritFromJavaAfterKotlin_before.kt") - public void testInheritFromJavaAfterKotlin_before() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromJavaAfterKotlin_before.kt"); - } - - @Test - @TestMetadata("inheritFromJava_after.kt") - public void testInheritFromJava_after() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromJava_after.kt"); - } - - @Test - @TestMetadata("inheritFromJava_before.kt") - public void testInheritFromJava_before() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject/inheritFromJava_before.kt"); - } - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/scopes/protectedVisibility") - @TestDataPath("$PROJECT_ROOT") - public class ProtectedVisibility extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInProtectedVisibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/scopes/protectedVisibility"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("complexCompanion.kt") - public void testComplexCompanion() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/protectedVisibility/complexCompanion.kt"); - } - - @Test - @TestMetadata("constructors.kt") - public void testConstructors() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/protectedVisibility/constructors.kt"); - } - - @Test - @TestMetadata("constructorsInner.kt") - public void testConstructorsInner() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/protectedVisibility/constructorsInner.kt"); - } - - @Test - @TestMetadata("innerClassInJava.kt") - public void testInnerClassInJava() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/protectedVisibility/innerClassInJava.kt"); - } - - @Test - @TestMetadata("innerProtectedClass.kt") - public void testInnerProtectedClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/protectedVisibility/innerProtectedClass.kt"); - } - - @Test - @TestMetadata("javaInheritedInKotlin.kt") - public void testJavaInheritedInKotlin() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/protectedVisibility/javaInheritedInKotlin.kt"); - } - - @Test - @TestMetadata("kt7971.kt") - public void testKt7971() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/protectedVisibility/kt7971.kt"); - } - - @Test - @TestMetadata("nonSuperCallConstructor.kt") - public void testNonSuperCallConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/protectedVisibility/nonSuperCallConstructor.kt"); - } - - @Test - @TestMetadata("nonSuperCallConstructorJavaDifferentPackage.kt") - public void testNonSuperCallConstructorJavaDifferentPackage() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/protectedVisibility/nonSuperCallConstructorJavaDifferentPackage.kt"); - } - - @Test - @TestMetadata("nonSuperCallConstructorJavaSamePackage.kt") - public void testNonSuperCallConstructorJavaSamePackage() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/protectedVisibility/nonSuperCallConstructorJavaSamePackage.kt"); - } - - @Test - @TestMetadata("protectedCallOnSubClass.kt") - public void testProtectedCallOnSubClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/protectedVisibility/protectedCallOnSubClass.kt"); - } - - @Test - @TestMetadata("smartcastOnExtensionReceiver.kt") - public void testSmartcastOnExtensionReceiver() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/protectedVisibility/smartcastOnExtensionReceiver.kt"); - } - - @Test - @TestMetadata("syntheticPropertyExtensions.kt") - public void testSyntheticPropertyExtensions() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/protectedVisibility/syntheticPropertyExtensions.kt"); - } - - @Test - @TestMetadata("syntheticSAMExtensions.kt") - public void testSyntheticSAMExtensions() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/protectedVisibility/syntheticSAMExtensions.kt"); - } - - @Test - @TestMetadata("unstableSmartCast.kt") - public void testUnstableSmartCast() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/protectedVisibility/unstableSmartCast.kt"); - } - - @Test - @TestMetadata("withSmartcast.kt") - public void testWithSmartcast() throws Exception { - runTest("compiler/testData/diagnostics/tests/scopes/protectedVisibility/withSmartcast.kt"); - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/script") - @TestDataPath("$PROJECT_ROOT") - public class Script extends AbstractDiagnosticUsingJavacTest { - @Test - @TestMetadata("AccessForwardDeclarationInScript.kts") - public void testAccessForwardDeclarationInScript() throws Exception { - runTest("compiler/testData/diagnostics/tests/script/AccessForwardDeclarationInScript.kts"); - } - - @Test - public void testAllFilesPresentInScript() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/script"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("ComplexScript.kts") - public void testComplexScript() throws Exception { - runTest("compiler/testData/diagnostics/tests/script/ComplexScript.kts"); - } - - @Test - @TestMetadata("destructuringDeclarationsScript.kts") - public void testDestructuringDeclarationsScript() throws Exception { - runTest("compiler/testData/diagnostics/tests/script/destructuringDeclarationsScript.kts"); - } - - @Test - @TestMetadata("imports.kts") - public void testImports() throws Exception { - runTest("compiler/testData/diagnostics/tests/script/imports.kts"); - } - - @Test - @TestMetadata("LateInit.kts") - public void testLateInit() throws Exception { - runTest("compiler/testData/diagnostics/tests/script/LateInit.kts"); - } - - @Test - @TestMetadata("NestedInnerClass.kts") - public void testNestedInnerClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/script/NestedInnerClass.kts"); - } - - @Test - @TestMetadata("PrivateVal.kts") - public void testPrivateVal() throws Exception { - runTest("compiler/testData/diagnostics/tests/script/PrivateVal.kts"); - } - - @Test - @TestMetadata("resolveInitializerOfDestructuringDeclarationOnce.kts") - public void testResolveInitializerOfDestructuringDeclarationOnce() throws Exception { - runTest("compiler/testData/diagnostics/tests/script/resolveInitializerOfDestructuringDeclarationOnce.kts"); - } - - @Test - @TestMetadata("SimpleScript.kts") - public void testSimpleScript() throws Exception { - runTest("compiler/testData/diagnostics/tests/script/SimpleScript.kts"); - } - - @Test - @TestMetadata("topLevelPropertiesWithGetSet.kts") - public void testTopLevelPropertiesWithGetSet() throws Exception { - runTest("compiler/testData/diagnostics/tests/script/topLevelPropertiesWithGetSet.kts"); - } - - @Test - @TestMetadata("topLevelVariable.kts") - public void testTopLevelVariable() throws Exception { - runTest("compiler/testData/diagnostics/tests/script/topLevelVariable.kts"); - } - - @Test - @TestMetadata("typealiasInScript.kts") - public void testTypealiasInScript() throws Exception { - runTest("compiler/testData/diagnostics/tests/script/typealiasInScript.kts"); - } - - @Test - @TestMetadata("varInScript.kts") - public void testVarInScript() throws Exception { - runTest("compiler/testData/diagnostics/tests/script/varInScript.kts"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/sealed") - @TestDataPath("$PROJECT_ROOT") - public class Sealed extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInSealed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/sealed"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("DerivedTopLevel.kt") - public void testDerivedTopLevel() throws Exception { - runTest("compiler/testData/diagnostics/tests/sealed/DerivedTopLevel.kt"); - } - - @Test - @TestMetadata("DoubleInner.kt") - public void testDoubleInner() throws Exception { - runTest("compiler/testData/diagnostics/tests/sealed/DoubleInner.kt"); - } - - @Test - @TestMetadata("ExhaustiveOnRoot.kt") - public void testExhaustiveOnRoot() throws Exception { - runTest("compiler/testData/diagnostics/tests/sealed/ExhaustiveOnRoot.kt"); - } - - @Test - @TestMetadata("ExhaustiveOnTree.kt") - public void testExhaustiveOnTree() throws Exception { - runTest("compiler/testData/diagnostics/tests/sealed/ExhaustiveOnTree.kt"); - } - - @Test - @TestMetadata("ExhaustiveOnTriangleStar.kt") - public void testExhaustiveOnTriangleStar() throws Exception { - runTest("compiler/testData/diagnostics/tests/sealed/ExhaustiveOnTriangleStar.kt"); - } - - @Test - @TestMetadata("ExhaustiveWhen.kt") - public void testExhaustiveWhen() throws Exception { - runTest("compiler/testData/diagnostics/tests/sealed/ExhaustiveWhen.kt"); - } - - @Test - @TestMetadata("ExhaustiveWhenDoubleInner.kt") - public void testExhaustiveWhenDoubleInner() throws Exception { - runTest("compiler/testData/diagnostics/tests/sealed/ExhaustiveWhenDoubleInner.kt"); - } - - @Test - @TestMetadata("ExhaustiveWhenMultipleInner.kt") - public void testExhaustiveWhenMultipleInner() throws Exception { - runTest("compiler/testData/diagnostics/tests/sealed/ExhaustiveWhenMultipleInner.kt"); - } - - @Test - @TestMetadata("ExhaustiveWhenNegated.kt") - public void testExhaustiveWhenNegated() throws Exception { - runTest("compiler/testData/diagnostics/tests/sealed/ExhaustiveWhenNegated.kt"); - } - - @Test - @TestMetadata("ExhaustiveWhenNegatedTwice.kt") - public void testExhaustiveWhenNegatedTwice() throws Exception { - runTest("compiler/testData/diagnostics/tests/sealed/ExhaustiveWhenNegatedTwice.kt"); - } - - @Test - @TestMetadata("ExhaustiveWhenOnNestedSealed.kt") - public void testExhaustiveWhenOnNestedSealed() throws Exception { - runTest("compiler/testData/diagnostics/tests/sealed/ExhaustiveWhenOnNestedSealed.kt"); - } - - @Test - @TestMetadata("ExhaustiveWhenOnNullable.kt") - public void testExhaustiveWhenOnNullable() throws Exception { - runTest("compiler/testData/diagnostics/tests/sealed/ExhaustiveWhenOnNullable.kt"); - } - - @Test - @TestMetadata("ExhaustiveWhenWithAdditionalMember.kt") - public void testExhaustiveWhenWithAdditionalMember() throws Exception { - runTest("compiler/testData/diagnostics/tests/sealed/ExhaustiveWhenWithAdditionalMember.kt"); - } - - @Test - @TestMetadata("ExhaustiveWhenWithElse.kt") - public void testExhaustiveWhenWithElse() throws Exception { - runTest("compiler/testData/diagnostics/tests/sealed/ExhaustiveWhenWithElse.kt"); - } - - @Test - @TestMetadata("ExhaustiveWithFreedom.kt") - public void testExhaustiveWithFreedom() throws Exception { - runTest("compiler/testData/diagnostics/tests/sealed/ExhaustiveWithFreedom.kt"); - } - - @Test - @TestMetadata("inheritorInDifferentModule.kt") - public void testInheritorInDifferentModule() throws Exception { - runTest("compiler/testData/diagnostics/tests/sealed/inheritorInDifferentModule.kt"); - } - - @Test - @TestMetadata("Local.kt") - public void testLocal() throws Exception { - runTest("compiler/testData/diagnostics/tests/sealed/Local.kt"); - } - - @Test - @TestMetadata("LocalSealed.kt") - public void testLocalSealed() throws Exception { - runTest("compiler/testData/diagnostics/tests/sealed/LocalSealed.kt"); - } - - @Test - @TestMetadata("MultipleFiles_enabled.kt") - public void testMultipleFiles_enabled() throws Exception { - runTest("compiler/testData/diagnostics/tests/sealed/MultipleFiles_enabled.kt"); - } - - @Test - @TestMetadata("NestedSealed.kt") - public void testNestedSealed() throws Exception { - runTest("compiler/testData/diagnostics/tests/sealed/NestedSealed.kt"); - } - - @Test - @TestMetadata("NestedSealedWithoutRestrictions.kt") - public void testNestedSealedWithoutRestrictions() throws Exception { - runTest("compiler/testData/diagnostics/tests/sealed/NestedSealedWithoutRestrictions.kt"); - } - - @Test - @TestMetadata("NeverConstructed.kt") - public void testNeverConstructed() throws Exception { - runTest("compiler/testData/diagnostics/tests/sealed/NeverConstructed.kt"); - } - - @Test - @TestMetadata("NeverDerivedFromNested.kt") - public void testNeverDerivedFromNested() throws Exception { - runTest("compiler/testData/diagnostics/tests/sealed/NeverDerivedFromNested.kt"); - } - - @Test - @TestMetadata("NeverEnum.kt") - public void testNeverEnum() throws Exception { - runTest("compiler/testData/diagnostics/tests/sealed/NeverEnum.kt"); - } - - @Test - @TestMetadata("NeverFinal.kt") - public void testNeverFinal() throws Exception { - runTest("compiler/testData/diagnostics/tests/sealed/NeverFinal.kt"); - } - - @Test - @TestMetadata("NeverInterface.kt") - public void testNeverInterface() throws Exception { - runTest("compiler/testData/diagnostics/tests/sealed/NeverInterface.kt"); - } - - @Test - @TestMetadata("NeverObject.kt") - public void testNeverObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/sealed/NeverObject.kt"); - } - - @Test - @TestMetadata("NeverOpen.kt") - public void testNeverOpen() throws Exception { - runTest("compiler/testData/diagnostics/tests/sealed/NeverOpen.kt"); - } - - @Test - @TestMetadata("NonExhaustiveWhen.kt") - public void testNonExhaustiveWhen() throws Exception { - runTest("compiler/testData/diagnostics/tests/sealed/NonExhaustiveWhen.kt"); - } - - @Test - @TestMetadata("NonExhaustiveWhenNegated.kt") - public void testNonExhaustiveWhenNegated() throws Exception { - runTest("compiler/testData/diagnostics/tests/sealed/NonExhaustiveWhenNegated.kt"); - } - - @Test - @TestMetadata("NonExhaustiveWhenWithAdditionalCase.kt") - public void testNonExhaustiveWhenWithAdditionalCase() throws Exception { - runTest("compiler/testData/diagnostics/tests/sealed/NonExhaustiveWhenWithAdditionalCase.kt"); - } - - @Test - @TestMetadata("NonExhaustiveWhenWithAnyCase.kt") - public void testNonExhaustiveWhenWithAnyCase() throws Exception { - runTest("compiler/testData/diagnostics/tests/sealed/NonExhaustiveWhenWithAnyCase.kt"); - } - - @Test - @TestMetadata("NonPrivateConstructor.kt") - public void testNonPrivateConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/sealed/NonPrivateConstructor.kt"); - } - - @Test - @TestMetadata("NotFinal.kt") - public void testNotFinal() throws Exception { - runTest("compiler/testData/diagnostics/tests/sealed/NotFinal.kt"); - } - - @Test - @TestMetadata("OperationWhen.kt") - public void testOperationWhen() throws Exception { - runTest("compiler/testData/diagnostics/tests/sealed/OperationWhen.kt"); - } - - @Test - @TestMetadata("RedundantAbstract.kt") - public void testRedundantAbstract() throws Exception { - runTest("compiler/testData/diagnostics/tests/sealed/RedundantAbstract.kt"); - } - - @Test - @TestMetadata("TreeWhen.kt") - public void testTreeWhen() throws Exception { - runTest("compiler/testData/diagnostics/tests/sealed/TreeWhen.kt"); - } - - @Test - @TestMetadata("TreeWhenFunctional.kt") - public void testTreeWhenFunctional() throws Exception { - runTest("compiler/testData/diagnostics/tests/sealed/TreeWhenFunctional.kt"); - } - - @Test - @TestMetadata("TreeWhenFunctionalNoIs.kt") - public void testTreeWhenFunctionalNoIs() throws Exception { - runTest("compiler/testData/diagnostics/tests/sealed/TreeWhenFunctionalNoIs.kt"); - } - - @Test - @TestMetadata("WhenOnEmptySealed.kt") - public void testWhenOnEmptySealed() throws Exception { - runTest("compiler/testData/diagnostics/tests/sealed/WhenOnEmptySealed.kt"); - } - - @Test - @TestMetadata("WithInterface.kt") - public void testWithInterface() throws Exception { - runTest("compiler/testData/diagnostics/tests/sealed/WithInterface.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/sealed/interfaces") - @TestDataPath("$PROJECT_ROOT") - public class Interfaces extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInInterfaces() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/sealed/interfaces"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("inheritorInDifferentModule.kt") - public void testInheritorInDifferentModule() throws Exception { - runTest("compiler/testData/diagnostics/tests/sealed/interfaces/inheritorInDifferentModule.kt"); - } - - @Test - @TestMetadata("sealedInterfacesDisabled.kt") - public void testSealedInterfacesDisabled() throws Exception { - runTest("compiler/testData/diagnostics/tests/sealed/interfaces/sealedInterfacesDisabled.kt"); - } - - @Test - @TestMetadata("simpleSealedInterface.kt") - public void testSimpleSealedInterface() throws Exception { - runTest("compiler/testData/diagnostics/tests/sealed/interfaces/simpleSealedInterface.kt"); - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/secondaryConstructors") - @TestDataPath("$PROJECT_ROOT") - public class SecondaryConstructors extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInSecondaryConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/secondaryConstructors"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("argumentsResolveInBodyAndDelegationCall.kt") - public void testArgumentsResolveInBodyAndDelegationCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/argumentsResolveInBodyAndDelegationCall.kt"); - } - - @Test - @TestMetadata("classInitializersWithoutPrimary.kt") - public void testClassInitializersWithoutPrimary() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/classInitializersWithoutPrimary.kt"); - } - - @Test - @TestMetadata("companionObjectScope.kt") - public void testCompanionObjectScope() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/companionObjectScope.kt"); - } - - @Test - @TestMetadata("constructorCallType.kt") - public void testConstructorCallType() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/constructorCallType.kt"); - } - - @Test - @TestMetadata("constructorInObject.kt") - public void testConstructorInObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/constructorInObject.kt"); - } - - @Test - @TestMetadata("constructorInTrait.kt") - public void testConstructorInTrait() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/constructorInTrait.kt"); - } - - @Test - @TestMetadata("ctrsAnnotationResolve.kt") - public void testCtrsAnnotationResolve() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/ctrsAnnotationResolve.kt"); - } - - @Test - @TestMetadata("cyclicDelegationCalls.kt") - public void testCyclicDelegationCalls() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/cyclicDelegationCalls.kt"); - } - - @Test - @TestMetadata("dataClasses.kt") - public void testDataClasses() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/dataClasses.kt"); - } - - @Test - @TestMetadata("dataFlowInDelegationCall.kt") - public void testDataFlowInDelegationCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/dataFlowInDelegationCall.kt"); - } - - @Test - @TestMetadata("delegationByWithoutPrimary.kt") - public void testDelegationByWithoutPrimary() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/delegationByWithoutPrimary.kt"); - } - - @Test - @TestMetadata("enums.kt") - public void testEnums() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/enums.kt"); - } - - @Test - @TestMetadata("errorsOnEmptyDelegationCall.kt") - public void testErrorsOnEmptyDelegationCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/errorsOnEmptyDelegationCall.kt"); - } - - @Test - @TestMetadata("expectedPrimaryConstructorCall.kt") - public void testExpectedPrimaryConstructorCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/expectedPrimaryConstructorCall.kt"); - } - - @Test - @TestMetadata("generics.kt") - public void testGenerics() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/generics.kt"); - } - - @Test - @TestMetadata("generics2.kt") - public void testGenerics2() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/generics2.kt"); - } - - @Test - @TestMetadata("generics3.kt") - public void testGenerics3() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/generics3.kt"); - } - - @Test - @TestMetadata("headerSupertypeInitialization.kt") - public void testHeaderSupertypeInitialization() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/headerSupertypeInitialization.kt"); - } - - @Test - @TestMetadata("implicitSuperCallErrorsIfPrimary.kt") - public void testImplicitSuperCallErrorsIfPrimary() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/implicitSuperCallErrorsIfPrimary.kt"); - } - - @Test - @TestMetadata("initializationFromOtherInstance.kt") - public void testInitializationFromOtherInstance() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/initializationFromOtherInstance.kt"); - } - - @Test - @TestMetadata("kt6992.kt") - public void testKt6992() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/kt6992.kt"); - } - - @Test - @TestMetadata("kt6993.kt") - public void testKt6993() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/kt6993.kt"); - } - - @Test - @TestMetadata("kt6994.kt") - public void testKt6994() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/kt6994.kt"); - } - - @Test - @TestMetadata("lambdaInDelegation.kt") - public void testLambdaInDelegation() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/lambdaInDelegation.kt"); - } - - @Test - @TestMetadata("nestedExtendsInner.kt") - public void testNestedExtendsInner() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/nestedExtendsInner.kt"); - } - - @Test - @TestMetadata("noDefaultIfEmptySecondary.kt") - public void testNoDefaultIfEmptySecondary() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/noDefaultIfEmptySecondary.kt"); - } - - @Test - @TestMetadata("noPrimaryConstructor.kt") - public void testNoPrimaryConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/noPrimaryConstructor.kt"); - } - - @Test - @TestMetadata("noSupertypeInitWithSecondaryConstructors.kt") - public void testNoSupertypeInitWithSecondaryConstructors() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/noSupertypeInitWithSecondaryConstructors.kt"); - } - - @Test - @TestMetadata("propertyInitializationWithPrimary.kt") - public void testPropertyInitializationWithPrimary() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/propertyInitializationWithPrimary.kt"); - } - - @Test - @TestMetadata("propertyInitializationWithoutPrimary.kt") - public void testPropertyInitializationWithoutPrimary() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/propertyInitializationWithoutPrimary.kt"); - } - - @Test - @TestMetadata("redeclarations.kt") - public void testRedeclarations() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/redeclarations.kt"); - } - - @Test - @TestMetadata("redeclarationsOfConstructorsIgnored.kt") - public void testRedeclarationsOfConstructorsIgnored() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/redeclarationsOfConstructorsIgnored.kt"); - } - - @Test - @TestMetadata("reportResolutionErrorOnImplicitOnce.kt") - public void testReportResolutionErrorOnImplicitOnce() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/reportResolutionErrorOnImplicitOnce.kt"); - } - - @Test - @TestMetadata("resolvePropertyInitializerWithoutPrimary.kt") - public void testResolvePropertyInitializerWithoutPrimary() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/resolvePropertyInitializerWithoutPrimary.kt"); - } - - @Test - @TestMetadata("return.kt") - public void testReturn() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/return.kt"); - } - - @Test - @TestMetadata("superAnyNonEmpty.kt") - public void testSuperAnyNonEmpty() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/superAnyNonEmpty.kt"); - } - - @Test - @TestMetadata("superSecondaryNonExisting.kt") - public void testSuperSecondaryNonExisting() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/superSecondaryNonExisting.kt"); - } - - @Test - @TestMetadata("thisNonExisting.kt") - public void testThisNonExisting() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/thisNonExisting.kt"); - } - - @Test - @TestMetadata("unreachableCode.kt") - public void testUnreachableCode() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/unreachableCode.kt"); - } - - @Test - @TestMetadata("useOfPropertiesWithPrimary.kt") - public void testUseOfPropertiesWithPrimary() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/useOfPropertiesWithPrimary.kt"); - } - - @Test - @TestMetadata("useOfPropertiesWithoutPrimary.kt") - public void testUseOfPropertiesWithoutPrimary() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/useOfPropertiesWithoutPrimary.kt"); - } - - @Test - @TestMetadata("valOrValAndModifiersInCtr.kt") - public void testValOrValAndModifiersInCtr() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/valOrValAndModifiersInCtr.kt"); - } - - @Test - @TestMetadata("varargsInDelegationCallToPrimary.kt") - public void testVarargsInDelegationCallToPrimary() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/varargsInDelegationCallToPrimary.kt"); - } - - @Test - @TestMetadata("varargsInDelegationCallToSecondary.kt") - public void testVarargsInDelegationCallToSecondary() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/varargsInDelegationCallToSecondary.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker") - @TestDataPath("$PROJECT_ROOT") - public class HeaderCallChecker extends AbstractDiagnosticUsingJavacTest { - @Test - @TestMetadata("accessBaseGenericFromInnerExtendingSameBase.kt") - public void testAccessBaseGenericFromInnerExtendingSameBase() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/accessBaseGenericFromInnerExtendingSameBase.kt"); - } - - @Test - @TestMetadata("accessBaseGenericFromInnerExtendingSameBase2.kt") - public void testAccessBaseGenericFromInnerExtendingSameBase2() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/accessBaseGenericFromInnerExtendingSameBase2.kt"); - } - - @Test - @TestMetadata("accessBaseWithSameExtension.kt") - public void testAccessBaseWithSameExtension() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/accessBaseWithSameExtension.kt"); - } - - @Test - @TestMetadata("accessGenericBaseWithSameExtension.kt") - public void testAccessGenericBaseWithSameExtension() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/accessGenericBaseWithSameExtension.kt"); - } - - @Test - public void testAllFilesPresentInHeaderCallChecker() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("innerInstanceCreation.kt") - public void testInnerInstanceCreation() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/innerInstanceCreation.kt"); - } - - @Test - @TestMetadata("lambdaAsArgument.kt") - public void testLambdaAsArgument() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/lambdaAsArgument.kt"); - } - - @Test - @TestMetadata("memberFunAccess.kt") - public void testMemberFunAccess() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/memberFunAccess.kt"); - } - - @Test - @TestMetadata("objectLiteralAsArgument.kt") - public void testObjectLiteralAsArgument() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/objectLiteralAsArgument.kt"); - } - - @Test - @TestMetadata("objectLiteralAsDefaultValueParameter.kt") - public void testObjectLiteralAsDefaultValueParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/objectLiteralAsDefaultValueParameter.kt"); - } - - @Test - @TestMetadata("operatorCall.kt") - public void testOperatorCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/operatorCall.kt"); - } - - @Test - @TestMetadata("passingInstance.kt") - public void testPassingInstance() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/passingInstance.kt"); - } - - @Test - @TestMetadata("propertyAccess.kt") - public void testPropertyAccess() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/propertyAccess.kt"); - } - - @Test - @TestMetadata("propertyAccessUnitialized.kt") - public void testPropertyAccessUnitialized() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/propertyAccessUnitialized.kt"); - } - - @Test - @TestMetadata("superFunAccess.kt") - public void testSuperFunAccess() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/superFunAccess.kt"); - } - - @Test - @TestMetadata("superFunAccessOverriden.kt") - public void testSuperFunAccessOverriden() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/superFunAccessOverriden.kt"); - } - - @Test - @TestMetadata("superPropertyAccess.kt") - public void testSuperPropertyAccess() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/superPropertyAccess.kt"); - } - - @Test - @TestMetadata("thisAsExtensionReceiver.kt") - public void testThisAsExtensionReceiver() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/thisAsExtensionReceiver.kt"); - } - - @Test - @TestMetadata("usingOuterInstance.kt") - public void testUsingOuterInstance() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/usingOuterInstance.kt"); - } - - @Test - @TestMetadata("usingOuterProperty.kt") - public void testUsingOuterProperty() throws Exception { - runTest("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/usingOuterProperty.kt"); - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/senselessComparison") - @TestDataPath("$PROJECT_ROOT") - public class SenselessComparison extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInSenselessComparison() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/senselessComparison"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("noExplicitType.kt") - public void testNoExplicitType() throws Exception { - runTest("compiler/testData/diagnostics/tests/senselessComparison/noExplicitType.kt"); - } - - @Test - @TestMetadata("parenthesized.kt") - public void testParenthesized() throws Exception { - runTest("compiler/testData/diagnostics/tests/senselessComparison/parenthesized.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/shadowing") - @TestDataPath("$PROJECT_ROOT") - public class Shadowing extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInShadowing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/shadowing"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("noNameShadowingForSimpleParameters.kt") - public void testNoNameShadowingForSimpleParameters() throws Exception { - runTest("compiler/testData/diagnostics/tests/shadowing/noNameShadowingForSimpleParameters.kt"); - } - - @Test - @TestMetadata("ShadowLambdaParameter.kt") - public void testShadowLambdaParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/shadowing/ShadowLambdaParameter.kt"); - } - - @Test - @TestMetadata("ShadowMultiDeclarationWithFunParameter.kt") - public void testShadowMultiDeclarationWithFunParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/shadowing/ShadowMultiDeclarationWithFunParameter.kt"); - } - - @Test - @TestMetadata("ShadowParameterInFunctionBody.kt") - public void testShadowParameterInFunctionBody() throws Exception { - runTest("compiler/testData/diagnostics/tests/shadowing/ShadowParameterInFunctionBody.kt"); - } - - @Test - @TestMetadata("ShadowParameterInNestedBlockInFor.kt") - public void testShadowParameterInNestedBlockInFor() throws Exception { - runTest("compiler/testData/diagnostics/tests/shadowing/ShadowParameterInNestedBlockInFor.kt"); - } - - @Test - @TestMetadata("ShadowPropertyInClosure.kt") - public void testShadowPropertyInClosure() throws Exception { - runTest("compiler/testData/diagnostics/tests/shadowing/ShadowPropertyInClosure.kt"); - } - - @Test - @TestMetadata("ShadowPropertyInFor.kt") - public void testShadowPropertyInFor() throws Exception { - runTest("compiler/testData/diagnostics/tests/shadowing/ShadowPropertyInFor.kt"); - } - - @Test - @TestMetadata("ShadowPropertyInFunction.kt") - public void testShadowPropertyInFunction() throws Exception { - runTest("compiler/testData/diagnostics/tests/shadowing/ShadowPropertyInFunction.kt"); - } - - @Test - @TestMetadata("ShadowVariableInFor.kt") - public void testShadowVariableInFor() throws Exception { - runTest("compiler/testData/diagnostics/tests/shadowing/ShadowVariableInFor.kt"); - } - - @Test - @TestMetadata("ShadowVariableInNestedBlock.kt") - public void testShadowVariableInNestedBlock() throws Exception { - runTest("compiler/testData/diagnostics/tests/shadowing/ShadowVariableInNestedBlock.kt"); - } - - @Test - @TestMetadata("ShadowVariableInNestedClosure.kt") - public void testShadowVariableInNestedClosure() throws Exception { - runTest("compiler/testData/diagnostics/tests/shadowing/ShadowVariableInNestedClosure.kt"); - } - - @Test - @TestMetadata("ShadowVariableInNestedClosureParam.kt") - public void testShadowVariableInNestedClosureParam() throws Exception { - runTest("compiler/testData/diagnostics/tests/shadowing/ShadowVariableInNestedClosureParam.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/smartCasts") - @TestDataPath("$PROJECT_ROOT") - public class SmartCasts extends AbstractDiagnosticUsingJavacTest { - @Test - @TestMetadata("afterBinaryExpr.kt") - public void testAfterBinaryExpr() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/afterBinaryExpr.kt"); - } - - @Test - public void testAllFilesPresentInSmartCasts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("alwaysNull.kt") - public void testAlwaysNull() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/alwaysNull.kt"); - } - - @Test - @TestMetadata("alwaysNullWithJava.kt") - public void testAlwaysNullWithJava() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/alwaysNullWithJava.kt"); - } - - @Test - @TestMetadata("classObjectMember.kt") - public void testClassObjectMember() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/classObjectMember.kt"); - } - - @Test - @TestMetadata("combineWithNoSelectorInfo.kt") - public void testCombineWithNoSelectorInfo() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/combineWithNoSelectorInfo.kt"); - } - - @Test - @TestMetadata("comparisonUnderAnd.kt") - public void testComparisonUnderAnd() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/comparisonUnderAnd.kt"); - } - - @Test - @TestMetadata("complexComparison.kt") - public void testComplexComparison() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/complexComparison.kt"); - } - - @Test - @TestMetadata("complexConditionsWithExcl.kt") - public void testComplexConditionsWithExcl() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/complexConditionsWithExcl.kt"); - } - - @Test - @TestMetadata("dataFlowInfoForArguments.kt") - public void testDataFlowInfoForArguments() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/dataFlowInfoForArguments.kt"); - } - - @Test - @TestMetadata("doubleLambdaArgument.kt") - public void testDoubleLambdaArgument() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/doubleLambdaArgument.kt"); - } - - @Test - @TestMetadata("elvisExclExcl.kt") - public void testElvisExclExcl() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/elvisExclExcl.kt"); - } - - @Test - @TestMetadata("elvisExclExclMerge.kt") - public void testElvisExclExclMerge() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/elvisExclExclMerge.kt"); - } - - @Test - @TestMetadata("elvisExclExclPlatform.kt") - public void testElvisExclExclPlatform() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/elvisExclExclPlatform.kt"); - } - - @Test - @TestMetadata("elvisExprNotNull.kt") - public void testElvisExprNotNull() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/elvisExprNotNull.kt"); - } - - @Test - @TestMetadata("elvisNothingRHS.kt") - public void testElvisNothingRHS() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/elvisNothingRHS.kt"); - } - - @Test - @TestMetadata("elvisRHS.kt") - public void testElvisRHS() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/elvisRHS.kt"); - } - - @Test - @TestMetadata("enumEntryMembers_after.kt") - public void testEnumEntryMembers_after() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/enumEntryMembers_after.kt"); - } - - @Test - @TestMetadata("enumEntryMembers_before.kt") - public void testEnumEntryMembers_before() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/enumEntryMembers_before.kt"); - } - - @Test - @TestMetadata("equals.kt") - public void testEquals() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/equals.kt"); - } - - @Test - @TestMetadata("exclUnderAnd.kt") - public void testExclUnderAnd() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/exclUnderAnd.kt"); - } - - @Test - @TestMetadata("explicitDefaultGetter.kt") - public void testExplicitDefaultGetter() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/explicitDefaultGetter.kt"); - } - - @Test - @TestMetadata("extensionSafeCall.kt") - public void testExtensionSafeCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/extensionSafeCall.kt"); - } - - @Test - @TestMetadata("fakeSmartCastOnEquality.kt") - public void testFakeSmartCastOnEquality() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/fakeSmartCastOnEquality.kt"); - } - - @Test - @TestMetadata("falseReceiverSmartCast.kt") - public void testFalseReceiverSmartCast() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/falseReceiverSmartCast.kt"); - } - - @Test - @TestMetadata("falseUnnecessaryCall.kt") - public void testFalseUnnecessaryCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/falseUnnecessaryCall.kt"); - } - - @Test - @TestMetadata("fieldExclExcl.kt") - public void testFieldExclExcl() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/fieldExclExcl.kt"); - } - - @Test - @TestMetadata("fieldInGetter.kt") - public void testFieldInGetter() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/fieldInGetter.kt"); - } - - @Test - @TestMetadata("fieldPlus.kt") - public void testFieldPlus() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/fieldPlus.kt"); - } - - @Test - @TestMetadata("genericIntersection.kt") - public void testGenericIntersection() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/genericIntersection.kt"); - } - - @Test - @TestMetadata("genericSet.kt") - public void testGenericSet() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/genericSet.kt"); - } - - @Test - @TestMetadata("ifCascadeExprNotNull.kt") - public void testIfCascadeExprNotNull() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/ifCascadeExprNotNull.kt"); - } - - @Test - @TestMetadata("ifExprInConditionNonNull.kt") - public void testIfExprInConditionNonNull() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/ifExprInConditionNonNull.kt"); - } - - @Test - @TestMetadata("ifExprInWhenSubjectNonNull.kt") - public void testIfExprInWhenSubjectNonNull() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/ifExprInWhenSubjectNonNull.kt"); - } - - @Test - @TestMetadata("ifExprNonNull.kt") - public void testIfExprNonNull() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/ifExprNonNull.kt"); - } - - @Test - @TestMetadata("ifWhenExprNonNull.kt") - public void testIfWhenExprNonNull() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/ifWhenExprNonNull.kt"); - } - - @Test - @TestMetadata("implicitReceiver.kt") - public void testImplicitReceiver() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/implicitReceiver.kt"); - } - - @Test - @TestMetadata("implicitToGrandSon.kt") - public void testImplicitToGrandSon() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/implicitToGrandSon.kt"); - } - - @Test - @TestMetadata("incDecToNull.kt") - public void testIncDecToNull() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/incDecToNull.kt"); - } - - @Test - @TestMetadata("kt10232.kt") - public void testKt10232() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/kt10232.kt"); - } - - @Test - @TestMetadata("kt10444.kt") - public void testKt10444() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/kt10444.kt"); - } - - @Test - @TestMetadata("kt10483.kt") - public void testKt10483() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/kt10483.kt"); - } - - @Test - @TestMetadata("kt1461.kt") - public void testKt1461() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/kt1461.kt"); - } - - @Test - @TestMetadata("kt2422.kt") - public void testKt2422() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/kt2422.kt"); - } - - @Test - @TestMetadata("kt27221.kt") - public void testKt27221() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/kt27221.kt"); - } - - @Test - @TestMetadata("kt27221_2.kt") - public void testKt27221_2() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/kt27221_2.kt"); - } - - @Test - @TestMetadata("kt27221_irrelevantClasses.kt") - public void testKt27221_irrelevantClasses() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/kt27221_irrelevantClasses.kt"); - } - - @Test - @TestMetadata("kt2865.kt") - public void testKt2865() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/kt2865.kt"); - } - - @Test - @TestMetadata("kt30826.kt") - public void testKt30826() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/kt30826.kt"); - } - - @Test - @TestMetadata("kt30927.kt") - public void testKt30927() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/kt30927.kt"); - } - - @Test - @TestMetadata("kt3224.kt") - public void testKt3224() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/kt3224.kt"); - } - - @Test - @TestMetadata("kt32358_1.kt") - public void testKt32358_1() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/kt32358_1.kt"); - } - - @Test - @TestMetadata("kt32358_2.kt") - public void testKt32358_2() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/kt32358_2.kt"); - } - - @Test - @TestMetadata("kt32358_3.kt") - public void testKt32358_3() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/kt32358_3.kt"); - } - - @Test - @TestMetadata("kt3244.kt") - public void testKt3244() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/kt3244.kt"); - } - - @Test - @TestMetadata("kt3572.kt") - public void testKt3572() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/kt3572.kt"); - } - - @Test - @TestMetadata("kt3711.kt") - public void testKt3711() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/kt3711.kt"); - } - - @Test - @TestMetadata("kt3899.kt") - public void testKt3899() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/kt3899.kt"); - } - - @Test - @TestMetadata("kt3993.kt") - public void testKt3993() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/kt3993.kt"); - } - - @Test - @TestMetadata("kt5427.kt") - public void testKt5427() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/kt5427.kt"); - } - - @Test - @TestMetadata("kt5455.kt") - public void testKt5455() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/kt5455.kt"); - } - - @Test - @TestMetadata("kt6819.kt") - public void testKt6819() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/kt6819.kt"); - } - - @Test - @TestMetadata("kt7561.kt") - public void testKt7561() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/kt7561.kt"); - } - - @Test - @TestMetadata("lambdaAndArgument.kt") - public void testLambdaAndArgument() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/lambdaAndArgument.kt"); - } - - @Test - @TestMetadata("lambdaAndArgumentFun.kt") - public void testLambdaAndArgumentFun() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/lambdaAndArgumentFun.kt"); - } - - @Test - @TestMetadata("lambdaArgumentNoSubstitutedReturn.kt") - public void testLambdaArgumentNoSubstitutedReturn() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/lambdaArgumentNoSubstitutedReturn.kt"); - } - - @Test - @TestMetadata("lambdaArgumentWithBoundWithoutType.kt") - public void testLambdaArgumentWithBoundWithoutType() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/lambdaArgumentWithBoundWithoutType.kt"); - } - - @Test - @TestMetadata("lambdaArgumentWithExpectedGenericType.kt") - public void testLambdaArgumentWithExpectedGenericType() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/lambdaArgumentWithExpectedGenericType.kt"); - } - - @Test - @TestMetadata("lambdaArgumentWithoutType.kt") - public void testLambdaArgumentWithoutType() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/lambdaArgumentWithoutType.kt"); - } - - @Test - @TestMetadata("lambdaArgumentWithoutTypeIf.kt") - public void testLambdaArgumentWithoutTypeIf() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/lambdaArgumentWithoutTypeIf.kt"); - } - - @Test - @TestMetadata("lambdaArgumentWithoutTypeIfMerge.kt") - public void testLambdaArgumentWithoutTypeIfMerge() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/lambdaArgumentWithoutTypeIfMerge.kt"); - } - - @Test - @TestMetadata("lambdaArgumentWithoutTypeWhen.kt") - public void testLambdaArgumentWithoutTypeWhen() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/lambdaArgumentWithoutTypeWhen.kt"); - } - - @Test - @TestMetadata("lambdaCall.kt") - public void testLambdaCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/lambdaCall.kt"); - } - - @Test - @TestMetadata("lambdaCallAnnotated.kt") - public void testLambdaCallAnnotated() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/lambdaCallAnnotated.kt"); - } - - @Test - @TestMetadata("lambdaDeclaresAndModifies.kt") - public void testLambdaDeclaresAndModifies() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/lambdaDeclaresAndModifies.kt"); - } - - @Test - @TestMetadata("lambdaDeclaresAndModifiesInLoop.kt") - public void testLambdaDeclaresAndModifiesInLoop() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/lambdaDeclaresAndModifiesInLoop.kt"); - } - - @Test - @TestMetadata("lambdaDeclaresAndModifiesInSecondary.kt") - public void testLambdaDeclaresAndModifiesInSecondary() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/lambdaDeclaresAndModifiesInSecondary.kt"); - } - - @Test - @TestMetadata("lambdaDeclaresAndModifiesWithDirectEq.kt") - public void testLambdaDeclaresAndModifiesWithDirectEq() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/lambdaDeclaresAndModifiesWithDirectEq.kt"); - } - - @Test - @TestMetadata("lambdaUsesOwnerModifies.kt") - public void testLambdaUsesOwnerModifies() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/lambdaUsesOwnerModifies.kt"); - } - - @Test - @TestMetadata("level_1_0.kt") - public void testLevel_1_0() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/level_1_0.kt"); - } - - @Test - @TestMetadata("localClassChanges.kt") - public void testLocalClassChanges() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/localClassChanges.kt"); - } - - @Test - @TestMetadata("localDelegatedPropertyAfter.kt") - public void testLocalDelegatedPropertyAfter() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/localDelegatedPropertyAfter.kt"); - } - - @Test - @TestMetadata("localDelegatedPropertyBefore.kt") - public void testLocalDelegatedPropertyBefore() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/localDelegatedPropertyBefore.kt"); - } - - @Test - @TestMetadata("localFunBetween.kt") - public void testLocalFunBetween() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/localFunBetween.kt"); - } - - @Test - @TestMetadata("localFunChanges.kt") - public void testLocalFunChanges() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/localFunChanges.kt"); - } - - @Test - @TestMetadata("localObjectChanges.kt") - public void testLocalObjectChanges() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/localObjectChanges.kt"); - } - - @Test - @TestMetadata("multipleResolvedCalls.kt") - public void testMultipleResolvedCalls() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/multipleResolvedCalls.kt"); - } - - @Test - @TestMetadata("noErrorCheckForPackageLevelVal.kt") - public void testNoErrorCheckForPackageLevelVal() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/noErrorCheckForPackageLevelVal.kt"); - } - - @Test - @TestMetadata("noUnnecessarySmartCastForReceiver.kt") - public void testNoUnnecessarySmartCastForReceiver() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/noUnnecessarySmartCastForReceiver.kt"); - } - - @Test - @TestMetadata("notNullorNotNull.kt") - public void testNotNullorNotNull() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/notNullorNotNull.kt"); - } - - @Test - @TestMetadata("openInSealed.kt") - public void testOpenInSealed() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/openInSealed.kt"); - } - - @Test - @TestMetadata("ownerDeclaresBothModifies.kt") - public void testOwnerDeclaresBothModifies() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/ownerDeclaresBothModifies.kt"); - } - - @Test - @TestMetadata("propertyAsCondition.kt") - public void testPropertyAsCondition() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/propertyAsCondition.kt"); - } - - @Test - @TestMetadata("propertyToNotNull.kt") - public void testPropertyToNotNull() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/propertyToNotNull.kt"); - } - - @Test - @TestMetadata("safeAs.kt") - public void testSafeAs() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/safeAs.kt"); - } - - @Test - @TestMetadata("severalSmartCastsOnReified.kt") - public void testSeveralSmartCastsOnReified() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/severalSmartCastsOnReified.kt"); - } - - @Test - @TestMetadata("shortIfExprNotNull.kt") - public void testShortIfExprNotNull() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/shortIfExprNotNull.kt"); - } - - @Test - @TestMetadata("smartCastAndArgumentApproximation.kt") - public void testSmartCastAndArgumentApproximation() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/smartCastAndArgumentApproximation.kt"); - } - - @Test - @TestMetadata("smartCastOnElvis.kt") - public void testSmartCastOnElvis() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/smartCastOnElvis.kt"); - } - - @Test - @TestMetadata("smartCastOnIf.kt") - public void testSmartCastOnIf() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/smartCastOnIf.kt"); - } - - @Test - @TestMetadata("smartCastOnLastExpressionOfLambdaAfterNothing.kt") - public void testSmartCastOnLastExpressionOfLambdaAfterNothing() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/smartCastOnLastExpressionOfLambdaAfterNothing.kt"); - } - - @Test - @TestMetadata("smartCastOnWhen.kt") - public void testSmartCastOnWhen() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/smartCastOnWhen.kt"); - } - - @Test - @TestMetadata("smartcastOnSameFieldOfDifferentInstances.kt") - public void testSmartcastOnSameFieldOfDifferentInstances() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/smartcastOnSameFieldOfDifferentInstances.kt"); - } - - @Test - @TestMetadata("smartcastToNothingAfterCheckingForNull.kt") - public void testSmartcastToNothingAfterCheckingForNull() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/smartcastToNothingAfterCheckingForNull.kt"); - } - - @Test - @TestMetadata("thisWithLabel.kt") - public void testThisWithLabel() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/thisWithLabel.kt"); - } - - @Test - @TestMetadata("thisWithLabelAsReceiverPart.kt") - public void testThisWithLabelAsReceiverPart() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/thisWithLabelAsReceiverPart.kt"); - } - - @Test - @TestMetadata("threeImplicitReceivers.kt") - public void testThreeImplicitReceivers() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/threeImplicitReceivers.kt"); - } - - @Test - @TestMetadata("twoImplicitReceivers.kt") - public void testTwoImplicitReceivers() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/twoImplicitReceivers.kt"); - } - - @Test - @TestMetadata("typeDegradation.kt") - public void testTypeDegradation() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/typeDegradation.kt"); - } - - @Test - @TestMetadata("typeInComparison.kt") - public void testTypeInComparison() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/typeInComparison.kt"); - } - - @Test - @TestMetadata("unstableToStable.kt") - public void testUnstableToStable() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/unstableToStable.kt"); - } - - @Test - @TestMetadata("unstableToStableTypes.kt") - public void testUnstableToStableTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/unstableToStableTypes.kt"); - } - - @Test - @TestMetadata("varChangedInInitializer.kt") - public void testVarChangedInInitializer() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varChangedInInitializer.kt"); - } - - @Test - @TestMetadata("varChangedInLocalInitializer.kt") - public void testVarChangedInLocalInitializer() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varChangedInLocalInitializer.kt"); - } - - @Test - @TestMetadata("varInAccessor.kt") - public void testVarInAccessor() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varInAccessor.kt"); - } - - @Test - @TestMetadata("varInInitNoPrimary.kt") - public void testVarInInitNoPrimary() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varInInitNoPrimary.kt"); - } - - @Test - @TestMetadata("varInInitializer.kt") - public void testVarInInitializer() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varInInitializer.kt"); - } - - @Test - @TestMetadata("varInSecondaryConstructor.kt") - public void testVarInSecondaryConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varInSecondaryConstructor.kt"); - } - - @Test - @TestMetadata("varInsideLocalFun.kt") - public void testVarInsideLocalFun() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varInsideLocalFun.kt"); - } - - @Test - @TestMetadata("whenExprNonNull.kt") - public void testWhenExprNonNull() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/whenExprNonNull.kt"); - } - - @Test - @TestMetadata("whenIfExprNonNull.kt") - public void testWhenIfExprNonNull() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/whenIfExprNonNull.kt"); - } - - @Test - @TestMetadata("whenSubjectImpossible.kt") - public void testWhenSubjectImpossible() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/whenSubjectImpossible.kt"); - } - - @Test - @TestMetadata("whenSubjectImpossibleJava.kt") - public void testWhenSubjectImpossibleJava() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/whenSubjectImpossibleJava.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/smartCasts/castchecks") - @TestDataPath("$PROJECT_ROOT") - public class Castchecks extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInCastchecks() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/castchecks"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("basicOff.kt") - public void testBasicOff() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/castchecks/basicOff.kt"); - } - - @Test - @TestMetadata("basicOn.kt") - public void testBasicOn() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/castchecks/basicOn.kt"); - } - - @Test - @TestMetadata("castInTryWithCatch.kt") - public void testCastInTryWithCatch() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/castchecks/castInTryWithCatch.kt"); - } - - @Test - @TestMetadata("castInTryWithoutCatch.kt") - public void testCastInTryWithoutCatch() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/castchecks/castInTryWithoutCatch.kt"); - } - - @Test - @TestMetadata("impossible.kt") - public void testImpossible() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/castchecks/impossible.kt"); - } - - @Test - @TestMetadata("insideCall.kt") - public void testInsideCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/castchecks/insideCall.kt"); - } - - @Test - @TestMetadata("smartCastOfNullableExpressionWithExpectedType.kt") - public void testSmartCastOfNullableExpressionWithExpectedType() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/castchecks/smartCastOfNullableExpressionWithExpectedType.kt"); - } - - @Test - @TestMetadata("variables.kt") - public void testVariables() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/castchecks/variables.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/smartCasts/elvis") - @TestDataPath("$PROJECT_ROOT") - public class Elvis extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInElvis() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/elvis"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("basicOff.kt") - public void testBasicOff() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/elvis/basicOff.kt"); - } - - @Test - @TestMetadata("basicOn.kt") - public void testBasicOn() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/elvis/basicOn.kt"); - } - - @Test - @TestMetadata("impossible.kt") - public void testImpossible() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/elvis/impossible.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/smartCasts/inference") - @TestDataPath("$PROJECT_ROOT") - public class Inference extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInInference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/inference"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("dependentOnPrevArg.kt") - public void testDependentOnPrevArg() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/inference/dependentOnPrevArg.kt"); - } - - @Test - @TestMetadata("intersectionTypes.kt") - public void testIntersectionTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/inference/intersectionTypes.kt"); - } - - @Test - @TestMetadata("kt1275.kt") - public void testKt1275() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/inference/kt1275.kt"); - } - - @Test - @TestMetadata("kt1355.kt") - public void testKt1355() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/inference/kt1355.kt"); - } - - @Test - @TestMetadata("kt25432.kt") - public void testKt25432() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/inference/kt25432.kt"); - } - - @Test - @TestMetadata("kt2746.kt") - public void testKt2746() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/inference/kt2746.kt"); - } - - @Test - @TestMetadata("kt2851.kt") - public void testKt2851() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/inference/kt2851.kt"); - } - - @Test - @TestMetadata("kt29767.kt") - public void testKt29767() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/inference/kt29767.kt"); - } - - @Test - @TestMetadata("kt39010.kt") - public void testKt39010() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/inference/kt39010.kt"); - } - - @Test - @TestMetadata("kt39010_2.kt") - public void testKt39010_2() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/inference/kt39010_2.kt"); - } - - @Test - @TestMetadata("kt4009.kt") - public void testKt4009() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/inference/kt4009.kt"); - } - - @Test - @TestMetadata("kt4403.kt") - public void testKt4403() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/inference/kt4403.kt"); - } - - @Test - @TestMetadata("kt4415.kt") - public void testKt4415() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/inference/kt4415.kt"); - } - - @Test - @TestMetadata("kt6242.kt") - public void testKt6242() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/inference/kt6242.kt"); - } - - @Test - @TestMetadata("smartCastOnReceiver.kt") - public void testSmartCastOnReceiver() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/inference/smartCastOnReceiver.kt"); - } - - @Test - @TestMetadata("stabilityOfSmartcastsAgainstGenericFunctions.kt") - public void testStabilityOfSmartcastsAgainstGenericFunctions() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/inference/stabilityOfSmartcastsAgainstGenericFunctions.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/smartCasts/intersectionScope") - @TestDataPath("$PROJECT_ROOT") - public class IntersectionScope extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInIntersectionScope() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/intersectionScope"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("conflictTypeParameters.kt") - public void testConflictTypeParameters() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/intersectionScope/conflictTypeParameters.kt"); - } - - @Test - @TestMetadata("conflictingReturnType.kt") - public void testConflictingReturnType() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/intersectionScope/conflictingReturnType.kt"); - } - - @Test - @TestMetadata("flexibleTypes.kt") - public void testFlexibleTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/intersectionScope/flexibleTypes.kt"); - } - - @Test - @TestMetadata("moreSpecificSetter.kt") - public void testMoreSpecificSetter() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/intersectionScope/moreSpecificSetter.kt"); - } - - @Test - @TestMetadata("moreSpecificVisibility.kt") - public void testMoreSpecificVisibility() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/intersectionScope/moreSpecificVisibility.kt"); - } - - @Test - @TestMetadata("mostSpecific.kt") - public void testMostSpecific() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/intersectionScope/mostSpecific.kt"); - } - - @Test - @TestMetadata("mostSpecificIrrelevant.kt") - public void testMostSpecificIrrelevant() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/intersectionScope/mostSpecificIrrelevant.kt"); - } - - @Test - @TestMetadata("properties.kt") - public void testProperties() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/intersectionScope/properties.kt"); - } - - @Test - @TestMetadata("propertiesConflict.kt") - public void testPropertiesConflict() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/intersectionScope/propertiesConflict.kt"); - } - - @Test - @TestMetadata("refineReturnType.kt") - public void testRefineReturnType() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/intersectionScope/refineReturnType.kt"); - } - - @Test - @TestMetadata("simple.kt") - public void testSimple() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/intersectionScope/simple.kt"); - } - - @Test - @TestMetadata("unstableSmartCast.kt") - public void testUnstableSmartCast() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/intersectionScope/unstableSmartCast.kt"); - } - - @Test - @TestMetadata("validTypeParameters.kt") - public void testValidTypeParameters() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/intersectionScope/validTypeParameters.kt"); - } - - @Test - @TestMetadata("validTypeParametersNoSmartCast.kt") - public void testValidTypeParametersNoSmartCast() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/intersectionScope/validTypeParametersNoSmartCast.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/smartCasts/loops") - @TestDataPath("$PROJECT_ROOT") - public class Loops extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInLoops() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/loops"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("assignElvisIfBreakInsideWhileTrue.kt") - public void testAssignElvisIfBreakInsideWhileTrue() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/assignElvisIfBreakInsideWhileTrue.kt"); - } - - @Test - @TestMetadata("assignWhenInsideWhileTrue.kt") - public void testAssignWhenInsideWhileTrue() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/assignWhenInsideWhileTrue.kt"); - } - - @Test - @TestMetadata("callBreakBetweenInsideDoWhile.kt") - public void testCallBreakBetweenInsideDoWhile() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/callBreakBetweenInsideDoWhile.kt"); - } - - @Test - @TestMetadata("callBreakFirstInsideDoWhile.kt") - public void testCallBreakFirstInsideDoWhile() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/callBreakFirstInsideDoWhile.kt"); - } - - @Test - @TestMetadata("callBreakInsideDoWhile.kt") - public void testCallBreakInsideDoWhile() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/callBreakInsideDoWhile.kt"); - } - - @Test - @TestMetadata("callBreakSecondInsideDoWhile.kt") - public void testCallBreakSecondInsideDoWhile() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/callBreakSecondInsideDoWhile.kt"); - } - - @Test - @TestMetadata("callBreakThirdInsideDoWhile.kt") - public void testCallBreakThirdInsideDoWhile() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/callBreakThirdInsideDoWhile.kt"); - } - - @Test - @TestMetadata("doWhile.kt") - public void testDoWhile() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/doWhile.kt"); - } - - @Test - @TestMetadata("doWhileBreak.kt") - public void testDoWhileBreak() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/doWhileBreak.kt"); - } - - @Test - @TestMetadata("doWhileContinue.kt") - public void testDoWhileContinue() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/doWhileContinue.kt"); - } - - @Test - @TestMetadata("doWhileEarlyBreak.kt") - public void testDoWhileEarlyBreak() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/doWhileEarlyBreak.kt"); - } - - @Test - @TestMetadata("doWhileEarlyContinue.kt") - public void testDoWhileEarlyContinue() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/doWhileEarlyContinue.kt"); - } - - @Test - @TestMetadata("doWhileInCondition.kt") - public void testDoWhileInCondition() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/doWhileInCondition.kt"); - } - - @Test - @TestMetadata("doWhileInConditionWithBreak.kt") - public void testDoWhileInConditionWithBreak() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/doWhileInConditionWithBreak.kt"); - } - - @Test - @TestMetadata("doWhileLiteral.kt") - public void testDoWhileLiteral() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/doWhileLiteral.kt"); - } - - @Test - @TestMetadata("doWhileNotNullBreak.kt") - public void testDoWhileNotNullBreak() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/doWhileNotNullBreak.kt"); - } - - @Test - @TestMetadata("doWhileNull.kt") - public void testDoWhileNull() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/doWhileNull.kt"); - } - - @Test - @TestMetadata("doWhileNullWithBreak.kt") - public void testDoWhileNullWithBreak() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/doWhileNullWithBreak.kt"); - } - - @Test - @TestMetadata("elvisBreakInsideDoWhile.kt") - public void testElvisBreakInsideDoWhile() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/elvisBreakInsideDoWhile.kt"); - } - - @Test - @TestMetadata("elvisIfBreakInsideWhileTrue.kt") - public void testElvisIfBreakInsideWhileTrue() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/elvisIfBreakInsideWhileTrue.kt"); - } - - @Test - @TestMetadata("elvisInsideDoWhile.kt") - public void testElvisInsideDoWhile() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/elvisInsideDoWhile.kt"); - } - - @Test - @TestMetadata("elvisLeftBreakInsideWhileTrue.kt") - public void testElvisLeftBreakInsideWhileTrue() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/elvisLeftBreakInsideWhileTrue.kt"); - } - - @Test - @TestMetadata("ifBlockInsideDoWhile.kt") - public void testIfBlockInsideDoWhile() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/ifBlockInsideDoWhile.kt"); - } - - @Test - @TestMetadata("ifBreakAssignInsideDoWhile.kt") - public void testIfBreakAssignInsideDoWhile() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/ifBreakAssignInsideDoWhile.kt"); - } - - @Test - @TestMetadata("ifBreakAssignInsideWhileTrue.kt") - public void testIfBreakAssignInsideWhileTrue() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/ifBreakAssignInsideWhileTrue.kt"); - } - - @Test - @TestMetadata("ifBreakExprInsideWhileTrue.kt") - public void testIfBreakExprInsideWhileTrue() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/ifBreakExprInsideWhileTrue.kt"); - } - - @Test - @TestMetadata("ifElseBlockInsideDoWhile.kt") - public void testIfElseBlockInsideDoWhile() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/ifElseBlockInsideDoWhile.kt"); - } - - @Test - @TestMetadata("ifInsideDoWhile.kt") - public void testIfInsideDoWhile() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/ifInsideDoWhile.kt"); - } - - @Test - @TestMetadata("leftElvisBreakInsideWhileTrue.kt") - public void testLeftElvisBreakInsideWhileTrue() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/leftElvisBreakInsideWhileTrue.kt"); - } - - @Test - @TestMetadata("nestedDoWhile.kt") - public void testNestedDoWhile() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/nestedDoWhile.kt"); - } - - @Test - @TestMetadata("nestedDoWhileWithLongContinue.kt") - public void testNestedDoWhileWithLongContinue() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/nestedDoWhileWithLongContinue.kt"); - } - - @Test - @TestMetadata("nestedLoops.kt") - public void testNestedLoops() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/nestedLoops.kt"); - } - - @Test - @TestMetadata("nestedLoopsShort.kt") - public void testNestedLoopsShort() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/nestedLoopsShort.kt"); - } - - @Test - @TestMetadata("nestedLoopsWithBreak.kt") - public void testNestedLoopsWithBreak() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/nestedLoopsWithBreak.kt"); - } - - @Test - @TestMetadata("nestedLoopsWithLongBreak.kt") - public void testNestedLoopsWithLongBreak() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/nestedLoopsWithLongBreak.kt"); - } - - @Test - @TestMetadata("nestedLoopsWithLongContinue.kt") - public void testNestedLoopsWithLongContinue() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/nestedLoopsWithLongContinue.kt"); - } - - @Test - @TestMetadata("plusAssignWhenInsideDoWhile.kt") - public void testPlusAssignWhenInsideDoWhile() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/plusAssignWhenInsideDoWhile.kt"); - } - - @Test - @TestMetadata("safeCallBreakInsideDoWhile.kt") - public void testSafeCallBreakInsideDoWhile() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/safeCallBreakInsideDoWhile.kt"); - } - - @Test - @TestMetadata("safeCallInsideDoWhile.kt") - public void testSafeCallInsideDoWhile() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/safeCallInsideDoWhile.kt"); - } - - @Test - @TestMetadata("useInsideDoWhile.kt") - public void testUseInsideDoWhile() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/useInsideDoWhile.kt"); - } - - @Test - @TestMetadata("whenInsideWhileTrue.kt") - public void testWhenInsideWhileTrue() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/whenInsideWhileTrue.kt"); - } - - @Test - @TestMetadata("whenReturnInsideWhileTrue.kt") - public void testWhenReturnInsideWhileTrue() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/whenReturnInsideWhileTrue.kt"); - } - - @Test - @TestMetadata("whileInCondition.kt") - public void testWhileInCondition() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/whileInCondition.kt"); - } - - @Test - @TestMetadata("whileInConditionWithBreak.kt") - public void testWhileInConditionWithBreak() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/whileInConditionWithBreak.kt"); - } - - @Test - @TestMetadata("whileNull.kt") - public void testWhileNull() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/whileNull.kt"); - } - - @Test - @TestMetadata("whileNullAssignToSomething.kt") - public void testWhileNullAssignToSomething() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/whileNullAssignToSomething.kt"); - } - - @Test - @TestMetadata("whileNullWithBreak.kt") - public void testWhileNullWithBreak() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/whileNullWithBreak.kt"); - } - - @Test - @TestMetadata("whileSimple.kt") - public void testWhileSimple() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/whileSimple.kt"); - } - - @Test - @TestMetadata("whileTrivial.kt") - public void testWhileTrivial() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/whileTrivial.kt"); - } - - @Test - @TestMetadata("whileTrue.kt") - public void testWhileTrue() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/whileTrue.kt"); - } - - @Test - @TestMetadata("whileTrueBreakReturn.kt") - public void testWhileTrueBreakReturn() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/whileTrueBreakReturn.kt"); - } - - @Test - @TestMetadata("whileTrueEarlyBreak.kt") - public void testWhileTrueEarlyBreak() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/whileTrueEarlyBreak.kt"); - } - - @Test - @TestMetadata("whileTrueReturn.kt") - public void testWhileTrueReturn() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/whileTrueReturn.kt"); - } - - @Test - @TestMetadata("WhileTrueWithBreakInIfCondition.kt") - public void testWhileTrueWithBreakInIfCondition() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/WhileTrueWithBreakInIfCondition.kt"); - } - - @Test - @TestMetadata("whileWithAssertInConditionAndBreakAfter.kt") - public void testWhileWithAssertInConditionAndBreakAfter() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/whileWithAssertInConditionAndBreakAfter.kt"); - } - - @Test - @TestMetadata("whileWithAssertInConditionAndBreakBefore.kt") - public void testWhileWithAssertInConditionAndBreakBefore() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/loops/whileWithAssertInConditionAndBreakBefore.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/smartCasts/objectLiterals") - @TestDataPath("$PROJECT_ROOT") - public class ObjectLiterals extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInObjectLiterals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/objectLiterals"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("assignment.kt") - public void testAssignment() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/objectLiterals/assignment.kt"); - } - - @Test - @TestMetadata("base.kt") - public void testBase() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/objectLiterals/base.kt"); - } - - @Test - @TestMetadata("captured.kt") - public void testCaptured() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/objectLiterals/captured.kt"); - } - - @Test - @TestMetadata("exclexcl.kt") - public void testExclexcl() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/objectLiterals/exclexcl.kt"); - } - - @Test - @TestMetadata("exclexclArgument.kt") - public void testExclexclArgument() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/objectLiterals/exclexclArgument.kt"); - } - - @Test - @TestMetadata("exclexclTwoArgument.kt") - public void testExclexclTwoArgument() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/objectLiterals/exclexclTwoArgument.kt"); - } - - @Test - @TestMetadata("kt7110.kt") - public void testKt7110() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/objectLiterals/kt7110.kt"); - } - - @Test - @TestMetadata("receiver.kt") - public void testReceiver() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/objectLiterals/receiver.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/smartCasts/publicVals") - @TestDataPath("$PROJECT_ROOT") - public class PublicVals extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInPublicVals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/publicVals"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("customGetter.kt") - public void testCustomGetter() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/publicVals/customGetter.kt"); - } - - @Test - @TestMetadata("delegate.kt") - public void testDelegate() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/publicVals/delegate.kt"); - } - - @Test - @TestMetadata("kt4409.kt") - public void testKt4409() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/publicVals/kt4409.kt"); - } - - @Test - @TestMetadata("kt5502.kt") - public void testKt5502() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/publicVals/kt5502.kt"); - } - - @Test - @TestMetadata("open.kt") - public void testOpen() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/publicVals/open.kt"); - } - - @Test - @TestMetadata("otherModule.kt") - public void testOtherModule() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/publicVals/otherModule.kt"); - } - - @Test - @TestMetadata("protected.kt") - public void testProtected() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/publicVals/protected.kt"); - } - - @Test - @TestMetadata("simple.kt") - public void testSimple() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/publicVals/simple.kt"); - } - - @Test - @TestMetadata("var.kt") - public void testVar() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/publicVals/var.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/smartCasts/safecalls") - @TestDataPath("$PROJECT_ROOT") - public class Safecalls extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInSafecalls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/safecalls"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("anotherVal.kt") - public void testAnotherVal() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/anotherVal.kt"); - } - - @Test - @TestMetadata("argument.kt") - public void testArgument() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/argument.kt"); - } - - @Test - @TestMetadata("chainAndUse.kt") - public void testChainAndUse() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/chainAndUse.kt"); - } - - @Test - @TestMetadata("chainInChain.kt") - public void testChainInChain() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/chainInChain.kt"); - } - - @Test - @TestMetadata("chainMixedUnsafe.kt") - public void testChainMixedUnsafe() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/chainMixedUnsafe.kt"); - } - - @Test - @TestMetadata("doubleCall.kt") - public void testDoubleCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/doubleCall.kt"); - } - - @Test - @TestMetadata("extension.kt") - public void testExtension() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/extension.kt"); - } - - @Test - @TestMetadata("extensionCall.kt") - public void testExtensionCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/extensionCall.kt"); - } - - @Test - @TestMetadata("falseArgument.kt") - public void testFalseArgument() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/falseArgument.kt"); - } - - @Test - @TestMetadata("falseChain.kt") - public void testFalseChain() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/falseChain.kt"); - } - - @Test - @TestMetadata("falseExtension.kt") - public void testFalseExtension() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/falseExtension.kt"); - } - - @Test - @TestMetadata("falseSecondArgument.kt") - public void testFalseSecondArgument() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/falseSecondArgument.kt"); - } - - @Test - @TestMetadata("innerReceiver.kt") - public void testInnerReceiver() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/innerReceiver.kt"); - } - - @Test - @TestMetadata("insideCall.kt") - public void testInsideCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/insideCall.kt"); - } - - @Test - @TestMetadata("insideIfExpr.kt") - public void testInsideIfExpr() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/insideIfExpr.kt"); - } - - @Test - @TestMetadata("longChain.kt") - public void testLongChain() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/longChain.kt"); - } - - @Test - @TestMetadata("nullableReceiver.kt") - public void testNullableReceiver() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/nullableReceiver.kt"); - } - - @Test - @TestMetadata("nullableReceiverInLongChain.kt") - public void testNullableReceiverInLongChain() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/nullableReceiverInLongChain.kt"); - } - - @Test - @TestMetadata("nullableReceiverWithExclExcl.kt") - public void testNullableReceiverWithExclExcl() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/nullableReceiverWithExclExcl.kt"); - } - - @Test - @TestMetadata("nullableReceiverWithFlexible.kt") - public void testNullableReceiverWithFlexible() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/nullableReceiverWithFlexible.kt"); - } - - @Test - @TestMetadata("property.kt") - public void testProperty() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/property.kt"); - } - - @Test - @TestMetadata("propertyChain.kt") - public void testPropertyChain() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/propertyChain.kt"); - } - - @Test - @TestMetadata("receiver.kt") - public void testReceiver() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/receiver.kt"); - } - - @Test - @TestMetadata("receiverAndChain.kt") - public void testReceiverAndChain() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/receiverAndChain.kt"); - } - - @Test - @TestMetadata("receiverAndChainFalse.kt") - public void testReceiverAndChainFalse() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/receiverAndChainFalse.kt"); - } - - @Test - @TestMetadata("safeAccessReceiverNotNull.kt") - public void testSafeAccessReceiverNotNull() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/safeAccessReceiverNotNull.kt"); - } - - @Test - @TestMetadata("simple.kt") - public void testSimple() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/simple.kt"); - } - - @Test - @TestMetadata("simpleNullableReceiver.kt") - public void testSimpleNullableReceiver() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/simpleNullableReceiver.kt"); - } - - @Test - @TestMetadata("twoArgs.kt") - public void testTwoArgs() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/safecalls/twoArgs.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/smartCasts/variables") - @TestDataPath("$PROJECT_ROOT") - public class Variables extends AbstractDiagnosticUsingJavacTest { - @Test - @TestMetadata("accessorAndFunction.kt") - public void testAccessorAndFunction() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/variables/accessorAndFunction.kt"); - } - - @Test - public void testAllFilesPresentInVariables() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/variables"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("assignment.kt") - public void testAssignment() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/variables/assignment.kt"); - } - - @Test - @TestMetadata("assignmentConversion.kt") - public void testAssignmentConversion() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/variables/assignmentConversion.kt"); - } - - @Test - @TestMetadata("doWhileWithMiddleBreak.kt") - public void testDoWhileWithMiddleBreak() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/variables/doWhileWithMiddleBreak.kt"); - } - - @Test - @TestMetadata("ifElseBlockInsideDoWhile.kt") - public void testIfElseBlockInsideDoWhile() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/variables/ifElseBlockInsideDoWhile.kt"); - } - - @Test - @TestMetadata("ifElseBlockInsideDoWhileWithBreak.kt") - public void testIfElseBlockInsideDoWhileWithBreak() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/variables/ifElseBlockInsideDoWhileWithBreak.kt"); - } - - @Test - @TestMetadata("ifNullAssignment.kt") - public void testIfNullAssignment() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/variables/ifNullAssignment.kt"); - } - - @Test - @TestMetadata("ifVarIs.kt") - public void testIfVarIs() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/variables/ifVarIs.kt"); - } - - @Test - @TestMetadata("ifVarIsAnd.kt") - public void testIfVarIsAnd() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/variables/ifVarIsAnd.kt"); - } - - @Test - @TestMetadata("ifVarIsChanged.kt") - public void testIfVarIsChanged() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/variables/ifVarIsChanged.kt"); - } - - @Test - @TestMetadata("inPropertySam.kt") - public void testInPropertySam() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/variables/inPropertySam.kt"); - } - - @Test - @TestMetadata("infix.kt") - public void testInfix() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/variables/infix.kt"); - } - - @Test - @TestMetadata("initialization.kt") - public void testInitialization() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/variables/initialization.kt"); - } - - @Test - @TestMetadata("kt7599.kt") - public void testKt7599() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/variables/kt7599.kt"); - } - - @Test - @TestMetadata("lambdaBetweenArguments.kt") - public void testLambdaBetweenArguments() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/variables/lambdaBetweenArguments.kt"); - } - - @Test - @TestMetadata("property.kt") - public void testProperty() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/variables/property.kt"); - } - - @Test - @TestMetadata("propertyNotNeeded.kt") - public void testPropertyNotNeeded() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/variables/propertyNotNeeded.kt"); - } - - @Test - @TestMetadata("propertySubtype.kt") - public void testPropertySubtype() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/variables/propertySubtype.kt"); - } - - @Test - @TestMetadata("propertySubtypeInMember.kt") - public void testPropertySubtypeInMember() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/variables/propertySubtypeInMember.kt"); - } - - @Test - @TestMetadata("propertySubtypeInMemberCheck.kt") - public void testPropertySubtypeInMemberCheck() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/variables/propertySubtypeInMemberCheck.kt"); - } - - @Test - @TestMetadata("varAsUse.kt") - public void testVarAsUse() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/variables/varAsUse.kt"); - } - - @Test - @TestMetadata("varChangedInLoop.kt") - public void testVarChangedInLoop() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/variables/varChangedInLoop.kt"); - } - - @Test - @TestMetadata("varNotChangedInLoop.kt") - public void testVarNotChangedInLoop() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/variables/varNotChangedInLoop.kt"); - } - - @Test - @TestMetadata("whileTrue.kt") - public void testWhileTrue() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/variables/whileTrue.kt"); - } - - @Test - @TestMetadata("whileWithBreak.kt") - public void testWhileWithBreak() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/variables/whileWithBreak.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/smartCasts/varnotnull") - @TestDataPath("$PROJECT_ROOT") - public class Varnotnull extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInVarnotnull() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/varnotnull"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("assignNestedWhile.kt") - public void testAssignNestedWhile() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/assignNestedWhile.kt"); - } - - @Test - @TestMetadata("assignment.kt") - public void testAssignment() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/assignment.kt"); - } - - @Test - @TestMetadata("boundInitializer.kt") - public void testBoundInitializer() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/boundInitializer.kt"); - } - - @Test - @TestMetadata("boundInitializerWrong.kt") - public void testBoundInitializerWrong() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/boundInitializerWrong.kt"); - } - - @Test - @TestMetadata("capturedInClosureModifiedBefore.kt") - public void testCapturedInClosureModifiedBefore() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/capturedInClosureModifiedBefore.kt"); - } - - @Test - @TestMetadata("capturedInClosureOff.kt") - public void testCapturedInClosureOff() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/capturedInClosureOff.kt"); - } - - @Test - @TestMetadata("doWhileWithBreak.kt") - public void testDoWhileWithBreak() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/doWhileWithBreak.kt"); - } - - @Test - @TestMetadata("doWhileWithMiddleBreak.kt") - public void testDoWhileWithMiddleBreak() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/doWhileWithMiddleBreak.kt"); - } - - @Test - @TestMetadata("forEach.kt") - public void testForEach() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/forEach.kt"); - } - - @Test - @TestMetadata("forEachWithBreak.kt") - public void testForEachWithBreak() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/forEachWithBreak.kt"); - } - - @Test - @TestMetadata("forEachWithContinue.kt") - public void testForEachWithContinue() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/forEachWithContinue.kt"); - } - - @Test - @TestMetadata("ifVarNotNull.kt") - public void testIfVarNotNull() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/ifVarNotNull.kt"); - } - - @Test - @TestMetadata("ifVarNotNullAnd.kt") - public void testIfVarNotNullAnd() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/ifVarNotNullAnd.kt"); - } - - @Test - @TestMetadata("ifVarNullElse.kt") - public void testIfVarNullElse() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/ifVarNullElse.kt"); - } - - @Test - @TestMetadata("ifVarNullReturn.kt") - public void testIfVarNullReturn() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/ifVarNullReturn.kt"); - } - - @Test - @TestMetadata("inference.kt") - public void testInference() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/inference.kt"); - } - - @Test - @TestMetadata("infiniteWhileWithBreak.kt") - public void testInfiniteWhileWithBreak() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/infiniteWhileWithBreak.kt"); - } - - @Test - @TestMetadata("infix.kt") - public void testInfix() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/infix.kt"); - } - - @Test - @TestMetadata("initInTryReturnInCatch.kt") - public void testInitInTryReturnInCatch() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/initInTryReturnInCatch.kt"); - } - - @Test - @TestMetadata("initialization.kt") - public void testInitialization() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/initialization.kt"); - } - - @Test - @TestMetadata("iterations.kt") - public void testIterations() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/iterations.kt"); - } - - @Test - @TestMetadata("nestedDoWhile.kt") - public void testNestedDoWhile() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/nestedDoWhile.kt"); - } - - @Test - @TestMetadata("nestedLoops.kt") - public void testNestedLoops() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/nestedLoops.kt"); - } - - @Test - @TestMetadata("nestedWhile.kt") - public void testNestedWhile() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/nestedWhile.kt"); - } - - @Test - @TestMetadata("plusplusMinusminus.kt") - public void testPlusplusMinusminus() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/plusplusMinusminus.kt"); - } - - @Test - @TestMetadata("postfixNotnullClassIncrement.kt") - public void testPostfixNotnullClassIncrement() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/postfixNotnullClassIncrement.kt"); - } - - @Test - @TestMetadata("postfixNullableClassIncrement.kt") - public void testPostfixNullableClassIncrement() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/postfixNullableClassIncrement.kt"); - } - - @Test - @TestMetadata("postfixNullableIncrement.kt") - public void testPostfixNullableIncrement() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/postfixNullableIncrement.kt"); - } - - @Test - @TestMetadata("prefixNotnullClassIncrement.kt") - public void testPrefixNotnullClassIncrement() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/prefixNotnullClassIncrement.kt"); - } - - @Test - @TestMetadata("prefixNullableClassIncrement.kt") - public void testPrefixNullableClassIncrement() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/prefixNullableClassIncrement.kt"); - } - - @Test - @TestMetadata("prefixNullableIncrement.kt") - public void testPrefixNullableIncrement() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/prefixNullableIncrement.kt"); - } - - @Test - @TestMetadata("setNotNullInTry.kt") - public void testSetNotNullInTry() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/setNotNullInTry.kt"); - } - - @Test - @TestMetadata("setNullInTry.kt") - public void testSetNullInTry() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/setNullInTry.kt"); - } - - @Test - @TestMetadata("setNullInTryFinally.kt") - public void testSetNullInTryFinally() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/setNullInTryFinally.kt"); - } - - @Test - @TestMetadata("setNullInTryUnsound.kt") - public void testSetNullInTryUnsound() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/setNullInTryUnsound.kt"); - } - - @Test - @TestMetadata("setSameInTry.kt") - public void testSetSameInTry() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/setSameInTry.kt"); - } - - @Test - @TestMetadata("toFlexibleType.kt") - public void testToFlexibleType() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/toFlexibleType.kt"); - } - - @Test - @TestMetadata("unnecessary.kt") - public void testUnnecessary() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/unnecessary.kt"); - } - - @Test - @TestMetadata("unnecessaryWithBranch.kt") - public void testUnnecessaryWithBranch() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/unnecessaryWithBranch.kt"); - } - - @Test - @TestMetadata("unnecessaryWithMap.kt") - public void testUnnecessaryWithMap() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/unnecessaryWithMap.kt"); - } - - @Test - @TestMetadata("varCapturedInClosure.kt") - public void testVarCapturedInClosure() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/varCapturedInClosure.kt"); - } - - @Test - @TestMetadata("varCapturedInInlineClosure.kt") - public void testVarCapturedInInlineClosure() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/varCapturedInInlineClosure.kt"); - } - - @Test - @TestMetadata("varCapturedInSafeClosure.kt") - public void testVarCapturedInSafeClosure() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/varCapturedInSafeClosure.kt"); - } - - @Test - @TestMetadata("varChangedInLoop.kt") - public void testVarChangedInLoop() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/varChangedInLoop.kt"); - } - - @Test - @TestMetadata("varCheck.kt") - public void testVarCheck() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/varCheck.kt"); - } - - @Test - @TestMetadata("varIntNull.kt") - public void testVarIntNull() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/varIntNull.kt"); - } - - @Test - @TestMetadata("varNotChangedInLoop.kt") - public void testVarNotChangedInLoop() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/varNotChangedInLoop.kt"); - } - - @Test - @TestMetadata("varNull.kt") - public void testVarNull() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/varNull.kt"); - } - - @Test - @TestMetadata("whileTrue.kt") - public void testWhileTrue() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/whileTrue.kt"); - } - - @Test - @TestMetadata("whileTrueWithBracketSet.kt") - public void testWhileTrueWithBracketSet() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/whileTrueWithBracketSet.kt"); - } - - @Test - @TestMetadata("whileTrueWithBrackets.kt") - public void testWhileTrueWithBrackets() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/whileTrueWithBrackets.kt"); - } - - @Test - @TestMetadata("whileWithBreak.kt") - public void testWhileWithBreak() throws Exception { - runTest("compiler/testData/diagnostics/tests/smartCasts/varnotnull/whileWithBreak.kt"); - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/sourceCompatibility") - @TestDataPath("$PROJECT_ROOT") - public class SourceCompatibility extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInSourceCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/sourceCompatibility"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("inlineFunctionAlways.kt") - public void testInlineFunctionAlways() throws Exception { - runTest("compiler/testData/diagnostics/tests/sourceCompatibility/inlineFunctionAlways.kt"); - } - - @Test - @TestMetadata("noBigFunctionTypes.kt") - public void testNoBigFunctionTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/sourceCompatibility/noBigFunctionTypes.kt"); - } - - @Test - @TestMetadata("noCallableReferencesWithEmptyLHS.kt") - public void testNoCallableReferencesWithEmptyLHS() throws Exception { - runTest("compiler/testData/diagnostics/tests/sourceCompatibility/noCallableReferencesWithEmptyLHS.kt"); - } - - @Test - @TestMetadata("noDataClassInheritance.kt") - public void testNoDataClassInheritance() throws Exception { - runTest("compiler/testData/diagnostics/tests/sourceCompatibility/noDataClassInheritance.kt"); - } - - @Test - @TestMetadata("noInlineProperty.kt") - public void testNoInlineProperty() throws Exception { - runTest("compiler/testData/diagnostics/tests/sourceCompatibility/noInlineProperty.kt"); - } - - @Test - @TestMetadata("noLocalDelegatedProperty.kt") - public void testNoLocalDelegatedProperty() throws Exception { - runTest("compiler/testData/diagnostics/tests/sourceCompatibility/noLocalDelegatedProperty.kt"); - } - - @Test - @TestMetadata("noLocalDelegatedPropertyInScript.kts") - public void testNoLocalDelegatedPropertyInScript() throws Exception { - runTest("compiler/testData/diagnostics/tests/sourceCompatibility/noLocalDelegatedPropertyInScript.kts"); - } - - @Test - @TestMetadata("noMultiplatformProjects.kt") - public void testNoMultiplatformProjects() throws Exception { - runTest("compiler/testData/diagnostics/tests/sourceCompatibility/noMultiplatformProjects.kt"); - } - - @Test - @TestMetadata("noTopLevelSealedInheritance.kt") - public void testNoTopLevelSealedInheritance() throws Exception { - runTest("compiler/testData/diagnostics/tests/sourceCompatibility/noTopLevelSealedInheritance.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion") - @TestDataPath("$PROJECT_ROOT") - public class ApiVersion extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInApiVersion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("annotations.kt") - public void testAnnotations() throws Exception { - runTest("compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion/annotations.kt"); - } - - @Test - @TestMetadata("classesAndConstructors.kt") - public void testClassesAndConstructors() throws Exception { - runTest("compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion/classesAndConstructors.kt"); - } - - @Test - @TestMetadata("overriddenMembers.kt") - public void testOverriddenMembers() throws Exception { - runTest("compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion/overriddenMembers.kt"); - } - - @Test - @TestMetadata("propertyAccessors.kt") - public void testPropertyAccessors() throws Exception { - runTest("compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion/propertyAccessors.kt"); - } - - @Test - @TestMetadata("simpleMembers.kt") - public void testSimpleMembers() throws Exception { - runTest("compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion/simpleMembers.kt"); - } - - @Test - @TestMetadata("sinceOldVersionIsOK.kt") - public void testSinceOldVersionIsOK() throws Exception { - runTest("compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion/sinceOldVersionIsOK.kt"); - } - - @Test - @TestMetadata("typealiasesAsCompanionObjects.kt") - public void testTypealiasesAsCompanionObjects() throws Exception { - runTest("compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion/typealiasesAsCompanionObjects.kt"); - } - - @Test - @TestMetadata("typealiasesAsConstructors.kt") - public void testTypealiasesAsConstructors() throws Exception { - runTest("compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion/typealiasesAsConstructors.kt"); - } - - @Test - @TestMetadata("typealiasesAsObjects.kt") - public void testTypealiasesAsObjects() throws Exception { - runTest("compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion/typealiasesAsObjects.kt"); - } - - @Test - @TestMetadata("typealiasesAsTypes.kt") - public void testTypealiasesAsTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion/typealiasesAsTypes.kt"); - } - - @Test - @TestMetadata("typealiasesOnImport.kt") - public void testTypealiasesOnImport() throws Exception { - runTest("compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion/typealiasesOnImport.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/sourceCompatibility/noBoundCallableReferences") - @TestDataPath("$PROJECT_ROOT") - public class NoBoundCallableReferences extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInNoBoundCallableReferences() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/sourceCompatibility/noBoundCallableReferences"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("boundCallableReference.kt") - public void testBoundCallableReference() throws Exception { - runTest("compiler/testData/diagnostics/tests/sourceCompatibility/noBoundCallableReferences/boundCallableReference.kt"); - } - - @Test - @TestMetadata("boundClassLiteral.kt") - public void testBoundClassLiteral() throws Exception { - runTest("compiler/testData/diagnostics/tests/sourceCompatibility/noBoundCallableReferences/boundClassLiteral.kt"); - } - - @Test - @TestMetadata("qualifiedJavaClassLiteralInKClassExtension.kt") - public void testQualifiedJavaClassLiteralInKClassExtension() throws Exception { - runTest("compiler/testData/diagnostics/tests/sourceCompatibility/noBoundCallableReferences/qualifiedJavaClassLiteralInKClassExtension.kt"); - } - - @Test - @TestMetadata("qualifiedJavaClassReferenceInKClassExtension.kt") - public void testQualifiedJavaClassReferenceInKClassExtension() throws Exception { - runTest("compiler/testData/diagnostics/tests/sourceCompatibility/noBoundCallableReferences/qualifiedJavaClassReferenceInKClassExtension.kt"); - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/substitutions") - @TestDataPath("$PROJECT_ROOT") - public class Substitutions extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInSubstitutions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/substitutions"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("kt1558-short.kt") - public void testKt1558_short() throws Exception { - runTest("compiler/testData/diagnostics/tests/substitutions/kt1558-short.kt"); - } - - @Test - @TestMetadata("kt4887.kt") - public void testKt4887() throws Exception { - runTest("compiler/testData/diagnostics/tests/substitutions/kt4887.kt"); - } - - @Test - @TestMetadata("starProjections.kt") - public void testStarProjections() throws Exception { - runTest("compiler/testData/diagnostics/tests/substitutions/starProjections.kt"); - } - - @Test - @TestMetadata("upperBoundsSubstitutionForOverloadResolutionWithAmbiguity.kt") - public void testUpperBoundsSubstitutionForOverloadResolutionWithAmbiguity() throws Exception { - runTest("compiler/testData/diagnostics/tests/substitutions/upperBoundsSubstitutionForOverloadResolutionWithAmbiguity.kt"); - } - - @Test - @TestMetadata("upperBoundsSubstitutionForOverloadResolutionWithErrorTypes.kt") - public void testUpperBoundsSubstitutionForOverloadResolutionWithErrorTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/substitutions/upperBoundsSubstitutionForOverloadResolutionWithErrorTypes.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/subtyping") - @TestDataPath("$PROJECT_ROOT") - public class Subtyping extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInSubtyping() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/subtyping"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("extFunctionTypeAsSuperType.kt") - public void testExtFunctionTypeAsSuperType() throws Exception { - runTest("compiler/testData/diagnostics/tests/subtyping/extFunctionTypeAsSuperType.kt"); - } - - @Test - @TestMetadata("findClosestCorrespondingSupertype.kt") - public void testFindClosestCorrespondingSupertype() throws Exception { - runTest("compiler/testData/diagnostics/tests/subtyping/findClosestCorrespondingSupertype.kt"); - } - - @Test - @TestMetadata("functionTypeAsSuperType.kt") - public void testFunctionTypeAsSuperType() throws Exception { - runTest("compiler/testData/diagnostics/tests/subtyping/functionTypeAsSuperType.kt"); - } - - @Test - @TestMetadata("invariantArgumentForTypeParameterWithMultipleBounds.kt") - public void testInvariantArgumentForTypeParameterWithMultipleBounds() throws Exception { - runTest("compiler/testData/diagnostics/tests/subtyping/invariantArgumentForTypeParameterWithMultipleBounds.kt"); - } - - @Test - @TestMetadata("javaAndKotlinSuperType.kt") - public void testJavaAndKotlinSuperType() throws Exception { - runTest("compiler/testData/diagnostics/tests/subtyping/javaAndKotlinSuperType.kt"); - } - - @Test - @TestMetadata("kt2069.kt") - public void testKt2069() throws Exception { - runTest("compiler/testData/diagnostics/tests/subtyping/kt2069.kt"); - } - - @Test - @TestMetadata("kt2744.kt") - public void testKt2744() throws Exception { - runTest("compiler/testData/diagnostics/tests/subtyping/kt2744.kt"); - } - - @Test - @TestMetadata("kt304.kt") - public void testKt304() throws Exception { - runTest("compiler/testData/diagnostics/tests/subtyping/kt304.kt"); - } - - @Test - @TestMetadata("kt3159.kt") - public void testKt3159() throws Exception { - runTest("compiler/testData/diagnostics/tests/subtyping/kt3159.kt"); - } - - @Test - @TestMetadata("kt-1457.kt") - public void testKt_1457() throws Exception { - runTest("compiler/testData/diagnostics/tests/subtyping/kt-1457.kt"); - } - - @Test - @TestMetadata("localAnonymousObjects.kt") - public void testLocalAnonymousObjects() throws Exception { - runTest("compiler/testData/diagnostics/tests/subtyping/localAnonymousObjects.kt"); - } - - @Test - @TestMetadata("localClasses.kt") - public void testLocalClasses() throws Exception { - runTest("compiler/testData/diagnostics/tests/subtyping/localClasses.kt"); - } - - @Test - @TestMetadata("memberAnonymousObjects.kt") - public void testMemberAnonymousObjects() throws Exception { - runTest("compiler/testData/diagnostics/tests/subtyping/memberAnonymousObjects.kt"); - } - - @Test - @TestMetadata("nestedIntoLocalClasses.kt") - public void testNestedIntoLocalClasses() throws Exception { - runTest("compiler/testData/diagnostics/tests/subtyping/nestedIntoLocalClasses.kt"); - } - - @Test - @TestMetadata("nestedLocalClasses.kt") - public void testNestedLocalClasses() throws Exception { - runTest("compiler/testData/diagnostics/tests/subtyping/nestedLocalClasses.kt"); - } - - @Test - @TestMetadata("topLevelAnonymousObjects.kt") - public void testTopLevelAnonymousObjects() throws Exception { - runTest("compiler/testData/diagnostics/tests/subtyping/topLevelAnonymousObjects.kt"); - } - - @Test - @TestMetadata("unresolvedSupertype.kt") - public void testUnresolvedSupertype() throws Exception { - runTest("compiler/testData/diagnostics/tests/subtyping/unresolvedSupertype.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/suppress") - @TestDataPath("$PROJECT_ROOT") - public class Suppress extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInSuppress() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/suppress"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/suppress/allWarnings") - @TestDataPath("$PROJECT_ROOT") - public class AllWarnings extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInAllWarnings() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/suppress/allWarnings"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("suppressWarningsOnAnonymousObjectInVariable.kt") - public void testSuppressWarningsOnAnonymousObjectInVariable() throws Exception { - runTest("compiler/testData/diagnostics/tests/suppress/allWarnings/suppressWarningsOnAnonymousObjectInVariable.kt"); - } - - @Test - @TestMetadata("suppressWarningsOnClass.kt") - public void testSuppressWarningsOnClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/suppress/allWarnings/suppressWarningsOnClass.kt"); - } - - @Test - @TestMetadata("suppressWarningsOnClassObject.kt") - public void testSuppressWarningsOnClassObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/suppress/allWarnings/suppressWarningsOnClassObject.kt"); - } - - @Test - @TestMetadata("suppressWarningsOnExpression.kt") - public void testSuppressWarningsOnExpression() throws Exception { - runTest("compiler/testData/diagnostics/tests/suppress/allWarnings/suppressWarningsOnExpression.kt"); - } - - @Test - @TestMetadata("suppressWarningsOnFile.kt") - public void testSuppressWarningsOnFile() throws Exception { - runTest("compiler/testData/diagnostics/tests/suppress/allWarnings/suppressWarningsOnFile.kt"); - } - - @Test - @TestMetadata("suppressWarningsOnFunction.kt") - public void testSuppressWarningsOnFunction() throws Exception { - runTest("compiler/testData/diagnostics/tests/suppress/allWarnings/suppressWarningsOnFunction.kt"); - } - - @Test - @TestMetadata("suppressWarningsOnObject.kt") - public void testSuppressWarningsOnObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/suppress/allWarnings/suppressWarningsOnObject.kt"); - } - - @Test - @TestMetadata("suppressWarningsOnParameter.kt") - public void testSuppressWarningsOnParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/suppress/allWarnings/suppressWarningsOnParameter.kt"); - } - - @Test - @TestMetadata("suppressWarningsOnProperty.kt") - public void testSuppressWarningsOnProperty() throws Exception { - runTest("compiler/testData/diagnostics/tests/suppress/allWarnings/suppressWarningsOnProperty.kt"); - } - - @Test - @TestMetadata("suppressWarningsOnPropertyAccessor.kt") - public void testSuppressWarningsOnPropertyAccessor() throws Exception { - runTest("compiler/testData/diagnostics/tests/suppress/allWarnings/suppressWarningsOnPropertyAccessor.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/suppress/manyWarnings") - @TestDataPath("$PROJECT_ROOT") - public class ManyWarnings extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInManyWarnings() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/suppress/manyWarnings"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("mixed.kt") - public void testMixed() throws Exception { - runTest("compiler/testData/diagnostics/tests/suppress/manyWarnings/mixed.kt"); - } - - @Test - @TestMetadata("onClass.kt") - public void testOnClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/suppress/manyWarnings/onClass.kt"); - } - - @Test - @TestMetadata("onClassObject.kt") - public void testOnClassObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/suppress/manyWarnings/onClassObject.kt"); - } - - @Test - @TestMetadata("onExpression.kt") - public void testOnExpression() throws Exception { - runTest("compiler/testData/diagnostics/tests/suppress/manyWarnings/onExpression.kt"); - } - - @Test - @TestMetadata("onFunction.kt") - public void testOnFunction() throws Exception { - runTest("compiler/testData/diagnostics/tests/suppress/manyWarnings/onFunction.kt"); - } - - @Test - @TestMetadata("onObject.kt") - public void testOnObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/suppress/manyWarnings/onObject.kt"); - } - - @Test - @TestMetadata("onParameter.kt") - public void testOnParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/suppress/manyWarnings/onParameter.kt"); - } - - @Test - @TestMetadata("onProperty.kt") - public void testOnProperty() throws Exception { - runTest("compiler/testData/diagnostics/tests/suppress/manyWarnings/onProperty.kt"); - } - - @Test - @TestMetadata("onPropertyAccessor.kt") - public void testOnPropertyAccessor() throws Exception { - runTest("compiler/testData/diagnostics/tests/suppress/manyWarnings/onPropertyAccessor.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/suppress/oneWarning") - @TestDataPath("$PROJECT_ROOT") - public class OneWarning extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInOneWarning() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/suppress/oneWarning"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("onBlockStatement.kt") - public void testOnBlockStatement() throws Exception { - runTest("compiler/testData/diagnostics/tests/suppress/oneWarning/onBlockStatement.kt"); - } - - @Test - @TestMetadata("onBlockStatementSameLine.kt") - public void testOnBlockStatementSameLine() throws Exception { - runTest("compiler/testData/diagnostics/tests/suppress/oneWarning/onBlockStatementSameLine.kt"); - } - - @Test - @TestMetadata("onClass.kt") - public void testOnClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/suppress/oneWarning/onClass.kt"); - } - - @Test - @TestMetadata("onClassObject.kt") - public void testOnClassObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/suppress/oneWarning/onClassObject.kt"); - } - - @Test - @TestMetadata("onExpression.kt") - public void testOnExpression() throws Exception { - runTest("compiler/testData/diagnostics/tests/suppress/oneWarning/onExpression.kt"); - } - - @Test - @TestMetadata("onFunction.kt") - public void testOnFunction() throws Exception { - runTest("compiler/testData/diagnostics/tests/suppress/oneWarning/onFunction.kt"); - } - - @Test - @TestMetadata("onLocalVariable.kt") - public void testOnLocalVariable() throws Exception { - runTest("compiler/testData/diagnostics/tests/suppress/oneWarning/onLocalVariable.kt"); - } - - @Test - @TestMetadata("onObject.kt") - public void testOnObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/suppress/oneWarning/onObject.kt"); - } - - @Test - @TestMetadata("onParameter.kt") - public void testOnParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/suppress/oneWarning/onParameter.kt"); - } - - @Test - @TestMetadata("onProperty.kt") - public void testOnProperty() throws Exception { - runTest("compiler/testData/diagnostics/tests/suppress/oneWarning/onProperty.kt"); - } - - @Test - @TestMetadata("onPropertyAccessor.kt") - public void testOnPropertyAccessor() throws Exception { - runTest("compiler/testData/diagnostics/tests/suppress/oneWarning/onPropertyAccessor.kt"); - } - - @Test - @TestMetadata("onTypeParameter.kt") - public void testOnTypeParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/suppress/oneWarning/onTypeParameter.kt"); - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/suspendConversion") - @TestDataPath("$PROJECT_ROOT") - public class SuspendConversion extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInSuspendConversion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/suspendConversion"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("basicSuspendConversion.kt") - public void testBasicSuspendConversion() throws Exception { - runTest("compiler/testData/diagnostics/tests/suspendConversion/basicSuspendConversion.kt"); - } - - @Test - @TestMetadata("basicSuspendConversionForCallableReference.kt") - public void testBasicSuspendConversionForCallableReference() throws Exception { - runTest("compiler/testData/diagnostics/tests/suspendConversion/basicSuspendConversionForCallableReference.kt"); - } - - @Test - @TestMetadata("basicSuspendConversionGenerics.kt") - public void testBasicSuspendConversionGenerics() throws Exception { - runTest("compiler/testData/diagnostics/tests/suspendConversion/basicSuspendConversionGenerics.kt"); - } - - @Test - @TestMetadata("chainedFunSuspendConversionForSimpleExpression.kt") - public void testChainedFunSuspendConversionForSimpleExpression() throws Exception { - runTest("compiler/testData/diagnostics/tests/suspendConversion/chainedFunSuspendConversionForSimpleExpression.kt"); - } - - @Test - @TestMetadata("overloadResolutionBySuspendModifier.kt") - public void testOverloadResolutionBySuspendModifier() throws Exception { - runTest("compiler/testData/diagnostics/tests/suspendConversion/overloadResolutionBySuspendModifier.kt"); - } - - @Test - @TestMetadata("severalConversionsInOneCall.kt") - public void testSeveralConversionsInOneCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/suspendConversion/severalConversionsInOneCall.kt"); - } - - @Test - @TestMetadata("suspendAndFunConversionInDisabledMode.kt") - public void testSuspendAndFunConversionInDisabledMode() throws Exception { - runTest("compiler/testData/diagnostics/tests/suspendConversion/suspendAndFunConversionInDisabledMode.kt"); - } - - @Test - @TestMetadata("suspendConversionCompatibility.kt") - public void testSuspendConversionCompatibility() throws Exception { - runTest("compiler/testData/diagnostics/tests/suspendConversion/suspendConversionCompatibility.kt"); - } - - @Test - @TestMetadata("suspendConversionCompatibilityInDisabledMode.kt") - public void testSuspendConversionCompatibilityInDisabledMode() throws Exception { - runTest("compiler/testData/diagnostics/tests/suspendConversion/suspendConversionCompatibilityInDisabledMode.kt"); - } - - @Test - @TestMetadata("suspendConversionDisabled.kt") - public void testSuspendConversionDisabled() throws Exception { - runTest("compiler/testData/diagnostics/tests/suspendConversion/suspendConversionDisabled.kt"); - } - - @Test - @TestMetadata("suspendConversionOnVarargElements.kt") - public void testSuspendConversionOnVarargElements() throws Exception { - runTest("compiler/testData/diagnostics/tests/suspendConversion/suspendConversionOnVarargElements.kt"); - } - - @Test - @TestMetadata("suspendConversionWithFunInterfaces.kt") - public void testSuspendConversionWithFunInterfaces() throws Exception { - runTest("compiler/testData/diagnostics/tests/suspendConversion/suspendConversionWithFunInterfaces.kt"); - } - - @Test - @TestMetadata("suspendConversionWithReferenceAdaptation.kt") - public void testSuspendConversionWithReferenceAdaptation() throws Exception { - runTest("compiler/testData/diagnostics/tests/suspendConversion/suspendConversionWithReferenceAdaptation.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/syntheticExtensions") - @TestDataPath("$PROJECT_ROOT") - public class SyntheticExtensions extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInSyntheticExtensions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/syntheticExtensions"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties") - @TestDataPath("$PROJECT_ROOT") - public class JavaProperties extends AbstractDiagnosticUsingJavacTest { - @Test - @TestMetadata("AbbreviationName.kt") - public void testAbbreviationName() throws Exception { - runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/AbbreviationName.kt"); - } - - @Test - public void testAllFilesPresentInJavaProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("Bases.kt") - public void testBases() throws Exception { - runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/Bases.kt"); - } - - @Test - @TestMetadata("CompiledClass.kt") - public void testCompiledClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/CompiledClass.kt"); - } - - @Test - @TestMetadata("Deprecated.kt") - public void testDeprecated() throws Exception { - runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/Deprecated.kt"); - } - - @Test - @TestMetadata("FalseGetters.kt") - public void testFalseGetters() throws Exception { - runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/FalseGetters.kt"); - } - - @Test - @TestMetadata("FalseSetters.kt") - public void testFalseSetters() throws Exception { - runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/FalseSetters.kt"); - } - - @Test - @TestMetadata("FromTwoBases.kt") - public void testFromTwoBases() throws Exception { - runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/FromTwoBases.kt"); - } - - @Test - @TestMetadata("GenericClass.kt") - public void testGenericClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/GenericClass.kt"); - } - - @Test - @TestMetadata("GetA.kt") - public void testGetA() throws Exception { - runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/GetA.kt"); - } - - @Test - @TestMetadata("Getter.kt") - public void testGetter() throws Exception { - runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/Getter.kt"); - } - - @Test - @TestMetadata("GetterAndSetter.kt") - public void testGetterAndSetter() throws Exception { - runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/GetterAndSetter.kt"); - } - - @Test - @TestMetadata("ImplicitReceiver.kt") - public void testImplicitReceiver() throws Exception { - runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/ImplicitReceiver.kt"); - } - - @Test - @TestMetadata("IsNaming.kt") - public void testIsNaming() throws Exception { - runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/IsNaming.kt"); - } - - @Test - @TestMetadata("JavaOverridesKotlin.kt") - public void testJavaOverridesKotlin() throws Exception { - runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/JavaOverridesKotlin.kt"); - } - - @Test - @TestMetadata("KotlinOverridesJava.kt") - public void testKotlinOverridesJava() throws Exception { - runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/KotlinOverridesJava.kt"); - } - - @Test - @TestMetadata("KotlinOverridesJava2.kt") - public void testKotlinOverridesJava2() throws Exception { - runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/KotlinOverridesJava2.kt"); - } - - @Test - @TestMetadata("KotlinOverridesJava3.kt") - public void testKotlinOverridesJava3() throws Exception { - runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/KotlinOverridesJava3.kt"); - } - - @Test - @TestMetadata("KotlinOverridesJava4.kt") - public void testKotlinOverridesJava4() throws Exception { - runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/KotlinOverridesJava4.kt"); - } - - @Test - @TestMetadata("KotlinOverridesJava5.kt") - public void testKotlinOverridesJava5() throws Exception { - runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/KotlinOverridesJava5.kt"); - } - - @Test - @TestMetadata("OnlyAscii.kt") - public void testOnlyAscii() throws Exception { - runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/OnlyAscii.kt"); - } - - @Test - @TestMetadata("OnlyPublic.kt") - public void testOnlyPublic() throws Exception { - runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/OnlyPublic.kt"); - } - - @Test - @TestMetadata("OverrideGetterOnly.kt") - public void testOverrideGetterOnly() throws Exception { - runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/OverrideGetterOnly.kt"); - } - - @Test - @TestMetadata("PartiallySupportedSyntheticJavaPropertyReference.kt") - public void testPartiallySupportedSyntheticJavaPropertyReference() throws Exception { - runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/PartiallySupportedSyntheticJavaPropertyReference.kt"); - } - - @Test - @TestMetadata("SetterHasHigherAccess.kt") - public void testSetterHasHigherAccess() throws Exception { - runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/SetterHasHigherAccess.kt"); - } - - @Test - @TestMetadata("SetterOnly.kt") - public void testSetterOnly() throws Exception { - runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/SetterOnly.kt"); - } - - @Test - @TestMetadata("SmartCast.kt") - public void testSmartCast() throws Exception { - runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/SmartCast.kt"); - } - - @Test - @TestMetadata("SmartCastImplicitReceiver.kt") - public void testSmartCastImplicitReceiver() throws Exception { - runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/SmartCastImplicitReceiver.kt"); - } - - @Test - @TestMetadata("SyntheticJavaPropertyReference.kt") - public void testSyntheticJavaPropertyReference() throws Exception { - runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/SyntheticJavaPropertyReference.kt"); - } - - @Test - @TestMetadata("TypeAnnotation.kt") - public void testTypeAnnotation() throws Exception { - runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/TypeAnnotation.kt"); - } - - @Test - @TestMetadata("TypeParameterReceiver.kt") - public void testTypeParameterReceiver() throws Exception { - runTest("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/TypeParameterReceiver.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters") - @TestDataPath("$PROJECT_ROOT") - public class SamAdapters extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInSamAdapters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("Deprecated.kt") - public void testDeprecated() throws Exception { - runTest("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/Deprecated.kt"); - } - - @Test - @TestMetadata("GenericClass.kt") - public void testGenericClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericClass.kt"); - } - - @Test - @TestMetadata("GenericMethod.kt") - public void testGenericMethod() throws Exception { - runTest("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericMethod.kt"); - } - - @Test - @TestMetadata("GenericMethodInGenericClass.kt") - public void testGenericMethodInGenericClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericMethodInGenericClass.kt"); - } - - @Test - @TestMetadata("InnerClassInGeneric.kt") - public void testInnerClassInGeneric() throws Exception { - runTest("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/InnerClassInGeneric.kt"); - } - - @Test - @TestMetadata("NoNamedArgsAllowed.kt") - public void testNoNamedArgsAllowed() throws Exception { - runTest("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/NoNamedArgsAllowed.kt"); - } - - @Test - @TestMetadata("overloadResolution.kt") - public void testOverloadResolution() throws Exception { - runTest("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/overloadResolution.kt"); - } - - @Test - @TestMetadata("overloadResolutionStatic.kt") - public void testOverloadResolutionStatic() throws Exception { - runTest("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/overloadResolutionStatic.kt"); - } - - @Test - @TestMetadata("overloadResolutionStaticWithoutRefinedSams.kt") - public void testOverloadResolutionStaticWithoutRefinedSams() throws Exception { - runTest("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/overloadResolutionStaticWithoutRefinedSams.kt"); - } - - @Test - @TestMetadata("overloadResolutionWithoutRefinedSams.kt") - public void testOverloadResolutionWithoutRefinedSams() throws Exception { - runTest("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/overloadResolutionWithoutRefinedSams.kt"); - } - - @Test - @TestMetadata("PackageLocal.kt") - public void testPackageLocal() throws Exception { - runTest("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/PackageLocal.kt"); - } - - @Test - @TestMetadata("ParameterTypeAnnotation.kt") - public void testParameterTypeAnnotation() throws Exception { - runTest("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/ParameterTypeAnnotation.kt"); - } - - @Test - @TestMetadata("PassNull.kt") - public void testPassNull() throws Exception { - runTest("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/PassNull.kt"); - } - - @Test - @TestMetadata("Private.kt") - public void testPrivate() throws Exception { - runTest("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/Private.kt"); - } - - @Test - @TestMetadata("Protected.kt") - public void testProtected() throws Exception { - runTest("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/Protected.kt"); - } - - @Test - @TestMetadata("ReturnTypeAnnotation.kt") - public void testReturnTypeAnnotation() throws Exception { - runTest("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/ReturnTypeAnnotation.kt"); - } - - @Test - @TestMetadata("Simple.kt") - public void testSimple() throws Exception { - runTest("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/Simple.kt"); - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/targetedBuiltIns") - @TestDataPath("$PROJECT_ROOT") - public class TargetedBuiltIns extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInTargetedBuiltIns() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/targetedBuiltIns"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("concurrentMapRemove.kt") - public void testConcurrentMapRemove() throws Exception { - runTest("compiler/testData/diagnostics/tests/targetedBuiltIns/concurrentMapRemove.kt"); - } - - @Test - @TestMetadata("forEachRemainingNullability.kt") - public void testForEachRemainingNullability() throws Exception { - runTest("compiler/testData/diagnostics/tests/targetedBuiltIns/forEachRemainingNullability.kt"); - } - - @Test - @TestMetadata("getOrDefault.kt") - public void testGetOrDefault() throws Exception { - runTest("compiler/testData/diagnostics/tests/targetedBuiltIns/getOrDefault.kt"); - } - - @Test - @TestMetadata("mutableMapRemove.kt") - public void testMutableMapRemove() throws Exception { - runTest("compiler/testData/diagnostics/tests/targetedBuiltIns/mutableMapRemove.kt"); - } - - @Test - @TestMetadata("removeIf.kt") - public void testRemoveIf() throws Exception { - runTest("compiler/testData/diagnostics/tests/targetedBuiltIns/removeIf.kt"); - } - - @Test - @TestMetadata("stream.kt") - public void testStream() throws Exception { - runTest("compiler/testData/diagnostics/tests/targetedBuiltIns/stream.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/targetedBuiltIns/backwardCompatibility") - @TestDataPath("$PROJECT_ROOT") - public class BackwardCompatibility extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInBackwardCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/targetedBuiltIns/backwardCompatibility"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("basic.kt") - public void testBasic() throws Exception { - runTest("compiler/testData/diagnostics/tests/targetedBuiltIns/backwardCompatibility/basic.kt"); - } - - @Test - @TestMetadata("delegation.kt") - public void testDelegation() throws Exception { - runTest("compiler/testData/diagnostics/tests/targetedBuiltIns/backwardCompatibility/delegation.kt"); - } - - @Test - @TestMetadata("derivedInterfaces.kt") - public void testDerivedInterfaces() throws Exception { - runTest("compiler/testData/diagnostics/tests/targetedBuiltIns/backwardCompatibility/derivedInterfaces.kt"); - } - - @Test - @TestMetadata("derivedInterfacesWithKotlinFun.kt") - public void testDerivedInterfacesWithKotlinFun() throws Exception { - runTest("compiler/testData/diagnostics/tests/targetedBuiltIns/backwardCompatibility/derivedInterfacesWithKotlinFun.kt"); - } - - @Test - @TestMetadata("fillInStackTrace.kt") - public void testFillInStackTrace() throws Exception { - runTest("compiler/testData/diagnostics/tests/targetedBuiltIns/backwardCompatibility/fillInStackTrace.kt"); - } - - @Test - @TestMetadata("finalize.kt") - public void testFinalize() throws Exception { - runTest("compiler/testData/diagnostics/tests/targetedBuiltIns/backwardCompatibility/finalize.kt"); - } - - @Test - @TestMetadata("hashMapGetOrDefault.kt") - public void testHashMapGetOrDefault() throws Exception { - runTest("compiler/testData/diagnostics/tests/targetedBuiltIns/backwardCompatibility/hashMapGetOrDefault.kt"); - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/thisAndSuper") - @TestDataPath("$PROJECT_ROOT") - public class ThisAndSuper extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInThisAndSuper() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/thisAndSuper"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("ambigousLabelOnThis.kt") - public void testAmbigousLabelOnThis() throws Exception { - runTest("compiler/testData/diagnostics/tests/thisAndSuper/ambigousLabelOnThis.kt"); - } - - @Test - @TestMetadata("genericQualifiedSuperOverridden.kt") - public void testGenericQualifiedSuperOverridden() throws Exception { - runTest("compiler/testData/diagnostics/tests/thisAndSuper/genericQualifiedSuperOverridden.kt"); - } - - @Test - @TestMetadata("implicitInvokeOnSuper.kt") - public void testImplicitInvokeOnSuper() throws Exception { - runTest("compiler/testData/diagnostics/tests/thisAndSuper/implicitInvokeOnSuper.kt"); - } - - @Test - @TestMetadata("notAccessibleSuperInTrait.kt") - public void testNotAccessibleSuperInTrait() throws Exception { - runTest("compiler/testData/diagnostics/tests/thisAndSuper/notAccessibleSuperInTrait.kt"); - } - - @Test - @TestMetadata("qualifiedSuperOverridden.kt") - public void testQualifiedSuperOverridden() throws Exception { - runTest("compiler/testData/diagnostics/tests/thisAndSuper/qualifiedSuperOverridden.kt"); - } - - @Test - @TestMetadata("QualifiedThis.kt") - public void testQualifiedThis() throws Exception { - runTest("compiler/testData/diagnostics/tests/thisAndSuper/QualifiedThis.kt"); - } - - @Test - @TestMetadata("Super.kt") - public void testSuper() throws Exception { - runTest("compiler/testData/diagnostics/tests/thisAndSuper/Super.kt"); - } - - @Test - @TestMetadata("superInExtensionFunction.kt") - public void testSuperInExtensionFunction() throws Exception { - runTest("compiler/testData/diagnostics/tests/thisAndSuper/superInExtensionFunction.kt"); - } - - @Test - @TestMetadata("superInExtensionFunctionCall.kt") - public void testSuperInExtensionFunctionCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/thisAndSuper/superInExtensionFunctionCall.kt"); - } - - @Test - @TestMetadata("superInToplevelFunction.kt") - public void testSuperInToplevelFunction() throws Exception { - runTest("compiler/testData/diagnostics/tests/thisAndSuper/superInToplevelFunction.kt"); - } - - @Test - @TestMetadata("superIsNotAnExpression.kt") - public void testSuperIsNotAnExpression() throws Exception { - runTest("compiler/testData/diagnostics/tests/thisAndSuper/superIsNotAnExpression.kt"); - } - - @Test - @TestMetadata("thisInFunctionLiterals.kt") - public void testThisInFunctionLiterals() throws Exception { - runTest("compiler/testData/diagnostics/tests/thisAndSuper/thisInFunctionLiterals.kt"); - } - - @Test - @TestMetadata("thisInInnerClasses.kt") - public void testThisInInnerClasses() throws Exception { - runTest("compiler/testData/diagnostics/tests/thisAndSuper/thisInInnerClasses.kt"); - } - - @Test - @TestMetadata("thisInPropertyInitializer.kt") - public void testThisInPropertyInitializer() throws Exception { - runTest("compiler/testData/diagnostics/tests/thisAndSuper/thisInPropertyInitializer.kt"); - } - - @Test - @TestMetadata("thisInToplevelFunction.kt") - public void testThisInToplevelFunction() throws Exception { - runTest("compiler/testData/diagnostics/tests/thisAndSuper/thisInToplevelFunction.kt"); - } - - @Test - @TestMetadata("traitSuperCall.kt") - public void testTraitSuperCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/thisAndSuper/traitSuperCall.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper") - @TestDataPath("$PROJECT_ROOT") - public class UnqualifiedSuper extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInUnqualifiedSuper() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("ambiguousSuperWithGenerics.kt") - public void testAmbiguousSuperWithGenerics() throws Exception { - runTest("compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/ambiguousSuperWithGenerics.kt"); - } - - @Test - @TestMetadata("unqualifiedSuper.kt") - public void testUnqualifiedSuper() throws Exception { - runTest("compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/unqualifiedSuper.kt"); - } - - @Test - @TestMetadata("unqualifiedSuperWithAbstractMembers.kt") - public void testUnqualifiedSuperWithAbstractMembers() throws Exception { - runTest("compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/unqualifiedSuperWithAbstractMembers.kt"); - } - - @Test - @TestMetadata("unqualifiedSuperWithCallableProperty.kt") - public void testUnqualifiedSuperWithCallableProperty() throws Exception { - runTest("compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/unqualifiedSuperWithCallableProperty.kt"); - } - - @Test - @TestMetadata("unqualifiedSuperWithDeeperHierarchies.kt") - public void testUnqualifiedSuperWithDeeperHierarchies() throws Exception { - runTest("compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/unqualifiedSuperWithDeeperHierarchies.kt"); - } - - @Test - @TestMetadata("unqualifiedSuperWithGenerics.kt") - public void testUnqualifiedSuperWithGenerics() throws Exception { - runTest("compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/unqualifiedSuperWithGenerics.kt"); - } - - @Test - @TestMetadata("unqualifiedSuperWithInnerClass.kt") - public void testUnqualifiedSuperWithInnerClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/unqualifiedSuperWithInnerClass.kt"); - } - - @Test - @TestMetadata("unqualifiedSuperWithInterfaces.kt") - public void testUnqualifiedSuperWithInterfaces() throws Exception { - runTest("compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/unqualifiedSuperWithInterfaces.kt"); - } - - @Test - @TestMetadata("unqualifiedSuperWithLocalClass.kt") - public void testUnqualifiedSuperWithLocalClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/unqualifiedSuperWithLocalClass.kt"); - } - - @Test - @TestMetadata("unqualifiedSuperWithUnresolvedBase.kt") - public void testUnqualifiedSuperWithUnresolvedBase() throws Exception { - runTest("compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/unqualifiedSuperWithUnresolvedBase.kt"); - } - - @Test - @TestMetadata("withMethodOfAnyOverridenInInterface.kt") - public void testWithMethodOfAnyOverridenInInterface() throws Exception { - runTest("compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/withMethodOfAnyOverridenInInterface.kt"); - } - - @Test - @TestMetadata("withMethodOverriddenInAnotherSupertype.kt") - public void testWithMethodOverriddenInAnotherSupertype() throws Exception { - runTest("compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/withMethodOverriddenInAnotherSupertype.kt"); - } - - @Test - @TestMetadata("withMethodsOfAny.kt") - public void testWithMethodsOfAny() throws Exception { - runTest("compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper/withMethodsOfAny.kt"); - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/traitWithRequired") - @TestDataPath("$PROJECT_ROOT") - public class TraitWithRequired extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInTraitWithRequired() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/traitWithRequired"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("traitRequiresAny.kt") - public void testTraitRequiresAny() throws Exception { - runTest("compiler/testData/diagnostics/tests/traitWithRequired/traitRequiresAny.kt"); - } - - @Test - @TestMetadata("traitSupertypeList.kt") - public void testTraitSupertypeList() throws Exception { - runTest("compiler/testData/diagnostics/tests/traitWithRequired/traitSupertypeList.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/typeParameters") - @TestDataPath("$PROJECT_ROOT") - public class TypeParameters extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInTypeParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/typeParameters"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("cannotHaveManyClassUpperBounds.kt") - public void testCannotHaveManyClassUpperBounds() throws Exception { - runTest("compiler/testData/diagnostics/tests/typeParameters/cannotHaveManyClassUpperBounds.kt"); - } - - @Test - @TestMetadata("deprecatedSyntax.kt") - public void testDeprecatedSyntax() throws Exception { - runTest("compiler/testData/diagnostics/tests/typeParameters/deprecatedSyntax.kt"); - } - - @Test - @TestMetadata("extFunctionTypeAsUpperBound.kt") - public void testExtFunctionTypeAsUpperBound() throws Exception { - runTest("compiler/testData/diagnostics/tests/typeParameters/extFunctionTypeAsUpperBound.kt"); - } - - @Test - @TestMetadata("functionTypeAsUpperBound.kt") - public void testFunctionTypeAsUpperBound() throws Exception { - runTest("compiler/testData/diagnostics/tests/typeParameters/functionTypeAsUpperBound.kt"); - } - - @Test - @TestMetadata("implicitNothingAgainstNotNothingExpectedType.kt") - public void testImplicitNothingAgainstNotNothingExpectedType() throws Exception { - runTest("compiler/testData/diagnostics/tests/typeParameters/implicitNothingAgainstNotNothingExpectedType.kt"); - } - - @Test - @TestMetadata("implicitNothingInReturnPosition.kt") - public void testImplicitNothingInReturnPosition() throws Exception { - runTest("compiler/testData/diagnostics/tests/typeParameters/implicitNothingInReturnPosition.kt"); - } - - @Test - @TestMetadata("implicitNothingOfJavaCallAgainstNotNothingExpectedType.kt") - public void testImplicitNothingOfJavaCallAgainstNotNothingExpectedType() throws Exception { - runTest("compiler/testData/diagnostics/tests/typeParameters/implicitNothingOfJavaCallAgainstNotNothingExpectedType.kt"); - } - - @Test - @TestMetadata("implicitNothingOnDelegates.kt") - public void testImplicitNothingOnDelegates() throws Exception { - runTest("compiler/testData/diagnostics/tests/typeParameters/implicitNothingOnDelegates.kt"); - } - - @Test - @TestMetadata("misplacedConstraints.kt") - public void testMisplacedConstraints() throws Exception { - runTest("compiler/testData/diagnostics/tests/typeParameters/misplacedConstraints.kt"); - } - - @Test - @TestMetadata("propertyTypeParameters.kt") - public void testPropertyTypeParameters() throws Exception { - runTest("compiler/testData/diagnostics/tests/typeParameters/propertyTypeParameters.kt"); - } - - @Test - @TestMetadata("propertyTypeParametersWithUpperBounds.kt") - public void testPropertyTypeParametersWithUpperBounds() throws Exception { - runTest("compiler/testData/diagnostics/tests/typeParameters/propertyTypeParametersWithUpperBounds.kt"); - } - - @Test - @TestMetadata("repeatedBound.kt") - public void testRepeatedBound() throws Exception { - runTest("compiler/testData/diagnostics/tests/typeParameters/repeatedBound.kt"); - } - - @Test - @TestMetadata("upperBoundCannotBeArray.kt") - public void testUpperBoundCannotBeArray() throws Exception { - runTest("compiler/testData/diagnostics/tests/typeParameters/upperBoundCannotBeArray.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/typealias") - @TestDataPath("$PROJECT_ROOT") - public class Typealias extends AbstractDiagnosticUsingJavacTest { - @Test - @TestMetadata("aliasesOnly.kt") - public void testAliasesOnly() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/aliasesOnly.kt"); - } - - @Test - public void testAllFilesPresentInTypealias() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/typealias"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("annotationsOnTypeAliases.kt") - public void testAnnotationsOnTypeAliases() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/annotationsOnTypeAliases.kt"); - } - - @Test - @TestMetadata("boundViolationInTypeAliasConstructor.kt") - public void testBoundViolationInTypeAliasConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/boundViolationInTypeAliasConstructor.kt"); - } - - @Test - @TestMetadata("boundsViolationInDeepTypeAliasExpansion.kt") - public void testBoundsViolationInDeepTypeAliasExpansion() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/boundsViolationInDeepTypeAliasExpansion.kt"); - } - - @Test - @TestMetadata("boundsViolationInTypeAliasExpansion.kt") - public void testBoundsViolationInTypeAliasExpansion() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/boundsViolationInTypeAliasExpansion.kt"); - } - - @Test - @TestMetadata("boundsViolationInTypeAliasRHS.kt") - public void testBoundsViolationInTypeAliasRHS() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/boundsViolationInTypeAliasRHS.kt"); - } - - @Test - @TestMetadata("capturingTypeParametersFromOuterClass.kt") - public void testCapturingTypeParametersFromOuterClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/capturingTypeParametersFromOuterClass.kt"); - } - - @Test - @TestMetadata("classReference.kt") - public void testClassReference() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/classReference.kt"); - } - - @Test - @TestMetadata("conflictingProjections.kt") - public void testConflictingProjections() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/conflictingProjections.kt"); - } - - @Test - @TestMetadata("constructorCallThroughPrivateAlias.kt") - public void testConstructorCallThroughPrivateAlias() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/constructorCallThroughPrivateAlias.kt"); - } - - @Test - @TestMetadata("cyclicInheritanceViaTypeAlias.kt") - public void testCyclicInheritanceViaTypeAlias() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/cyclicInheritanceViaTypeAlias.kt"); - } - - @Test - @TestMetadata("enumEntryQualifier.kt") - public void testEnumEntryQualifier() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/enumEntryQualifier.kt"); - } - - @Test - @TestMetadata("exposedExpandedType.kt") - public void testExposedExpandedType() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/exposedExpandedType.kt"); - } - - @Test - @TestMetadata("functionTypeInTypeAlias.kt") - public void testFunctionTypeInTypeAlias() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/functionTypeInTypeAlias.kt"); - } - - @Test - @TestMetadata("genericTypeAliasConstructor.kt") - public void testGenericTypeAliasConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/genericTypeAliasConstructor.kt"); - } - - @Test - @TestMetadata("genericTypeAliasObject.kt") - public void testGenericTypeAliasObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/genericTypeAliasObject.kt"); - } - - @Test - @TestMetadata("illegalTypeInTypeAliasExpansion.kt") - public void testIllegalTypeInTypeAliasExpansion() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/illegalTypeInTypeAliasExpansion.kt"); - } - - @Test - @TestMetadata("import.kt") - public void testImport() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/import.kt"); - } - - @Test - @TestMetadata("importForTypealiasObject.kt") - public void testImportForTypealiasObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/importForTypealiasObject.kt"); - } - - @Test - @TestMetadata("importFromTypeAliasObject.kt") - public void testImportFromTypeAliasObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/importFromTypeAliasObject.kt"); - } - - @Test - @TestMetadata("importMemberFromJavaViaAlias.kt") - public void testImportMemberFromJavaViaAlias() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/importMemberFromJavaViaAlias.kt"); - } - - @Test - @TestMetadata("inGenerics.kt") - public void testInGenerics() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/inGenerics.kt"); - } - - @Test - @TestMetadata("inSupertypesList.kt") - public void testInSupertypesList() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/inSupertypesList.kt"); - } - - @Test - @TestMetadata("inheritedNestedTypeAlias.kt") - public void testInheritedNestedTypeAlias() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/inheritedNestedTypeAlias.kt"); - } - - @Test - @TestMetadata("inhreritedTypeAliasQualifiedByDerivedClass.kt") - public void testInhreritedTypeAliasQualifiedByDerivedClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/inhreritedTypeAliasQualifiedByDerivedClass.kt"); - } - - @Test - @TestMetadata("innerClassTypeAliasConstructor.kt") - public void testInnerClassTypeAliasConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/innerClassTypeAliasConstructor.kt"); - } - - @Test - @TestMetadata("innerClassTypeAliasConstructorInSupertypes.kt") - public void testInnerClassTypeAliasConstructorInSupertypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/innerClassTypeAliasConstructorInSupertypes.kt"); - } - - @Test - @TestMetadata("innerTypeAliasAsType.kt") - public void testInnerTypeAliasAsType() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/innerTypeAliasAsType.kt"); - } - - @Test - @TestMetadata("innerTypeAliasAsType2.kt") - public void testInnerTypeAliasAsType2() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/innerTypeAliasAsType2.kt"); - } - - @Test - @TestMetadata("innerTypeAliasConstructor.kt") - public void testInnerTypeAliasConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/innerTypeAliasConstructor.kt"); - } - - @Test - @TestMetadata("isAsWithTypeAlias.kt") - public void testIsAsWithTypeAlias() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/isAsWithTypeAlias.kt"); - } - - @Test - @TestMetadata("javaStaticMembersViaTypeAlias.kt") - public void testJavaStaticMembersViaTypeAlias() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/javaStaticMembersViaTypeAlias.kt"); - } - - @Test - @TestMetadata("kt14498.kt") - public void testKt14498() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/kt14498.kt"); - } - - @Test - @TestMetadata("kt14498a.kt") - public void testKt14498a() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/kt14498a.kt"); - } - - @Test - @TestMetadata("kt14518.kt") - public void testKt14518() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/kt14518.kt"); - } - - @Test - @TestMetadata("kt14641.kt") - public void testKt14641() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/kt14641.kt"); - } - - @Test - @TestMetadata("kt15734.kt") - public void testKt15734() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/kt15734.kt"); - } - - @Test - @TestMetadata("kt19601.kt") - public void testKt19601() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/kt19601.kt"); - } - - @Test - @TestMetadata("localTypeAlias.kt") - public void testLocalTypeAlias() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/localTypeAlias.kt"); - } - - @Test - @TestMetadata("localTypeAliasConstructor.kt") - public void testLocalTypeAliasConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/localTypeAliasConstructor.kt"); - } - - @Test - @TestMetadata("localTypeAliasModifiers.kt") - public void testLocalTypeAliasModifiers() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/localTypeAliasModifiers.kt"); - } - - @Test - @TestMetadata("localTypeAliasRecursive.kt") - public void testLocalTypeAliasRecursive() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/localTypeAliasRecursive.kt"); - } - - @Test - @TestMetadata("methodReference.kt") - public void testMethodReference() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/methodReference.kt"); - } - - @Test - @TestMetadata("nested.kt") - public void testNested() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/nested.kt"); - } - - @Test - @TestMetadata("nestedCapturingTypeParameters.kt") - public void testNestedCapturingTypeParameters() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/nestedCapturingTypeParameters.kt"); - } - - @Test - @TestMetadata("nestedSubstituted.kt") - public void testNestedSubstituted() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/nestedSubstituted.kt"); - } - - @Test - @TestMetadata("noApproximationInTypeAliasArgumentSubstitution.kt") - public void testNoApproximationInTypeAliasArgumentSubstitution() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/noApproximationInTypeAliasArgumentSubstitution.kt"); - } - - @Test - @TestMetadata("noRHS.kt") - public void testNoRHS() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/noRHS.kt"); - } - - @Test - @TestMetadata("parameterRestrictions.kt") - public void testParameterRestrictions() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/parameterRestrictions.kt"); - } - - @Test - @TestMetadata("parameterSubstitution.kt") - public void testParameterSubstitution() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/parameterSubstitution.kt"); - } - - @Test - @TestMetadata("privateInFile.kt") - public void testPrivateInFile() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/privateInFile.kt"); - } - - @Test - @TestMetadata("projectionsInTypeAliasConstructor.kt") - public void testProjectionsInTypeAliasConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/projectionsInTypeAliasConstructor.kt"); - } - - @Test - @TestMetadata("recursive.kt") - public void testRecursive() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/recursive.kt"); - } - - @Test - @TestMetadata("returnTypeNothingShouldBeSpecifiedExplicitly.kt") - public void testReturnTypeNothingShouldBeSpecifiedExplicitly() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/returnTypeNothingShouldBeSpecifiedExplicitly.kt"); - } - - @Test - @TestMetadata("simpleTypeAlias.kt") - public void testSimpleTypeAlias() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/simpleTypeAlias.kt"); - } - - @Test - @TestMetadata("starImportOnTypeAlias.kt") - public void testStarImportOnTypeAlias() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/starImportOnTypeAlias.kt"); - } - - @Test - @TestMetadata("starProjection.kt") - public void testStarProjection() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/starProjection.kt"); - } - - @Test - @TestMetadata("starProjectionInTypeAliasArgument.kt") - public void testStarProjectionInTypeAliasArgument() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/starProjectionInTypeAliasArgument.kt"); - } - - @Test - @TestMetadata("substitutionVariance.kt") - public void testSubstitutionVariance() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/substitutionVariance.kt"); - } - - @Test - @TestMetadata("throwJLException.kt") - public void testThrowJLException() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/throwJLException.kt"); - } - - @Test - @TestMetadata("topLevelTypeAliasesOnly.kt") - public void testTopLevelTypeAliasesOnly() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/topLevelTypeAliasesOnly.kt"); - } - - @Test - @TestMetadata("typeAliasArgumentsInCompanionObject.kt") - public void testTypeAliasArgumentsInCompanionObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/typeAliasArgumentsInCompanionObject.kt"); - } - - @Test - @TestMetadata("typeAliasArgumentsInConstructor.kt") - public void testTypeAliasArgumentsInConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/typeAliasArgumentsInConstructor.kt"); - } - - @Test - @TestMetadata("typeAliasAsBareType.kt") - public void testTypeAliasAsBareType() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/typeAliasAsBareType.kt"); - } - - @Test - @TestMetadata("typeAliasAsQualifier.kt") - public void testTypeAliasAsQualifier() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/typeAliasAsQualifier.kt"); - } - - @Test - @TestMetadata("typeAliasAsSuperQualifier.kt") - public void testTypeAliasAsSuperQualifier() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/typeAliasAsSuperQualifier.kt"); - } - - @Test - @TestMetadata("typeAliasConstructor.kt") - public void testTypeAliasConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/typeAliasConstructor.kt"); - } - - @Test - @TestMetadata("typeAliasConstructorCrazyProjections.kt") - public void testTypeAliasConstructorCrazyProjections() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/typeAliasConstructorCrazyProjections.kt"); - } - - @Test - @TestMetadata("typeAliasConstructorForInterface.kt") - public void testTypeAliasConstructorForInterface() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/typeAliasConstructorForInterface.kt"); - } - - @Test - @TestMetadata("typeAliasConstructorForProjection.kt") - public void testTypeAliasConstructorForProjection() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/typeAliasConstructorForProjection.kt"); - } - - @Test - @TestMetadata("typeAliasConstructorForProjectionInSupertypes.kt") - public void testTypeAliasConstructorForProjectionInSupertypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/typeAliasConstructorForProjectionInSupertypes.kt"); - } - - @Test - @TestMetadata("typeAliasConstructorInSuperCall.kt") - public void testTypeAliasConstructorInSuperCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/typeAliasConstructorInSuperCall.kt"); - } - - @Test - @TestMetadata("typeAliasConstructorInferenceInSupertypesList.kt") - public void testTypeAliasConstructorInferenceInSupertypesList() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/typeAliasConstructorInferenceInSupertypesList.kt"); - } - - @Test - @TestMetadata("typeAliasConstructorReturnType.kt") - public void testTypeAliasConstructorReturnType() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/typeAliasConstructorReturnType.kt"); - } - - @Test - @TestMetadata("typeAliasConstructorTypeArgumentsInference.kt") - public void testTypeAliasConstructorTypeArgumentsInference() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInference.kt"); - } - - @Test - @TestMetadata("typeAliasConstructorTypeArgumentsInferenceWithNestedCalls.kt") - public void testTypeAliasConstructorTypeArgumentsInferenceWithNestedCalls() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInferenceWithNestedCalls.kt"); - } - - @Test - @TestMetadata("typeAliasConstructorTypeArgumentsInferenceWithNestedCalls2.kt") - public void testTypeAliasConstructorTypeArgumentsInferenceWithNestedCalls2() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInferenceWithNestedCalls2.kt"); - } - - @Test - @TestMetadata("typeAliasConstructorTypeArgumentsInferenceWithPhantomTypes.kt") - public void testTypeAliasConstructorTypeArgumentsInferenceWithPhantomTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInferenceWithPhantomTypes.kt"); - } - - @Test - @TestMetadata("typeAliasConstructorVsFunction.kt") - public void testTypeAliasConstructorVsFunction() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/typeAliasConstructorVsFunction.kt"); - } - - @Test - @TestMetadata("typeAliasConstructorWrongClass.kt") - public void testTypeAliasConstructorWrongClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/typeAliasConstructorWrongClass.kt"); - } - - @Test - @TestMetadata("typeAliasConstructorWrongVisibility.kt") - public void testTypeAliasConstructorWrongVisibility() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/typeAliasConstructorWrongVisibility.kt"); - } - - @Test - @TestMetadata("typeAliasExpansionRepeatedAnnotations.kt") - public void testTypeAliasExpansionRepeatedAnnotations() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/typeAliasExpansionRepeatedAnnotations.kt"); - } - - @Test - @TestMetadata("typeAliasForProjectionInSuperInterfaces.kt") - public void testTypeAliasForProjectionInSuperInterfaces() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/typeAliasForProjectionInSuperInterfaces.kt"); - } - - @Test - @TestMetadata("typeAliasInAnonymousObjectType.kt") - public void testTypeAliasInAnonymousObjectType() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/typeAliasInAnonymousObjectType.kt"); - } - - @Test - @TestMetadata("typeAliasInvisibleObject.kt") - public void testTypeAliasInvisibleObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/typeAliasInvisibleObject.kt"); - } - - @Test - @TestMetadata("typeAliasIsUsedAsATypeArgumentInOtherAlias.kt") - public void testTypeAliasIsUsedAsATypeArgumentInOtherAlias() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/typeAliasIsUsedAsATypeArgumentInOtherAlias.kt"); - } - - @Test - @TestMetadata("typeAliasNotNull.kt") - public void testTypeAliasNotNull() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/typeAliasNotNull.kt"); - } - - @Test - @TestMetadata("typeAliasObject.kt") - public void testTypeAliasObject() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/typeAliasObject.kt"); - } - - @Test - @TestMetadata("typeAliasObjectWithInvoke.kt") - public void testTypeAliasObjectWithInvoke() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/typeAliasObjectWithInvoke.kt"); - } - - @Test - @TestMetadata("typeAliasShouldExpandToClass.kt") - public void testTypeAliasShouldExpandToClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/typeAliasShouldExpandToClass.kt"); - } - - @Test - @TestMetadata("typeAliasesInImportDirectives.kt") - public void testTypeAliasesInImportDirectives() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/typeAliasesInImportDirectives.kt"); - } - - @Test - @TestMetadata("typeAliasesInQualifiers.kt") - public void testTypeAliasesInQualifiers() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/typeAliasesInQualifiers.kt"); - } - - @Test - @TestMetadata("typealiasRhsAnnotations.kt") - public void testTypealiasRhsAnnotations() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/typealiasRhsAnnotations.kt"); - } - - @Test - @TestMetadata("typealiasRhsAnnotationsInArguments.kt") - public void testTypealiasRhsAnnotationsInArguments() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/typealiasRhsAnnotationsInArguments.kt"); - } - - @Test - @TestMetadata("typealiasRhsRepeatedAnnotationInArguments.kt") - public void testTypealiasRhsRepeatedAnnotationInArguments() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/typealiasRhsRepeatedAnnotationInArguments.kt"); - } - - @Test - @TestMetadata("typealiasRhsRepeatedAnnotations.kt") - public void testTypealiasRhsRepeatedAnnotations() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/typealiasRhsRepeatedAnnotations.kt"); - } - - @Test - @TestMetadata("unsupportedTypeAlias.kt") - public void testUnsupportedTypeAlias() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/unsupportedTypeAlias.kt"); - } - - @Test - @TestMetadata("unusedTypeAliasParameter.kt") - public void testUnusedTypeAliasParameter() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/unusedTypeAliasParameter.kt"); - } - - @Test - @TestMetadata("wrongNumberOfArgumentsInTypeAliasConstructor.kt") - public void testWrongNumberOfArgumentsInTypeAliasConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/typealias/wrongNumberOfArgumentsInTypeAliasConstructor.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/underscoresInNumericLiterals") - @TestDataPath("$PROJECT_ROOT") - public class UnderscoresInNumericLiterals extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInUnderscoresInNumericLiterals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/underscoresInNumericLiterals"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("illegalUnderscores.kt") - public void testIllegalUnderscores() throws Exception { - runTest("compiler/testData/diagnostics/tests/underscoresInNumericLiterals/illegalUnderscores.kt"); - } - - @Test - @TestMetadata("noUnderscores.kt") - public void testNoUnderscores() throws Exception { - runTest("compiler/testData/diagnostics/tests/underscoresInNumericLiterals/noUnderscores.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/unit") - @TestDataPath("$PROJECT_ROOT") - public class Unit extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInUnit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/unit"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("nullableUnit.kt") - public void testNullableUnit() throws Exception { - runTest("compiler/testData/diagnostics/tests/unit/nullableUnit.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/unitConversion") - @TestDataPath("$PROJECT_ROOT") - public class UnitConversion extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInUnitConversion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/unitConversion"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("chainedFunSuspendUnitConversion.kt") - public void testChainedFunSuspendUnitConversion() throws Exception { - runTest("compiler/testData/diagnostics/tests/unitConversion/chainedFunSuspendUnitConversion.kt"); - } - - @Test - @TestMetadata("chainedFunUnitConversion.kt") - public void testChainedFunUnitConversion() throws Exception { - runTest("compiler/testData/diagnostics/tests/unitConversion/chainedFunUnitConversion.kt"); - } - - @Test - @TestMetadata("chainedUnitSuspendConversion.kt") - public void testChainedUnitSuspendConversion() throws Exception { - runTest("compiler/testData/diagnostics/tests/unitConversion/chainedUnitSuspendConversion.kt"); - } - - @Test - @TestMetadata("noUnitConversionForGenericTypeFromArrow.kt") - public void testNoUnitConversionForGenericTypeFromArrow() throws Exception { - runTest("compiler/testData/diagnostics/tests/unitConversion/noUnitConversionForGenericTypeFromArrow.kt"); - } - - @Test - @TestMetadata("noUnitConversionOnReturningGenericFunctionalType.kt") - public void testNoUnitConversionOnReturningGenericFunctionalType() throws Exception { - runTest("compiler/testData/diagnostics/tests/unitConversion/noUnitConversionOnReturningGenericFunctionalType.kt"); - } - - @Test - @TestMetadata("unitConversionCompatibility.kt") - public void testUnitConversionCompatibility() throws Exception { - runTest("compiler/testData/diagnostics/tests/unitConversion/unitConversionCompatibility.kt"); - } - - @Test - @TestMetadata("unitConversionDisabledForSimpleArguments.kt") - public void testUnitConversionDisabledForSimpleArguments() throws Exception { - runTest("compiler/testData/diagnostics/tests/unitConversion/unitConversionDisabledForSimpleArguments.kt"); - } - - @Test - @TestMetadata("unitConversionForAllKinds.kt") - public void testUnitConversionForAllKinds() throws Exception { - runTest("compiler/testData/diagnostics/tests/unitConversion/unitConversionForAllKinds.kt"); - } - - @Test - @TestMetadata("unitConversionForSubtypes.kt") - public void testUnitConversionForSubtypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/unitConversion/unitConversionForSubtypes.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/valueClasses") - @TestDataPath("$PROJECT_ROOT") - public class ValueClasses extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInValueClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/valueClasses"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("basicValueClassDeclaration.kt") - public void testBasicValueClassDeclaration() throws Exception { - runTest("compiler/testData/diagnostics/tests/valueClasses/basicValueClassDeclaration.kt"); - } - - @Test - @TestMetadata("basicValueClassDeclarationDisabled.kt") - public void testBasicValueClassDeclarationDisabled() throws Exception { - runTest("compiler/testData/diagnostics/tests/valueClasses/basicValueClassDeclarationDisabled.kt"); - } - - @Test - @TestMetadata("constructorsJvmSignaturesClash.kt") - public void testConstructorsJvmSignaturesClash() throws Exception { - runTest("compiler/testData/diagnostics/tests/valueClasses/constructorsJvmSignaturesClash.kt"); - } - - @Test - @TestMetadata("delegatedPropertyInValueClass.kt") - public void testDelegatedPropertyInValueClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/valueClasses/delegatedPropertyInValueClass.kt"); - } - - @Test - @TestMetadata("functionsJvmSignaturesClash.kt") - public void testFunctionsJvmSignaturesClash() throws Exception { - runTest("compiler/testData/diagnostics/tests/valueClasses/functionsJvmSignaturesClash.kt"); - } - - @Test - @TestMetadata("functionsJvmSignaturesConflictOnInheritance.kt") - public void testFunctionsJvmSignaturesConflictOnInheritance() throws Exception { - runTest("compiler/testData/diagnostics/tests/valueClasses/functionsJvmSignaturesConflictOnInheritance.kt"); - } - - @Test - @TestMetadata("identityComparisonWithValueClasses.kt") - public void testIdentityComparisonWithValueClasses() throws Exception { - runTest("compiler/testData/diagnostics/tests/valueClasses/identityComparisonWithValueClasses.kt"); - } - - @Test - @TestMetadata("jvmInlineApplicability.kt") - public void testJvmInlineApplicability() throws Exception { - runTest("compiler/testData/diagnostics/tests/valueClasses/jvmInlineApplicability.kt"); - } - - @Test - @TestMetadata("lateinitValueClasses.kt") - public void testLateinitValueClasses() throws Exception { - runTest("compiler/testData/diagnostics/tests/valueClasses/lateinitValueClasses.kt"); - } - - @Test - @TestMetadata("presenceOfInitializerBlockInsideValueClass.kt") - public void testPresenceOfInitializerBlockInsideValueClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/valueClasses/presenceOfInitializerBlockInsideValueClass.kt"); - } - - @Test - @TestMetadata("presenceOfPublicPrimaryConstructorForValueClass.kt") - public void testPresenceOfPublicPrimaryConstructorForValueClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/valueClasses/presenceOfPublicPrimaryConstructorForValueClass.kt"); - } - - @Test - @TestMetadata("propertiesWithBackingFieldsInsideValueClass.kt") - public void testPropertiesWithBackingFieldsInsideValueClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/valueClasses/propertiesWithBackingFieldsInsideValueClass.kt"); - } - - @Test - @TestMetadata("recursiveValueClasses.kt") - public void testRecursiveValueClasses() throws Exception { - runTest("compiler/testData/diagnostics/tests/valueClasses/recursiveValueClasses.kt"); - } - - @Test - @TestMetadata("reservedMembersAndConstructsInsideValueClass.kt") - public void testReservedMembersAndConstructsInsideValueClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/valueClasses/reservedMembersAndConstructsInsideValueClass.kt"); - } - - @Test - @TestMetadata("unsignedLiteralsWithoutArtifactOnClasspath.kt") - public void testUnsignedLiteralsWithoutArtifactOnClasspath() throws Exception { - runTest("compiler/testData/diagnostics/tests/valueClasses/unsignedLiteralsWithoutArtifactOnClasspath.kt"); - } - - @Test - @TestMetadata("valueClassCanOnlyImplementInterfaces.kt") - public void testValueClassCanOnlyImplementInterfaces() throws Exception { - runTest("compiler/testData/diagnostics/tests/valueClasses/valueClassCanOnlyImplementInterfaces.kt"); - } - - @Test - @TestMetadata("valueClassCannotImplementInterfaceByDelegation.kt") - public void testValueClassCannotImplementInterfaceByDelegation() throws Exception { - runTest("compiler/testData/diagnostics/tests/valueClasses/valueClassCannotImplementInterfaceByDelegation.kt"); - } - - @Test - @TestMetadata("valueClassConstructorParameterWithDefaultValue.kt") - public void testValueClassConstructorParameterWithDefaultValue() throws Exception { - runTest("compiler/testData/diagnostics/tests/valueClasses/valueClassConstructorParameterWithDefaultValue.kt"); - } - - @Test - @TestMetadata("valueClassDeclarationCheck.kt") - public void testValueClassDeclarationCheck() throws Exception { - runTest("compiler/testData/diagnostics/tests/valueClasses/valueClassDeclarationCheck.kt"); - } - - @Test - @TestMetadata("valueClassImplementsCollection.kt") - public void testValueClassImplementsCollection() throws Exception { - runTest("compiler/testData/diagnostics/tests/valueClasses/valueClassImplementsCollection.kt"); - } - - @Test - @TestMetadata("valueClassWithForbiddenUnderlyingType.kt") - public void testValueClassWithForbiddenUnderlyingType() throws Exception { - runTest("compiler/testData/diagnostics/tests/valueClasses/valueClassWithForbiddenUnderlyingType.kt"); - } - - @Test - @TestMetadata("valueClassesInsideAnnotations.kt") - public void testValueClassesInsideAnnotations() throws Exception { - runTest("compiler/testData/diagnostics/tests/valueClasses/valueClassesInsideAnnotations.kt"); - } - - @Test - @TestMetadata("varargsOnParametersOfValueClassType.kt") - public void testVarargsOnParametersOfValueClassType() throws Exception { - runTest("compiler/testData/diagnostics/tests/valueClasses/varargsOnParametersOfValueClassType.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/varargs") - @TestDataPath("$PROJECT_ROOT") - public class Varargs extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInVarargs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/varargs"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("AmbiguousVararg.kt") - public void testAmbiguousVararg() throws Exception { - runTest("compiler/testData/diagnostics/tests/varargs/AmbiguousVararg.kt"); - } - - @Test - @TestMetadata("assignArrayToVararagInNamedFormWithInference.kt") - public void testAssignArrayToVararagInNamedFormWithInference() throws Exception { - runTest("compiler/testData/diagnostics/tests/varargs/assignArrayToVararagInNamedFormWithInference.kt"); - } - - @Test - @TestMetadata("assignArrayToVararagInNamedForm_1_3.kt") - public void testAssignArrayToVararagInNamedForm_1_3() throws Exception { - runTest("compiler/testData/diagnostics/tests/varargs/assignArrayToVararagInNamedForm_1_3.kt"); - } - - @Test - @TestMetadata("assignArrayToVararagInNamedForm_1_4.kt") - public void testAssignArrayToVararagInNamedForm_1_4() throws Exception { - runTest("compiler/testData/diagnostics/tests/varargs/assignArrayToVararagInNamedForm_1_4.kt"); - } - - @Test - @TestMetadata("assignNonConstSingleArrayElementAsVarargInAnnotation.kt") - public void testAssignNonConstSingleArrayElementAsVarargInAnnotation() throws Exception { - runTest("compiler/testData/diagnostics/tests/varargs/assignNonConstSingleArrayElementAsVarargInAnnotation.kt"); - } - - @Test - @TestMetadata("assignNonConstSingleArrayElementAsVarargInAnnotationError.kt") - public void testAssignNonConstSingleArrayElementAsVarargInAnnotationError() throws Exception { - runTest("compiler/testData/diagnostics/tests/varargs/assignNonConstSingleArrayElementAsVarargInAnnotationError.kt"); - } - - @Test - @TestMetadata("assigningArraysToVarargsInAnnotations.kt") - public void testAssigningArraysToVarargsInAnnotations() throws Exception { - runTest("compiler/testData/diagnostics/tests/varargs/assigningArraysToVarargsInAnnotations.kt"); - } - - @Test - @TestMetadata("assigningSingleElementsInNamedFormAnnDeprecation_after.kt") - public void testAssigningSingleElementsInNamedFormAnnDeprecation_after() throws Exception { - runTest("compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormAnnDeprecation_after.kt"); - } - - @Test - @TestMetadata("assigningSingleElementsInNamedFormAnnDeprecation_before.kt") - public void testAssigningSingleElementsInNamedFormAnnDeprecation_before() throws Exception { - runTest("compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormAnnDeprecation_before.kt"); - } - - @Test - @TestMetadata("assigningSingleElementsInNamedFormFunDeprecation_after.kt") - public void testAssigningSingleElementsInNamedFormFunDeprecation_after() throws Exception { - runTest("compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormFunDeprecation_after.kt"); - } - - @Test - @TestMetadata("assigningSingleElementsInNamedFormFunDeprecation_before.kt") - public void testAssigningSingleElementsInNamedFormFunDeprecation_before() throws Exception { - runTest("compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormFunDeprecation_before.kt"); - } - - @Test - @TestMetadata("inferredNullableArrayAsVararg.kt") - public void testInferredNullableArrayAsVararg() throws Exception { - runTest("compiler/testData/diagnostics/tests/varargs/inferredNullableArrayAsVararg.kt"); - } - - @Test - @TestMetadata("kt1781.kt") - public void testKt1781() throws Exception { - runTest("compiler/testData/diagnostics/tests/varargs/kt1781.kt"); - } - - @Test - @TestMetadata("kt1835.kt") - public void testKt1835() throws Exception { - runTest("compiler/testData/diagnostics/tests/varargs/kt1835.kt"); - } - - @Test - @TestMetadata("kt1838-param.kt") - public void testKt1838_param() throws Exception { - runTest("compiler/testData/diagnostics/tests/varargs/kt1838-param.kt"); - } - - @Test - @TestMetadata("kt1838-val.kt") - public void testKt1838_val() throws Exception { - runTest("compiler/testData/diagnostics/tests/varargs/kt1838-val.kt"); - } - - @Test - @TestMetadata("kt2163.kt") - public void testKt2163() throws Exception { - runTest("compiler/testData/diagnostics/tests/varargs/kt2163.kt"); - } - - @Test - @TestMetadata("kt422.kt") - public void testKt422() throws Exception { - runTest("compiler/testData/diagnostics/tests/varargs/kt422.kt"); - } - - @Test - @TestMetadata("MoreSpecificVarargsOfEqualLength.kt") - public void testMoreSpecificVarargsOfEqualLength() throws Exception { - runTest("compiler/testData/diagnostics/tests/varargs/MoreSpecificVarargsOfEqualLength.kt"); - } - - @Test - @TestMetadata("MostSepcificVarargsWithJava.kt") - public void testMostSepcificVarargsWithJava() throws Exception { - runTest("compiler/testData/diagnostics/tests/varargs/MostSepcificVarargsWithJava.kt"); - } - - @Test - @TestMetadata("NilaryVsVararg.kt") - public void testNilaryVsVararg() throws Exception { - runTest("compiler/testData/diagnostics/tests/varargs/NilaryVsVararg.kt"); - } - - @Test - @TestMetadata("noAssigningArraysToVarargsFeature.kt") - public void testNoAssigningArraysToVarargsFeature() throws Exception { - runTest("compiler/testData/diagnostics/tests/varargs/noAssigningArraysToVarargsFeature.kt"); - } - - @Test - @TestMetadata("NullableTypeForVarargArgument.kt") - public void testNullableTypeForVarargArgument() throws Exception { - runTest("compiler/testData/diagnostics/tests/varargs/NullableTypeForVarargArgument.kt"); - } - - @Test - @TestMetadata("prohibitAssigningSingleElementsInNamedForm.kt") - public void testProhibitAssigningSingleElementsInNamedForm() throws Exception { - runTest("compiler/testData/diagnostics/tests/varargs/prohibitAssigningSingleElementsInNamedForm.kt"); - } - - @Test - @TestMetadata("UnaryVsVararg.kt") - public void testUnaryVsVararg() throws Exception { - runTest("compiler/testData/diagnostics/tests/varargs/UnaryVsVararg.kt"); - } - - @Test - @TestMetadata("varargInSetter.kt") - public void testVarargInSetter() throws Exception { - runTest("compiler/testData/diagnostics/tests/varargs/varargInSetter.kt"); - } - - @Test - @TestMetadata("varargIterator.kt") - public void testVarargIterator() throws Exception { - runTest("compiler/testData/diagnostics/tests/varargs/varargIterator.kt"); - } - - @Test - @TestMetadata("varargOfNothing.kt") - public void testVarargOfNothing() throws Exception { - runTest("compiler/testData/diagnostics/tests/varargs/varargOfNothing.kt"); - } - - @Test - @TestMetadata("varargViewedAsArray.kt") - public void testVarargViewedAsArray() throws Exception { - runTest("compiler/testData/diagnostics/tests/varargs/varargViewedAsArray.kt"); - } - - @Test - @TestMetadata("varargsAndFunctionLiterals.kt") - public void testVarargsAndFunctionLiterals() throws Exception { - runTest("compiler/testData/diagnostics/tests/varargs/varargsAndFunctionLiterals.kt"); - } - - @Test - @TestMetadata("varargsAndOut1.kt") - public void testVarargsAndOut1() throws Exception { - runTest("compiler/testData/diagnostics/tests/varargs/varargsAndOut1.kt"); - } - - @Test - @TestMetadata("varargsAndOut2.kt") - public void testVarargsAndOut2() throws Exception { - runTest("compiler/testData/diagnostics/tests/varargs/varargsAndOut2.kt"); - } - - @Test - @TestMetadata("varargsAndPair.kt") - public void testVarargsAndPair() throws Exception { - runTest("compiler/testData/diagnostics/tests/varargs/varargsAndPair.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/variance") - @TestDataPath("$PROJECT_ROOT") - public class Variance extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInVariance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/variance"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("Class.kt") - public void testClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/variance/Class.kt"); - } - - @Test - @TestMetadata("ea1337846.kt") - public void testEa1337846() throws Exception { - runTest("compiler/testData/diagnostics/tests/variance/ea1337846.kt"); - } - - @Test - @TestMetadata("Function.kt") - public void testFunction() throws Exception { - runTest("compiler/testData/diagnostics/tests/variance/Function.kt"); - } - - @Test - @TestMetadata("FunctionTypes.kt") - public void testFunctionTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/variance/FunctionTypes.kt"); - } - - @Test - @TestMetadata("InPosition.kt") - public void testInPosition() throws Exception { - runTest("compiler/testData/diagnostics/tests/variance/InPosition.kt"); - } - - @Test - @TestMetadata("InvariantPosition.kt") - public void testInvariantPosition() throws Exception { - runTest("compiler/testData/diagnostics/tests/variance/InvariantPosition.kt"); - } - - @Test - @TestMetadata("NullableTypes.kt") - public void testNullableTypes() throws Exception { - runTest("compiler/testData/diagnostics/tests/variance/NullableTypes.kt"); - } - - @Test - @TestMetadata("OutPosition.kt") - public void testOutPosition() throws Exception { - runTest("compiler/testData/diagnostics/tests/variance/OutPosition.kt"); - } - - @Test - @TestMetadata("PrimaryConstructor.kt") - public void testPrimaryConstructor() throws Exception { - runTest("compiler/testData/diagnostics/tests/variance/PrimaryConstructor.kt"); - } - - @Test - @TestMetadata("ValProperty.kt") - public void testValProperty() throws Exception { - runTest("compiler/testData/diagnostics/tests/variance/ValProperty.kt"); - } - - @Test - @TestMetadata("VarProperty.kt") - public void testVarProperty() throws Exception { - runTest("compiler/testData/diagnostics/tests/variance/VarProperty.kt"); - } - - @Test - @TestMetadata("Visibility.kt") - public void testVisibility() throws Exception { - runTest("compiler/testData/diagnostics/tests/variance/Visibility.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/variance/privateToThis") - @TestDataPath("$PROJECT_ROOT") - public class PrivateToThis extends AbstractDiagnosticUsingJavacTest { - @Test - @TestMetadata("Abstract.kt") - public void testAbstract() throws Exception { - runTest("compiler/testData/diagnostics/tests/variance/privateToThis/Abstract.kt"); - } - - @Test - public void testAllFilesPresentInPrivateToThis() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/variance/privateToThis"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("FunctionCall.kt") - public void testFunctionCall() throws Exception { - runTest("compiler/testData/diagnostics/tests/variance/privateToThis/FunctionCall.kt"); - } - - @Test - @TestMetadata("GetVal.kt") - public void testGetVal() throws Exception { - runTest("compiler/testData/diagnostics/tests/variance/privateToThis/GetVal.kt"); - } - - @Test - @TestMetadata("SetVar.kt") - public void testSetVar() throws Exception { - runTest("compiler/testData/diagnostics/tests/variance/privateToThis/SetVar.kt"); - } - - @Test - @TestMetadata("ValReassigned.kt") - public void testValReassigned() throws Exception { - runTest("compiler/testData/diagnostics/tests/variance/privateToThis/ValReassigned.kt"); - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/visibility") - @TestDataPath("$PROJECT_ROOT") - public class Visibility extends AbstractDiagnosticUsingJavacTest { - @Test - @TestMetadata("abstractInvisibleMemberFromJava.kt") - public void testAbstractInvisibleMemberFromJava() throws Exception { - runTest("compiler/testData/diagnostics/tests/visibility/abstractInvisibleMemberFromJava.kt"); - } - - @Test - @TestMetadata("abstractInvisibleMemberFromKotlin.kt") - public void testAbstractInvisibleMemberFromKotlin() throws Exception { - runTest("compiler/testData/diagnostics/tests/visibility/abstractInvisibleMemberFromKotlin.kt"); - } - - @Test - @TestMetadata("abstractInvisibleMemberFromKotlinWarning.kt") - public void testAbstractInvisibleMemberFromKotlinWarning() throws Exception { - runTest("compiler/testData/diagnostics/tests/visibility/abstractInvisibleMemberFromKotlinWarning.kt"); - } - - @Test - public void testAllFilesPresentInVisibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/visibility"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("invisibleSetterOfJavaClass.kt") - public void testInvisibleSetterOfJavaClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/visibility/invisibleSetterOfJavaClass.kt"); - } - - @Test - @TestMetadata("invisibleSetterOfJavaClassWithDisabledFeature.kt") - public void testInvisibleSetterOfJavaClassWithDisabledFeature() throws Exception { - runTest("compiler/testData/diagnostics/tests/visibility/invisibleSetterOfJavaClassWithDisabledFeature.kt"); - } - - @Test - @TestMetadata("lackOfInvisibleSetterOfJavaClassInSamePackage.kt") - public void testLackOfInvisibleSetterOfJavaClassInSamePackage() throws Exception { - runTest("compiler/testData/diagnostics/tests/visibility/lackOfInvisibleSetterOfJavaClassInSamePackage.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/when") - @TestDataPath("$PROJECT_ROOT") - public class When extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInWhen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/when"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("AnnotatedWhenStatement.kt") - public void testAnnotatedWhenStatement() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/AnnotatedWhenStatement.kt"); - } - - @Test - @TestMetadata("BranchBypassVal.kt") - public void testBranchBypassVal() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/BranchBypassVal.kt"); - } - - @Test - @TestMetadata("BranchBypassVar.kt") - public void testBranchBypassVar() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/BranchBypassVar.kt"); - } - - @Test - @TestMetadata("BranchFalseBypass.kt") - public void testBranchFalseBypass() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/BranchFalseBypass.kt"); - } - - @Test - @TestMetadata("BranchFalseBypassElse.kt") - public void testBranchFalseBypassElse() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/BranchFalseBypassElse.kt"); - } - - @Test - @TestMetadata("CommaInWhenConditionWithoutArgument.kt") - public void testCommaInWhenConditionWithoutArgument() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/CommaInWhenConditionWithoutArgument.kt"); - } - - @Test - @TestMetadata("DuplicatedLabels.kt") - public void testDuplicatedLabels() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/DuplicatedLabels.kt"); - } - - @Test - @TestMetadata("ElseOnNullableEnum.kt") - public void testElseOnNullableEnum() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/ElseOnNullableEnum.kt"); - } - - @Test - @TestMetadata("ElseOnNullableEnumWithSmartCast.kt") - public void testElseOnNullableEnumWithSmartCast() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/ElseOnNullableEnumWithSmartCast.kt"); - } - - @Test - @TestMetadata("EmptyConditionWithExpression.kt") - public void testEmptyConditionWithExpression() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/EmptyConditionWithExpression.kt"); - } - - @Test - @TestMetadata("EmptyConditionWithExpressionEnum.kt") - public void testEmptyConditionWithExpressionEnum() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/EmptyConditionWithExpressionEnum.kt"); - } - - @Test - @TestMetadata("ExhaustiveBoolean.kt") - public void testExhaustiveBoolean() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/ExhaustiveBoolean.kt"); - } - - @Test - @TestMetadata("ExhaustiveBooleanBrackets.kt") - public void testExhaustiveBooleanBrackets() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/ExhaustiveBooleanBrackets.kt"); - } - - @Test - @TestMetadata("ExhaustiveBooleanComplex.kt") - public void testExhaustiveBooleanComplex() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/ExhaustiveBooleanComplex.kt"); - } - - @Test - @TestMetadata("ExhaustiveBooleanNullable.kt") - public void testExhaustiveBooleanNullable() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/ExhaustiveBooleanNullable.kt"); - } - - @Test - @TestMetadata("ExhaustiveBreakContinue.kt") - public void testExhaustiveBreakContinue() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/ExhaustiveBreakContinue.kt"); - } - - @Test - @TestMetadata("ExhaustiveEnumIs.kt") - public void testExhaustiveEnumIs() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/ExhaustiveEnumIs.kt"); - } - - @Test - @TestMetadata("ExhaustiveEnumMixed.kt") - public void testExhaustiveEnumMixed() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/ExhaustiveEnumMixed.kt"); - } - - @Test - @TestMetadata("ExhaustiveInitialization.kt") - public void testExhaustiveInitialization() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/ExhaustiveInitialization.kt"); - } - - @Test - @TestMetadata("ExhaustiveNoInitialization.kt") - public void testExhaustiveNoInitialization() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/ExhaustiveNoInitialization.kt"); - } - - @Test - @TestMetadata("ExhaustiveNullable.kt") - public void testExhaustiveNullable() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/ExhaustiveNullable.kt"); - } - - @Test - @TestMetadata("ExhaustivePlatformEnum.kt") - public void testExhaustivePlatformEnum() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/ExhaustivePlatformEnum.kt"); - } - - @Test - @TestMetadata("ExhaustivePlatformEnumAnnotated.kt") - public void testExhaustivePlatformEnumAnnotated() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/ExhaustivePlatformEnumAnnotated.kt"); - } - - @Test - @TestMetadata("ExhaustivePlatformEnumElse.kt") - public void testExhaustivePlatformEnumElse() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/ExhaustivePlatformEnumElse.kt"); - } - - @Test - @TestMetadata("ExhaustivePlatformEnumNull.kt") - public void testExhaustivePlatformEnumNull() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/ExhaustivePlatformEnumNull.kt"); - } - - @Test - @TestMetadata("ExhaustivePlatformEnumStatement.kt") - public void testExhaustivePlatformEnumStatement() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/ExhaustivePlatformEnumStatement.kt"); - } - - @Test - @TestMetadata("ExhaustiveReturn.kt") - public void testExhaustiveReturn() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/ExhaustiveReturn.kt"); - } - - @Test - @TestMetadata("ExhaustiveReturnThrow.kt") - public void testExhaustiveReturnThrow() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/ExhaustiveReturnThrow.kt"); - } - - @Test - @TestMetadata("ExhaustiveValOverConditionalInit.kt") - public void testExhaustiveValOverConditionalInit() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/ExhaustiveValOverConditionalInit.kt"); - } - - @Test - @TestMetadata("ExhaustiveVarOverConditionalInit.kt") - public void testExhaustiveVarOverConditionalInit() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/ExhaustiveVarOverConditionalInit.kt"); - } - - @Test - @TestMetadata("ExhaustiveWithNullabilityCheck.kt") - public void testExhaustiveWithNullabilityCheck() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/ExhaustiveWithNullabilityCheck.kt"); - } - - @Test - @TestMetadata("ExhaustiveWithNullabilityCheckBefore.kt") - public void testExhaustiveWithNullabilityCheckBefore() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/ExhaustiveWithNullabilityCheckBefore.kt"); - } - - @Test - @TestMetadata("ExhaustiveWithNullabilityCheckBoolean.kt") - public void testExhaustiveWithNullabilityCheckBoolean() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/ExhaustiveWithNullabilityCheckBoolean.kt"); - } - - @Test - @TestMetadata("ExhaustiveWithNullabilityCheckElse.kt") - public void testExhaustiveWithNullabilityCheckElse() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/ExhaustiveWithNullabilityCheckElse.kt"); - } - - @Test - @TestMetadata("kt10439.kt") - public void testKt10439() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/kt10439.kt"); - } - - @Test - @TestMetadata("kt10809.kt") - public void testKt10809() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/kt10809.kt"); - } - - @Test - @TestMetadata("kt10811.kt") - public void testKt10811() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/kt10811.kt"); - } - - @Test - @TestMetadata("kt4434.kt") - public void testKt4434() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/kt4434.kt"); - } - - @Test - @TestMetadata("kt9929.kt") - public void testKt9929() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/kt9929.kt"); - } - - @Test - @TestMetadata("kt9972.kt") - public void testKt9972() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/kt9972.kt"); - } - - @Test - @TestMetadata("NoElseExpectedUnit.kt") - public void testNoElseExpectedUnit() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/NoElseExpectedUnit.kt"); - } - - @Test - @TestMetadata("NoElseNoExpectedType.kt") - public void testNoElseNoExpectedType() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/NoElseNoExpectedType.kt"); - } - - @Test - @TestMetadata("NoElseReturnedCoercionToUnit.kt") - public void testNoElseReturnedCoercionToUnit() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/NoElseReturnedCoercionToUnit.kt"); - } - - @Test - @TestMetadata("NoElseReturnedFromLambdaExpectedInt.kt") - public void testNoElseReturnedFromLambdaExpectedInt() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/NoElseReturnedFromLambdaExpectedInt.kt"); - } - - @Test - @TestMetadata("NoElseReturnedNonUnit.kt") - public void testNoElseReturnedNonUnit() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/NoElseReturnedNonUnit.kt"); - } - - @Test - @TestMetadata("NoElseReturnedUnit.kt") - public void testNoElseReturnedUnit() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/NoElseReturnedUnit.kt"); - } - - @Test - @TestMetadata("NoElseWhenStatement.kt") - public void testNoElseWhenStatement() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/NoElseWhenStatement.kt"); - } - - @Test - @TestMetadata("NonExhaustiveBooleanNullable.kt") - public void testNonExhaustiveBooleanNullable() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/NonExhaustiveBooleanNullable.kt"); - } - - @Test - @TestMetadata("NonExhaustivePlatformEnum.kt") - public void testNonExhaustivePlatformEnum() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/NonExhaustivePlatformEnum.kt"); - } - - @Test - @TestMetadata("NonExhaustiveWarning.kt") - public void testNonExhaustiveWarning() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/NonExhaustiveWarning.kt"); - } - - @Test - @TestMetadata("NonExhaustiveWarningElse.kt") - public void testNonExhaustiveWarningElse() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/NonExhaustiveWarningElse.kt"); - } - - @Test - @TestMetadata("NonExhaustiveWarningFalse.kt") - public void testNonExhaustiveWarningFalse() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/NonExhaustiveWarningFalse.kt"); - } - - @Test - @TestMetadata("NonExhaustiveWarningForSealedClass.kt") - public void testNonExhaustiveWarningForSealedClass() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/NonExhaustiveWarningForSealedClass.kt"); - } - - @Test - @TestMetadata("NonExhaustiveWarningNull.kt") - public void testNonExhaustiveWarningNull() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/NonExhaustiveWarningNull.kt"); - } - - @Test - @TestMetadata("NonExhaustiveWithNullabilityCheck.kt") - public void testNonExhaustiveWithNullabilityCheck() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/NonExhaustiveWithNullabilityCheck.kt"); - } - - @Test - @TestMetadata("PropertyNotInitialized.kt") - public void testPropertyNotInitialized() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/PropertyNotInitialized.kt"); - } - - @Test - @TestMetadata("RedundantElse.kt") - public void testRedundantElse() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/RedundantElse.kt"); - } - - @Test - @TestMetadata("ReservedExhaustiveWhen.kt") - public void testReservedExhaustiveWhen() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/ReservedExhaustiveWhen.kt"); - } - - @Test - @TestMetadata("TopLevelSealed.kt") - public void testTopLevelSealed() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/TopLevelSealed.kt"); - } - - @Test - @TestMetadata("When.kt") - public void testWhen() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/When.kt"); - } - - @Test - @TestMetadata("whenAndLambdaWithExpectedType.kt") - public void testWhenAndLambdaWithExpectedType() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/whenAndLambdaWithExpectedType.kt"); - } - - @Test - @TestMetadata("WhenTypeDisjunctions.kt") - public void testWhenTypeDisjunctions() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/WhenTypeDisjunctions.kt"); - } - - @Test - @TestMetadata("whenWithNothingAndLambdas.kt") - public void testWhenWithNothingAndLambdas() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/whenWithNothingAndLambdas.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/tests/when/withSubjectVariable") - @TestDataPath("$PROJECT_ROOT") - public class WithSubjectVariable extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInWithSubjectVariable() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/when/withSubjectVariable"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("capturingInInitializer.kt") - public void testCapturingInInitializer() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/withSubjectVariable/capturingInInitializer.kt"); - } - - @Test - @TestMetadata("invisibleOutsideOfWhen.kt") - public void testInvisibleOutsideOfWhen() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/withSubjectVariable/invisibleOutsideOfWhen.kt"); - } - - @Test - @TestMetadata("jumpoutInInitializer.kt") - public void testJumpoutInInitializer() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/withSubjectVariable/jumpoutInInitializer.kt"); - } - - @Test - @TestMetadata("nestedWhenWithSubject.kt") - public void testNestedWhenWithSubject() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/withSubjectVariable/nestedWhenWithSubject.kt"); - } - - @Test - @TestMetadata("noSubjectVariableName.kt") - public void testNoSubjectVariableName() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/withSubjectVariable/noSubjectVariableName.kt"); - } - - @Test - @TestMetadata("reassignmentToWhenSubjectVariable.kt") - public void testReassignmentToWhenSubjectVariable() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/withSubjectVariable/reassignmentToWhenSubjectVariable.kt"); - } - - @Test - @TestMetadata("shadowingOtherVariable.kt") - public void testShadowingOtherVariable() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/withSubjectVariable/shadowingOtherVariable.kt"); - } - - @Test - @TestMetadata("smartCastOnValueBoundToSubjectVariable.kt") - public void testSmartCastOnValueBoundToSubjectVariable() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/withSubjectVariable/smartCastOnValueBoundToSubjectVariable.kt"); - } - - @Test - @TestMetadata("smartCastsOnSubjectVariable.kt") - public void testSmartCastsOnSubjectVariable() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/withSubjectVariable/smartCastsOnSubjectVariable.kt"); - } - - @Test - @TestMetadata("smartcastToEnum.kt") - public void testSmartcastToEnum() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/withSubjectVariable/smartcastToEnum.kt"); - } - - @Test - @TestMetadata("smartcastToSealed.kt") - public void testSmartcastToSealed() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/withSubjectVariable/smartcastToSealed.kt"); - } - - @Test - @TestMetadata("softModifierName.kt") - public void testSoftModifierName() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/withSubjectVariable/softModifierName.kt"); - } - - @Test - @TestMetadata("subjectVariableInIsPattern.kt") - public void testSubjectVariableInIsPattern() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/withSubjectVariable/subjectVariableInIsPattern.kt"); - } - - @Test - @TestMetadata("unsupportedFeature.kt") - public void testUnsupportedFeature() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/withSubjectVariable/unsupportedFeature.kt"); - } - - @Test - @TestMetadata("unsupportedVariableDeclarationsInWhenSubject.kt") - public void testUnsupportedVariableDeclarationsInWhenSubject() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/withSubjectVariable/unsupportedVariableDeclarationsInWhenSubject.kt"); - } - - @Test - @TestMetadata("unusedWhenSubjectVariable.kt") - public void testUnusedWhenSubjectVariable() throws Exception { - runTest("compiler/testData/diagnostics/tests/when/withSubjectVariable/unusedWhenSubjectVariable.kt"); - } - } + @TestMetadata("StaticImportsAmbiguity.kt") + public void testStaticImportsAmbiguity() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/fieldsResolution/StaticImportsAmbiguity.kt"); } } @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib") + @TestMetadata("compiler/testData/diagnostics/tests/javac/imports") @TestDataPath("$PROJECT_ROOT") - public class TestsWithStdLib extends AbstractDiagnosticUsingJavacTest { + public class Imports extends AbstractDiagnosticUsingJavacTest { @Test - @TestMetadata("addAllProjection.kt") - public void testAddAllProjection() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/addAllProjection.kt"); + public void testAllFilesPresentInImports() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/imports"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test - public void testAllFilesPresentInTestsWithStdLib() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + @TestMetadata("AllUnderImportsAmbiguity.kt") + public void testAllUnderImportsAmbiguity() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/AllUnderImportsAmbiguity.kt"); } @Test - @TestMetadata("ArrayOfNothing.kt") - public void testArrayOfNothing() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/ArrayOfNothing.kt"); + @TestMetadata("AllUnderImportsLessPriority.kt") + public void testAllUnderImportsLessPriority() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/AllUnderImportsLessPriority.kt"); } @Test - @TestMetadata("assignedInSynchronized.kt") - public void testAssignedInSynchronized() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/assignedInSynchronized.kt"); + @TestMetadata("ClassImportsConflicting.kt") + public void testClassImportsConflicting() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/ClassImportsConflicting.kt"); } @Test - @TestMetadata("CallCompanionProtectedNonStatic.kt") - public void testCallCompanionProtectedNonStatic() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/CallCompanionProtectedNonStatic.kt"); + @TestMetadata("CurrentPackageAndAllUnderImport.kt") + public void testCurrentPackageAndAllUnderImport() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/CurrentPackageAndAllUnderImport.kt"); } @Test - @TestMetadata("CallToMainRedeclaredInMultiFile.kt") - public void testCallToMainRedeclaredInMultiFile() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/CallToMainRedeclaredInMultiFile.kt"); + @TestMetadata("CurrentPackageAndExplicitImport.kt") + public void testCurrentPackageAndExplicitImport() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/CurrentPackageAndExplicitImport.kt"); } @Test - @TestMetadata("commonCollections.kt") - public void testCommonCollections() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/commonCollections.kt"); + @TestMetadata("CurrentPackageAndExplicitNestedImport.kt") + public void testCurrentPackageAndExplicitNestedImport() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/CurrentPackageAndExplicitNestedImport.kt"); } @Test - @TestMetadata("elvisOnJavaList.kt") - public void testElvisOnJavaList() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/elvisOnJavaList.kt"); + @TestMetadata("CurrentPackageAndNestedAsteriskImport.kt") + public void testCurrentPackageAndNestedAsteriskImport() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/CurrentPackageAndNestedAsteriskImport.kt"); } @Test - @TestMetadata("elvisOnUnitInLet.kt") - public void testElvisOnUnitInLet() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/elvisOnUnitInLet.kt"); + @TestMetadata("ImportGenericVsPackage.kt") + public void testImportGenericVsPackage() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/ImportGenericVsPackage.kt"); } @Test - @TestMetadata("hugeUnresolvedKotlinxHtml.kt") - public void testHugeUnresolvedKotlinxHtml() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/hugeUnresolvedKotlinxHtml.kt"); + @TestMetadata("ImportProtectedClass.kt") + public void testImportProtectedClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/ImportProtectedClass.kt"); } @Test - @TestMetadata("ifElseJavaList.kt") - public void testIfElseJavaList() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/ifElseJavaList.kt"); + @TestMetadata("ImportTwoTimes.kt") + public void testImportTwoTimes() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/ImportTwoTimes.kt"); } @Test - @TestMetadata("implicitCastToAny.kt") - public void testImplicitCastToAny() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/implicitCastToAny.kt"); + @TestMetadata("ImportTwoTimesStar.kt") + public void testImportTwoTimesStar() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/ImportTwoTimesStar.kt"); } @Test - @TestMetadata("InaccessibleInternalClass.kt") - public void testInaccessibleInternalClass() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/InaccessibleInternalClass.kt"); + @TestMetadata("NestedAndTopLevelClassClash.kt") + public void testNestedAndTopLevelClassClash() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/NestedAndTopLevelClassClash.kt"); } @Test - @TestMetadata("instar.kt") - public void testInstar() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/instar.kt"); + @TestMetadata("NestedClassClash.kt") + public void testNestedClassClash() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/NestedClassClash.kt"); } @Test - @TestMetadata("javaClassOnCompanion.kt") - public void testJavaClassOnCompanion() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/javaClassOnCompanion.kt"); + @TestMetadata("PackageExplicitAndStartImport.kt") + public void testPackageExplicitAndStartImport() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/PackageExplicitAndStartImport.kt"); } @Test - @TestMetadata("javaForKClass.kt") - public void testJavaForKClass() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/javaForKClass.kt"); + @TestMetadata("PackagePrivateAndPublicNested.kt") + public void testPackagePrivateAndPublicNested() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/PackagePrivateAndPublicNested.kt"); } @Test - @TestMetadata("kt8050.kt") - public void testKt8050() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/kt8050.kt"); + @TestMetadata("TopLevelClassVsPackage.kt") + public void testTopLevelClassVsPackage() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/TopLevelClassVsPackage.kt"); } @Test - @TestMetadata("kt9078.kt") - public void testKt9078() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/kt9078.kt"); + @TestMetadata("TopLevelClassVsPackage2.kt") + public void testTopLevelClassVsPackage2() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/TopLevelClassVsPackage2.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/javac/inheritance") + @TestDataPath("$PROJECT_ROOT") + public class Inheritance extends AbstractDiagnosticUsingJavacTest { + @Test + public void testAllFilesPresentInInheritance() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/inheritance"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test - @TestMetadata("kt9985.kt") - public void testKt9985() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/kt9985.kt"); + @TestMetadata("IheritanceOfInner.kt") + public void testIheritanceOfInner() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/IheritanceOfInner.kt"); } @Test - @TestMetadata("outstar.kt") - public void testOutstar() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/outstar.kt"); + @TestMetadata("InheritanceAmbiguity.kt") + public void testInheritanceAmbiguity() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/InheritanceAmbiguity.kt"); } @Test - @TestMetadata("overrideWithFunctionalType.kt") - public void testOverrideWithFunctionalType() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/overrideWithFunctionalType.kt"); + @TestMetadata("InheritanceAmbiguity2.kt") + public void testInheritanceAmbiguity2() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/InheritanceAmbiguity2.kt"); } @Test - @TestMetadata("PropertyDelegateWithPrivateSet.kt") - public void testPropertyDelegateWithPrivateSet() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/PropertyDelegateWithPrivateSet.kt"); + @TestMetadata("InheritanceAmbiguity3.kt") + public void testInheritanceAmbiguity3() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/InheritanceAmbiguity3.kt"); } @Test - @TestMetadata("pureReifiable.kt") - public void testPureReifiable() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/pureReifiable.kt"); + @TestMetadata("InheritanceAmbiguity4.kt") + public void testInheritanceAmbiguity4() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/InheritanceAmbiguity4.kt"); } @Test - @TestMetadata("pureReifiableArrayOperations.kt") - public void testPureReifiableArrayOperations() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/pureReifiableArrayOperations.kt"); + @TestMetadata("InheritanceWithKotlin.kt") + public void testInheritanceWithKotlin() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/InheritanceWithKotlin.kt"); } @Test - @TestMetadata("RedeclarationMainInMultiFileClass.kt") - public void testRedeclarationMainInMultiFileClass() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/RedeclarationMainInMultiFileClass.kt"); + @TestMetadata("InheritanceWithKotlinClasses.kt") + public void testInheritanceWithKotlinClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/InheritanceWithKotlinClasses.kt"); } @Test - @TestMetadata("RenameOnImportHidesDefaultImport.kt") - public void testRenameOnImportHidesDefaultImport() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/RenameOnImportHidesDefaultImport.kt"); + @TestMetadata("InheritedInner.kt") + public void testInheritedInner() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/InheritedInner.kt"); } @Test - @TestMetadata("shadowingInDestructuring.kt") - public void testShadowingInDestructuring() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/shadowingInDestructuring.kt"); + @TestMetadata("InheritedInner2.kt") + public void testInheritedInner2() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/InheritedInner2.kt"); } @Test - @TestMetadata("streams.kt") - public void testStreams() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/streams.kt"); + @TestMetadata("InheritedInnerAndSupertypeWithSameName.kt") + public void testInheritedInnerAndSupertypeWithSameName() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/InheritedInnerAndSupertypeWithSameName.kt"); } - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations") - @TestDataPath("$PROJECT_ROOT") - public class Annotations extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("annotationsTargetingLateinitAccessors.kt") - public void testAnnotationsTargetingLateinitAccessors() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationsTargetingLateinitAccessors.kt"); - } - - @Test - @TestMetadata("annotationsTargetingNonExistentAccessor.kt") - public void testAnnotationsTargetingNonExistentAccessor() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationsTargetingNonExistentAccessor.kt"); - } - - @Test - @TestMetadata("ClassObjectAnnotatedWithItsKClass.kt") - public void testClassObjectAnnotatedWithItsKClass() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/ClassObjectAnnotatedWithItsKClass.kt"); - } - - @Test - @TestMetadata("defaultValueMustBeConstant.kt") - public void testDefaultValueMustBeConstant() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/defaultValueMustBeConstant.kt"); - } - - @Test - @TestMetadata("explicitMetadata.kt") - public void testExplicitMetadata() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/explicitMetadata.kt"); - } - - @Test - @TestMetadata("jvmRecordWithoutJdk15.kt") - public void testJvmRecordWithoutJdk15() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmRecordWithoutJdk15.kt"); - } - - @Test - @TestMetadata("JvmSyntheticOnDelegate.kt") - public void testJvmSyntheticOnDelegate() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/JvmSyntheticOnDelegate.kt"); - } - - @Test - @TestMetadata("qualifiedCallValue.kt") - public void testQualifiedCallValue() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/qualifiedCallValue.kt"); - } - - @Test - @TestMetadata("strictfpOnClass.kt") - public void testStrictfpOnClass() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/strictfpOnClass.kt"); - } - - @Test - @TestMetadata("Synchronized.kt") - public void testSynchronized() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/Synchronized.kt"); - } - - @Test - @TestMetadata("SynchronizedOnInterfaceCompanionMember.kt") - public void testSynchronizedOnInterfaceCompanionMember() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/SynchronizedOnInterfaceCompanionMember.kt"); - } - - @Test - @TestMetadata("targetuse.kt") - public void testTargetuse() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/targetuse.kt"); - } - - @Test - @TestMetadata("throws.kt") - public void testThrows() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/throws.kt"); - } - - @Test - @TestMetadata("TransientOnDelegate.kt") - public void testTransientOnDelegate() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/TransientOnDelegate.kt"); - } - - @Test - @TestMetadata("Volatile.kt") - public void testVolatile() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/Volatile.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability") - @TestDataPath("$PROJECT_ROOT") - public class AnnotationApplicability extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInAnnotationApplicability() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("annotationsOnUseSiteTargets.kt") - public void testAnnotationsOnUseSiteTargets() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability/annotationsOnUseSiteTargets.kt"); - } - - @Test - @TestMetadata("illegalPlatformName.kt") - public void testIllegalPlatformName() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability/illegalPlatformName.kt"); - } - - @Test - @TestMetadata("jvmName.kt") - public void testJvmName() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability/jvmName.kt"); - } - - @Test - @TestMetadata("jvmNameOnMangledNames.kt") - public void testJvmNameOnMangledNames() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability/jvmNameOnMangledNames.kt"); - } - - @Test - @TestMetadata("multifileClassPart.kt") - public void testMultifileClassPart() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability/multifileClassPart.kt"); - } - - @Test - @TestMetadata("multifileClassPartWithJavaAnnotation.kt") - public void testMultifileClassPartWithJavaAnnotation() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability/multifileClassPartWithJavaAnnotation.kt"); - } - - @Test - @TestMetadata("suppressOnFunctionReference.kt") - public void testSuppressOnFunctionReference() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability/suppressOnFunctionReference.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant") - @TestDataPath("$PROJECT_ROOT") - public class AnnotationParameterMustBeConstant extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInAnnotationParameterMustBeConstant() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("array.kt") - public void testArray() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/array.kt"); - } - - @Test - @TestMetadata("simple.kt") - public void testSimple() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/simple.kt"); - } - - @Test - @TestMetadata("useOfNonConstVal.kt") - public void testUseOfNonConstVal() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/useOfNonConstVal.kt"); - } - - @Test - @TestMetadata("vararg.kt") - public void testVararg() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/vararg.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters") - @TestDataPath("$PROJECT_ROOT") - public class AnnotationParameters extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInAnnotationParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("kt10136.kt") - public void testKt10136() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/kt10136.kt"); - } - - @Test - @TestMetadata("nonConstValAsArgument.kt") - public void testNonConstValAsArgument() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/nonConstValAsArgument.kt"); - } - - @Test - @TestMetadata("orderWithValue.kt") - public void testOrderWithValue() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/orderWithValue.kt"); - } - - @Test - @TestMetadata("orderWithoutValue.kt") - public void testOrderWithoutValue() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/orderWithoutValue.kt"); - } - - @Test - @TestMetadata("valueArray.kt") - public void testValueArray() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArray.kt"); - } - - @Test - @TestMetadata("valueArrayAndOtherDefault.kt") - public void testValueArrayAndOtherDefault() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArrayAndOtherDefault.kt"); - } - - @Test - @TestMetadata("valueArrayOnly.kt") - public void testValueArrayOnly() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArrayOnly.kt"); - } - - @Test - @TestMetadata("valueArrayWithDefault.kt") - public void testValueArrayWithDefault() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArrayWithDefault.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter") - @TestDataPath("$PROJECT_ROOT") - public class AnnotationWithVarargParameter extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInAnnotationWithVarargParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("javaAnnotationWithVarargArgument.kt") - public void testJavaAnnotationWithVarargArgument() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter/javaAnnotationWithVarargArgument.kt"); - } - - @Test - @TestMetadata("kotlinAnnotationWithVarargArgument.kt") - public void testKotlinAnnotationWithVarargArgument() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter/kotlinAnnotationWithVarargArgument.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter") - @TestDataPath("$PROJECT_ROOT") - public class JavaAnnotationsWithKClassParameter extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInJavaAnnotationsWithKClassParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("annotationAsArgument.kt") - public void testAnnotationAsArgument() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/annotationAsArgument.kt"); - } - - @Test - @TestMetadata("arg.kt") - public void testArg() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/arg.kt"); - } - - @Test - @TestMetadata("argAndOtherDefault.kt") - public void testArgAndOtherDefault() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/argAndOtherDefault.kt"); - } - - @Test - @TestMetadata("argArray.kt") - public void testArgArray() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/argArray.kt"); - } - - @Test - @TestMetadata("argWithDefault.kt") - public void testArgWithDefault() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/argWithDefault.kt"); - } - - @Test - @TestMetadata("argWithDefaultAndOther.kt") - public void testArgWithDefaultAndOther() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/argWithDefaultAndOther.kt"); - } - - @Test - @TestMetadata("twoArgs.kt") - public void testTwoArgs() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/twoArgs.kt"); - } - - @Test - @TestMetadata("value.kt") - public void testValue() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/value.kt"); - } - - @Test - @TestMetadata("valueAndOtherDefault.kt") - public void testValueAndOtherDefault() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/valueAndOtherDefault.kt"); - } - - @Test - @TestMetadata("valueArray.kt") - public void testValueArray() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/valueArray.kt"); - } - - @Test - @TestMetadata("valueWithDefault.kt") - public void testValueWithDefault() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/valueWithDefault.kt"); - } - - @Test - @TestMetadata("valueWithDefaultAndOther.kt") - public void testValueWithDefaultAndOther() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/valueWithDefaultAndOther.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault") - @TestDataPath("$PROJECT_ROOT") - public class JvmDefault extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInJvmDefault() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("generic.kt") - public void testGeneric() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/generic.kt"); - } - - @Test - @TestMetadata("javaOverride.kt") - public void testJavaOverride() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/javaOverride.kt"); - } - - @Test - @TestMetadata("javaOverrideAll.kt") - public void testJavaOverrideAll() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/javaOverrideAll.kt"); - } - - @Test - @TestMetadata("jvmDefaultInInheritance.kt") - public void testJvmDefaultInInheritance() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/jvmDefaultInInheritance.kt"); - } - - @Test - @TestMetadata("jvmDefaults.kt") - public void testJvmDefaults() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/jvmDefaults.kt"); - } - - @Test - @TestMetadata("jvmDefaultsWithJava.kt") - public void testJvmDefaultsWithJava() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/jvmDefaultsWithJava.kt"); - } - - @Test - @TestMetadata("noJvmDefaultFlag.kt") - public void testNoJvmDefaultFlag() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/noJvmDefaultFlag.kt"); - } - - @Test - @TestMetadata("notInterface.kt") - public void testNotInterface() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/notInterface.kt"); - } - - @Test - @TestMetadata("propertyAccessor.kt") - public void testPropertyAccessor() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/propertyAccessor.kt"); - } - - @Test - @TestMetadata("simpleOverride.kt") - public void testSimpleOverride() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/simpleOverride.kt"); - } - - @Test - @TestMetadata("simplePropertyOverride.kt") - public void testSimplePropertyOverride() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/simplePropertyOverride.kt"); - } - - @Test - @TestMetadata("superCall.kt") - public void testSuperCall() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/superCall.kt"); - } - - @Test - @TestMetadata("superCallAmbiguity.kt") - public void testSuperCallAmbiguity() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/superCallAmbiguity.kt"); - } - - @Test - @TestMetadata("superCallAmbiguity2.kt") - public void testSuperCallAmbiguity2() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/superCallAmbiguity2.kt"); - } - - @Test - @TestMetadata("superCallAmbiguity3.kt") - public void testSuperCallAmbiguity3() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/superCallAmbiguity3.kt"); - } - - @Test - @TestMetadata("target6.kt") - public void testTarget6() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/target6.kt"); - } - - @Test - @TestMetadata("target8.kt") - public void testTarget8() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/target8.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/allCompatibility") - @TestDataPath("$PROJECT_ROOT") - public class AllCompatibility extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInAllCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("specialization.kt") - public void testSpecialization() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/allCompatibility/specialization.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/jvmDefaultWithoutCompatibility") - @TestDataPath("$PROJECT_ROOT") - public class JvmDefaultWithoutCompatibility extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInJvmDefaultWithoutCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/jvmDefaultWithoutCompatibility"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("target6.kt") - public void testTarget6() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/jvmDefaultWithoutCompatibility/target6.kt"); - } - - @Test - @TestMetadata("target8.kt") - public void testTarget8() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/jvmDefaultWithoutCompatibility/target8.kt"); - } - - @Test - @TestMetadata("target8Disabled.kt") - public void testTarget8Disabled() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/jvmDefaultWithoutCompatibility/target8Disabled.kt"); - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmField") - @TestDataPath("$PROJECT_ROOT") - public class JvmField extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInJvmField() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmField"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("clashWithCompanionObjectField.kt") - public void testClashWithCompanionObjectField() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmField/clashWithCompanionObjectField.kt"); - } - - @Test - @TestMetadata("inMultiFileFacade.kt") - public void testInMultiFileFacade() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmField/inMultiFileFacade.kt"); - } - - @Test - @TestMetadata("inSingleFileFacade.kt") - public void testInSingleFileFacade() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmField/inSingleFileFacade.kt"); - } - - @Test - @TestMetadata("interface13.kt") - public void testInterface13() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmField/interface13.kt"); - } - - @Test - @TestMetadata("jvmFieldApplicability.kt") - public void testJvmFieldApplicability() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmField/jvmFieldApplicability.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads") - @TestDataPath("$PROJECT_ROOT") - public class JvmOverloads extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInJvmOverloads() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("JvmOverloadWithNoDefaults.kt") - public void testJvmOverloadWithNoDefaults() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/JvmOverloadWithNoDefaults.kt"); - } - - @Test - @TestMetadata("jvmOverloadsOnAbstractMethods.kt") - public void testJvmOverloadsOnAbstractMethods() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/jvmOverloadsOnAbstractMethods.kt"); - } - - @Test - @TestMetadata("jvmOverloadsOnAnnotationClassConstructor_1_3.kt") - public void testJvmOverloadsOnAnnotationClassConstructor_1_3() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/jvmOverloadsOnAnnotationClassConstructor_1_3.kt"); - } - - @Test - @TestMetadata("jvmOverloadsOnAnnotationClassConstructor_1_4.kt") - public void testJvmOverloadsOnAnnotationClassConstructor_1_4() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/jvmOverloadsOnAnnotationClassConstructor_1_4.kt"); - } - - @Test - @TestMetadata("jvmOverloadsOnMangledFunctions.kt") - public void testJvmOverloadsOnMangledFunctions() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/jvmOverloadsOnMangledFunctions.kt"); - } - - @Test - @TestMetadata("jvmOverloadsOnPrivate.kt") - public void testJvmOverloadsOnPrivate() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/jvmOverloadsOnPrivate.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmPackageName") - @TestDataPath("$PROJECT_ROOT") - public class JvmPackageName extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInJvmPackageName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmPackageName"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("incorrectJvmPackageName.kt") - public void testIncorrectJvmPackageName() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmPackageName/incorrectJvmPackageName.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmSpecialFunctions") - @TestDataPath("$PROJECT_ROOT") - public class JvmSpecialFunctions extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInJvmSpecialFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmSpecialFunctions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("apiVersionIsAtLeastHasConstArguments.kt") - public void testApiVersionIsAtLeastHasConstArguments() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmSpecialFunctions/apiVersionIsAtLeastHasConstArguments.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic") - @TestDataPath("$PROJECT_ROOT") - public class JvmStatic extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInJvmStatic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("constOrJvmFieldProperty.kt") - public void testConstOrJvmFieldProperty() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/constOrJvmFieldProperty.kt"); - } - - @Test - @TestMetadata("constructorProperty.kt") - public void testConstructorProperty() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/constructorProperty.kt"); - } - - @Test - @TestMetadata("constructorProperty_LL13.kt") - public void testConstructorProperty_LL13() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/constructorProperty_LL13.kt"); - } - - @Test - @TestMetadata("constructors.kt") - public void testConstructors() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/constructors.kt"); - } - - @Test - @TestMetadata("finalAndAbstract.kt") - public void testFinalAndAbstract() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/finalAndAbstract.kt"); - } - - @Test - @TestMetadata("functions.kt") - public void testFunctions() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/functions.kt"); - } - - @Test - @TestMetadata("functions_LL13.kt") - public void testFunctions_LL13() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/functions_LL13.kt"); - } - - @Test - @TestMetadata("interfaceCompanion_LL12.kt") - public void testInterfaceCompanion_LL12() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/interfaceCompanion_LL12.kt"); - } - - @Test - @TestMetadata("interfaceCompanion_LL13_16.kt") - public void testInterfaceCompanion_LL13_16() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/interfaceCompanion_LL13_16.kt"); - } - - @Test - @TestMetadata("interfaceCompanion_LL13_18.kt") - public void testInterfaceCompanion_LL13_18() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/interfaceCompanion_LL13_18.kt"); - } - - @Test - @TestMetadata("localFun.kt") - public void testLocalFun() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/localFun.kt"); - } - - @Test - @TestMetadata("localFun_LL13.kt") - public void testLocalFun_LL13() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/localFun_LL13.kt"); - } - - @Test - @TestMetadata("mainInObject.kt") - public void testMainInObject() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/mainInObject.kt"); - } - - @Test - @TestMetadata("privateCompanionObject.kt") - public void testPrivateCompanionObject() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/privateCompanionObject.kt"); - } - - @Test - @TestMetadata("property.kt") - public void testProperty() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/property.kt"); - } - - @Test - @TestMetadata("property_LL13.kt") - public void testProperty_LL13() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/property_LL13.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/kClass") - @TestDataPath("$PROJECT_ROOT") - public class KClass extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInKClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/kClass"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("kClassArrayInAnnotationsInVariance.kt") - public void testKClassArrayInAnnotationsInVariance() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsInVariance.kt"); - } - - @Test - @TestMetadata("kClassArrayInAnnotationsOutVariance.kt") - public void testKClassArrayInAnnotationsOutVariance() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsOutVariance.kt"); - } - - @Test - @TestMetadata("kClassInAnnotation.kt") - public void testKClassInAnnotation() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInAnnotation.kt"); - } - - @Test - @TestMetadata("kClassInAnnotationsInVariance.kt") - public void testKClassInAnnotationsInVariance() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInAnnotationsInVariance.kt"); - } - - @Test - @TestMetadata("kClassInAnnotationsOutVariance.kt") - public void testKClassInAnnotationsOutVariance() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInAnnotationsOutVariance.kt"); - } - - @Test - @TestMetadata("kClassInvariantTP.kt") - public void testKClassInvariantTP() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInvariantTP.kt"); - } - - @Test - @TestMetadata("kClassOutArrayInAnnotationsOutVariance.kt") - public void testKClassOutArrayInAnnotationsOutVariance() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassOutArrayInAnnotationsOutVariance.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument") - @TestDataPath("$PROJECT_ROOT") - public class ProhibitPositionedArgument extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInProhibitPositionedArgument() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("kotlinAnnotation.kt") - public void testKotlinAnnotation() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/kotlinAnnotation.kt"); - } - - @Test - @TestMetadata("tooManyArgs.kt") - public void testTooManyArgs() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/tooManyArgs.kt"); - } - - @Test - @TestMetadata("typeMismatch.kt") - public void testTypeMismatch() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/typeMismatch.kt"); - } - - @Test - @TestMetadata("withValue.kt") - public void testWithValue() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/withValue.kt"); - } - - @Test - @TestMetadata("withoutValue.kt") - public void testWithoutValue() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/withoutValue.kt"); - } - } + @Test + @TestMetadata("InheritedInnerUsageInInner.kt") + public void testInheritedInnerUsageInInner() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/InheritedInnerUsageInInner.kt"); } - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/assert") - @TestDataPath("$PROJECT_ROOT") - public class Assert extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInAssert() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/assert"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("cast.kt") - public void testCast() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/assert/cast.kt"); - } - - @Test - @TestMetadata("safeCall.kt") - public void testSafeCall() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/assert/safeCall.kt"); - } + @Test + @TestMetadata("InheritedKotlinInner.kt") + public void testInheritedKotlinInner() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/InheritedKotlinInner.kt"); } - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/builtins") - @TestDataPath("$PROJECT_ROOT") - public class Builtins extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInBuiltins() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/builtins"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("arraysAreCloneable.kt") - public void testArraysAreCloneable() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/builtins/arraysAreCloneable.kt"); - } + @Test + @TestMetadata("InnerAndInheritedInner.kt") + public void testInnerAndInheritedInner() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/InnerAndInheritedInner.kt"); } - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/cast") - @TestDataPath("$PROJECT_ROOT") - public class Cast extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInCast() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/cast"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("AsInsideIn.kt") - public void testAsInsideIn() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/cast/AsInsideIn.kt"); - } - - @Test - @TestMetadata("IsArray.kt") - public void testIsArray() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/cast/IsArray.kt"); - } - - @Test - @TestMetadata("IsReified.kt") - public void testIsReified() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/cast/IsReified.kt"); - } + @Test + @TestMetadata("ManyInheritedClasses.kt") + public void testManyInheritedClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/ManyInheritedClasses.kt"); } - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/contracts") - @TestDataPath("$PROJECT_ROOT") - public class Contracts extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInContracts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow") - @TestDataPath("$PROJECT_ROOT") - public class Controlflow extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInControlflow() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining") - @TestDataPath("$PROJECT_ROOT") - public class FlowInlining extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInFlowInlining() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("breakContinuesInInlinedLambda.kt") - public void testBreakContinuesInInlinedLambda() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining/breakContinuesInInlinedLambda.kt"); - } - - @Test - @TestMetadata("expressionBody.kt") - public void testExpressionBody() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining/expressionBody.kt"); - } - - @Test - @TestMetadata("implicitCastToAnyInReturnType.kt") - public void testImplicitCastToAnyInReturnType() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining/implicitCastToAnyInReturnType.kt"); - } - - @Test - @TestMetadata("inlinedLambdaAlwaysThrows.kt") - public void testInlinedLambdaAlwaysThrows() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining/inlinedLambdaAlwaysThrows.kt"); - } - - @Test - @TestMetadata("irrelevantUnknownClosure.kt") - public void testIrrelevantUnknownClosure() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining/irrelevantUnknownClosure.kt"); - } - - @Test - @TestMetadata("labeledReturns.kt") - public void testLabeledReturns() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining/labeledReturns.kt"); - } - - @Test - @TestMetadata("nestedTryCatchFinally.kt") - public void testNestedTryCatchFinally() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining/nestedTryCatchFinally.kt"); - } - - @Test - @TestMetadata("nestedTryCatchs.kt") - public void testNestedTryCatchs() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining/nestedTryCatchs.kt"); - } - - @Test - @TestMetadata("nonLocalReturn.kt") - public void testNonLocalReturn() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining/nonLocalReturn.kt"); - } - - @Test - @TestMetadata("nonReturningInlinedLambda.kt") - public void testNonReturningInlinedLambda() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining/nonReturningInlinedLambda.kt"); - } - - @Test - @TestMetadata("safeCallAndInPlaceReturn.kt") - public void testSafeCallAndInPlaceReturn() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining/safeCallAndInPlaceReturn.kt"); - } - - @Test - @TestMetadata("severalJumpOutsFromInlinedLambda.kt") - public void testSeveralJumpOutsFromInlinedLambda() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining/severalJumpOutsFromInlinedLambda.kt"); - } - - @Test - @TestMetadata("throwIfNotCalled.kt") - public void testThrowIfNotCalled() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining/throwIfNotCalled.kt"); - } - - @Test - @TestMetadata("tryCatch.kt") - public void testTryCatch() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining/tryCatch.kt"); - } - - @Test - @TestMetadata("tryCatchFinally.kt") - public void testTryCatchFinally() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining/tryCatchFinally.kt"); - } - - @Test - @TestMetadata("typeMismatch.kt") - public void testTypeMismatch() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining/typeMismatch.kt"); - } - - @Test - @TestMetadata("unreachableCode.kt") - public void testUnreachableCode() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining/unreachableCode.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization") - @TestDataPath("$PROJECT_ROOT") - public class Initialization extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInInitialization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/atLeastOnce") - @TestDataPath("$PROJECT_ROOT") - public class AtLeastOnce extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInAtLeastOnce() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/atLeastOnce"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("valDefiniteReassignment.kt") - public void testValDefiniteReassignment() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/atLeastOnce/valDefiniteReassignment.kt"); - } - - @Test - @TestMetadata("varDefiniteInitialization.kt") - public void testVarDefiniteInitialization() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/atLeastOnce/varDefiniteInitialization.kt"); - } - - @Test - @TestMetadata("varIndefiniteIntialization.kt") - public void testVarIndefiniteIntialization() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/atLeastOnce/varIndefiniteIntialization.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/exactlyOnce") - @TestDataPath("$PROJECT_ROOT") - public class ExactlyOnce extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInExactlyOnce() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/exactlyOnce"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("valDefiniteInitialization.kt") - public void testValDefiniteInitialization() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/exactlyOnce/valDefiniteInitialization.kt"); - } - - @Test - @TestMetadata("valDefiniteReassignment.kt") - public void testValDefiniteReassignment() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/exactlyOnce/valDefiniteReassignment.kt"); - } - - @Test - @TestMetadata("valIndefiniteInitialization.kt") - public void testValIndefiniteInitialization() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/exactlyOnce/valIndefiniteInitialization.kt"); - } - - @Test - @TestMetadata("varDefiniteInitalization.kt") - public void testVarDefiniteInitalization() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/exactlyOnce/varDefiniteInitalization.kt"); - } - - @Test - @TestMetadata("varIndefiniteInitialization.kt") - public void testVarIndefiniteInitialization() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/exactlyOnce/varIndefiniteInitialization.kt"); - } - - @Test - @TestMetadata("withReceiver.kt") - public void testWithReceiver() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/exactlyOnce/withReceiver.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/unknown") - @TestDataPath("$PROJECT_ROOT") - public class Unknown extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInUnknown() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/unknown"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("unknownInvocations.kt") - public void testUnknownInvocations() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/unknown/unknownInvocations.kt"); - } - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl") - @TestDataPath("$PROJECT_ROOT") - public class Dsl extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInDsl() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("callUsualContractFunction.kt") - public void testCallUsualContractFunction() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/callUsualContractFunction.kt"); - } - - @Test - @TestMetadata("fqnContractFunction.kt") - public void testFqnContractFunction() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/fqnContractFunction.kt"); - } - - @Test - @TestMetadata("rewriteAtSliceFunctor.kt") - public void testRewriteAtSliceFunctor() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/rewriteAtSliceFunctor.kt"); - } - - @Test - @TestMetadata("useBeforeDeclaration.kt") - public void testUseBeforeDeclaration() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/useBeforeDeclaration.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors") - @TestDataPath("$PROJECT_ROOT") - public class Errors extends AbstractDiagnosticUsingJavacTest { - @Test - @TestMetadata("accessToOuterThis.kt") - public void testAccessToOuterThis() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors/accessToOuterThis.kt"); - } - - @Test - public void testAllFilesPresentInErrors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("booleanComparisons.kt") - public void testBooleanComparisons() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors/booleanComparisons.kt"); - } - - @Test - @TestMetadata("callInContractDescription.kt") - public void testCallInContractDescription() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors/callInContractDescription.kt"); - } - - @Test - @TestMetadata("contractCallSites.1.3.kt") - public void testContractCallSites_1_3() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors/contractCallSites.1.3.kt"); - } - - @Test - @TestMetadata("contractCallSites.1.4.kt") - public void testContractCallSites_1_4() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors/contractCallSites.1.4.kt"); - } - - @Test - @TestMetadata("emptyContract.kt") - public void testEmptyContract() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors/emptyContract.kt"); - } - - @Test - @TestMetadata("illegalConstructionInContractBlock.kt") - public void testIllegalConstructionInContractBlock() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors/illegalConstructionInContractBlock.kt"); - } - - @Test - @TestMetadata("illegalEqualsCondition.kt") - public void testIllegalEqualsCondition() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors/illegalEqualsCondition.kt"); - } - - @Test - @TestMetadata("nestedConditionalEffects.kt") - public void testNestedConditionalEffects() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors/nestedConditionalEffects.kt"); - } - - @Test - @TestMetadata("nonLambdaLiteralAsArgument.kt") - public void testNonLambdaLiteralAsArgument() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors/nonLambdaLiteralAsArgument.kt"); - } - - @Test - @TestMetadata("notFirstStatement.kt") - public void testNotFirstStatement() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors/notFirstStatement.kt"); - } - - @Test - @TestMetadata("recursiveContract.kt") - public void testRecursiveContract() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors/recursiveContract.kt"); - } - - @Test - @TestMetadata("recursiveContractCustomContractFunction.kt") - public void testRecursiveContractCustomContractFunction() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors/recursiveContractCustomContractFunction.kt"); - } - - @Test - @TestMetadata("referenceToProperty.1.3.kt") - public void testReferenceToProperty_1_3() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors/referenceToProperty.1.3.kt"); - } - - @Test - @TestMetadata("referenceToProperty.1.4.kt") - public void testReferenceToProperty_1_4() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors/referenceToProperty.1.4.kt"); - } - - @Test - @TestMetadata("typeReferences.1.3.kt") - public void testTypeReferences_1_3() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors/typeReferences.1.3.kt"); - } - - @Test - @TestMetadata("typeReferences.1.4.kt") - public void testTypeReferences_1_4() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors/typeReferences.1.4.kt"); - } - - @Test - @TestMetadata("unlabeledReceiver.kt") - public void testUnlabeledReceiver() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors/unlabeledReceiver.kt"); - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/contracts/fromStdlib") - @TestDataPath("$PROJECT_ROOT") - public class FromStdlib extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInFromStdlib() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/fromStdlib"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("check.kt") - public void testCheck() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/fromStdlib/check.kt"); - } - - @Test - @TestMetadata("fromStandardKt.kt") - public void testFromStandardKt() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/fromStdlib/fromStandardKt.kt"); - } - - @Test - @TestMetadata("isNullOrBlank.kt") - public void testIsNullOrBlank() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/fromStdlib/isNullOrBlank.kt"); - } - - @Test - @TestMetadata("isNullOrEmpty.kt") - public void testIsNullOrEmpty() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/fromStdlib/isNullOrEmpty.kt"); - } - - @Test - @TestMetadata("require.kt") - public void testRequire() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/fromStdlib/require.kt"); - } - - @Test - @TestMetadata("synchronize.kt") - public void testSynchronize() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/fromStdlib/synchronize.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/contracts/newSyntax") - @TestDataPath("$PROJECT_ROOT") - public class NewSyntax extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInNewSyntax() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/newSyntax"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("complexContractDescription.kt") - public void testComplexContractDescription() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/newSyntax/complexContractDescription.kt"); - } - - @Test - @TestMetadata("onelineFunctionsContractDescription.kt") - public void testOnelineFunctionsContractDescription() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/newSyntax/onelineFunctionsContractDescription.kt"); - } - - @Test - @TestMetadata("propertyAccessorsContractDescription.kt") - public void testPropertyAccessorsContractDescription() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/newSyntax/propertyAccessorsContractDescription.kt"); - } - - @Test - @TestMetadata("simpleFunctionsContractDescription.kt") - public void testSimpleFunctionsContractDescription() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/newSyntax/simpleFunctionsContractDescription.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts") - @TestDataPath("$PROJECT_ROOT") - public class Smartcasts extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInSmartcasts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("callWithDefaultValue.kt") - public void testCallWithDefaultValue() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/callWithDefaultValue.kt"); - } - - @Test - @TestMetadata("catchExceptionSpilling.kt") - public void testCatchExceptionSpilling() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/catchExceptionSpilling.kt"); - } - - @Test - @TestMetadata("compositions.kt") - public void testCompositions() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/compositions.kt"); - } - - @Test - @TestMetadata("contractsOnMembers.kt") - public void testContractsOnMembers() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/contractsOnMembers.kt"); - } - - @Test - @TestMetadata("deeplyNested.kt") - public void testDeeplyNested() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/deeplyNested.kt"); - } - - @Test - @TestMetadata("extensionReceiver.kt") - public void testExtensionReceiver() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/extensionReceiver.kt"); - } - - @Test - @TestMetadata("extensionReceiver_after.kt") - public void testExtensionReceiver_after() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/extensionReceiver_after.kt"); - } - - @Test - @TestMetadata("externalArguments.kt") - public void testExternalArguments() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/externalArguments.kt"); - } - - @Test - @TestMetadata("intersectingInfo.kt") - public void testIntersectingInfo() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/intersectingInfo.kt"); - } - - @Test - @TestMetadata("intersectionTypes.kt") - public void testIntersectionTypes() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/intersectionTypes.kt"); - } - - @Test - @TestMetadata("nullabilitySmartcastWhenNullability.kt") - public void testNullabilitySmartcastWhenNullability() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/nullabilitySmartcastWhenNullability.kt"); - } - - @Test - @TestMetadata("partiallyIncorrect.kt") - public void testPartiallyIncorrect() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/partiallyIncorrect.kt"); - } - - @Test - @TestMetadata("receiver.kt") - public void testReceiver() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/receiver.kt"); - } - - @Test - @TestMetadata("reifiedGeneric.kt") - public void testReifiedGeneric() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/reifiedGeneric.kt"); - } - - @Test - @TestMetadata("safecallAndReturnsNull.kt") - public void testSafecallAndReturnsNull() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/safecallAndReturnsNull.kt"); - } - - @Test - @TestMetadata("throwsEffect.kt") - public void testThrowsEffect() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/throwsEffect.kt"); - } - - @Test - @TestMetadata("typeSmartcastWhenNullability.kt") - public void testTypeSmartcastWhenNullability() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/typeSmartcastWhenNullability.kt"); - } - - @Test - @TestMetadata("unreachableBranches.kt") - public void testUnreachableBranches() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/unreachableBranches.kt"); - } - - @Test - @TestMetadata("valueOfContractedFunctionIngored.kt") - public void testValueOfContractedFunctionIngored() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/valueOfContractedFunctionIngored.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/multieffect") - @TestDataPath("$PROJECT_ROOT") - public class Multieffect extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInMultieffect() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/multieffect"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("implicitIff.kt") - public void testImplicitIff() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/multieffect/implicitIff.kt"); - } - - @Test - @TestMetadata("returnsAndCalls.kt") - public void testReturnsAndCalls() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/multieffect/returnsAndCalls.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/operatorsTests") - @TestDataPath("$PROJECT_ROOT") - public class OperatorsTests extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInOperatorsTests() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/operatorsTests"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("andOperator.kt") - public void testAndOperator() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/operatorsTests/andOperator.kt"); - } - - @Test - @TestMetadata("andOperatorWithConstant.kt") - public void testAndOperatorWithConstant() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/operatorsTests/andOperatorWithConstant.kt"); - } - - @Test - @TestMetadata("andOperatorWithUnknown.kt") - public void testAndOperatorWithUnknown() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/operatorsTests/andOperatorWithUnknown.kt"); - } - - @Test - @TestMetadata("equalsOperator.kt") - public void testEqualsOperator() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/operatorsTests/equalsOperator.kt"); - } - - @Test - @TestMetadata("equalsWithNullableBoolean.kt") - public void testEqualsWithNullableBoolean() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/operatorsTests/equalsWithNullableBoolean.kt"); - } - - @Test - @TestMetadata("isInstanceOperator.kt") - public void testIsInstanceOperator() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/operatorsTests/isInstanceOperator.kt"); - } - - @Test - @TestMetadata("orOperator.kt") - public void testOrOperator() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/operatorsTests/orOperator.kt"); - } - - @Test - @TestMetadata("orOperatorWithConstant.kt") - public void testOrOperatorWithConstant() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/operatorsTests/orOperatorWithConstant.kt"); - } - - @Test - @TestMetadata("orOperatorWithUnknown.kt") - public void testOrOperatorWithUnknown() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/operatorsTests/orOperatorWithUnknown.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/when") - @TestDataPath("$PROJECT_ROOT") - public class When extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInWhen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/when"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("kt36818.kt") - public void testKt36818() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/when/kt36818.kt"); - } - - @Test - @TestMetadata("withSubject.kt") - public void testWithSubject() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/when/withSubject.kt"); - } - - @Test - @TestMetadata("withSubjectNullableBoolean.kt") - public void testWithSubjectNullableBoolean() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/when/withSubjectNullableBoolean.kt"); - } - - @Test - @TestMetadata("withoutSubject.kt") - public void testWithoutSubject() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/when/withoutSubject.kt"); - } - } - } + @Test + @TestMetadata("SameInnersInSupertypeAndSupertypesSupertype.kt") + public void testSameInnersInSupertypeAndSupertypesSupertype() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/SameInnersInSupertypeAndSupertypesSupertype.kt"); } - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines") - @TestDataPath("$PROJECT_ROOT") - public class Coroutines extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInCoroutines() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("allowNullOperatorsForResult_1_3.kt") - public void testAllowNullOperatorsForResult_1_3() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/allowNullOperatorsForResult_1_3.kt"); - } - - @Test - @TestMetadata("allowNullOperatorsForResult_1_4.kt") - public void testAllowNullOperatorsForResult_1_4() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/allowNullOperatorsForResult_1_4.kt"); - } - - @Test - @TestMetadata("allowResultInReturnTypeWithFlag.kt") - public void testAllowResultInReturnTypeWithFlag() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/allowResultInReturnTypeWithFlag.kt"); - } - - @Test - @TestMetadata("allowResultInReturnType_1_3.kt") - public void testAllowResultInReturnType_1_3() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/allowResultInReturnType_1_3.kt"); - } - - @Test - @TestMetadata("allowResultInReturnType_1_4.kt") - public void testAllowResultInReturnType_1_4() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/allowResultInReturnType_1_4.kt"); - } - - @Test - @TestMetadata("basicBuildListBuildMap.kt") - public void testBasicBuildListBuildMap() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/basicBuildListBuildMap.kt"); - } - - @Test - @TestMetadata("callableReferences.kt") - public void testCallableReferences() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/callableReferences.kt"); - } - - @Test - @TestMetadata("coroutineContext.kt") - public void testCoroutineContext() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/coroutineContext.kt"); - } - - @Test - @TestMetadata("coroutinesDisabled.kt") - public void testCoroutinesDisabled() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/coroutinesDisabled.kt"); - } - - @Test - @TestMetadata("coroutinesEnabledWithWarning.kt") - public void testCoroutinesEnabledWithWarning() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/coroutinesEnabledWithWarning.kt"); - } - - @Test - @TestMetadata("illegalSuspendCalls.kt") - public void testIllegalSuspendCalls() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/illegalSuspendCalls.kt"); - } - - @Test - @TestMetadata("illegalSuspendCallsForDelegated.kt") - public void testIllegalSuspendCallsForDelegated() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/illegalSuspendCallsForDelegated.kt"); - } - - @Test - @TestMetadata("irrelevantSuspendDeclarations.kt") - public void testIrrelevantSuspendDeclarations() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/irrelevantSuspendDeclarations.kt"); - } - - @Test - @TestMetadata("kSuspendFunctionAsSupertype.kt") - public void testKSuspendFunctionAsSupertype() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/kSuspendFunctionAsSupertype.kt"); - } - - @Test - @TestMetadata("kt18292.kt") - public void testKt18292() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/kt18292.kt"); - } - - @Test - @TestMetadata("kt28658.kt") - public void testKt28658() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/kt28658.kt"); - } - - @Test - @TestMetadata("kt36947.kt") - public void testKt36947() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/kt36947.kt"); - } - - @Test - @TestMetadata("kt37309.kt") - public void testKt37309() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/kt37309.kt"); - } - - @Test - @TestMetadata("kt38179.kt") - public void testKt38179() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/kt38179.kt"); - } - - @Test - @TestMetadata("kt41430.kt") - public void testKt41430() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/kt41430.kt"); - } - - @Test - @TestMetadata("lambdaExpectedType.kt") - public void testLambdaExpectedType() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/lambdaExpectedType.kt"); - } - - @Test - @TestMetadata("mixingSuspendability.kt") - public void testMixingSuspendability() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/mixingSuspendability.kt"); - } - - @Test - @TestMetadata("modifierFormForNonBuiltInSuspend.kt") - public void testModifierFormForNonBuiltInSuspend() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/modifierFormForNonBuiltInSuspend.kt"); - } - - @Test - @TestMetadata("modifierFormForNonBuiltInSuspendWithAnyParameter.kt") - public void testModifierFormForNonBuiltInSuspendWithAnyParameter() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/modifierFormForNonBuiltInSuspendWithAnyParameter.kt"); - } - - @Test - @TestMetadata("noDefaultCoroutineImports.kt") - public void testNoDefaultCoroutineImports() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/noDefaultCoroutineImports.kt"); - } - - @Test - @TestMetadata("nonLocalSuspension.kt") - public void testNonLocalSuspension() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/nonLocalSuspension.kt"); - } - - @Test - @TestMetadata("nonModifierFormForBuiltIn.kt") - public void testNonModifierFormForBuiltIn() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/nonModifierFormForBuiltIn.kt"); - } - - @Test - @TestMetadata("nonModifierFormForBuiltInRenameOnImport.kt") - public void testNonModifierFormForBuiltInRenameOnImport() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/nonModifierFormForBuiltInRenameOnImport.kt"); - } - - @Test - @TestMetadata("operators.kt") - public void testOperators() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/operators.kt"); - } - - @Test - @TestMetadata("returnLabelForBuiltInSuspend.kt") - public void testReturnLabelForBuiltInSuspend() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/returnLabelForBuiltInSuspend.kt"); - } - - @Test - @TestMetadata("suspendApplicability.kt") - public void testSuspendApplicability() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendApplicability.kt"); - } - - @Test - @TestMetadata("suspendConflictsWithNoSuspend.kt") - public void testSuspendConflictsWithNoSuspend() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendConflictsWithNoSuspend.kt"); - } - - @Test - @TestMetadata("suspendCoroutineOrReturn.kt") - public void testSuspendCoroutineOrReturn() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendCoroutineOrReturn.kt"); - } - - @Test - @TestMetadata("suspendCoroutineOrReturn_1_2.kt") - public void testSuspendCoroutineOrReturn_1_2() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendCoroutineOrReturn_1_2.kt"); - } - - @Test - @TestMetadata("suspendCoroutineUnavailableWithNewAPI.kt") - public void testSuspendCoroutineUnavailableWithNewAPI() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendCoroutineUnavailableWithNewAPI.kt"); - } - - @Test - @TestMetadata("suspendCoroutineUnavailableWithOldAPI.kt") - public void testSuspendCoroutineUnavailableWithOldAPI() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendCoroutineUnavailableWithOldAPI.kt"); - } - - @Test - @TestMetadata("suspendCovarianJavaOverride.kt") - public void testSuspendCovarianJavaOverride() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendCovarianJavaOverride.kt"); - } - - @Test - @TestMetadata("suspendDestructuring.kt") - public void testSuspendDestructuring() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendDestructuring.kt"); - } - - @Test - @TestMetadata("suspendExternalFunctions.kt") - public void testSuspendExternalFunctions() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendExternalFunctions.kt"); - } - - @Test - @TestMetadata("suspendFunctionN.kt") - public void testSuspendFunctionN() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionN.kt"); - } - - @Test - @TestMetadata("suspendFunctions.kt") - public void testSuspendFunctions() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctions.kt"); - } - - @Test - @TestMetadata("suspendJavaImplementationFromDifferentClass.kt") - public void testSuspendJavaImplementationFromDifferentClass() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendJavaImplementationFromDifferentClass.kt"); - } - - @Test - @TestMetadata("suspendJavaOverrides.kt") - public void testSuspendJavaOverrides() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendJavaOverrides.kt"); - } - - @Test - @TestMetadata("suspendLambda.kt") - public void testSuspendLambda() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendLambda.kt"); - } - - @Test - @TestMetadata("suspendOverridability.kt") - public void testSuspendOverridability() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendOverridability.kt"); - } - - @Test - @TestMetadata("suspendTest.kt") - public void testSuspendTest() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendTest.kt"); - } - - @Test - @TestMetadata("suspensionPointInMonitor.kt") - public void testSuspensionPointInMonitor() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspensionPointInMonitor.kt"); - } - - @Test - @TestMetadata("suspensionPointInMonitorNewInf.kt") - public void testSuspensionPointInMonitorNewInf() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspensionPointInMonitorNewInf.kt"); - } - - @Test - @TestMetadata("suspesionInDefaultValue.kt") - public void testSuspesionInDefaultValue() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspesionInDefaultValue.kt"); - } - - @Test - @TestMetadata("tryCatchLambda.kt") - public void testTryCatchLambda() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/tryCatchLambda.kt"); - } - - @Test - @TestMetadata("unsupported.kt") - public void testUnsupported() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/unsupported.kt"); - } - - @Test - @TestMetadata("usageOfResultTypeInReturnType.kt") - public void testUsageOfResultTypeInReturnType() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/usageOfResultTypeInReturnType.kt"); - } - - @Test - @TestMetadata("usageOfResultTypeInReturnType_1_4.kt") - public void testUsageOfResultTypeInReturnType_1_4() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/usageOfResultTypeInReturnType_1_4.kt"); - } - - @Test - @TestMetadata("usageOfResultTypeWithNullableOperators.kt") - public void testUsageOfResultTypeWithNullableOperators() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/usageOfResultTypeWithNullableOperators.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/callableReference") - @TestDataPath("$PROJECT_ROOT") - public class CallableReference extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines/callableReference"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("bigArity.kt") - public void testBigArity() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/callableReference/bigArity.kt"); - } - - @Test - @TestMetadata("callableReferenceOnUnresolvedLHS.kt") - public void testCallableReferenceOnUnresolvedLHS() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/callableReference/callableReferenceOnUnresolvedLHS.kt"); - } - - @Test - @TestMetadata("property.kt") - public void testProperty() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/callableReference/property.kt"); - } - - @Test - @TestMetadata("suspendConversionForCallableReferences.kt") - public void testSuspendConversionForCallableReferences() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/callableReference/suspendConversionForCallableReferences.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference") - @TestDataPath("$PROJECT_ROOT") - public class Inference extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInInference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("applyInsideCoroutine.kt") - public void testApplyInsideCoroutine() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/applyInsideCoroutine.kt"); - } - - @Test - @TestMetadata("builderInferenceForMaterializeWithExpectedType.kt") - public void testBuilderInferenceForMaterializeWithExpectedType() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/builderInferenceForMaterializeWithExpectedType.kt"); - } - - @Test - @TestMetadata("callableReferenceAndCoercionToUnit.kt") - public void testCallableReferenceAndCoercionToUnit() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/callableReferenceAndCoercionToUnit.kt"); - } - - @Test - @TestMetadata("callableReferenceToASuspendFunction.kt") - public void testCallableReferenceToASuspendFunction() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/callableReferenceToASuspendFunction.kt"); - } - - @Test - @TestMetadata("chainCallWithExtensionExplicitTypes.kt") - public void testChainCallWithExtensionExplicitTypes() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/chainCallWithExtensionExplicitTypes.kt"); - } - - @Test - @TestMetadata("coroutineInferenceWithCapturedTypeVariable.kt") - public void testCoroutineInferenceWithCapturedTypeVariable() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/coroutineInferenceWithCapturedTypeVariable.kt"); - } - - @Test - @TestMetadata("correctMember.kt") - public void testCorrectMember() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/correctMember.kt"); - } - - @Test - @TestMetadata("doubleColonExpressionToClassWithParameters.kt") - public void testDoubleColonExpressionToClassWithParameters() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/doubleColonExpressionToClassWithParameters.kt"); - } - - @Test - @TestMetadata("elvisOperatorAgainstFlexibleType.kt") - public void testElvisOperatorAgainstFlexibleType() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/elvisOperatorAgainstFlexibleType.kt"); - } - - @Test - @TestMetadata("extensionPriority.kt") - public void testExtensionPriority() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/extensionPriority.kt"); - } - - @Test - @TestMetadata("extensionSuspend.kt") - public void testExtensionSuspend() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/extensionSuspend.kt"); - } - - @Test - @TestMetadata("extensionWithNonValuableConstraints.kt") - public void testExtensionWithNonValuableConstraints() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/extensionWithNonValuableConstraints.kt"); - } - - @Test - @TestMetadata("extensionsWithNonValuableConstraintsGenericBase.kt") - public void testExtensionsWithNonValuableConstraintsGenericBase() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/extensionsWithNonValuableConstraintsGenericBase.kt"); - } - - @Test - @TestMetadata("extensionsWithNonValuableConstraints_1_2.kt") - public void testExtensionsWithNonValuableConstraints_1_2() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/extensionsWithNonValuableConstraints_1_2.kt"); - } - - @Test - @TestMetadata("incorrectCalls.kt") - public void testIncorrectCalls() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/incorrectCalls.kt"); - } - - @Test - @TestMetadata("inferCoroutineTypeInOldVersion.kt") - public void testInferCoroutineTypeInOldVersion() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/inferCoroutineTypeInOldVersion.kt"); - } - - @Test - @TestMetadata("inferenceFromMethodInsideLocalVariable.kt") - public void testInferenceFromMethodInsideLocalVariable() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/inferenceFromMethodInsideLocalVariable.kt"); - } - - @Test - @TestMetadata("kt15516.kt") - public void testKt15516() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt15516.kt"); - } - - @Test - @TestMetadata("kt32097.kt") - public void testKt32097() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt32097.kt"); - } - - @Test - @TestMetadata("kt32203.kt") - public void testKt32203() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt32203.kt"); - } - - @Test - @TestMetadata("kt32271.kt") - public void testKt32271() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt32271.kt"); - } - - @Test - @TestMetadata("kt33542.kt") - public void testKt33542() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt33542.kt"); - } - - @Test - @TestMetadata("kt35306.kt") - public void testKt35306() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt35306.kt"); - } - - @Test - @TestMetadata("kt35684.kt") - public void testKt35684() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt35684.kt"); - } - - @Test - @TestMetadata("kt36202.kt") - public void testKt36202() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt36202.kt"); - } - - @Test - @TestMetadata("kt36220.kt") - public void testKt36220() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt36220.kt"); - } - - @Test - @TestMetadata("kt38420.kt") - public void testKt38420() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt38420.kt"); - } - - @Test - @TestMetadata("kt38667.kt") - public void testKt38667() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt38667.kt"); - } - - @Test - @TestMetadata("kt38766.kt") - public void testKt38766() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt38766.kt"); - } - - @Test - @TestMetadata("kt41164.kt") - public void testKt41164() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt41164.kt"); - } - - @Test - @TestMetadata("kt41308.kt") - public void testKt41308() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt41308.kt"); - } - - @Test - @TestMetadata("kt41396.kt") - public void testKt41396() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/kt41396.kt"); - } - - @Test - @TestMetadata("nestedLambdaInferenceWithListMap.kt") - public void testNestedLambdaInferenceWithListMap() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/nestedLambdaInferenceWithListMap.kt"); - } - - @Test - @TestMetadata("nestedSuspendCallInsideLambda.kt") - public void testNestedSuspendCallInsideLambda() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/nestedSuspendCallInsideLambda.kt"); - } - - @Test - @TestMetadata("plusAssignInCoroutineContext.kt") - public void testPlusAssignInCoroutineContext() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/plusAssignInCoroutineContext.kt"); - } - - @Test - @TestMetadata("plusAssignWithLambda.kt") - public void testPlusAssignWithLambda() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/plusAssignWithLambda.kt"); - } - - @Test - @TestMetadata("plusAssignWithLambda2.kt") - public void testPlusAssignWithLambda2() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/plusAssignWithLambda2.kt"); - } - - @Test - @TestMetadata("qualifiedResolvedExpressionInsideBuilderInference.kt") - public void testQualifiedResolvedExpressionInsideBuilderInference() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/qualifiedResolvedExpressionInsideBuilderInference.kt"); - } - - @Test - @TestMetadata("recursiveGenerators.kt") - public void testRecursiveGenerators() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/recursiveGenerators.kt"); - } - - @Test - @TestMetadata("recursiveGenerators2.kt") - public void testRecursiveGenerators2() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/recursiveGenerators2.kt"); - } - - @Test - @TestMetadata("resolveUsualCallWithBuilderInference.kt") - public void testResolveUsualCallWithBuilderInference() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/resolveUsualCallWithBuilderInference.kt"); - } - - @Test - @TestMetadata("returnTypeInference.kt") - public void testReturnTypeInference() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/returnTypeInference.kt"); - } - - @Test - @TestMetadata("returnTypeInference2.kt") - public void testReturnTypeInference2() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/returnTypeInference2.kt"); - } - - @Test - @TestMetadata("severalCandidatesWithDifferentVisibility.kt") - public void testSeveralCandidatesWithDifferentVisibility() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/severalCandidatesWithDifferentVisibility.kt"); - } - - @Test - @TestMetadata("simpleGenerator.kt") - public void testSimpleGenerator() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/simpleGenerator.kt"); - } - - @Test - @TestMetadata("suspendCallsWithErrors.kt") - public void testSuspendCallsWithErrors() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/suspendCallsWithErrors.kt"); - } - - @Test - @TestMetadata("suspendCallsWrongUpperBound.kt") - public void testSuspendCallsWrongUpperBound() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/suspendCallsWrongUpperBound.kt"); - } - - @Test - @TestMetadata("twoReceiversInScope.kt") - public void testTwoReceiversInScope() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/twoReceiversInScope.kt"); - } - - @Test - @TestMetadata("typeFromReceiver.kt") - public void testTypeFromReceiver() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/typeFromReceiver.kt"); - } - - @Test - @TestMetadata("useInferenceInformationFromExtension.kt") - public void testUseInferenceInformationFromExtension() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/useInferenceInformationFromExtension.kt"); - } - - @Test - @TestMetadata("variableCallInsideBuilderFunction.kt") - public void testVariableCallInsideBuilderFunction() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/variableCallInsideBuilderFunction.kt"); - } - - @Test - @TestMetadata("variableOfAFunctionTypeCall.kt") - public void testVariableOfAFunctionTypeCall() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/variableOfAFunctionTypeCall.kt"); - } - - @Test - @TestMetadata("withParameter.kt") - public void testWithParameter() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/withParameter.kt"); - } - - @Test - @TestMetadata("withUninferredParameter.kt") - public void testWithUninferredParameter() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference/withUninferredParameter.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline") - @TestDataPath("$PROJECT_ROOT") - public class InlineCrossinline extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInInlineCrossinline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("inlineOrdinaryOfCrossinlineOrdinary.kt") - public void testInlineOrdinaryOfCrossinlineOrdinary() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline/inlineOrdinaryOfCrossinlineOrdinary.kt"); - } - - @Test - @TestMetadata("inlineOrdinaryOfCrossinlineSuspend.kt") - public void testInlineOrdinaryOfCrossinlineSuspend() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline/inlineOrdinaryOfCrossinlineSuspend.kt"); - } - - @Test - @TestMetadata("inlineOrdinaryOfNoinlineOrdinary.kt") - public void testInlineOrdinaryOfNoinlineOrdinary() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline/inlineOrdinaryOfNoinlineOrdinary.kt"); - } - - @Test - @TestMetadata("inlineOrdinaryOfNoinlineSuspend.kt") - public void testInlineOrdinaryOfNoinlineSuspend() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline/inlineOrdinaryOfNoinlineSuspend.kt"); - } - - @Test - @TestMetadata("inlineOrdinaryOfOrdinary.kt") - public void testInlineOrdinaryOfOrdinary() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline/inlineOrdinaryOfOrdinary.kt"); - } - - @Test - @TestMetadata("inlineOrdinaryOfSuspend.kt") - public void testInlineOrdinaryOfSuspend() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline/inlineOrdinaryOfSuspend.kt"); - } - - @Test - @TestMetadata("inlineSuspendOfCrossinlineOrdinary.kt") - public void testInlineSuspendOfCrossinlineOrdinary() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline/inlineSuspendOfCrossinlineOrdinary.kt"); - } - - @Test - @TestMetadata("inlineSuspendOfCrossinlineSuspend.kt") - public void testInlineSuspendOfCrossinlineSuspend() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline/inlineSuspendOfCrossinlineSuspend.kt"); - } - - @Test - @TestMetadata("inlineSuspendOfNoinlineOrdinary.kt") - public void testInlineSuspendOfNoinlineOrdinary() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline/inlineSuspendOfNoinlineOrdinary.kt"); - } - - @Test - @TestMetadata("inlineSuspendOfNoinlineSuspend.kt") - public void testInlineSuspendOfNoinlineSuspend() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline/inlineSuspendOfNoinlineSuspend.kt"); - } - - @Test - @TestMetadata("inlineSuspendOfOrdinary.kt") - public void testInlineSuspendOfOrdinary() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline/inlineSuspendOfOrdinary.kt"); - } - - @Test - @TestMetadata("inlineSuspendOfSuspend.kt") - public void testInlineSuspendOfSuspend() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline/inlineSuspendOfSuspend.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/release") - @TestDataPath("$PROJECT_ROOT") - public class Release extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInRelease() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines/release"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("coroutineContext.kt") - public void testCoroutineContext() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/release/coroutineContext.kt"); - } - - @Test - @TestMetadata("languageVersionIsNotEqualToApiVersion.kt") - public void testLanguageVersionIsNotEqualToApiVersion() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/release/languageVersionIsNotEqualToApiVersion.kt"); - } - - @Test - @TestMetadata("suspend.kt") - public void testSuspend() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/release/suspend.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/restrictSuspension") - @TestDataPath("$PROJECT_ROOT") - public class RestrictSuspension extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInRestrictSuspension() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines/restrictSuspension"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("allMembersAllowed.kt") - public void testAllMembersAllowed() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/restrictSuspension/allMembersAllowed.kt"); - } - - @Test - @TestMetadata("extensions.kt") - public void testExtensions() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/restrictSuspension/extensions.kt"); - } - - @Test - @TestMetadata("memberExtension.kt") - public void testMemberExtension() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/restrictSuspension/memberExtension.kt"); - } - - @Test - @TestMetadata("notRelatedFun.kt") - public void testNotRelatedFun() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/restrictSuspension/notRelatedFun.kt"); - } - - @Test - @TestMetadata("outerYield_1_2.kt") - public void testOuterYield_1_2() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/restrictSuspension/outerYield_1_2.kt"); - } - - @Test - @TestMetadata("outerYield_1_3.kt") - public void testOuterYield_1_3() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/restrictSuspension/outerYield_1_3.kt"); - } - - @Test - @TestMetadata("sameInstance.kt") - public void testSameInstance() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/restrictSuspension/sameInstance.kt"); - } - - @Test - @TestMetadata("simpleForbidden.kt") - public void testSimpleForbidden() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/restrictSuspension/simpleForbidden.kt"); - } - - @Test - @TestMetadata("wrongEnclosingFunction.kt") - public void testWrongEnclosingFunction() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/restrictSuspension/wrongEnclosingFunction.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType") - @TestDataPath("$PROJECT_ROOT") - public class SuspendFunctionType extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInSuspendFunctionType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("functionVsSuspendFunction.kt") - public void testFunctionVsSuspendFunction() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/functionVsSuspendFunction.kt"); - } - - @Test - @TestMetadata("inference1.kt") - public void testInference1() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/inference1.kt"); - } - - @Test - @TestMetadata("inference2.kt") - public void testInference2() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/inference2.kt"); - } - - @Test - @TestMetadata("inference3.kt") - public void testInference3() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/inference3.kt"); - } - - @Test - @TestMetadata("inference4.kt") - public void testInference4() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/inference4.kt"); - } - - @Test - @TestMetadata("inline.kt") - public void testInline() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/inline.kt"); - } - - @Test - @TestMetadata("invoke.kt") - public void testInvoke() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/invoke.kt"); - } - - @Test - @TestMetadata("lambdaInOverriddenValInitializer.kt") - public void testLambdaInOverriddenValInitializer() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/lambdaInOverriddenValInitializer.kt"); - } - - @Test - @TestMetadata("lambdaInValInitializer.kt") - public void testLambdaInValInitializer() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/lambdaInValInitializer.kt"); - } - - @Test - @TestMetadata("modifierApplicability.kt") - public void testModifierApplicability() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/modifierApplicability.kt"); - } - - @Test - @TestMetadata("noInvokeForSuspendFunction.kt") - public void testNoInvokeForSuspendFunction() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/noInvokeForSuspendFunction.kt"); - } - - @Test - @TestMetadata("noValueParameters.kt") - public void testNoValueParameters() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/noValueParameters.kt"); - } - - @Test - @TestMetadata("nullableSuspendFunction.kt") - public void testNullableSuspendFunction() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/nullableSuspendFunction.kt"); - } - - @Test - @TestMetadata("suspendFunctionN.kt") - public void testSuspendFunctionN() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType/suspendFunctionN.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/coroutines/tailCalls") - @TestDataPath("$PROJECT_ROOT") - public class TailCalls extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInTailCalls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines/tailCalls"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("forbidden.kt") - public void testForbidden() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/tailCalls/forbidden.kt"); - } - - @Test - @TestMetadata("localFunctions.kt") - public void testLocalFunctions() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/tailCalls/localFunctions.kt"); - } - - @Test - @TestMetadata("nothingTypedSuspendFunction_1_2.kt") - public void testNothingTypedSuspendFunction_1_2() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/tailCalls/nothingTypedSuspendFunction_1_2.kt"); - } - - @Test - @TestMetadata("nothingTypedSuspendFunction_1_3.kt") - public void testNothingTypedSuspendFunction_1_3() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/tailCalls/nothingTypedSuspendFunction_1_3.kt"); - } - - @Test - @TestMetadata("recursive.kt") - public void testRecursive() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/tailCalls/recursive.kt"); - } - - @Test - @TestMetadata("tryCatch.kt") - public void testTryCatch() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/tailCalls/tryCatch.kt"); - } - - @Test - @TestMetadata("valid.kt") - public void testValid() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/tailCalls/valid.kt"); - } - } + @Test + @TestMetadata("SuperTypeWithSameInner.kt") + public void testSuperTypeWithSameInner() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/SuperTypeWithSameInner.kt"); } - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/deprecated") - @TestDataPath("$PROJECT_ROOT") - public class Deprecated extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInDeprecated() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/deprecated"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } + @Test + @TestMetadata("SupertypeInnerAndTypeParameterWithSameNames.kt") + public void testSupertypeInnerAndTypeParameterWithSameNames() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/SupertypeInnerAndTypeParameterWithSameNames.kt"); + } + } - @Test - @TestMetadata("deprecationOnReadBytes.kt") - public void testDeprecationOnReadBytes() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/deprecated/deprecationOnReadBytes.kt"); - } - - @Test - @TestMetadata("noDeprecationOnReadBytes.kt") - public void testNoDeprecationOnReadBytes() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/deprecated/noDeprecationOnReadBytes.kt"); - } + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/javac/inners") + @TestDataPath("$PROJECT_ROOT") + public class Inners extends AbstractDiagnosticUsingJavacTest { + @Test + public void testAllFilesPresentInInners() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/inners"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature") - @TestDataPath("$PROJECT_ROOT") - public class DuplicateJvmSignature extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInDuplicateJvmSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("delegatedProperty.kt") - public void testDelegatedProperty() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/delegatedProperty.kt"); - } - - @Test - @TestMetadata("jvmNames.kt") - public void testJvmNames() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/jvmNames.kt"); - } - - @Test - @TestMetadata("jvmNamesDuplicate.kt") - public void testJvmNamesDuplicate() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/jvmNamesDuplicate.kt"); - } - - @Test - @TestMetadata("jvmOverloads.kt") - public void testJvmOverloads() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/jvmOverloads.kt"); - } - - @Test - @TestMetadata("jvmStaticInClassObject.kt") - public void testJvmStaticInClassObject() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/jvmStaticInClassObject.kt"); - } - - @Test - @TestMetadata("jvmStaticInObject.kt") - public void testJvmStaticInObject() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/jvmStaticInObject.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics") - @TestDataPath("$PROJECT_ROOT") - public class Statics extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInStatics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("jjk.kt") - public void testJjk() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/jjk.kt"); - } - - @Test - @TestMetadata("jk.kt") - public void testJk() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/jk.kt"); - } - - @Test - @TestMetadata("jkjk.kt") - public void testJkjk() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/jkjk.kt"); - } - - @Test - @TestMetadata("kotlinMembersVsJavaNonVisibleStatics.kt") - public void testKotlinMembersVsJavaNonVisibleStatics() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics/kotlinMembersVsJavaNonVisibleStatics.kt"); - } - } + @Test + @TestMetadata("ComplexCase.kt") + public void testComplexCase() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inners/ComplexCase.kt"); } - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/experimental") - @TestDataPath("$PROJECT_ROOT") - public class Experimental extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInExperimental() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/experimental"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("annotation.kt") - public void testAnnotation() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/annotation.kt"); - } - - @Test - @TestMetadata("bodyUsages.kt") - public void testBodyUsages() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/bodyUsages.kt"); - } - - @Test - @TestMetadata("bodyUsagesAndInline.kt") - public void testBodyUsagesAndInline() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/bodyUsagesAndInline.kt"); - } - - @Test - @TestMetadata("classMembers.kt") - public void testClassMembers() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/classMembers.kt"); - } - - @Test - @TestMetadata("classMembersOverlyExperimental.kt") - public void testClassMembersOverlyExperimental() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/classMembersOverlyExperimental.kt"); - } - - @Test - @TestMetadata("constVal.kt") - public void testConstVal() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/constVal.kt"); - } - - @Test - @TestMetadata("deeplyNestedClass.kt") - public void testDeeplyNestedClass() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/deeplyNestedClass.kt"); - } - - @Test - @TestMetadata("errors.kt") - public void testErrors() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/errors.kt"); - } - - @Test - @TestMetadata("experimentalIsNotEnabled.kt") - public void testExperimentalIsNotEnabled() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/experimentalIsNotEnabled.kt"); - } - - @Test - @TestMetadata("experimentalOnWholeModule.kt") - public void testExperimentalOnWholeModule() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/experimentalOnWholeModule.kt"); - } - - @Test - @TestMetadata("experimentalUnsignedLiterals.kt") - public void testExperimentalUnsignedLiterals() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/experimentalUnsignedLiterals.kt"); - } - - @Test - @TestMetadata("fullFqNameUsage.kt") - public void testFullFqNameUsage() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/fullFqNameUsage.kt"); - } - - @Test - @TestMetadata("importStatement.kt") - public void testImportStatement() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/importStatement.kt"); - } - - @Test - @TestMetadata("incorrectTargetsForExperimentalAnnotation.kt") - public void testIncorrectTargetsForExperimentalAnnotation() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/incorrectTargetsForExperimentalAnnotation.kt"); - } - - @Test - @TestMetadata("incorrectUseExperimental.kt") - public void testIncorrectUseExperimental() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/incorrectUseExperimental.kt"); - } - - @Test - @TestMetadata("override.kt") - public void testOverride() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/override.kt"); - } - - @Test - @TestMetadata("overrideDifferentExperimentalities.kt") - public void testOverrideDifferentExperimentalities() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/overrideDifferentExperimentalities.kt"); - } - - @Test - @TestMetadata("topLevel.kt") - public void testTopLevel() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/topLevel.kt"); - } - - @Test - @TestMetadata("typealias.kt") - public void testTypealias() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/typealias.kt"); - } - - @Test - @TestMetadata("usageNotAsAnnotation.kt") - public void testUsageNotAsAnnotation() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/usageNotAsAnnotation.kt"); - } - - @Test - @TestMetadata("useExperimentalOnFile.kt") - public void testUseExperimentalOnFile() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/useExperimentalOnFile.kt"); - } - - @Test - @TestMetadata("useExperimentalOnFileWithVeryExperimentalMarker.kt") - public void testUseExperimentalOnFileWithVeryExperimentalMarker() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/useExperimentalOnFileWithVeryExperimentalMarker.kt"); - } - - @Test - @TestMetadata("useExperimentalOnWholeModule.kt") - public void testUseExperimentalOnWholeModule() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/useExperimentalOnWholeModule.kt"); - } - - @Test - @TestMetadata("useExperimentalTargets.kt") - public void testUseExperimentalTargets() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/useExperimentalTargets.kt"); - } - - @Test - @TestMetadata("useExperimentalWithSeveralAnnotations.kt") - public void testUseExperimentalWithSeveralAnnotations() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/useExperimentalWithSeveralAnnotations.kt"); - } - - @Test - @TestMetadata("wasExperimental.kt") - public void testWasExperimental() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/experimental/wasExperimental.kt"); - } + @Test + @TestMetadata("ComplexCase2.kt") + public void testComplexCase2() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inners/ComplexCase2.kt"); } - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/factoryPattern") - @TestDataPath("$PROJECT_ROOT") - public class FactoryPattern extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInFactoryPattern() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/factoryPattern"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("independentResolutionInLambda.kt") - public void testIndependentResolutionInLambda() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/factoryPattern/independentResolutionInLambda.kt"); - } - - @Test - @TestMetadata("multipleOverloads_1.kt") - public void testMultipleOverloads_1() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/factoryPattern/multipleOverloads_1.kt"); - } - - @Test - @TestMetadata("multipleOverloads_2.kt") - public void testMultipleOverloads_2() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/factoryPattern/multipleOverloads_2.kt"); - } - - @Test - @TestMetadata("multipleOverloads_3.kt") - public void testMultipleOverloads_3() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/factoryPattern/multipleOverloads_3.kt"); - } - - @Test - @TestMetadata("overloadByLambdaReturnType_disabled.kt") - public void testOverloadByLambdaReturnType_disabled() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/factoryPattern/overloadByLambdaReturnType_disabled.kt"); - } - - @Test - @TestMetadata("overloadByLambdaReturnType_enabled.kt") - public void testOverloadByLambdaReturnType_enabled() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/factoryPattern/overloadByLambdaReturnType_enabled.kt"); - } - - @Test - @TestMetadata("overloadByLambdaReturnType_enabled_no_annotation.kt") - public void testOverloadByLambdaReturnType_enabled_no_annotation() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/factoryPattern/overloadByLambdaReturnType_enabled_no_annotation.kt"); - } - - @Test - @TestMetadata("referenceWithTheSameNameAsContainingProperty.kt") - public void testReferenceWithTheSameNameAsContainingProperty() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/factoryPattern/referenceWithTheSameNameAsContainingProperty.kt"); - } - - @Test - @TestMetadata("resolutionInOldInference.kt") - public void testResolutionInOldInference() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/factoryPattern/resolutionInOldInference.kt"); - } - - @Test - @TestMetadata("returnFromInlineLambda.kt") - public void testReturnFromInlineLambda() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/factoryPattern/returnFromInlineLambda.kt"); - } + @Test + @TestMetadata("CurrentPackageAndInner.kt") + public void testCurrentPackageAndInner() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inners/CurrentPackageAndInner.kt"); } - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/forInArrayLoop") - @TestDataPath("$PROJECT_ROOT") - public class ForInArrayLoop extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInForInArrayLoop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/forInArrayLoop"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("capturedRangeVariableAssignmentBefore13.kt") - public void testCapturedRangeVariableAssignmentBefore13() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/forInArrayLoop/capturedRangeVariableAssignmentBefore13.kt"); - } - - @Test - @TestMetadata("forInFieldUpdatedInLoopBodyBefore13.kt") - public void testForInFieldUpdatedInLoopBodyBefore13() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/forInArrayLoop/forInFieldUpdatedInLoopBodyBefore13.kt"); - } - - @Test - @TestMetadata("rangeLocalDelegatedPropertyAssignmentBefore13.kt") - public void testRangeLocalDelegatedPropertyAssignmentBefore13() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/forInArrayLoop/rangeLocalDelegatedPropertyAssignmentBefore13.kt"); - } - - @Test - @TestMetadata("rangeVariableAssignment13.kt") - public void testRangeVariableAssignment13() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/forInArrayLoop/rangeVariableAssignment13.kt"); - } - - @Test - @TestMetadata("rangeVariableAssignmentBefore13.kt") - public void testRangeVariableAssignmentBefore13() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/forInArrayLoop/rangeVariableAssignmentBefore13.kt"); - } + @Test + @TestMetadata("ImportThriceNestedClass.kt") + public void testImportThriceNestedClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inners/ImportThriceNestedClass.kt"); } - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/functionLiterals") - @TestDataPath("$PROJECT_ROOT") - public class FunctionLiterals extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInFunctionLiterals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/functionLiterals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("pseudocodeMemoryOverhead.kt") - public void testPseudocodeMemoryOverhead() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/functionLiterals/pseudocodeMemoryOverhead.kt"); - } + @Test + @TestMetadata("InnerInInner.kt") + public void testInnerInInner() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inners/InnerInInner.kt"); } - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/inference") - @TestDataPath("$PROJECT_ROOT") - public class Inference extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInInference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("arrayConstructor.kt") - public void testArrayConstructor() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/arrayConstructor.kt"); - } - - @Test - @TestMetadata("callableReferenceOnParameter.kt") - public void testCallableReferenceOnParameter() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/callableReferenceOnParameter.kt"); - } - - @Test - @TestMetadata("integerLiterals.kt") - public void testIntegerLiterals() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/integerLiterals.kt"); - } - - @Test - @TestMetadata("intersectDfiTypesBeforeCapturing.kt") - public void testIntersectDfiTypesBeforeCapturing() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/intersectDfiTypesBeforeCapturing.kt"); - } - - @Test - @TestMetadata("intersectionInputType.kt") - public void testIntersectionInputType() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/intersectionInputType.kt"); - } - - @Test - @TestMetadata("kt11266.kt") - public void testKt11266() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/kt11266.kt"); - } - - @Test - @TestMetadata("kt12008.kt") - public void testKt12008() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/kt12008.kt"); - } - - @Test - @TestMetadata("kt1558.kt") - public void testKt1558() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/kt1558.kt"); - } - - @Test - @TestMetadata("kt27772.kt") - public void testKt27772() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/kt27772.kt"); - } - - @Test - @TestMetadata("kt30292.kt") - public void testKt30292() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/kt30292.kt"); - } - - @Test - @TestMetadata("kt32345.kt") - public void testKt32345() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/kt32345.kt"); - } - - @Test - @TestMetadata("kt3458.kt") - public void testKt3458() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/kt3458.kt"); - } - - @Test - @TestMetadata("kt35847.kt") - public void testKt35847() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/kt35847.kt"); - } - - @Test - @TestMetadata("kt36249.kt") - public void testKt36249() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/kt36249.kt"); - } - - @Test - @TestMetadata("kt36951.kt") - public void testKt36951() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/kt36951.kt"); - } - - @Test - @TestMetadata("kt37627.kt") - public void testKt37627() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/kt37627.kt"); - } - - @Test - @TestMetadata("kt38143.kt") - public void testKt38143() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/kt38143.kt"); - } - - @Test - @TestMetadata("kt38737.kt") - public void testKt38737() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/kt38737.kt"); - } - - @Test - @TestMetadata("kt38801.kt") - public void testKt38801() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/kt38801.kt"); - } - - @Test - @TestMetadata("kt42620.kt") - public void testKt42620() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/kt42620.kt"); - } - - @Test - @TestMetadata("kt4975.kt") - public void testKt4975() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/kt4975.kt"); - } - - @Test - @TestMetadata("recursiveFlexibleAssertions.kt") - public void testRecursiveFlexibleAssertions() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/recursiveFlexibleAssertions.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve") - @TestDataPath("$PROJECT_ROOT") - public class AnnotationsForResolve extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInAnnotationsForResolve() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("checkLowPriorityIsResolvedSuccessfully.kt") - public void testCheckLowPriorityIsResolvedSuccessfully() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/checkLowPriorityIsResolvedSuccessfully.kt"); - } - - @Test - @TestMetadata("exactAnnotation.kt") - public void testExactAnnotation() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/exactAnnotation.kt"); - } - - @Test - @TestMetadata("exactAnnotationWithUpperBoundConstraint.kt") - public void testExactAnnotationWithUpperBoundConstraint() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/exactAnnotationWithUpperBoundConstraint.kt"); - } - - @Test - @TestMetadata("explicitTypeArgumentAsValidInputType.kt") - public void testExplicitTypeArgumentAsValidInputType() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/explicitTypeArgumentAsValidInputType.kt"); - } - - @Test - @TestMetadata("internalAnnotationsOnTypes.kt") - public void testInternalAnnotationsOnTypes() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/internalAnnotationsOnTypes.kt"); - } - - @Test - @TestMetadata("kt26698.kt") - public void testKt26698() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/kt26698.kt"); - } - - @Test - @TestMetadata("kt29307.kt") - public void testKt29307() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/kt29307.kt"); - } - - @Test - @TestMetadata("kt35210.kt") - public void testKt35210() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/kt35210.kt"); - } - - @Test - @TestMetadata("noInferAndLowPriority.kt") - public void testNoInferAndLowPriority() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/noInferAndLowPriority.kt"); - } - - @Test - @TestMetadata("noInferAnnotation.kt") - public void testNoInferAnnotation() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/noInferAnnotation.kt"); - } - - @Test - @TestMetadata("notNullAnnotation.kt") - public void testNotNullAnnotation() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/notNullAnnotation.kt"); - } - - @Test - @TestMetadata("onlyInputTypeAndJava.kt") - public void testOnlyInputTypeAndJava() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypeAndJava.kt"); - } - - @Test - @TestMetadata("onlyInputTypeRecursiveBoundAndProjections.kt") - public void testOnlyInputTypeRecursiveBoundAndProjections() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypeRecursiveBoundAndProjections.kt"); - } - - @Test - @TestMetadata("onlyInputTypes.kt") - public void testOnlyInputTypes() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypes.kt"); - } - - @Test - @TestMetadata("onlyInputTypesAndLowPriority.kt") - public void testOnlyInputTypesAndLowPriority() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesAndLowPriority.kt"); - } - - @Test - @TestMetadata("onlyInputTypesAndTopLevelCapturedTypes.kt") - public void testOnlyInputTypesAndTopLevelCapturedTypes() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesAndTopLevelCapturedTypes.kt"); - } - - @Test - @TestMetadata("onlyInputTypesAnnotationWithPlatformTypes.kt") - public void testOnlyInputTypesAnnotationWithPlatformTypes() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesAnnotationWithPlatformTypes.kt"); - } - - @Test - @TestMetadata("onlyInputTypesCaptured.kt") - public void testOnlyInputTypesCaptured() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesCaptured.kt"); - } - - @Test - @TestMetadata("onlyInputTypesCommonConstraintSystem.kt") - public void testOnlyInputTypesCommonConstraintSystem() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesCommonConstraintSystem.kt"); - } - - @Test - @TestMetadata("onlyInputTypesUpperBound.kt") - public void testOnlyInputTypesUpperBound() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesUpperBound.kt"); - } - - @Test - @TestMetadata("onlyInputTypesWarning.kt") - public void testOnlyInputTypesWarning() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesWarning.kt"); - } - - @Test - @TestMetadata("onlyInputTypesWithVarargs.kt") - public void testOnlyInputTypesWithVarargs() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesWithVarargs.kt"); - } - - @Test - @TestMetadata("propagationOfNoInferAnnotation.kt") - public void testPropagationOfNoInferAnnotation() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/propagationOfNoInferAnnotation.kt"); - } - - @Test - @TestMetadata("resolveWithOnlyInputTypesAnnotation.kt") - public void testResolveWithOnlyInputTypesAnnotation() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/resolveWithOnlyInputTypesAnnotation.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/inference/completion") - @TestDataPath("$PROJECT_ROOT") - public class Completion extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInCompletion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference/completion"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis") - @TestDataPath("$PROJECT_ROOT") - public class PostponedArgumentsAnalysis extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInPostponedArgumentsAnalysis() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("callableReferences.kt") - public void testCallableReferences() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/callableReferences.kt"); - } - - @Test - @TestMetadata("complexInterdependentInputOutputTypes.kt") - public void testComplexInterdependentInputOutputTypes() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/complexInterdependentInputOutputTypes.kt"); - } - - @Test - @TestMetadata("deepLambdas.kt") - public void testDeepLambdas() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/deepLambdas.kt"); - } - - @Test - @TestMetadata("fixIndependentVariables.kt") - public void testFixIndependentVariables() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/fixIndependentVariables.kt"); - } - - @Test - @TestMetadata("fixInputTypeToMoreSpecificType.kt") - public void testFixInputTypeToMoreSpecificType() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/fixInputTypeToMoreSpecificType.kt"); - } - - @Test - @TestMetadata("fixReceiverToMoreSpecificType.kt") - public void testFixReceiverToMoreSpecificType() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/fixReceiverToMoreSpecificType.kt"); - } - - @Test - @TestMetadata("kt38799.kt") - public void testKt38799() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/kt38799.kt"); - } - - @Test - @TestMetadata("manyArguments.kt") - public void testManyArguments() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/manyArguments.kt"); - } - - @Test - @TestMetadata("moreSpecificOutputType.kt") - public void testMoreSpecificOutputType() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/moreSpecificOutputType.kt"); - } - - @Test - @TestMetadata("rerunStagesAfterFixationInFullMode.kt") - public void testRerunStagesAfterFixationInFullMode() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/rerunStagesAfterFixationInFullMode.kt"); - } - - @Test - @TestMetadata("rerunStagesAfterFixationInPartialMode.kt") - public void testRerunStagesAfterFixationInPartialMode() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/rerunStagesAfterFixationInPartialMode.kt"); - } - - @Test - @TestMetadata("suspendFunctions.kt") - public void testSuspendFunctions() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/suspendFunctions.kt"); - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/performance") - @TestDataPath("$PROJECT_ROOT") - public class Performance extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInPerformance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/performance"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("reuseBuiltFunctionalTypesForIdLambdas.kt") - public void testReuseBuiltFunctionalTypesForIdLambdas() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/performance/reuseBuiltFunctionalTypesForIdLambdas.kt"); - } - - @Test - @TestMetadata("reuseBuiltFunctionalTypesForLambdas.kt") - public void testReuseBuiltFunctionalTypesForLambdas() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/performance/reuseBuiltFunctionalTypesForLambdas.kt"); - } - - @Test - @TestMetadata("reuseBuiltFunctionalTypesForPairOfLambdas.kt") - public void testReuseBuiltFunctionalTypesForPairOfLambdas() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/performance/reuseBuiltFunctionalTypesForPairOfLambdas.kt"); - } - - @Test - @TestMetadata("reuseBuiltFunctionalTypesForPairsOfDeepLambdas.kt") - public void testReuseBuiltFunctionalTypesForPairsOfDeepLambdas() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/performance/reuseBuiltFunctionalTypesForPairsOfDeepLambdas.kt"); - } - - @Test - @TestMetadata("reuseBuiltFunctionalTypesForPairsOfDeepMixedLambdas.kt") - public void testReuseBuiltFunctionalTypesForPairsOfDeepMixedLambdas() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/performance/reuseBuiltFunctionalTypesForPairsOfDeepMixedLambdas.kt"); - } - - @Test - @TestMetadata("reuseBuiltFunctionalTypesForPairsOfIdLambdas.kt") - public void testReuseBuiltFunctionalTypesForPairsOfIdLambdas() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/performance/reuseBuiltFunctionalTypesForPairsOfIdLambdas.kt"); - } - } - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/inference/delegates") - @TestDataPath("$PROJECT_ROOT") - public class Delegates extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInDelegates() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference/delegates"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("kt31219.kt") - public void testKt31219() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/delegates/kt31219.kt"); - } - - @Test - @TestMetadata("kt31679.kt") - public void testKt31679() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/delegates/kt31679.kt"); - } - - @Test - @TestMetadata("kt32249.kt") - public void testKt32249() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/delegates/kt32249.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/inference/nothingType") - @TestDataPath("$PROJECT_ROOT") - public class NothingType extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInNothingType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference/nothingType"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("dontInferToNullableNothingInDelegates.kt") - public void testDontInferToNullableNothingInDelegates() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/nothingType/dontInferToNullableNothingInDelegates.kt"); - } - - @Test - @TestMetadata("dontSpreadWarningToNotReturningNothingSubResolvedAtoms.kt") - public void testDontSpreadWarningToNotReturningNothingSubResolvedAtoms() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/nothingType/dontSpreadWarningToNotReturningNothingSubResolvedAtoms.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/inference/performance") - @TestDataPath("$PROJECT_ROOT") - public class Performance extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInPerformance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference/performance"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("kt41644.kt") - public void testKt41644() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/performance/kt41644.kt"); - } - - @Test - @TestMetadata("kt41741.kt") - public void testKt41741() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/performance/kt41741.kt"); - } - - @Test - @TestMetadata("kt42195.kt") - public void testKt42195() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inference/performance/kt42195.kt"); - } - } + @Test + @TestMetadata("Nested.kt") + public void testNested() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inners/Nested.kt"); } - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/inline") - @TestDataPath("$PROJECT_ROOT") - public class Inline extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inline"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } + @Test + @TestMetadata("ThriceNestedClass.kt") + public void testThriceNestedClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inners/ThriceNestedClass.kt"); + } + } - @Test - @TestMetadata("inlineOnlySuppressesNothingToInline.kt") - public void testInlineOnlySuppressesNothingToInline() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inline/inlineOnlySuppressesNothingToInline.kt"); - } - - @Test - @TestMetadata("synchronizedOnInline.kt") - public void testSynchronizedOnInline() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/inline/synchronizedOnInline.kt"); - } + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/javac/qualifiedExpression") + @TestDataPath("$PROJECT_ROOT") + public class QualifiedExpression extends AbstractDiagnosticUsingJavacTest { + @Test + public void testAllFilesPresentInQualifiedExpression() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/qualifiedExpression"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/java") - @TestDataPath("$PROJECT_ROOT") - public class Java extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/java"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("concurrentHashMapContains.kt") - public void testConcurrentHashMapContains() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/java/concurrentHashMapContains.kt"); - } - - @Test - @TestMetadata("concurrentHashMapContainsError.kt") - public void testConcurrentHashMapContainsError() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/java/concurrentHashMapContainsError.kt"); - } - - @Test - @TestMetadata("functionN.kt") - public void testFunctionN() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/java/functionN.kt"); - } - - @Test - @TestMetadata("inheritedFunctionN.kt") - public void testInheritedFunctionN() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/java/inheritedFunctionN.kt"); - } - - @Test - @TestMetadata("patternCompileCallableReference.kt") - public void testPatternCompileCallableReference() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/java/patternCompileCallableReference.kt"); - } + @Test + @TestMetadata("GenericClassVsPackage.kt") + public void testGenericClassVsPackage() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/qualifiedExpression/GenericClassVsPackage.kt"); } - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/kt7585") - @TestDataPath("$PROJECT_ROOT") - public class Kt7585 extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInKt7585() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/kt7585"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("delegate.kt") - public void testDelegate() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/kt7585/delegate.kt"); - } + @Test + @TestMetadata("PackageVsClass.kt") + public void testPackageVsClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/qualifiedExpression/PackageVsClass.kt"); } - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/lateinit") - @TestDataPath("$PROJECT_ROOT") - public class Lateinit extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInLateinit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/lateinit"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("isInitialized.kt") - public void testIsInitialized() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/lateinit/isInitialized.kt"); - } + @Test + @TestMetadata("PackageVsClass2.kt") + public void testPackageVsClass2() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/qualifiedExpression/PackageVsClass2.kt"); } - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/multiplatform") - @TestDataPath("$PROJECT_ROOT") - public class Multiplatform extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInMultiplatform() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/multiplatform"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("jvmOverloads.kt") - public void testJvmOverloads() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/multiplatform/jvmOverloads.kt"); - } + @Test + @TestMetadata("PackageVsRootClass.kt") + public void testPackageVsRootClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/qualifiedExpression/PackageVsRootClass.kt"); } - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/native") - @TestDataPath("$PROJECT_ROOT") - public class Native extends AbstractDiagnosticUsingJavacTest { - @Test - @TestMetadata("abstract.kt") - public void testAbstract() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/native/abstract.kt"); - } + @Test + @TestMetadata("visibleClassVsQualifiedClass.kt") + public void testVisibleClassVsQualifiedClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/qualifiedExpression/visibleClassVsQualifiedClass.kt"); + } + } - @Test - public void testAllFilesPresentInNative() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/native"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("body.kt") - public void testBody() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/native/body.kt"); - } - - @Test - @TestMetadata("constructor.kt") - public void testConstructor() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/native/constructor.kt"); - } - - @Test - @TestMetadata("inline.kt") - public void testInline() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/native/inline.kt"); - } - - @Test - @TestMetadata("noBody.kt") - public void testNoBody() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/native/noBody.kt"); - } - - @Test - @TestMetadata("nonFunction.kt") - public void testNonFunction() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/native/nonFunction.kt"); - } - - @Test - @TestMetadata("override.kt") - public void testOverride() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/native/override.kt"); - } - - @Test - @TestMetadata("reified.kt") - public void testReified() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/native/reified.kt"); - } - - @Test - @TestMetadata("trait.kt") - public void testTrait() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/native/trait.kt"); - } + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/javac/typeParameters") + @TestDataPath("$PROJECT_ROOT") + public class TypeParameters extends AbstractDiagnosticUsingJavacTest { + @Test + public void testAllFilesPresentInTypeParameters() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/typeParameters"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection") - @TestDataPath("$PROJECT_ROOT") - public class PurelyImplementedCollection extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInPurelyImplementedCollection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("arrayList.kt") - public void testArrayList() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/arrayList.kt"); - } - - @Test - @TestMetadata("arrayListNullable.kt") - public void testArrayListNullable() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/arrayListNullable.kt"); - } - - @Test - @TestMetadata("customClassMutableCollection.kt") - public void testCustomClassMutableCollection() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/customClassMutableCollection.kt"); - } - - @Test - @TestMetadata("customClassMutableList.kt") - public void testCustomClassMutableList() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/customClassMutableList.kt"); - } - - @Test - @TestMetadata("invalidFqName.kt") - public void testInvalidFqName() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/invalidFqName.kt"); - } - - @Test - @TestMetadata("maps.kt") - public void testMaps() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/maps.kt"); - } - - @Test - @TestMetadata("mapsWithNullableKey.kt") - public void testMapsWithNullableKey() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/mapsWithNullableKey.kt"); - } - - @Test - @TestMetadata("mapsWithNullableValues.kt") - public void testMapsWithNullableValues() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/mapsWithNullableValues.kt"); - } - - @Test - @TestMetadata("sets.kt") - public void testSets() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/sets.kt"); - } - - @Test - @TestMetadata("wrongTypeParametersCount.kt") - public void testWrongTypeParametersCount() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection/wrongTypeParametersCount.kt"); - } + @Test + @TestMetadata("Clash.kt") + public void testClash() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/typeParameters/Clash.kt"); } - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/reflection") - @TestDataPath("$PROJECT_ROOT") - public class Reflection extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInReflection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/reflection"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("noReflectionInClassPath.kt") - public void testNoReflectionInClassPath() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/reflection/noReflectionInClassPath.kt"); - } + @Test + @TestMetadata("ComplexCase.kt") + public void testComplexCase() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/typeParameters/ComplexCase.kt"); } - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/regression") - @TestDataPath("$PROJECT_ROOT") - public class Regression extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInRegression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/regression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("ea63992.kt") - public void testEa63992() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/regression/ea63992.kt"); - } - - @Test - @TestMetadata("ea65206.kt") - public void testEa65206() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/regression/ea65206.kt"); - } - - @Test - @TestMetadata("ea66827_dataClassWrongToString.kt") - public void testEa66827_dataClassWrongToString() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/regression/ea66827_dataClassWrongToString.kt"); - } - - @Test - @TestMetadata("ea70485_functionTypeInheritor.kt") - public void testEa70485_functionTypeInheritor() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/regression/ea70485_functionTypeInheritor.kt"); - } - - @Test - @TestMetadata("ea70880_illegalJvmName.kt") - public void testEa70880_illegalJvmName() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/regression/ea70880_illegalJvmName.kt"); - } - - @Test - @TestMetadata("kt10001.kt") - public void testKt10001() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/regression/kt10001.kt"); - } - - @Test - @TestMetadata("kt2082.kt") - public void testKt2082() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/regression/kt2082.kt"); - } - - @Test - @TestMetadata("kt26806.kt") - public void testKt26806() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/regression/kt26806.kt"); - } - - @Test - @TestMetadata("kt34391.kt") - public void testKt34391() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/regression/kt34391.kt"); - } - - @Test - @TestMetadata("kt37554.kt") - public void testKt37554() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/regression/kt37554.kt"); - } - - @Test - @TestMetadata("kt37706.kt") - public void testKt37706() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/regression/kt37706.kt"); - } - - @Test - @TestMetadata("kt37727.kt") - public void testKt37727() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/regression/kt37727.kt"); - } - - @Test - @TestMetadata("kt37735.kt") - public void testKt37735() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/regression/kt37735.kt"); - } - - @Test - @TestMetadata("kt9820_javaFunctionTypeInheritor.kt") - public void testKt9820_javaFunctionTypeInheritor() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/regression/kt9820_javaFunctionTypeInheritor.kt"); - } - - @Test - @TestMetadata("kt-37497.kt") - public void testKt_37497() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/regression/kt-37497.kt"); - } + @Test + @TestMetadata("InheritedInnerAndTypeParameterWithSameNames.kt") + public void testInheritedInnerAndTypeParameterWithSameNames() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/typeParameters/InheritedInnerAndTypeParameterWithSameNames.kt"); } - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/reified") - @TestDataPath("$PROJECT_ROOT") - public class Reified extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInReified() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/reified"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("arrayConstruction.kt") - public void testArrayConstruction() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/reified/arrayConstruction.kt"); - } - - @Test - @TestMetadata("arrayOfNullsReified.kt") - public void testArrayOfNullsReified() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/reified/arrayOfNullsReified.kt"); - } - - @Test - @TestMetadata("kt11881.kt") - public void testKt11881() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/reified/kt11881.kt"); - } - - @Test - @TestMetadata("nonCallableReiefied.kt") - public void testNonCallableReiefied() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/reified/nonCallableReiefied.kt"); - } - - @Test - @TestMetadata("reifiedNothingSubstitution.kt") - public void testReifiedNothingSubstitution() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/reified/reifiedNothingSubstitution.kt"); - } + @Test + @TestMetadata("InnerWithTypeParameter.kt") + public void testInnerWithTypeParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/typeParameters/InnerWithTypeParameter.kt"); } - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/resolve") - @TestDataPath("$PROJECT_ROOT") - public class Resolve extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInResolve() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/resolve"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("hidesMembers.kt") - public void testHidesMembers() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/resolve/hidesMembers.kt"); - } - - @Test - @TestMetadata("hidesMembers2.kt") - public void testHidesMembers2() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/resolve/hidesMembers2.kt"); - } - - @Test - @TestMetadata("javaPackageMembers.kt") - public void testJavaPackageMembers() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/resolve/javaPackageMembers.kt"); - } - - @Test - @TestMetadata("javaStaticMembers.kt") - public void testJavaStaticMembers() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/resolve/javaStaticMembers.kt"); - } - - @Test - @TestMetadata("kt10103.kt") - public void testKt10103() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/resolve/kt10103.kt"); - } - - @Test - @TestMetadata("kt10732a.kt") - public void testKt10732a() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/resolve/kt10732a.kt"); - } - - @Test - @TestMetadata("kt4711.kt") - public void testKt4711() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/resolve/kt4711.kt"); - } - - @Test - @TestMetadata("samAgainstFunctionalType.kt") - public void testSamAgainstFunctionalType() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/resolve/samAgainstFunctionalType.kt"); - } - - @Test - @TestMetadata("samConstructorVsFun.kt") - public void testSamConstructorVsFun() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/resolve/samConstructorVsFun.kt"); - } - - @Test - @TestMetadata("samOverloadsWithGenerics.kt") - public void testSamOverloadsWithGenerics() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/resolve/samOverloadsWithGenerics.kt"); - } - - @Test - @TestMetadata("samOverloadsWithGenericsWithoutRefinedSams.kt") - public void testSamOverloadsWithGenericsWithoutRefinedSams() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/resolve/samOverloadsWithGenericsWithoutRefinedSams.kt"); - } - - @Test - @TestMetadata("samOverloadsWithKtFunction.kt") - public void testSamOverloadsWithKtFunction() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/resolve/samOverloadsWithKtFunction.kt"); - } - - @Test - @TestMetadata("samOverloadsWithKtFunctionWithoutRefinedSams.kt") - public void testSamOverloadsWithKtFunctionWithoutRefinedSams() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/resolve/samOverloadsWithKtFunctionWithoutRefinedSams.kt"); - } + @Test + @TestMetadata("NestedWithInner.kt") + public void testNestedWithInner() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/typeParameters/NestedWithInner.kt"); } - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/smartcasts") - @TestDataPath("$PROJECT_ROOT") - public class Smartcasts extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInSmartcasts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/smartcasts"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("forEachSafe.kt") - public void testForEachSafe() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/smartcasts/forEachSafe.kt"); - } - - @Test - @TestMetadata("forEachUnsafe.kt") - public void testForEachUnsafe() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/smartcasts/forEachUnsafe.kt"); - } - - @Test - @TestMetadata("kt10463.kt") - public void testKt10463() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/smartcasts/kt10463.kt"); - } - - @Test - @TestMetadata("lazyDeclaresAndModifies.kt") - public void testLazyDeclaresAndModifies() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/smartcasts/lazyDeclaresAndModifies.kt"); - } - - @Test - @TestMetadata("letAlwaysChangesToNotNull.kt") - public void testLetAlwaysChangesToNotNull() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/smartcasts/letAlwaysChangesToNotNull.kt"); - } - - @Test - @TestMetadata("letChangesToNotNull.kt") - public void testLetChangesToNotNull() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/smartcasts/letChangesToNotNull.kt"); - } - - @Test - @TestMetadata("letChangesToNull.kt") - public void testLetChangesToNull() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/smartcasts/letChangesToNull.kt"); - } - - @Test - @TestMetadata("letChangesToNullComplex.kt") - public void testLetChangesToNullComplex() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/smartcasts/letChangesToNullComplex.kt"); - } - - @Test - @TestMetadata("letMergeNotNull.kt") - public void testLetMergeNotNull() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/smartcasts/letMergeNotNull.kt"); - } - - @Test - @TestMetadata("letStable.kt") - public void testLetStable() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/smartcasts/letStable.kt"); - } - - @Test - @TestMetadata("letUsesOwnReceiver.kt") - public void testLetUsesOwnReceiver() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/smartcasts/letUsesOwnReceiver.kt"); - } - - @Test - @TestMetadata("listOfGeneric.kt") - public void testListOfGeneric() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/smartcasts/listOfGeneric.kt"); - } - - @Test - @TestMetadata("withChangesToNull.kt") - public void testWithChangesToNull() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/smartcasts/withChangesToNull.kt"); - } + @Test + @TestMetadata("SeveralInnersWithTypeParameters.kt") + public void testSeveralInnersWithTypeParameters() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/typeParameters/SeveralInnersWithTypeParameters.kt"); } - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/sourceCompatibility") - @TestDataPath("$PROJECT_ROOT") - public class SourceCompatibility extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInSourceCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/sourceCompatibility"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("noDefaultImportOfKotlinComparisons.kt") - public void testNoDefaultImportOfKotlinComparisons() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/sourceCompatibility/noDefaultImportOfKotlinComparisons.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/targetedBuiltIns") - @TestDataPath("$PROJECT_ROOT") - public class TargetedBuiltIns extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInTargetedBuiltIns() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/targetedBuiltIns"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("blackListed.kt") - public void testBlackListed() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/targetedBuiltIns/blackListed.kt"); - } - - @Test - @TestMetadata("unsupportedFeature.kt") - public void testUnsupportedFeature() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/targetedBuiltIns/unsupportedFeature.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/trailingComma") - @TestDataPath("$PROJECT_ROOT") - public class TrailingComma extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInTrailingComma() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/trailingComma"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("multiVariableDeclarationWithDisabledFeature.kt") - public void testMultiVariableDeclarationWithDisabledFeature() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/trailingComma/multiVariableDeclarationWithDisabledFeature.kt"); - } - - @Test - @TestMetadata("multiVariableDeclarationWithEnabledFeature.kt") - public void testMultiVariableDeclarationWithEnabledFeature() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/trailingComma/multiVariableDeclarationWithEnabledFeature.kt"); - } - - @Test - @TestMetadata("noDisambiguation.kt") - public void testNoDisambiguation() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/trailingComma/noDisambiguation.kt"); - } - - @Test - @TestMetadata("typeArgumentsWithDisabledFeature.kt") - public void testTypeArgumentsWithDisabledFeature() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/trailingComma/typeArgumentsWithDisabledFeature.kt"); - } - - @Test - @TestMetadata("typeArgumentsWithEnabledFeature.kt") - public void testTypeArgumentsWithEnabledFeature() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/trailingComma/typeArgumentsWithEnabledFeature.kt"); - } - - @Test - @TestMetadata("typeParametersWithDisabledFeature.kt") - public void testTypeParametersWithDisabledFeature() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/trailingComma/typeParametersWithDisabledFeature.kt"); - } - - @Test - @TestMetadata("typeParametersWithEnabledFeature.kt") - public void testTypeParametersWithEnabledFeature() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/trailingComma/typeParametersWithEnabledFeature.kt"); - } - - @Test - @TestMetadata("valueArgumentsWithDisabledFeature.kt") - public void testValueArgumentsWithDisabledFeature() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/trailingComma/valueArgumentsWithDisabledFeature.kt"); - } - - @Test - @TestMetadata("valueArgumentsWithEnabledFeature.kt") - public void testValueArgumentsWithEnabledFeature() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/trailingComma/valueArgumentsWithEnabledFeature.kt"); - } - - @Test - @TestMetadata("valueParametersWithDisabledFeature.kt") - public void testValueParametersWithDisabledFeature() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/trailingComma/valueParametersWithDisabledFeature.kt"); - } - - @Test - @TestMetadata("valueParametersWithEnabledFeature.kt") - public void testValueParametersWithEnabledFeature() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/trailingComma/valueParametersWithEnabledFeature.kt"); - } - - @Test - @TestMetadata("whenEntryWithDisabledFeature.kt") - public void testWhenEntryWithDisabledFeature() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/trailingComma/whenEntryWithDisabledFeature.kt"); - } - - @Test - @TestMetadata("whenEntryWithEnabledFeature.kt") - public void testWhenEntryWithEnabledFeature() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/trailingComma/whenEntryWithEnabledFeature.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/tryCatch") - @TestDataPath("$PROJECT_ROOT") - public class TryCatch extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInTryCatch() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/tryCatch"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("assignTry.kt") - public void testAssignTry() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/tryCatch/assignTry.kt"); - } - - @Test - @TestMetadata("boundedSmartcasts.kt") - public void testBoundedSmartcasts() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/tryCatch/boundedSmartcasts.kt"); - } - - @Test - @TestMetadata("catchRedeclaration.kt") - public void testCatchRedeclaration() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/tryCatch/catchRedeclaration.kt"); - } - - @Test - @TestMetadata("correctSmartcasts.kt") - public void testCorrectSmartcasts() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/tryCatch/correctSmartcasts.kt"); - } - - @Test - @TestMetadata("correctSmartcasts_after.kt") - public void testCorrectSmartcasts_after() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/tryCatch/correctSmartcasts_after.kt"); - } - - @Test - @TestMetadata("falseNegativeSmartcasts.kt") - public void testFalseNegativeSmartcasts() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/tryCatch/falseNegativeSmartcasts.kt"); - } - - @Test - @TestMetadata("falseNegativeSmartcasts_after.kt") - public void testFalseNegativeSmartcasts_after() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/tryCatch/falseNegativeSmartcasts_after.kt"); - } - - @Test - @TestMetadata("falsePositiveSmartcasts.kt") - public void testFalsePositiveSmartcasts() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/tryCatch/falsePositiveSmartcasts.kt"); - } - - @Test - @TestMetadata("falsePositiveSmartcasts_after.kt") - public void testFalsePositiveSmartcasts_after() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/tryCatch/falsePositiveSmartcasts_after.kt"); - } - - @Test - @TestMetadata("tryExpression.kt") - public void testTryExpression() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/tryCatch/tryExpression.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/typealias") - @TestDataPath("$PROJECT_ROOT") - public class Typealias extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInTypealias() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/typealias"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("exceptionTypeAliases.kt") - public void testExceptionTypeAliases() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/typealias/exceptionTypeAliases.kt"); - } - - @Test - @TestMetadata("exceptionTypeAliasesInvisibleWithApiVersion1_0.kt") - public void testExceptionTypeAliasesInvisibleWithApiVersion1_0() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/typealias/exceptionTypeAliasesInvisibleWithApiVersion1_0.kt"); - } - - @Test - @TestMetadata("exceptionTypeAliasesInvisibleWithoutFeature.kt") - public void testExceptionTypeAliasesInvisibleWithoutFeature() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/typealias/exceptionTypeAliasesInvisibleWithoutFeature.kt"); - } - - @Test - @TestMetadata("hashMapTypeAlias.kt") - public void testHashMapTypeAlias() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/typealias/hashMapTypeAlias.kt"); - } - - @Test - @TestMetadata("typeAliasSamAdapterConstructors.kt") - public void testTypeAliasSamAdapterConstructors() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/typealias/typeAliasSamAdapterConstructors.kt"); - } - - @Test - @TestMetadata("typeAliasSamAdapterConstructors2.kt") - public void testTypeAliasSamAdapterConstructors2() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/typealias/typeAliasSamAdapterConstructors2.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/varargs") - @TestDataPath("$PROJECT_ROOT") - public class Varargs extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInVarargs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/varargs"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("kt3213.kt") - public void testKt3213() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/varargs/kt3213.kt"); - } - - @Test - @TestMetadata("kt4172j.kt") - public void testKt4172j() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/varargs/kt4172j.kt"); - } - - @Test - @TestMetadata("kt5534.kt") - public void testKt5534() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/varargs/kt5534.kt"); - } - } - - @Nested - @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/when") - @TestDataPath("$PROJECT_ROOT") - public class When extends AbstractDiagnosticUsingJavacTest { - @Test - public void testAllFilesPresentInWhen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/when"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @Test - @TestMetadata("kt10192.kt") - public void testKt10192() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/when/kt10192.kt"); - } - - @Test - @TestMetadata("kt10807.kt") - public void testKt10807() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/when/kt10807.kt"); - } - - @Test - @TestMetadata("noTypeArgumentsInConstructor.kt") - public void testNoTypeArgumentsInConstructor() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/when/noTypeArgumentsInConstructor.kt"); - } + @Test + @TestMetadata("TypeParametersInInnerAndOuterWithSameNames.kt") + public void testTypeParametersInInnerAndOuterWithSameNames() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/typeParameters/TypeParametersInInnerAndOuterWithSameNames.kt"); } } } diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java index a61fc273b49..158fa299781 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java @@ -16496,6 +16496,472 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti } } + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/javac") + @TestDataPath("$PROJECT_ROOT") + public class Javac extends AbstractFirDiagnosticTest { + @Test + public void testAllFilesPresentInJavac() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + } + + @Test + @TestMetadata("Annotations.kt") + public void testAnnotations() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/Annotations.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/javac/fieldsResolution") + @TestDataPath("$PROJECT_ROOT") + public class FieldsResolution extends AbstractFirDiagnosticTest { + @Test + public void testAllFilesPresentInFieldsResolution() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/fieldsResolution"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + } + + @Test + @TestMetadata("AsteriskStaticImportsAmbiguity.kt") + public void testAsteriskStaticImportsAmbiguity() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/fieldsResolution/AsteriskStaticImportsAmbiguity.kt"); + } + + @Test + @TestMetadata("BinaryInitializers.kt") + public void testBinaryInitializers() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/fieldsResolution/BinaryInitializers.kt"); + } + + @Test + @TestMetadata("ConstantByFqName.kt") + public void testConstantByFqName() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/fieldsResolution/ConstantByFqName.kt"); + } + + @Test + @TestMetadata("ConstantValues.kt") + public void testConstantValues() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/fieldsResolution/ConstantValues.kt"); + } + + @Test + @TestMetadata("ConstantValuesFromKtFile.kt") + public void testConstantValuesFromKtFile() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/fieldsResolution/ConstantValuesFromKtFile.kt"); + } + + @Test + @TestMetadata("FieldFromOuterClass.kt") + public void testFieldFromOuterClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/fieldsResolution/FieldFromOuterClass.kt"); + } + + @Test + @TestMetadata("InheritedField.kt") + public void testInheritedField() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/fieldsResolution/InheritedField.kt"); + } + + @Test + @TestMetadata("MultipleOuters.kt") + public void testMultipleOuters() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/fieldsResolution/MultipleOuters.kt"); + } + + @Test + @TestMetadata("ResolutionPriority.kt") + public void testResolutionPriority() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/fieldsResolution/ResolutionPriority.kt"); + } + + @Test + @TestMetadata("SameFieldInSupertypes.kt") + public void testSameFieldInSupertypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/fieldsResolution/SameFieldInSupertypes.kt"); + } + + @Test + @TestMetadata("StaticImport.kt") + public void testStaticImport() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/fieldsResolution/StaticImport.kt"); + } + + @Test + @TestMetadata("StaticImportsAmbiguity.kt") + public void testStaticImportsAmbiguity() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/fieldsResolution/StaticImportsAmbiguity.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/javac/imports") + @TestDataPath("$PROJECT_ROOT") + public class Imports extends AbstractFirDiagnosticTest { + @Test + public void testAllFilesPresentInImports() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/imports"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + } + + @Test + @TestMetadata("AllUnderImportsAmbiguity.kt") + public void testAllUnderImportsAmbiguity() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/AllUnderImportsAmbiguity.kt"); + } + + @Test + @TestMetadata("AllUnderImportsLessPriority.kt") + public void testAllUnderImportsLessPriority() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/AllUnderImportsLessPriority.kt"); + } + + @Test + @TestMetadata("ClassImportsConflicting.kt") + public void testClassImportsConflicting() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/ClassImportsConflicting.kt"); + } + + @Test + @TestMetadata("CurrentPackageAndAllUnderImport.kt") + public void testCurrentPackageAndAllUnderImport() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/CurrentPackageAndAllUnderImport.kt"); + } + + @Test + @TestMetadata("CurrentPackageAndExplicitImport.kt") + public void testCurrentPackageAndExplicitImport() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/CurrentPackageAndExplicitImport.kt"); + } + + @Test + @TestMetadata("CurrentPackageAndExplicitNestedImport.kt") + public void testCurrentPackageAndExplicitNestedImport() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/CurrentPackageAndExplicitNestedImport.kt"); + } + + @Test + @TestMetadata("CurrentPackageAndNestedAsteriskImport.kt") + public void testCurrentPackageAndNestedAsteriskImport() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/CurrentPackageAndNestedAsteriskImport.kt"); + } + + @Test + @TestMetadata("ImportGenericVsPackage.kt") + public void testImportGenericVsPackage() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/ImportGenericVsPackage.kt"); + } + + @Test + @TestMetadata("ImportProtectedClass.kt") + public void testImportProtectedClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/ImportProtectedClass.kt"); + } + + @Test + @TestMetadata("ImportTwoTimes.kt") + public void testImportTwoTimes() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/ImportTwoTimes.kt"); + } + + @Test + @TestMetadata("ImportTwoTimesStar.kt") + public void testImportTwoTimesStar() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/ImportTwoTimesStar.kt"); + } + + @Test + @TestMetadata("NestedAndTopLevelClassClash.kt") + public void testNestedAndTopLevelClassClash() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/NestedAndTopLevelClassClash.kt"); + } + + @Test + @TestMetadata("NestedClassClash.kt") + public void testNestedClassClash() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/NestedClassClash.kt"); + } + + @Test + @TestMetadata("PackageExplicitAndStartImport.kt") + public void testPackageExplicitAndStartImport() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/PackageExplicitAndStartImport.kt"); + } + + @Test + @TestMetadata("PackagePrivateAndPublicNested.kt") + public void testPackagePrivateAndPublicNested() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/PackagePrivateAndPublicNested.kt"); + } + + @Test + @TestMetadata("TopLevelClassVsPackage.kt") + public void testTopLevelClassVsPackage() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/TopLevelClassVsPackage.kt"); + } + + @Test + @TestMetadata("TopLevelClassVsPackage2.kt") + public void testTopLevelClassVsPackage2() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/imports/TopLevelClassVsPackage2.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/javac/inheritance") + @TestDataPath("$PROJECT_ROOT") + public class Inheritance extends AbstractFirDiagnosticTest { + @Test + public void testAllFilesPresentInInheritance() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/inheritance"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + } + + @Test + @TestMetadata("IheritanceOfInner.kt") + public void testIheritanceOfInner() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/IheritanceOfInner.kt"); + } + + @Test + @TestMetadata("InheritanceAmbiguity.kt") + public void testInheritanceAmbiguity() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/InheritanceAmbiguity.kt"); + } + + @Test + @TestMetadata("InheritanceAmbiguity2.kt") + public void testInheritanceAmbiguity2() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/InheritanceAmbiguity2.kt"); + } + + @Test + @TestMetadata("InheritanceAmbiguity3.kt") + public void testInheritanceAmbiguity3() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/InheritanceAmbiguity3.kt"); + } + + @Test + @TestMetadata("InheritanceAmbiguity4.kt") + public void testInheritanceAmbiguity4() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/InheritanceAmbiguity4.kt"); + } + + @Test + @TestMetadata("InheritanceWithKotlin.kt") + public void testInheritanceWithKotlin() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/InheritanceWithKotlin.kt"); + } + + @Test + @TestMetadata("InheritanceWithKotlinClasses.kt") + public void testInheritanceWithKotlinClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/InheritanceWithKotlinClasses.kt"); + } + + @Test + @TestMetadata("InheritedInner.kt") + public void testInheritedInner() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/InheritedInner.kt"); + } + + @Test + @TestMetadata("InheritedInner2.kt") + public void testInheritedInner2() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/InheritedInner2.kt"); + } + + @Test + @TestMetadata("InheritedInnerAndSupertypeWithSameName.kt") + public void testInheritedInnerAndSupertypeWithSameName() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/InheritedInnerAndSupertypeWithSameName.kt"); + } + + @Test + @TestMetadata("InheritedInnerUsageInInner.kt") + public void testInheritedInnerUsageInInner() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/InheritedInnerUsageInInner.kt"); + } + + @Test + @TestMetadata("InheritedKotlinInner.kt") + public void testInheritedKotlinInner() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/InheritedKotlinInner.kt"); + } + + @Test + @TestMetadata("InnerAndInheritedInner.kt") + public void testInnerAndInheritedInner() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/InnerAndInheritedInner.kt"); + } + + @Test + @TestMetadata("ManyInheritedClasses.kt") + public void testManyInheritedClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/ManyInheritedClasses.kt"); + } + + @Test + @TestMetadata("SameInnersInSupertypeAndSupertypesSupertype.kt") + public void testSameInnersInSupertypeAndSupertypesSupertype() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/SameInnersInSupertypeAndSupertypesSupertype.kt"); + } + + @Test + @TestMetadata("SuperTypeWithSameInner.kt") + public void testSuperTypeWithSameInner() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/SuperTypeWithSameInner.kt"); + } + + @Test + @TestMetadata("SupertypeInnerAndTypeParameterWithSameNames.kt") + public void testSupertypeInnerAndTypeParameterWithSameNames() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inheritance/SupertypeInnerAndTypeParameterWithSameNames.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/javac/inners") + @TestDataPath("$PROJECT_ROOT") + public class Inners extends AbstractFirDiagnosticTest { + @Test + public void testAllFilesPresentInInners() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/inners"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + } + + @Test + @TestMetadata("ComplexCase.kt") + public void testComplexCase() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inners/ComplexCase.kt"); + } + + @Test + @TestMetadata("ComplexCase2.kt") + public void testComplexCase2() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inners/ComplexCase2.kt"); + } + + @Test + @TestMetadata("CurrentPackageAndInner.kt") + public void testCurrentPackageAndInner() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inners/CurrentPackageAndInner.kt"); + } + + @Test + @TestMetadata("ImportThriceNestedClass.kt") + public void testImportThriceNestedClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inners/ImportThriceNestedClass.kt"); + } + + @Test + @TestMetadata("InnerInInner.kt") + public void testInnerInInner() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inners/InnerInInner.kt"); + } + + @Test + @TestMetadata("Nested.kt") + public void testNested() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inners/Nested.kt"); + } + + @Test + @TestMetadata("ThriceNestedClass.kt") + public void testThriceNestedClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/inners/ThriceNestedClass.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/javac/qualifiedExpression") + @TestDataPath("$PROJECT_ROOT") + public class QualifiedExpression extends AbstractFirDiagnosticTest { + @Test + public void testAllFilesPresentInQualifiedExpression() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/qualifiedExpression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + } + + @Test + @TestMetadata("GenericClassVsPackage.kt") + public void testGenericClassVsPackage() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/qualifiedExpression/GenericClassVsPackage.kt"); + } + + @Test + @TestMetadata("PackageVsClass.kt") + public void testPackageVsClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/qualifiedExpression/PackageVsClass.kt"); + } + + @Test + @TestMetadata("PackageVsClass2.kt") + public void testPackageVsClass2() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/qualifiedExpression/PackageVsClass2.kt"); + } + + @Test + @TestMetadata("PackageVsRootClass.kt") + public void testPackageVsRootClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/qualifiedExpression/PackageVsRootClass.kt"); + } + + @Test + @TestMetadata("visibleClassVsQualifiedClass.kt") + public void testVisibleClassVsQualifiedClass() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/qualifiedExpression/visibleClassVsQualifiedClass.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/javac/typeParameters") + @TestDataPath("$PROJECT_ROOT") + public class TypeParameters extends AbstractFirDiagnosticTest { + @Test + public void testAllFilesPresentInTypeParameters() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/typeParameters"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + } + + @Test + @TestMetadata("Clash.kt") + public void testClash() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/typeParameters/Clash.kt"); + } + + @Test + @TestMetadata("ComplexCase.kt") + public void testComplexCase() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/typeParameters/ComplexCase.kt"); + } + + @Test + @TestMetadata("InheritedInnerAndTypeParameterWithSameNames.kt") + public void testInheritedInnerAndTypeParameterWithSameNames() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/typeParameters/InheritedInnerAndTypeParameterWithSameNames.kt"); + } + + @Test + @TestMetadata("InnerWithTypeParameter.kt") + public void testInnerWithTypeParameter() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/typeParameters/InnerWithTypeParameter.kt"); + } + + @Test + @TestMetadata("NestedWithInner.kt") + public void testNestedWithInner() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/typeParameters/NestedWithInner.kt"); + } + + @Test + @TestMetadata("SeveralInnersWithTypeParameters.kt") + public void testSeveralInnersWithTypeParameters() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/typeParameters/SeveralInnersWithTypeParameters.kt"); + } + + @Test + @TestMetadata("TypeParametersInInnerAndOuterWithSameNames.kt") + public void testTypeParametersInInnerAndOuterWithSameNames() throws Exception { + runTest("compiler/testData/diagnostics/tests/javac/typeParameters/TypeParametersInInnerAndOuterWithSameNames.kt"); + } + } + } + @Nested @TestMetadata("compiler/testData/diagnostics/tests/labels") @TestDataPath("$PROJECT_ROOT") diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/generators/GenerateNewCompilerTests.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/generators/GenerateNewCompilerTests.kt index 81af0952713..dacb7084f04 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/generators/GenerateNewCompilerTests.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/generators/GenerateNewCompilerTests.kt @@ -19,8 +19,7 @@ fun main(args: Array) { } testClass { - model("diagnostics/tests", pattern = "^(.*)\\.kts?$", excludedPattern = excludedFirTestdataPattern) - model("diagnostics/testsWithStdLib", excludedPattern = excludedFirTestdataPattern) + model("diagnostics/tests/javac", pattern = "^(.*)\\.kts?$", excludedPattern = excludedFirTestdataPattern) } testClass(suiteTestClassName = "FirOldFrontendDiagnosticsTestGenerated") { diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/javac/AbstractJavacDiagnosticsTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/javac/AbstractJavacDiagnosticsTest.kt deleted file mode 100644 index b152a28d115..00000000000 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/javac/AbstractJavacDiagnosticsTest.kt +++ /dev/null @@ -1,59 +0,0 @@ -/* - * Copyright 2010-2017 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.checkers.javac - -import org.jetbrains.kotlin.checkers.AbstractDiagnosticsTest -import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment -import org.jetbrains.kotlin.config.JVMConfigurationKeys -import org.jetbrains.kotlin.test.util.KtTestUtil -import java.io.File - -abstract class AbstractJavacDiagnosticsTest : AbstractDiagnosticsTest() { - - private var useJavac = true - - override fun setupEnvironment(environment: KotlinCoreEnvironment, testDataFile: File, files: List) { - if (useJavac) { - val groupedByModule = files.groupBy(TestFile::module) - val allKtFiles = groupedByModule.values.flatMap { getKtFiles(it, true) } - environment.registerJavac(kotlinFiles = allKtFiles) - environment.configuration.put(JVMConfigurationKeys.USE_JAVAC, true) - } - } - - fun doTestWithoutJavacWrapper(path: String) { - useJavac = false - super.doTest(path) - } - - override fun getExpectedDiagnosticsFile(testDataFile: File): File { - val suffix = if (useJavac) ".WithJavac.txt" else ".WithoutJavac.txt" - val specialFile = File(testDataFile.parent, testDataFile.name + suffix) - return specialFile.takeIf { it.exists() } ?: super.getExpectedDiagnosticsFile(testDataFile) - } - - override fun createTestFiles(file: File, expectedText: String, modules: MutableMap): List { - val specialFile = getExpectedDiagnosticsFile(file) - if (file.path == specialFile.path) { - return super.createTestFiles(file, expectedText, modules) - } - - return super.createTestFiles(specialFile, - KtTestUtil.doLoadFile(specialFile), modules) - } -} - diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/javac/AbstractJavacFieldResolutionTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/javac/AbstractJavacFieldResolutionTest.kt deleted file mode 100644 index a087059ce0e..00000000000 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/javac/AbstractJavacFieldResolutionTest.kt +++ /dev/null @@ -1,42 +0,0 @@ -/* - * Copyright 2010-2017 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.checkers.javac - -import org.jetbrains.kotlin.checkers.AbstractDiagnosticsTest -import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment -import org.jetbrains.kotlin.config.JVMConfigurationKeys -import java.io.File - -abstract class AbstractJavacFieldResolutionTest : AbstractDiagnosticsTest() { - - private var useJavac = true - - override fun setupEnvironment(environment: KotlinCoreEnvironment, testDataFile: File, files: List) { - if (useJavac) { - val groupedByModule = files.groupBy(TestFile::module) - val allKtFiles = groupedByModule.values.flatMap { getKtFiles(it, true) } - environment.registerJavac(kotlinFiles = allKtFiles) - environment.configuration.put(JVMConfigurationKeys.USE_JAVAC, true) - } - } - - fun doTestWithoutJavacWrapper(path: String) { - useJavac = false - super.doTest(path) - } - -} \ No newline at end of file diff --git a/compiler/tests-gen/org/jetbrains/kotlin/checkers/javac/JavacDiagnosticsTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/checkers/javac/JavacDiagnosticsTestGenerated.java deleted file mode 100644 index 965a9f2f652..00000000000 --- a/compiler/tests-gen/org/jetbrains/kotlin/checkers/javac/JavacDiagnosticsTestGenerated.java +++ /dev/null @@ -1,736 +0,0 @@ -/* - * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. - * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. - */ - -package org.jetbrains.kotlin.checkers.javac; - -import com.intellij.testFramework.TestDataPath; -import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; -import org.jetbrains.kotlin.test.KotlinTestUtils; -import org.jetbrains.kotlin.test.TestMetadata; -import org.junit.runner.RunWith; - -import java.io.File; -import java.util.regex.Pattern; - -/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */ -@SuppressWarnings("all") -@RunWith(JUnit3RunnerWithInners.class) -public class JavacDiagnosticsTestGenerated extends AbstractJavacDiagnosticsTest { - @TestMetadata("compiler/testData/javac/diagnostics/tests") - @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Tests extends AbstractJavacDiagnosticsTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - - public void testAllFilesPresentInTests() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/javac/diagnostics/tests"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @TestMetadata("Annotations.kt") - public void testAnnotations() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/Annotations.kt"); - } - - @TestMetadata("compiler/testData/javac/diagnostics/tests/imports") - @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Imports extends AbstractJavacDiagnosticsTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - - public void testAllFilesPresentInImports() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/javac/diagnostics/tests/imports"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @TestMetadata("AllUnderImportsAmbiguity.kt") - public void testAllUnderImportsAmbiguity() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/imports/AllUnderImportsAmbiguity.kt"); - } - - @TestMetadata("AllUnderImportsLessPriority.kt") - public void testAllUnderImportsLessPriority() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/imports/AllUnderImportsLessPriority.kt"); - } - - @TestMetadata("ClassImportsConflicting.kt") - public void testClassImportsConflicting() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/imports/ClassImportsConflicting.kt"); - } - - @TestMetadata("CurrentPackageAndAllUnderImport.kt") - public void testCurrentPackageAndAllUnderImport() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndAllUnderImport.kt"); - } - - @TestMetadata("CurrentPackageAndExplicitImport.kt") - public void testCurrentPackageAndExplicitImport() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndExplicitImport.kt"); - } - - @TestMetadata("CurrentPackageAndExplicitNestedImport.kt") - public void testCurrentPackageAndExplicitNestedImport() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndExplicitNestedImport.kt"); - } - - @TestMetadata("CurrentPackageAndNestedAsteriskImport.kt") - public void testCurrentPackageAndNestedAsteriskImport() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndNestedAsteriskImport.kt"); - } - - @TestMetadata("ImportGenericVsPackage.kt") - public void testImportGenericVsPackage() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/imports/ImportGenericVsPackage.kt"); - } - - @TestMetadata("ImportProtectedClass.kt") - public void testImportProtectedClass() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/imports/ImportProtectedClass.kt"); - } - - @TestMetadata("ImportTwoTimes.kt") - public void testImportTwoTimes() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/imports/ImportTwoTimes.kt"); - } - - @TestMetadata("ImportTwoTimesStar.kt") - public void testImportTwoTimesStar() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/imports/ImportTwoTimesStar.kt"); - } - - @TestMetadata("NestedAndTopLevelClassClash.kt") - public void testNestedAndTopLevelClassClash() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/imports/NestedAndTopLevelClassClash.kt"); - } - - @TestMetadata("NestedClassClash.kt") - public void testNestedClassClash() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/imports/NestedClassClash.kt"); - } - - @TestMetadata("PackageExplicitAndStartImport.kt") - public void testPackageExplicitAndStartImport() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/imports/PackageExplicitAndStartImport.kt"); - } - - @TestMetadata("PackagePrivateAndPublicNested.kt") - public void testPackagePrivateAndPublicNested() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/imports/PackagePrivateAndPublicNested.kt"); - } - - @TestMetadata("TopLevelClassVsPackage.kt") - public void testTopLevelClassVsPackage() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/imports/TopLevelClassVsPackage.kt"); - } - - @TestMetadata("TopLevelClassVsPackage2.kt") - public void testTopLevelClassVsPackage2() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/imports/TopLevelClassVsPackage2.kt"); - } - } - - @TestMetadata("compiler/testData/javac/diagnostics/tests/inheritance") - @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Inheritance extends AbstractJavacDiagnosticsTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - - public void testAllFilesPresentInInheritance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/javac/diagnostics/tests/inheritance"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @TestMetadata("IheritanceOfInner.kt") - public void testIheritanceOfInner() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inheritance/IheritanceOfInner.kt"); - } - - @TestMetadata("InheritanceAmbiguity.kt") - public void testInheritanceAmbiguity() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity.kt"); - } - - @TestMetadata("InheritanceAmbiguity2.kt") - public void testInheritanceAmbiguity2() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity2.kt"); - } - - @TestMetadata("InheritanceAmbiguity3.kt") - public void testInheritanceAmbiguity3() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity3.kt"); - } - - @TestMetadata("InheritanceAmbiguity4.kt") - public void testInheritanceAmbiguity4() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity4.kt"); - } - - @TestMetadata("InheritanceWithKotlin.kt") - public void testInheritanceWithKotlin() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inheritance/InheritanceWithKotlin.kt"); - } - - @TestMetadata("InheritanceWithKotlinClasses.kt") - public void testInheritanceWithKotlinClasses() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inheritance/InheritanceWithKotlinClasses.kt"); - } - - @TestMetadata("InheritedInner.kt") - public void testInheritedInner() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inheritance/InheritedInner.kt"); - } - - @TestMetadata("InheritedInner2.kt") - public void testInheritedInner2() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inheritance/InheritedInner2.kt"); - } - - @TestMetadata("InheritedInnerAndSupertypeWithSameName.kt") - public void testInheritedInnerAndSupertypeWithSameName() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inheritance/InheritedInnerAndSupertypeWithSameName.kt"); - } - - @TestMetadata("InheritedInnerUsageInInner.kt") - public void testInheritedInnerUsageInInner() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inheritance/InheritedInnerUsageInInner.kt"); - } - - @TestMetadata("InheritedKotlinInner.kt") - public void testInheritedKotlinInner() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inheritance/InheritedKotlinInner.kt"); - } - - @TestMetadata("InnerAndInheritedInner.kt") - public void testInnerAndInheritedInner() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inheritance/InnerAndInheritedInner.kt"); - } - - @TestMetadata("ManyInheritedClasses.kt") - public void testManyInheritedClasses() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inheritance/ManyInheritedClasses.kt"); - } - - @TestMetadata("NoAmbiguity.kt") - public void testNoAmbiguity() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inheritance/NoAmbiguity.kt"); - } - - @TestMetadata("NoAmbiguity2.kt") - public void testNoAmbiguity2() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inheritance/NoAmbiguity2.kt"); - } - - @TestMetadata("SameInnersInSupertypeAndSupertypesSupertype.kt") - public void testSameInnersInSupertypeAndSupertypesSupertype() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inheritance/SameInnersInSupertypeAndSupertypesSupertype.kt"); - } - - @TestMetadata("SuperTypeWithSameInner.kt") - public void testSuperTypeWithSameInner() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inheritance/SuperTypeWithSameInner.kt"); - } - - @TestMetadata("SupertypeInnerAndTypeParameterWithSameNames.kt") - public void testSupertypeInnerAndTypeParameterWithSameNames() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inheritance/SupertypeInnerAndTypeParameterWithSameNames.kt"); - } - } - - @TestMetadata("compiler/testData/javac/diagnostics/tests/inners") - @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Inners extends AbstractJavacDiagnosticsTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - - public void testAllFilesPresentInInners() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/javac/diagnostics/tests/inners"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @TestMetadata("ComplexCase.kt") - public void testComplexCase() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inners/ComplexCase.kt"); - } - - @TestMetadata("ComplexCase2.kt") - public void testComplexCase2() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inners/ComplexCase2.kt"); - } - - @TestMetadata("CurrentPackageAndInner.kt") - public void testCurrentPackageAndInner() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inners/CurrentPackageAndInner.kt"); - } - - @TestMetadata("ImportThriceNestedClass.kt") - public void testImportThriceNestedClass() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inners/ImportThriceNestedClass.kt"); - } - - @TestMetadata("InnerInInner.kt") - public void testInnerInInner() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inners/InnerInInner.kt"); - } - - @TestMetadata("Nested.kt") - public void testNested() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inners/Nested.kt"); - } - - @TestMetadata("ThriceNestedClass.kt") - public void testThriceNestedClass() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inners/ThriceNestedClass.kt"); - } - } - - @TestMetadata("compiler/testData/javac/diagnostics/tests/qualifiedExpression") - @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class QualifiedExpression extends AbstractJavacDiagnosticsTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - - public void testAllFilesPresentInQualifiedExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/javac/diagnostics/tests/qualifiedExpression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @TestMetadata("GenericClassVsPackage.kt") - public void testGenericClassVsPackage() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/qualifiedExpression/GenericClassVsPackage.kt"); - } - - @TestMetadata("PackageVsClass.kt") - public void testPackageVsClass() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsClass.kt"); - } - - @TestMetadata("PackageVsClass2.kt") - public void testPackageVsClass2() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsClass2.kt"); - } - - @TestMetadata("PackageVsRootClass.kt") - public void testPackageVsRootClass() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsRootClass.kt"); - } - - @TestMetadata("visibleClassVsQualifiedClass.kt") - public void testVisibleClassVsQualifiedClass() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/qualifiedExpression/visibleClassVsQualifiedClass.kt"); - } - } - - @TestMetadata("compiler/testData/javac/diagnostics/tests/typeParameters") - @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class TypeParameters extends AbstractJavacDiagnosticsTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - - public void testAllFilesPresentInTypeParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/javac/diagnostics/tests/typeParameters"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @TestMetadata("Clash.kt") - public void testClash() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/typeParameters/Clash.kt"); - } - - @TestMetadata("ComplexCase.kt") - public void testComplexCase() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/typeParameters/ComplexCase.kt"); - } - - @TestMetadata("InheritedInnerAndTypeParameterWithSameNames.kt") - public void testInheritedInnerAndTypeParameterWithSameNames() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/typeParameters/InheritedInnerAndTypeParameterWithSameNames.kt"); - } - - @TestMetadata("InnerWithTypeParameter.kt") - public void testInnerWithTypeParameter() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/typeParameters/InnerWithTypeParameter.kt"); - } - - @TestMetadata("NestedWithInner.kt") - public void testNestedWithInner() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/typeParameters/NestedWithInner.kt"); - } - - @TestMetadata("SeveralInnersWithTypeParameters.kt") - public void testSeveralInnersWithTypeParameters() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/typeParameters/SeveralInnersWithTypeParameters.kt"); - } - - @TestMetadata("TypeParametersInInnerAndOuterWithSameNames.kt") - public void testTypeParametersInInnerAndOuterWithSameNames() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/typeParameters/TypeParametersInInnerAndOuterWithSameNames.kt"); - } - } - } - - @TestMetadata("compiler/testData/javac/diagnostics/tests") - @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class TestsWithoutJavac extends AbstractJavacDiagnosticsTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTestWithoutJavacWrapper, this, testDataFilePath); - } - - public void testAllFilesPresentInTestsWithoutJavac() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/javac/diagnostics/tests"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @TestMetadata("Annotations.kt") - public void testAnnotations() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/Annotations.kt"); - } - - @TestMetadata("compiler/testData/javac/diagnostics/tests/imports") - @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Imports extends AbstractJavacDiagnosticsTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTestWithoutJavacWrapper, this, testDataFilePath); - } - - public void testAllFilesPresentInImports() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/javac/diagnostics/tests/imports"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @TestMetadata("AllUnderImportsAmbiguity.kt") - public void testAllUnderImportsAmbiguity() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/imports/AllUnderImportsAmbiguity.kt"); - } - - @TestMetadata("AllUnderImportsLessPriority.kt") - public void testAllUnderImportsLessPriority() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/imports/AllUnderImportsLessPriority.kt"); - } - - @TestMetadata("ClassImportsConflicting.kt") - public void testClassImportsConflicting() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/imports/ClassImportsConflicting.kt"); - } - - @TestMetadata("CurrentPackageAndAllUnderImport.kt") - public void testCurrentPackageAndAllUnderImport() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndAllUnderImport.kt"); - } - - @TestMetadata("CurrentPackageAndExplicitImport.kt") - public void testCurrentPackageAndExplicitImport() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndExplicitImport.kt"); - } - - @TestMetadata("CurrentPackageAndExplicitNestedImport.kt") - public void testCurrentPackageAndExplicitNestedImport() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndExplicitNestedImport.kt"); - } - - @TestMetadata("CurrentPackageAndNestedAsteriskImport.kt") - public void testCurrentPackageAndNestedAsteriskImport() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/imports/CurrentPackageAndNestedAsteriskImport.kt"); - } - - @TestMetadata("ImportGenericVsPackage.kt") - public void testImportGenericVsPackage() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/imports/ImportGenericVsPackage.kt"); - } - - @TestMetadata("ImportProtectedClass.kt") - public void testImportProtectedClass() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/imports/ImportProtectedClass.kt"); - } - - @TestMetadata("ImportTwoTimes.kt") - public void testImportTwoTimes() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/imports/ImportTwoTimes.kt"); - } - - @TestMetadata("ImportTwoTimesStar.kt") - public void testImportTwoTimesStar() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/imports/ImportTwoTimesStar.kt"); - } - - @TestMetadata("NestedAndTopLevelClassClash.kt") - public void testNestedAndTopLevelClassClash() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/imports/NestedAndTopLevelClassClash.kt"); - } - - @TestMetadata("NestedClassClash.kt") - public void testNestedClassClash() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/imports/NestedClassClash.kt"); - } - - @TestMetadata("PackageExplicitAndStartImport.kt") - public void testPackageExplicitAndStartImport() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/imports/PackageExplicitAndStartImport.kt"); - } - - @TestMetadata("PackagePrivateAndPublicNested.kt") - public void testPackagePrivateAndPublicNested() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/imports/PackagePrivateAndPublicNested.kt"); - } - - @TestMetadata("TopLevelClassVsPackage.kt") - public void testTopLevelClassVsPackage() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/imports/TopLevelClassVsPackage.kt"); - } - - @TestMetadata("TopLevelClassVsPackage2.kt") - public void testTopLevelClassVsPackage2() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/imports/TopLevelClassVsPackage2.kt"); - } - } - - @TestMetadata("compiler/testData/javac/diagnostics/tests/inheritance") - @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Inheritance extends AbstractJavacDiagnosticsTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTestWithoutJavacWrapper, this, testDataFilePath); - } - - public void testAllFilesPresentInInheritance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/javac/diagnostics/tests/inheritance"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @TestMetadata("IheritanceOfInner.kt") - public void testIheritanceOfInner() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inheritance/IheritanceOfInner.kt"); - } - - @TestMetadata("InheritanceAmbiguity.kt") - public void testInheritanceAmbiguity() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity.kt"); - } - - @TestMetadata("InheritanceAmbiguity2.kt") - public void testInheritanceAmbiguity2() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity2.kt"); - } - - @TestMetadata("InheritanceAmbiguity3.kt") - public void testInheritanceAmbiguity3() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity3.kt"); - } - - @TestMetadata("InheritanceAmbiguity4.kt") - public void testInheritanceAmbiguity4() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inheritance/InheritanceAmbiguity4.kt"); - } - - @TestMetadata("InheritanceWithKotlin.kt") - public void testInheritanceWithKotlin() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inheritance/InheritanceWithKotlin.kt"); - } - - @TestMetadata("InheritanceWithKotlinClasses.kt") - public void testInheritanceWithKotlinClasses() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inheritance/InheritanceWithKotlinClasses.kt"); - } - - @TestMetadata("InheritedInner.kt") - public void testInheritedInner() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inheritance/InheritedInner.kt"); - } - - @TestMetadata("InheritedInner2.kt") - public void testInheritedInner2() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inheritance/InheritedInner2.kt"); - } - - @TestMetadata("InheritedInnerAndSupertypeWithSameName.kt") - public void testInheritedInnerAndSupertypeWithSameName() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inheritance/InheritedInnerAndSupertypeWithSameName.kt"); - } - - @TestMetadata("InheritedInnerUsageInInner.kt") - public void testInheritedInnerUsageInInner() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inheritance/InheritedInnerUsageInInner.kt"); - } - - @TestMetadata("InheritedKotlinInner.kt") - public void testInheritedKotlinInner() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inheritance/InheritedKotlinInner.kt"); - } - - @TestMetadata("InnerAndInheritedInner.kt") - public void testInnerAndInheritedInner() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inheritance/InnerAndInheritedInner.kt"); - } - - @TestMetadata("ManyInheritedClasses.kt") - public void testManyInheritedClasses() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inheritance/ManyInheritedClasses.kt"); - } - - @TestMetadata("NoAmbiguity.kt") - public void testNoAmbiguity() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inheritance/NoAmbiguity.kt"); - } - - @TestMetadata("NoAmbiguity2.kt") - public void testNoAmbiguity2() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inheritance/NoAmbiguity2.kt"); - } - - @TestMetadata("SameInnersInSupertypeAndSupertypesSupertype.kt") - public void testSameInnersInSupertypeAndSupertypesSupertype() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inheritance/SameInnersInSupertypeAndSupertypesSupertype.kt"); - } - - @TestMetadata("SuperTypeWithSameInner.kt") - public void testSuperTypeWithSameInner() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inheritance/SuperTypeWithSameInner.kt"); - } - - @TestMetadata("SupertypeInnerAndTypeParameterWithSameNames.kt") - public void testSupertypeInnerAndTypeParameterWithSameNames() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inheritance/SupertypeInnerAndTypeParameterWithSameNames.kt"); - } - } - - @TestMetadata("compiler/testData/javac/diagnostics/tests/inners") - @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Inners extends AbstractJavacDiagnosticsTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTestWithoutJavacWrapper, this, testDataFilePath); - } - - public void testAllFilesPresentInInners() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/javac/diagnostics/tests/inners"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @TestMetadata("ComplexCase.kt") - public void testComplexCase() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inners/ComplexCase.kt"); - } - - @TestMetadata("ComplexCase2.kt") - public void testComplexCase2() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inners/ComplexCase2.kt"); - } - - @TestMetadata("CurrentPackageAndInner.kt") - public void testCurrentPackageAndInner() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inners/CurrentPackageAndInner.kt"); - } - - @TestMetadata("ImportThriceNestedClass.kt") - public void testImportThriceNestedClass() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inners/ImportThriceNestedClass.kt"); - } - - @TestMetadata("InnerInInner.kt") - public void testInnerInInner() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inners/InnerInInner.kt"); - } - - @TestMetadata("Nested.kt") - public void testNested() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inners/Nested.kt"); - } - - @TestMetadata("ThriceNestedClass.kt") - public void testThriceNestedClass() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/inners/ThriceNestedClass.kt"); - } - } - - @TestMetadata("compiler/testData/javac/diagnostics/tests/qualifiedExpression") - @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class QualifiedExpression extends AbstractJavacDiagnosticsTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTestWithoutJavacWrapper, this, testDataFilePath); - } - - public void testAllFilesPresentInQualifiedExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/javac/diagnostics/tests/qualifiedExpression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @TestMetadata("GenericClassVsPackage.kt") - public void testGenericClassVsPackage() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/qualifiedExpression/GenericClassVsPackage.kt"); - } - - @TestMetadata("PackageVsClass.kt") - public void testPackageVsClass() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsClass.kt"); - } - - @TestMetadata("PackageVsClass2.kt") - public void testPackageVsClass2() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsClass2.kt"); - } - - @TestMetadata("PackageVsRootClass.kt") - public void testPackageVsRootClass() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/qualifiedExpression/PackageVsRootClass.kt"); - } - - @TestMetadata("visibleClassVsQualifiedClass.kt") - public void testVisibleClassVsQualifiedClass() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/qualifiedExpression/visibleClassVsQualifiedClass.kt"); - } - } - - @TestMetadata("compiler/testData/javac/diagnostics/tests/typeParameters") - @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class TypeParameters extends AbstractJavacDiagnosticsTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTestWithoutJavacWrapper, this, testDataFilePath); - } - - public void testAllFilesPresentInTypeParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/javac/diagnostics/tests/typeParameters"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); - } - - @TestMetadata("Clash.kt") - public void testClash() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/typeParameters/Clash.kt"); - } - - @TestMetadata("ComplexCase.kt") - public void testComplexCase() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/typeParameters/ComplexCase.kt"); - } - - @TestMetadata("InheritedInnerAndTypeParameterWithSameNames.kt") - public void testInheritedInnerAndTypeParameterWithSameNames() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/typeParameters/InheritedInnerAndTypeParameterWithSameNames.kt"); - } - - @TestMetadata("InnerWithTypeParameter.kt") - public void testInnerWithTypeParameter() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/typeParameters/InnerWithTypeParameter.kt"); - } - - @TestMetadata("NestedWithInner.kt") - public void testNestedWithInner() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/typeParameters/NestedWithInner.kt"); - } - - @TestMetadata("SeveralInnersWithTypeParameters.kt") - public void testSeveralInnersWithTypeParameters() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/typeParameters/SeveralInnersWithTypeParameters.kt"); - } - - @TestMetadata("TypeParametersInInnerAndOuterWithSameNames.kt") - public void testTypeParametersInInnerAndOuterWithSameNames() throws Exception { - runTest("compiler/testData/javac/diagnostics/tests/typeParameters/TypeParametersInInnerAndOuterWithSameNames.kt"); - } - } - } -} diff --git a/compiler/tests-gen/org/jetbrains/kotlin/checkers/javac/JavacFieldResolutionTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/checkers/javac/JavacFieldResolutionTestGenerated.java deleted file mode 100644 index b3b3dcff30d..00000000000 --- a/compiler/tests-gen/org/jetbrains/kotlin/checkers/javac/JavacFieldResolutionTestGenerated.java +++ /dev/null @@ -1,166 +0,0 @@ -/* - * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. - * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. - */ - -package org.jetbrains.kotlin.checkers.javac; - -import com.intellij.testFramework.TestDataPath; -import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; -import org.jetbrains.kotlin.test.KotlinTestUtils; -import org.jetbrains.kotlin.test.TestMetadata; -import org.junit.runner.RunWith; - -import java.io.File; -import java.util.regex.Pattern; - -/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */ -@SuppressWarnings("all") -@RunWith(JUnit3RunnerWithInners.class) -public class JavacFieldResolutionTestGenerated extends AbstractJavacFieldResolutionTest { - @TestMetadata("compiler/testData/javac/fieldsResolution/tests") - @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Tests extends AbstractJavacFieldResolutionTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - - public void testAllFilesPresentInTests() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/javac/fieldsResolution/tests"), Pattern.compile("^(.+)\\.kt$"), null, true); - } - - @TestMetadata("AsteriskStaticImportsAmbiguity.kt") - public void testAsteriskStaticImportsAmbiguity() throws Exception { - runTest("compiler/testData/javac/fieldsResolution/tests/AsteriskStaticImportsAmbiguity.kt"); - } - - @TestMetadata("BinaryInitializers.kt") - public void testBinaryInitializers() throws Exception { - runTest("compiler/testData/javac/fieldsResolution/tests/BinaryInitializers.kt"); - } - - @TestMetadata("ConstantByFqName.kt") - public void testConstantByFqName() throws Exception { - runTest("compiler/testData/javac/fieldsResolution/tests/ConstantByFqName.kt"); - } - - @TestMetadata("ConstantValues.kt") - public void testConstantValues() throws Exception { - runTest("compiler/testData/javac/fieldsResolution/tests/ConstantValues.kt"); - } - - @TestMetadata("ConstantValuesFromKtFile.kt") - public void testConstantValuesFromKtFile() throws Exception { - runTest("compiler/testData/javac/fieldsResolution/tests/ConstantValuesFromKtFile.kt"); - } - - @TestMetadata("FieldFromOuterClass.kt") - public void testFieldFromOuterClass() throws Exception { - runTest("compiler/testData/javac/fieldsResolution/tests/FieldFromOuterClass.kt"); - } - - @TestMetadata("InheritedField.kt") - public void testInheritedField() throws Exception { - runTest("compiler/testData/javac/fieldsResolution/tests/InheritedField.kt"); - } - - @TestMetadata("MultipleOuters.kt") - public void testMultipleOuters() throws Exception { - runTest("compiler/testData/javac/fieldsResolution/tests/MultipleOuters.kt"); - } - - @TestMetadata("ResolutionPriority.kt") - public void testResolutionPriority() throws Exception { - runTest("compiler/testData/javac/fieldsResolution/tests/ResolutionPriority.kt"); - } - - @TestMetadata("SameFieldInSupertypes.kt") - public void testSameFieldInSupertypes() throws Exception { - runTest("compiler/testData/javac/fieldsResolution/tests/SameFieldInSupertypes.kt"); - } - - @TestMetadata("StaticImport.kt") - public void testStaticImport() throws Exception { - runTest("compiler/testData/javac/fieldsResolution/tests/StaticImport.kt"); - } - - @TestMetadata("StaticImportsAmbiguity.kt") - public void testStaticImportsAmbiguity() throws Exception { - runTest("compiler/testData/javac/fieldsResolution/tests/StaticImportsAmbiguity.kt"); - } - } - - @TestMetadata("compiler/testData/javac/fieldsResolution/tests") - @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class TestsWithoutJavac extends AbstractJavacFieldResolutionTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTestWithoutJavacWrapper, this, testDataFilePath); - } - - public void testAllFilesPresentInTestsWithoutJavac() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/javac/fieldsResolution/tests"), Pattern.compile("^(.+)\\.kt$"), null, true); - } - - @TestMetadata("AsteriskStaticImportsAmbiguity.kt") - public void testAsteriskStaticImportsAmbiguity() throws Exception { - runTest("compiler/testData/javac/fieldsResolution/tests/AsteriskStaticImportsAmbiguity.kt"); - } - - @TestMetadata("BinaryInitializers.kt") - public void testBinaryInitializers() throws Exception { - runTest("compiler/testData/javac/fieldsResolution/tests/BinaryInitializers.kt"); - } - - @TestMetadata("ConstantByFqName.kt") - public void testConstantByFqName() throws Exception { - runTest("compiler/testData/javac/fieldsResolution/tests/ConstantByFqName.kt"); - } - - @TestMetadata("ConstantValues.kt") - public void testConstantValues() throws Exception { - runTest("compiler/testData/javac/fieldsResolution/tests/ConstantValues.kt"); - } - - @TestMetadata("ConstantValuesFromKtFile.kt") - public void testConstantValuesFromKtFile() throws Exception { - runTest("compiler/testData/javac/fieldsResolution/tests/ConstantValuesFromKtFile.kt"); - } - - @TestMetadata("FieldFromOuterClass.kt") - public void testFieldFromOuterClass() throws Exception { - runTest("compiler/testData/javac/fieldsResolution/tests/FieldFromOuterClass.kt"); - } - - @TestMetadata("InheritedField.kt") - public void testInheritedField() throws Exception { - runTest("compiler/testData/javac/fieldsResolution/tests/InheritedField.kt"); - } - - @TestMetadata("MultipleOuters.kt") - public void testMultipleOuters() throws Exception { - runTest("compiler/testData/javac/fieldsResolution/tests/MultipleOuters.kt"); - } - - @TestMetadata("ResolutionPriority.kt") - public void testResolutionPriority() throws Exception { - runTest("compiler/testData/javac/fieldsResolution/tests/ResolutionPriority.kt"); - } - - @TestMetadata("SameFieldInSupertypes.kt") - public void testSameFieldInSupertypes() throws Exception { - runTest("compiler/testData/javac/fieldsResolution/tests/SameFieldInSupertypes.kt"); - } - - @TestMetadata("StaticImport.kt") - public void testStaticImport() throws Exception { - runTest("compiler/testData/javac/fieldsResolution/tests/StaticImport.kt"); - } - - @TestMetadata("StaticImportsAmbiguity.kt") - public void testStaticImportsAmbiguity() throws Exception { - runTest("compiler/testData/javac/fieldsResolution/tests/StaticImportsAmbiguity.kt"); - } - } -} diff --git a/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt b/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt index e71841eec57..78922ab6224 100644 --- a/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt +++ b/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt @@ -66,25 +66,8 @@ import org.jetbrains.kotlin.visualizer.psi.AbstractPsiVisualizer fun main(args: Array) { System.setProperty("java.awt.headless", "true") - val excludedFirTestdataPattern = "^(.+)\\.fir\\.kts?\$" - generateTestGroupSuite(args) { testGroup("compiler/tests-gen", "compiler/testData") { - testClass { - model("javac/diagnostics/tests", excludedPattern = excludedFirTestdataPattern) - model( - "javac/diagnostics/tests", - testClassName = "TestsWithoutJavac", - testMethod = "doTestWithoutJavacWrapper", - excludedPattern = excludedFirTestdataPattern - ) - } - - testClass { - model("javac/fieldsResolution/tests") - model("javac/fieldsResolution/tests", testClassName = "TestsWithoutJavac", testMethod = "doTestWithoutJavacWrapper") - } - testClass { model("diagnostics/testsWithJsStdLib") } From c0e4452cf84deae228d0931db32877a0846d9799 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Wed, 9 Dec 2020 12:18:07 +0300 Subject: [PATCH 103/196] [TEST] Migrate AbstractDiagnosticsWithJdk9Test to new test runners --- .../{testsWithJava9 => tests}/kt11167.kt | 4 ++- .../{testsWithJava9 => tests}/kt11167.txt | 0 .../test/runners/DiagnosticTestGenerated.java | 6 ++++ ...irOldFrontendDiagnosticsTestGenerated.java | 6 ++++ .../AbstractDiagnosticsWithJdk9Test.kt | 25 ------------- .../DiagnosticsWithJdk9TestGenerated.java | 35 ------------------- .../generators/tests/GenerateCompilerTests.kt | 4 --- 7 files changed, 15 insertions(+), 65 deletions(-) rename compiler/testData/diagnostics/{testsWithJava9 => tests}/kt11167.kt (87%) rename compiler/testData/diagnostics/{testsWithJava9 => tests}/kt11167.txt (100%) delete mode 100644 compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractDiagnosticsWithJdk9Test.kt delete mode 100644 compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsWithJdk9TestGenerated.java diff --git a/compiler/testData/diagnostics/testsWithJava9/kt11167.kt b/compiler/testData/diagnostics/tests/kt11167.kt similarity index 87% rename from compiler/testData/diagnostics/testsWithJava9/kt11167.kt rename to compiler/testData/diagnostics/tests/kt11167.kt index 56696a9babc..c68da98130d 100644 --- a/compiler/testData/diagnostics/testsWithJava9/kt11167.kt +++ b/compiler/testData/diagnostics/tests/kt11167.kt @@ -1,4 +1,6 @@ -//WITH_RUNTIME +// FIR_IDENTICAL +// JDK_KIND: FULL_JDK_9 +// WITH_STDLIB import java.util.stream.IntStream fun foo(s: IntStream) { diff --git a/compiler/testData/diagnostics/testsWithJava9/kt11167.txt b/compiler/testData/diagnostics/tests/kt11167.txt similarity index 100% rename from compiler/testData/diagnostics/testsWithJava9/kt11167.txt rename to compiler/testData/diagnostics/tests/kt11167.txt diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java index c4100e77895..da147e88f5a 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java @@ -374,6 +374,12 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { runTest("compiler/testData/diagnostics/tests/IsExpressions.kt"); } + @Test + @TestMetadata("kt11167.kt") + public void testKt11167() throws Exception { + runTest("compiler/testData/diagnostics/tests/kt11167.kt"); + } + @Test @TestMetadata("kt13401.kt") public void testKt13401() throws Exception { diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java index 158fa299781..1287c50f77b 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java @@ -374,6 +374,12 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti runTest("compiler/testData/diagnostics/tests/IsExpressions.kt"); } + @Test + @TestMetadata("kt11167.kt") + public void testKt11167() throws Exception { + runTest("compiler/testData/diagnostics/tests/kt11167.kt"); + } + @Test @TestMetadata("kt13401.kt") public void testKt13401() throws Exception { diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractDiagnosticsWithJdk9Test.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractDiagnosticsWithJdk9Test.kt deleted file mode 100644 index f955621639d..00000000000 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractDiagnosticsWithJdk9Test.kt +++ /dev/null @@ -1,25 +0,0 @@ -/* - * Copyright 2010-2017 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.checkers - -import org.jetbrains.kotlin.test.TestJdkKind - -abstract class AbstractDiagnosticsWithJdk9Test : AbstractDiagnosticsTest() { - - override fun getTestJdkKind(files: List): TestJdkKind { - return TestJdkKind.FULL_JDK_9 - } -} \ No newline at end of file diff --git a/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsWithJdk9TestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsWithJdk9TestGenerated.java deleted file mode 100644 index a18684b1a66..00000000000 --- a/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsWithJdk9TestGenerated.java +++ /dev/null @@ -1,35 +0,0 @@ -/* - * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. - * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. - */ - -package org.jetbrains.kotlin.checkers; - -import com.intellij.testFramework.TestDataPath; -import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; -import org.jetbrains.kotlin.test.KotlinTestUtils; -import org.jetbrains.kotlin.test.TestMetadata; -import org.junit.runner.RunWith; - -import java.io.File; -import java.util.regex.Pattern; - -/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */ -@SuppressWarnings("all") -@TestMetadata("compiler/testData/diagnostics/testsWithJava9") -@TestDataPath("$PROJECT_ROOT") -@RunWith(JUnit3RunnerWithInners.class) -public class DiagnosticsWithJdk9TestGenerated extends AbstractDiagnosticsWithJdk9Test { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - - public void testAllFilesPresentInTestsWithJava9() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJava9"), Pattern.compile("^(.+)\\.kt$"), null, true); - } - - @TestMetadata("kt11167.kt") - public void testKt11167() throws Exception { - runTest("compiler/testData/diagnostics/testsWithJava9/kt11167.kt"); - } -} diff --git a/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt b/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt index 78922ab6224..b6335d57f23 100644 --- a/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt +++ b/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt @@ -84,10 +84,6 @@ fun main(args: Array) { model("diagnostics/testWithModifiedMockJdk") } - testClass { - model("diagnostics/testsWithJava9") - } - testClass { model("diagnostics/testsWithJava15") } From 23e704f36198c83bd5b5adb0c91b35dad6fbdc44 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Wed, 9 Dec 2020 12:28:49 +0300 Subject: [PATCH 104/196] [TEST] Migrate AbstractDiagnosticsWithExplicitApi to new test runners --- .../LanguageVersionSettingsBuilder.kt | 1 + .../directives/LanguageSettingsDirectives.kt | 8 +- .../testsWithExplicitApi/annotations.fir.kt | 47 +++++++++++ .../testsWithExplicitApi/annotations.kt | 0 .../tests/testsWithExplicitApi/classes.fir.kt | 47 +++++++++++ .../testsWithExplicitApi/classes.kt | 0 .../companionObject.fir.kt | 20 +++++ .../testsWithExplicitApi/companionObject.kt | 0 .../testsWithExplicitApi/constructors.fir.kt | 17 ++++ .../testsWithExplicitApi/constructors.kt | 0 .../testsWithExplicitApi/inlineClasses.fir.kt | 7 ++ .../testsWithExplicitApi/inlineClasses.kt | 0 .../testsWithExplicitApi/interfaces.fir.kt | 35 ++++++++ .../testsWithExplicitApi/interfaces.kt | 0 .../mustBeEffectivelyPublic.kt | 1 + .../testsWithExplicitApi/properties.fir.kt | 23 ++++++ .../testsWithExplicitApi/properties.kt | 0 .../testsWithExplicitApi/publishedApi.fir.kt | 7 ++ .../testsWithExplicitApi/publishedApi.kt | 0 .../testsWithExplicitApi/toplevel.fir.kt | 12 +++ .../testsWithExplicitApi/toplevel.kt | 0 .../test/runners/DiagnosticTestGenerated.java | 70 ++++++++++++++++ ...irOldFrontendDiagnosticsTestGenerated.java | 70 ++++++++++++++++ .../test/runners/AbstractDiagnosticTest.kt | 9 +++ .../AbstractDiagnosticsWithExplicitApi.kt | 19 ----- .../DiagnosticsWithExplicitApiGenerated.java | 80 ------------------- .../generators/tests/GenerateCompilerTests.kt | 4 - 27 files changed, 373 insertions(+), 104 deletions(-) create mode 100644 compiler/testData/diagnostics/tests/testsWithExplicitApi/annotations.fir.kt rename compiler/testData/diagnostics/{ => tests}/testsWithExplicitApi/annotations.kt (100%) create mode 100644 compiler/testData/diagnostics/tests/testsWithExplicitApi/classes.fir.kt rename compiler/testData/diagnostics/{ => tests}/testsWithExplicitApi/classes.kt (100%) create mode 100644 compiler/testData/diagnostics/tests/testsWithExplicitApi/companionObject.fir.kt rename compiler/testData/diagnostics/{ => tests}/testsWithExplicitApi/companionObject.kt (100%) create mode 100644 compiler/testData/diagnostics/tests/testsWithExplicitApi/constructors.fir.kt rename compiler/testData/diagnostics/{ => tests}/testsWithExplicitApi/constructors.kt (100%) create mode 100644 compiler/testData/diagnostics/tests/testsWithExplicitApi/inlineClasses.fir.kt rename compiler/testData/diagnostics/{ => tests}/testsWithExplicitApi/inlineClasses.kt (100%) create mode 100644 compiler/testData/diagnostics/tests/testsWithExplicitApi/interfaces.fir.kt rename compiler/testData/diagnostics/{ => tests}/testsWithExplicitApi/interfaces.kt (100%) rename compiler/testData/diagnostics/{ => tests}/testsWithExplicitApi/mustBeEffectivelyPublic.kt (94%) create mode 100644 compiler/testData/diagnostics/tests/testsWithExplicitApi/properties.fir.kt rename compiler/testData/diagnostics/{ => tests}/testsWithExplicitApi/properties.kt (100%) create mode 100644 compiler/testData/diagnostics/tests/testsWithExplicitApi/publishedApi.fir.kt rename compiler/testData/diagnostics/{ => tests}/testsWithExplicitApi/publishedApi.kt (100%) create mode 100644 compiler/testData/diagnostics/tests/testsWithExplicitApi/toplevel.fir.kt rename compiler/testData/diagnostics/{ => tests}/testsWithExplicitApi/toplevel.kt (100%) delete mode 100644 compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractDiagnosticsWithExplicitApi.kt delete mode 100644 compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsWithExplicitApiGenerated.java diff --git a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/builders/LanguageVersionSettingsBuilder.kt b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/builders/LanguageVersionSettingsBuilder.kt index de1f6bda417..bb7f2d5fcd2 100644 --- a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/builders/LanguageVersionSettingsBuilder.kt +++ b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/builders/LanguageVersionSettingsBuilder.kt @@ -64,6 +64,7 @@ class LanguageVersionSettingsBuilder { analysisFlag(AnalysisFlags.ignoreDataFlowInAssert, trueOrNull(LanguageSettingsDirectives.IGNORE_DATA_FLOW_IN_ASSERT in directives)), analysisFlag(AnalysisFlags.constraintSystemForOverloadResolution, directives.singleOrZeroValue(LanguageSettingsDirectives.CONSTRAINT_SYSTEM_FOR_OVERLOAD_RESOLUTION)), analysisFlag(AnalysisFlags.allowResultReturnType, trueOrNull(LanguageSettingsDirectives.ALLOW_RESULT_RETURN_TYPE in directives)), + analysisFlag(AnalysisFlags.explicitApiMode, directives.singleOrZeroValue(LanguageSettingsDirectives.EXPLICIT_API_MODE)), analysisFlag(JvmAnalysisFlags.jvmDefaultMode, directives.singleOrZeroValue(LanguageSettingsDirectives.JVM_DEFAULT_MODE)), analysisFlag(JvmAnalysisFlags.inheritMultifileParts, trueOrNull(LanguageSettingsDirectives.INHERIT_MULTIFILE_PARTS in directives)), diff --git a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/directives/LanguageSettingsDirectives.kt b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/directives/LanguageSettingsDirectives.kt index a0977487e29..2abf2bb179d 100644 --- a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/directives/LanguageSettingsDirectives.kt +++ b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/directives/LanguageSettingsDirectives.kt @@ -7,9 +7,11 @@ package org.jetbrains.kotlin.test.directives import org.jetbrains.kotlin.config.ApiVersion import org.jetbrains.kotlin.config.ConstraintSystemForOverloadResolutionMode +import org.jetbrains.kotlin.config.ExplicitApiMode import org.jetbrains.kotlin.config.JvmDefaultMode import org.jetbrains.kotlin.test.directives.model.SimpleDirectivesContainer +@Suppress("RemoveExplicitTypeArguments") object LanguageSettingsDirectives : SimpleDirectivesContainer() { val LANGUAGE by stringDirective( description = """ @@ -45,9 +47,13 @@ object LanguageSettingsDirectives : SimpleDirectivesContainer() { description = "Allow using Result in return type position" ) + val EXPLICIT_API_MODE by enumDirective( + "Configures explicit API mode (AnalysisFlags.explicitApiMode)", + additionalParser = ExplicitApiMode.Companion::fromString + ) + // --------------------- Jvm Analysis Flags --------------------- - @Suppress("RemoveExplicitTypeArguments") val JVM_DEFAULT_MODE by enumDirective( description = "Configures corresponding analysis flag (JvmAnalysisFlags.jvmDefaultMode)", additionalParser = JvmDefaultMode.Companion::fromStringOrNull diff --git a/compiler/testData/diagnostics/tests/testsWithExplicitApi/annotations.fir.kt b/compiler/testData/diagnostics/tests/testsWithExplicitApi/annotations.fir.kt new file mode 100644 index 00000000000..5fb4373d009 --- /dev/null +++ b/compiler/testData/diagnostics/tests/testsWithExplicitApi/annotations.fir.kt @@ -0,0 +1,47 @@ +// SKIP_TXT + +annotation class A + +@Target( + AnnotationTarget.CLASS, + AnnotationTarget.PROPERTY, + AnnotationTarget.CONSTRUCTOR, + AnnotationTarget.FUNCTION +) +public annotation class B + +annotation class C(val a: String) + +/** + * Foo1 KDoc + */ +@B +class Foo1() {} + +public class Foo2() { + /** + * KDoc for methodWithAnnotations + */ + @B + fun methodWithAnnotations() {} + + /** + * Property KDoc + */ + @B + var simple: Int = 10 +} + +public open class ClassWithOpen { + /** + * constructor KDoc + */ + @B + constructor() {} + + /** + * KDoc for openAnnotatedMethod + */ + @B + open fun openAnnotatedMethod() {} +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/testsWithExplicitApi/annotations.kt b/compiler/testData/diagnostics/tests/testsWithExplicitApi/annotations.kt similarity index 100% rename from compiler/testData/diagnostics/testsWithExplicitApi/annotations.kt rename to compiler/testData/diagnostics/tests/testsWithExplicitApi/annotations.kt diff --git a/compiler/testData/diagnostics/tests/testsWithExplicitApi/classes.fir.kt b/compiler/testData/diagnostics/tests/testsWithExplicitApi/classes.fir.kt new file mode 100644 index 00000000000..b94ba0effef --- /dev/null +++ b/compiler/testData/diagnostics/tests/testsWithExplicitApi/classes.fir.kt @@ -0,0 +1,47 @@ +// SKIP_TXT + +/** + * KDoc for Foo1 + */ +class Foo1() {} + +public class Foo2() { + /** + * KDoc for method + */ + fun method() {} + + /** + * KDoc for method2 + */ + public fun method2() {} + private fun method3() {} + + fun implicit() = 10 + public fun implicit2() = 10 + public fun implicit3(): Int = 10 +} + +public open class ClassWithOpen() { + /** + * KDoc for method + */ + fun method() {} + + /** + * KDoc for openMethod + */ + open fun openMethod() {} +} + +public data class FooData(val i: Int, val s: String) + +data class FooData2(val i: Int, val s: String) + +public class WithNested { + class Nested {} + inner class Inner {} +} + +enum class Foo { A, B } +public enum class Bar { A, B } \ No newline at end of file diff --git a/compiler/testData/diagnostics/testsWithExplicitApi/classes.kt b/compiler/testData/diagnostics/tests/testsWithExplicitApi/classes.kt similarity index 100% rename from compiler/testData/diagnostics/testsWithExplicitApi/classes.kt rename to compiler/testData/diagnostics/tests/testsWithExplicitApi/classes.kt diff --git a/compiler/testData/diagnostics/tests/testsWithExplicitApi/companionObject.fir.kt b/compiler/testData/diagnostics/tests/testsWithExplicitApi/companionObject.fir.kt new file mode 100644 index 00000000000..fb806d2ac0f --- /dev/null +++ b/compiler/testData/diagnostics/tests/testsWithExplicitApi/companionObject.fir.kt @@ -0,0 +1,20 @@ +// SKIP_TXT + +public class Bar { + companion object {} +} + +public class Bar2 { + companion object MyCompanion {} +} + +public class Bar3 { + /** + * Nested object KDoc + */ + object NestedObject {} +} + +data class FooData2(val i: Int, val s: String) { + object NestedObject {} +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/testsWithExplicitApi/companionObject.kt b/compiler/testData/diagnostics/tests/testsWithExplicitApi/companionObject.kt similarity index 100% rename from compiler/testData/diagnostics/testsWithExplicitApi/companionObject.kt rename to compiler/testData/diagnostics/tests/testsWithExplicitApi/companionObject.kt diff --git a/compiler/testData/diagnostics/tests/testsWithExplicitApi/constructors.fir.kt b/compiler/testData/diagnostics/tests/testsWithExplicitApi/constructors.fir.kt new file mode 100644 index 00000000000..fc5b06b9848 --- /dev/null +++ b/compiler/testData/diagnostics/tests/testsWithExplicitApi/constructors.fir.kt @@ -0,0 +1,17 @@ +// SKIP_TXT + +public class Foo1 () {} +public class Foo2 constructor() {} +public class Foo3 public constructor() {} +public class Foo4 private constructor() {} + +public class Foo5 { + /** + * constructor KDoc + */ + constructor() {} +} + +public class Foo6 { + public constructor() {} +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/testsWithExplicitApi/constructors.kt b/compiler/testData/diagnostics/tests/testsWithExplicitApi/constructors.kt similarity index 100% rename from compiler/testData/diagnostics/testsWithExplicitApi/constructors.kt rename to compiler/testData/diagnostics/tests/testsWithExplicitApi/constructors.kt diff --git a/compiler/testData/diagnostics/tests/testsWithExplicitApi/inlineClasses.fir.kt b/compiler/testData/diagnostics/tests/testsWithExplicitApi/inlineClasses.fir.kt new file mode 100644 index 00000000000..c44333df293 --- /dev/null +++ b/compiler/testData/diagnostics/tests/testsWithExplicitApi/inlineClasses.fir.kt @@ -0,0 +1,7 @@ +// !DIAGNOSTICS: -EXPERIMENTAL_FEATURE_WARNING +// SKIP_TXT + +inline class Value1(val inner: Int) +public inline class Value2(val inner: Int) +inline class Value3(public val inner: Int) +public inline class Value4(public val inner: Int) \ No newline at end of file diff --git a/compiler/testData/diagnostics/testsWithExplicitApi/inlineClasses.kt b/compiler/testData/diagnostics/tests/testsWithExplicitApi/inlineClasses.kt similarity index 100% rename from compiler/testData/diagnostics/testsWithExplicitApi/inlineClasses.kt rename to compiler/testData/diagnostics/tests/testsWithExplicitApi/inlineClasses.kt diff --git a/compiler/testData/diagnostics/tests/testsWithExplicitApi/interfaces.fir.kt b/compiler/testData/diagnostics/tests/testsWithExplicitApi/interfaces.fir.kt new file mode 100644 index 00000000000..865fc8dd083 --- /dev/null +++ b/compiler/testData/diagnostics/tests/testsWithExplicitApi/interfaces.fir.kt @@ -0,0 +1,35 @@ +// SKIP_TXT + +interface I1 { + fun i() +} + +public interface I2 { + fun i() +} + +public interface I3 { + public fun i() + public val v: Int +} + +public interface I4 { + public fun i(): Int + public val v: Int +} + +public class Impl: I3 { + override fun i() {} + override val v: Int + get() = 10 +} + +public class Impl2: I4 { + override fun i() = 10 + override val v = 10 +} + +private class PrivateImpl: I4 { + override fun i() = 10 + override val v = 10 +} diff --git a/compiler/testData/diagnostics/testsWithExplicitApi/interfaces.kt b/compiler/testData/diagnostics/tests/testsWithExplicitApi/interfaces.kt similarity index 100% rename from compiler/testData/diagnostics/testsWithExplicitApi/interfaces.kt rename to compiler/testData/diagnostics/tests/testsWithExplicitApi/interfaces.kt diff --git a/compiler/testData/diagnostics/testsWithExplicitApi/mustBeEffectivelyPublic.kt b/compiler/testData/diagnostics/tests/testsWithExplicitApi/mustBeEffectivelyPublic.kt similarity index 94% rename from compiler/testData/diagnostics/testsWithExplicitApi/mustBeEffectivelyPublic.kt rename to compiler/testData/diagnostics/tests/testsWithExplicitApi/mustBeEffectivelyPublic.kt index 4bb56d65530..fea38281152 100644 --- a/compiler/testData/diagnostics/testsWithExplicitApi/mustBeEffectivelyPublic.kt +++ b/compiler/testData/diagnostics/tests/testsWithExplicitApi/mustBeEffectivelyPublic.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // SKIP_TXT private class Foo { diff --git a/compiler/testData/diagnostics/tests/testsWithExplicitApi/properties.fir.kt b/compiler/testData/diagnostics/tests/testsWithExplicitApi/properties.fir.kt new file mode 100644 index 00000000000..c92e0da56a6 --- /dev/null +++ b/compiler/testData/diagnostics/tests/testsWithExplicitApi/properties.fir.kt @@ -0,0 +1,23 @@ +// SKIP_TXT + +public class Foo(val bar: Int, private var bar2: String, internal var bar3: Long, public var bar4: Int) { + /** + * Property KDoc + */ + var simple: Int = 10 + public var simple2: Int = 10 + + val withGetter: Int + get() = 10 + + public val withGetter2: Int + get() = 10 + + var getterAndSetter: Int = 10 + get() = field + set(v) { field = v } + + public var getterAndSetter2: Int = 10 + get() = field + set(v) { field = v } +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/testsWithExplicitApi/properties.kt b/compiler/testData/diagnostics/tests/testsWithExplicitApi/properties.kt similarity index 100% rename from compiler/testData/diagnostics/testsWithExplicitApi/properties.kt rename to compiler/testData/diagnostics/tests/testsWithExplicitApi/properties.kt diff --git a/compiler/testData/diagnostics/tests/testsWithExplicitApi/publishedApi.fir.kt b/compiler/testData/diagnostics/tests/testsWithExplicitApi/publishedApi.fir.kt new file mode 100644 index 00000000000..7827b84d9de --- /dev/null +++ b/compiler/testData/diagnostics/tests/testsWithExplicitApi/publishedApi.fir.kt @@ -0,0 +1,7 @@ +// SKIP_TXT +// WITH_RUNTIME + +public class A { + @PublishedApi + internal fun foo() = 1 +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/testsWithExplicitApi/publishedApi.kt b/compiler/testData/diagnostics/tests/testsWithExplicitApi/publishedApi.kt similarity index 100% rename from compiler/testData/diagnostics/testsWithExplicitApi/publishedApi.kt rename to compiler/testData/diagnostics/tests/testsWithExplicitApi/publishedApi.kt diff --git a/compiler/testData/diagnostics/tests/testsWithExplicitApi/toplevel.fir.kt b/compiler/testData/diagnostics/tests/testsWithExplicitApi/toplevel.fir.kt new file mode 100644 index 00000000000..9644173e86a --- /dev/null +++ b/compiler/testData/diagnostics/tests/testsWithExplicitApi/toplevel.fir.kt @@ -0,0 +1,12 @@ +// SKIP_TXT + +/** + * foo KDoc + */ +fun foo() {} + +public fun foo2() {} + +fun bar() = 10 +public fun bar2() = 10 +public fun bar3(): Int = 10 diff --git a/compiler/testData/diagnostics/testsWithExplicitApi/toplevel.kt b/compiler/testData/diagnostics/tests/testsWithExplicitApi/toplevel.kt similarity index 100% rename from compiler/testData/diagnostics/testsWithExplicitApi/toplevel.kt rename to compiler/testData/diagnostics/tests/testsWithExplicitApi/toplevel.kt diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java index da147e88f5a..2856c0b0511 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java @@ -28200,6 +28200,76 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { } } + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/testsWithExplicitApi") + @TestDataPath("$PROJECT_ROOT") + public class TestsWithExplicitApi extends AbstractDiagnosticTest { + @Test + public void testAllFilesPresentInTestsWithExplicitApi() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/testsWithExplicitApi"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + } + + @Test + @TestMetadata("annotations.kt") + public void testAnnotations() throws Exception { + runTest("compiler/testData/diagnostics/tests/testsWithExplicitApi/annotations.kt"); + } + + @Test + @TestMetadata("classes.kt") + public void testClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/testsWithExplicitApi/classes.kt"); + } + + @Test + @TestMetadata("companionObject.kt") + public void testCompanionObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/testsWithExplicitApi/companionObject.kt"); + } + + @Test + @TestMetadata("constructors.kt") + public void testConstructors() throws Exception { + runTest("compiler/testData/diagnostics/tests/testsWithExplicitApi/constructors.kt"); + } + + @Test + @TestMetadata("inlineClasses.kt") + public void testInlineClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/testsWithExplicitApi/inlineClasses.kt"); + } + + @Test + @TestMetadata("interfaces.kt") + public void testInterfaces() throws Exception { + runTest("compiler/testData/diagnostics/tests/testsWithExplicitApi/interfaces.kt"); + } + + @Test + @TestMetadata("mustBeEffectivelyPublic.kt") + public void testMustBeEffectivelyPublic() throws Exception { + runTest("compiler/testData/diagnostics/tests/testsWithExplicitApi/mustBeEffectivelyPublic.kt"); + } + + @Test + @TestMetadata("properties.kt") + public void testProperties() throws Exception { + runTest("compiler/testData/diagnostics/tests/testsWithExplicitApi/properties.kt"); + } + + @Test + @TestMetadata("publishedApi.kt") + public void testPublishedApi() throws Exception { + runTest("compiler/testData/diagnostics/tests/testsWithExplicitApi/publishedApi.kt"); + } + + @Test + @TestMetadata("toplevel.kt") + public void testToplevel() throws Exception { + runTest("compiler/testData/diagnostics/tests/testsWithExplicitApi/toplevel.kt"); + } + } + @Nested @TestMetadata("compiler/testData/diagnostics/tests/thisAndSuper") @TestDataPath("$PROJECT_ROOT") diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java index 1287c50f77b..8e0ed34e579 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java @@ -28104,6 +28104,76 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti } } + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/testsWithExplicitApi") + @TestDataPath("$PROJECT_ROOT") + public class TestsWithExplicitApi extends AbstractFirDiagnosticTest { + @Test + public void testAllFilesPresentInTestsWithExplicitApi() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/testsWithExplicitApi"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + } + + @Test + @TestMetadata("annotations.kt") + public void testAnnotations() throws Exception { + runTest("compiler/testData/diagnostics/tests/testsWithExplicitApi/annotations.kt"); + } + + @Test + @TestMetadata("classes.kt") + public void testClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/testsWithExplicitApi/classes.kt"); + } + + @Test + @TestMetadata("companionObject.kt") + public void testCompanionObject() throws Exception { + runTest("compiler/testData/diagnostics/tests/testsWithExplicitApi/companionObject.kt"); + } + + @Test + @TestMetadata("constructors.kt") + public void testConstructors() throws Exception { + runTest("compiler/testData/diagnostics/tests/testsWithExplicitApi/constructors.kt"); + } + + @Test + @TestMetadata("inlineClasses.kt") + public void testInlineClasses() throws Exception { + runTest("compiler/testData/diagnostics/tests/testsWithExplicitApi/inlineClasses.kt"); + } + + @Test + @TestMetadata("interfaces.kt") + public void testInterfaces() throws Exception { + runTest("compiler/testData/diagnostics/tests/testsWithExplicitApi/interfaces.kt"); + } + + @Test + @TestMetadata("mustBeEffectivelyPublic.kt") + public void testMustBeEffectivelyPublic() throws Exception { + runTest("compiler/testData/diagnostics/tests/testsWithExplicitApi/mustBeEffectivelyPublic.kt"); + } + + @Test + @TestMetadata("properties.kt") + public void testProperties() throws Exception { + runTest("compiler/testData/diagnostics/tests/testsWithExplicitApi/properties.kt"); + } + + @Test + @TestMetadata("publishedApi.kt") + public void testPublishedApi() throws Exception { + runTest("compiler/testData/diagnostics/tests/testsWithExplicitApi/publishedApi.kt"); + } + + @Test + @TestMetadata("toplevel.kt") + public void testToplevel() throws Exception { + runTest("compiler/testData/diagnostics/tests/testsWithExplicitApi/toplevel.kt"); + } + } + @Nested @TestMetadata("compiler/testData/diagnostics/tests/thisAndSuper") @TestDataPath("$PROJECT_ROOT") diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractDiagnosticTest.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractDiagnosticTest.kt index 9b304e7dd55..327321ba7b2 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractDiagnosticTest.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractDiagnosticTest.kt @@ -5,10 +5,13 @@ package org.jetbrains.kotlin.test.runners +import org.jetbrains.kotlin.config.ExplicitApiMode import org.jetbrains.kotlin.platform.jvm.JvmPlatforms import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder import org.jetbrains.kotlin.test.directives.JvmEnvironmentConfigurationDirectives.USE_PSI_CLASS_FILES_READING import org.jetbrains.kotlin.test.directives.JvmEnvironmentConfigurationDirectives.WITH_STDLIB +import org.jetbrains.kotlin.test.directives.LanguageSettingsDirectives +import org.jetbrains.kotlin.test.directives.LanguageSettingsDirectives.EXPLICIT_API_MODE import org.jetbrains.kotlin.test.frontend.classic.ClassicFrontendFacade import org.jetbrains.kotlin.test.frontend.classic.handlers.ClassicDiagnosticsHandler import org.jetbrains.kotlin.test.frontend.classic.handlers.DeclarationsDumpHandler @@ -61,5 +64,11 @@ abstract class AbstractDiagnosticTest : AbstractKotlinCompilerTest() { +WITH_STDLIB } } + + forTestsMatching("compiler/testData/diagnostics/tests/testsWithExplicitApi/*") { + defaultDirectives { + EXPLICIT_API_MODE with ExplicitApiMode.STRICT + } + } } } diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractDiagnosticsWithExplicitApi.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractDiagnosticsWithExplicitApi.kt deleted file mode 100644 index a5fb332ffdd..00000000000 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractDiagnosticsWithExplicitApi.kt +++ /dev/null @@ -1,19 +0,0 @@ -/* - * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors. - * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. - */ - -package org.jetbrains.kotlin.checkers - -import org.jetbrains.kotlin.config.* -import org.jetbrains.kotlin.test.ConfigurationKind - -abstract class AbstractDiagnosticsWithExplicitApi : AbstractDiagnosticsTest() { - override fun defaultLanguageVersionSettings(): LanguageVersionSettings = - CompilerTestLanguageVersionSettings( - DEFAULT_DIAGNOSTIC_TESTS_FEATURES, - LanguageVersionSettingsImpl.DEFAULT.apiVersion, - LanguageVersionSettingsImpl.DEFAULT.languageVersion, - mapOf(AnalysisFlags.explicitApiMode to ExplicitApiMode.STRICT) - ) -} \ No newline at end of file diff --git a/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsWithExplicitApiGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsWithExplicitApiGenerated.java deleted file mode 100644 index 84418a4e773..00000000000 --- a/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsWithExplicitApiGenerated.java +++ /dev/null @@ -1,80 +0,0 @@ -/* - * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. - * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. - */ - -package org.jetbrains.kotlin.checkers; - -import com.intellij.testFramework.TestDataPath; -import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; -import org.jetbrains.kotlin.test.KotlinTestUtils; -import org.jetbrains.kotlin.test.TestMetadata; -import org.junit.runner.RunWith; - -import java.io.File; -import java.util.regex.Pattern; - -/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */ -@SuppressWarnings("all") -@TestMetadata("compiler/testData/diagnostics/testsWithExplicitApi") -@TestDataPath("$PROJECT_ROOT") -@RunWith(JUnit3RunnerWithInners.class) -public class DiagnosticsWithExplicitApiGenerated extends AbstractDiagnosticsWithExplicitApi { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - - public void testAllFilesPresentInTestsWithExplicitApi() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithExplicitApi"), Pattern.compile("^(.+)\\.kt$"), null, true); - } - - @TestMetadata("annotations.kt") - public void testAnnotations() throws Exception { - runTest("compiler/testData/diagnostics/testsWithExplicitApi/annotations.kt"); - } - - @TestMetadata("classes.kt") - public void testClasses() throws Exception { - runTest("compiler/testData/diagnostics/testsWithExplicitApi/classes.kt"); - } - - @TestMetadata("companionObject.kt") - public void testCompanionObject() throws Exception { - runTest("compiler/testData/diagnostics/testsWithExplicitApi/companionObject.kt"); - } - - @TestMetadata("constructors.kt") - public void testConstructors() throws Exception { - runTest("compiler/testData/diagnostics/testsWithExplicitApi/constructors.kt"); - } - - @TestMetadata("inlineClasses.kt") - public void testInlineClasses() throws Exception { - runTest("compiler/testData/diagnostics/testsWithExplicitApi/inlineClasses.kt"); - } - - @TestMetadata("interfaces.kt") - public void testInterfaces() throws Exception { - runTest("compiler/testData/diagnostics/testsWithExplicitApi/interfaces.kt"); - } - - @TestMetadata("mustBeEffectivelyPublic.kt") - public void testMustBeEffectivelyPublic() throws Exception { - runTest("compiler/testData/diagnostics/testsWithExplicitApi/mustBeEffectivelyPublic.kt"); - } - - @TestMetadata("properties.kt") - public void testProperties() throws Exception { - runTest("compiler/testData/diagnostics/testsWithExplicitApi/properties.kt"); - } - - @TestMetadata("publishedApi.kt") - public void testPublishedApi() throws Exception { - runTest("compiler/testData/diagnostics/testsWithExplicitApi/publishedApi.kt"); - } - - @TestMetadata("toplevel.kt") - public void testToplevel() throws Exception { - runTest("compiler/testData/diagnostics/testsWithExplicitApi/toplevel.kt"); - } -} diff --git a/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt b/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt index b6335d57f23..2dce736d5c3 100644 --- a/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt +++ b/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt @@ -92,10 +92,6 @@ fun main(args: Array) { model("diagnostics/testsWithUnsignedTypes") } - testClass { - model("diagnostics/testsWithExplicitApi") - } - testClass { model("diagnostics/testsWithJvmBackend", targetBackend = TargetBackend.JVM_OLD) } From b43fa94cb64fdec6b95a3dbcbaed9e53a070bb5f Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Wed, 9 Dec 2020 12:40:17 +0300 Subject: [PATCH 105/196] [TEST] Migrate AbstractDiagnosticsWithUnsignedTypes to new test runners --- .../allowedVarargsOfUnsignedTypes.fir.kt | 12 ++ .../allowedVarargsOfUnsignedTypes.kt | 0 .../allowedVarargsOfUnsignedTypes.txt | 0 ...allDefaultConstructorOfUnsignedType.fir.kt | 1 + .../callDefaultConstructorOfUnsignedType.kt | 2 +- .../callDefaultConstructorOfUnsignedType.txt | 0 .../conversionOfSignedToUnsigned.fir.kt | 69 ++++++++++ .../conversionOfSignedToUnsigned.kt | 6 +- .../conversionOfSignedToUnsigned.txt | 0 .../inferenceForSignedAndUnsignedTypes.fir.kt | 20 +++ .../inferenceForSignedAndUnsignedTypes.kt | 6 +- .../inferenceForSignedAndUnsignedTypes.txt | 0 ...onversionForUnsignedTypesOnReceiver.fir.kt | 14 ++ .../noConversionForUnsignedTypesOnReceiver.kt | 0 ...noConversionForUnsignedTypesOnReceiver.txt | 0 ...ResolutionForSignedAndUnsignedTypes.fir.kt | 35 +++++ ...loadResolutionForSignedAndUnsignedTypes.kt | 2 +- ...oadResolutionForSignedAndUnsignedTypes.txt | 0 ...oUnsignedConversionWithExpectedType.fir.kt | 65 +++++++++ ...nedToUnsignedConversionWithExpectedType.kt | 2 +- ...edToUnsignedConversionWithExpectedType.txt | 0 .../explicitUnsignedLongTypeCheck.fir.kt | 16 +++ .../explicitUnsignedLongTypeCheck.kt | 2 +- .../explicitUnsignedLongTypeCheck.txt | 0 .../forbiddenEqualsOnUnsignedTypes.fir.kt | 23 ++++ .../forbiddenEqualsOnUnsignedTypes.kt | 0 .../forbiddenEqualsOnUnsignedTypes.txt | 0 .../unsignedTypes/lateinitUnsignedType.fir.kt | 9 ++ .../unsignedTypes}/lateinitUnsignedType.kt | 0 .../unsignedTypes}/lateinitUnsignedType.txt | 0 .../overloadResolutionOfBasicOperations.kt | 1 + .../overloadResolutionOfBasicOperations.txt | 0 .../unsignedLiteralsInsideConstVals.kt | 1 + .../unsignedLiteralsInsideConstVals.txt | 0 .../unsignedLiteralsOn1_2.fir.kt | 6 + .../unsignedTypes}/unsignedLiteralsOn1_2.kt | 0 .../unsignedTypes}/unsignedLiteralsOn1_2.txt | 0 ...nsignedLiteralsOverflowSignedBorder.fir.kt | 25 ++++ .../unsignedLiteralsOverflowSignedBorder.kt | 2 +- .../unsignedLiteralsOverflowSignedBorder.txt | 0 .../unsignedLiteralsTypeCheck.fir.kt | 23 ++++ .../unsignedLiteralsTypeCheck.kt | 2 +- .../unsignedLiteralsTypeCheck.txt | 0 .../varargTypeToArrayTypeCheck.fir.kt | 7 + .../varargTypeToArrayTypeCheck.kt | 0 .../varargTypeToArrayTypeCheck.txt | 0 .../wrongLongSuffixForULong.fir.kt | 4 + .../unsignedTypes}/wrongLongSuffixForULong.kt | 0 .../wrongLongSuffixForULong.txt | 0 .../test/runners/DiagnosticTestGenerated.java | 122 +++++++++++++++++ ...irOldFrontendDiagnosticsTestGenerated.java | 122 +++++++++++++++++ .../test/runners/AbstractDiagnosticTest.kt | 9 +- .../test/runners/AbstractFirDiagnosticTest.kt | 4 +- .../AbstractDiagnosticsWithUnsignedTypes.kt | 27 ---- ...DiagnosticsWithUnsignedTypesGenerated.java | 128 ------------------ .../generators/tests/GenerateCompilerTests.kt | 4 - 56 files changed, 598 insertions(+), 173 deletions(-) create mode 100644 compiler/testData/diagnostics/tests/unsignedTypes/allowedVarargsOfUnsignedTypes.fir.kt rename compiler/testData/diagnostics/{testsWithUnsignedTypes => tests/unsignedTypes}/allowedVarargsOfUnsignedTypes.kt (100%) rename compiler/testData/diagnostics/{testsWithUnsignedTypes => tests/unsignedTypes}/allowedVarargsOfUnsignedTypes.txt (100%) create mode 100644 compiler/testData/diagnostics/tests/unsignedTypes/callDefaultConstructorOfUnsignedType.fir.kt rename compiler/testData/diagnostics/{testsWithUnsignedTypes => tests/unsignedTypes}/callDefaultConstructorOfUnsignedType.kt (92%) rename compiler/testData/diagnostics/{testsWithUnsignedTypes => tests/unsignedTypes}/callDefaultConstructorOfUnsignedType.txt (100%) create mode 100644 compiler/testData/diagnostics/tests/unsignedTypes/conversions/conversionOfSignedToUnsigned.fir.kt rename compiler/testData/diagnostics/{testsWithUnsignedTypes => tests/unsignedTypes}/conversions/conversionOfSignedToUnsigned.kt (92%) rename compiler/testData/diagnostics/{testsWithUnsignedTypes => tests/unsignedTypes}/conversions/conversionOfSignedToUnsigned.txt (100%) create mode 100644 compiler/testData/diagnostics/tests/unsignedTypes/conversions/inferenceForSignedAndUnsignedTypes.fir.kt rename compiler/testData/diagnostics/{testsWithUnsignedTypes => tests/unsignedTypes}/conversions/inferenceForSignedAndUnsignedTypes.kt (69%) rename compiler/testData/diagnostics/{testsWithUnsignedTypes => tests/unsignedTypes}/conversions/inferenceForSignedAndUnsignedTypes.txt (100%) create mode 100644 compiler/testData/diagnostics/tests/unsignedTypes/conversions/noConversionForUnsignedTypesOnReceiver.fir.kt rename compiler/testData/diagnostics/{testsWithUnsignedTypes => tests/unsignedTypes}/conversions/noConversionForUnsignedTypesOnReceiver.kt (100%) rename compiler/testData/diagnostics/{testsWithUnsignedTypes => tests/unsignedTypes}/conversions/noConversionForUnsignedTypesOnReceiver.txt (100%) create mode 100644 compiler/testData/diagnostics/tests/unsignedTypes/conversions/overloadResolutionForSignedAndUnsignedTypes.fir.kt rename compiler/testData/diagnostics/{testsWithUnsignedTypes => tests/unsignedTypes}/conversions/overloadResolutionForSignedAndUnsignedTypes.kt (99%) rename compiler/testData/diagnostics/{testsWithUnsignedTypes => tests/unsignedTypes}/conversions/overloadResolutionForSignedAndUnsignedTypes.txt (100%) create mode 100644 compiler/testData/diagnostics/tests/unsignedTypes/conversions/signedToUnsignedConversionWithExpectedType.fir.kt rename compiler/testData/diagnostics/{testsWithUnsignedTypes => tests/unsignedTypes}/conversions/signedToUnsignedConversionWithExpectedType.kt (96%) rename compiler/testData/diagnostics/{testsWithUnsignedTypes => tests/unsignedTypes}/conversions/signedToUnsignedConversionWithExpectedType.txt (100%) create mode 100644 compiler/testData/diagnostics/tests/unsignedTypes/explicitUnsignedLongTypeCheck.fir.kt rename compiler/testData/diagnostics/{testsWithUnsignedTypes => tests/unsignedTypes}/explicitUnsignedLongTypeCheck.kt (99%) rename compiler/testData/diagnostics/{testsWithUnsignedTypes => tests/unsignedTypes}/explicitUnsignedLongTypeCheck.txt (100%) create mode 100644 compiler/testData/diagnostics/tests/unsignedTypes/forbiddenEqualsOnUnsignedTypes.fir.kt rename compiler/testData/diagnostics/{testsWithUnsignedTypes => tests/unsignedTypes}/forbiddenEqualsOnUnsignedTypes.kt (100%) rename compiler/testData/diagnostics/{testsWithUnsignedTypes => tests/unsignedTypes}/forbiddenEqualsOnUnsignedTypes.txt (100%) create mode 100644 compiler/testData/diagnostics/tests/unsignedTypes/lateinitUnsignedType.fir.kt rename compiler/testData/diagnostics/{testsWithUnsignedTypes => tests/unsignedTypes}/lateinitUnsignedType.kt (100%) rename compiler/testData/diagnostics/{testsWithUnsignedTypes => tests/unsignedTypes}/lateinitUnsignedType.txt (100%) rename compiler/testData/diagnostics/{testsWithUnsignedTypes => tests/unsignedTypes}/overloadResolutionOfBasicOperations.kt (84%) rename compiler/testData/diagnostics/{testsWithUnsignedTypes => tests/unsignedTypes}/overloadResolutionOfBasicOperations.txt (100%) rename compiler/testData/diagnostics/{testsWithUnsignedTypes => tests/unsignedTypes}/unsignedLiteralsInsideConstVals.kt (93%) rename compiler/testData/diagnostics/{testsWithUnsignedTypes => tests/unsignedTypes}/unsignedLiteralsInsideConstVals.txt (100%) create mode 100644 compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsOn1_2.fir.kt rename compiler/testData/diagnostics/{testsWithUnsignedTypes => tests/unsignedTypes}/unsignedLiteralsOn1_2.kt (100%) rename compiler/testData/diagnostics/{testsWithUnsignedTypes => tests/unsignedTypes}/unsignedLiteralsOn1_2.txt (100%) create mode 100644 compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsOverflowSignedBorder.fir.kt rename compiler/testData/diagnostics/{testsWithUnsignedTypes => tests/unsignedTypes}/unsignedLiteralsOverflowSignedBorder.kt (89%) rename compiler/testData/diagnostics/{testsWithUnsignedTypes => tests/unsignedTypes}/unsignedLiteralsOverflowSignedBorder.txt (100%) create mode 100644 compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsTypeCheck.fir.kt rename compiler/testData/diagnostics/{testsWithUnsignedTypes => tests/unsignedTypes}/unsignedLiteralsTypeCheck.kt (95%) rename compiler/testData/diagnostics/{testsWithUnsignedTypes => tests/unsignedTypes}/unsignedLiteralsTypeCheck.txt (100%) create mode 100644 compiler/testData/diagnostics/tests/unsignedTypes/varargTypeToArrayTypeCheck.fir.kt rename compiler/testData/diagnostics/{testsWithUnsignedTypes => tests/unsignedTypes}/varargTypeToArrayTypeCheck.kt (100%) rename compiler/testData/diagnostics/{testsWithUnsignedTypes => tests/unsignedTypes}/varargTypeToArrayTypeCheck.txt (100%) create mode 100644 compiler/testData/diagnostics/tests/unsignedTypes/wrongLongSuffixForULong.fir.kt rename compiler/testData/diagnostics/{testsWithUnsignedTypes => tests/unsignedTypes}/wrongLongSuffixForULong.kt (100%) rename compiler/testData/diagnostics/{testsWithUnsignedTypes => tests/unsignedTypes}/wrongLongSuffixForULong.txt (100%) delete mode 100644 compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractDiagnosticsWithUnsignedTypes.kt delete mode 100644 compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsWithUnsignedTypesGenerated.java diff --git a/compiler/testData/diagnostics/tests/unsignedTypes/allowedVarargsOfUnsignedTypes.fir.kt b/compiler/testData/diagnostics/tests/unsignedTypes/allowedVarargsOfUnsignedTypes.fir.kt new file mode 100644 index 00000000000..5663d51289c --- /dev/null +++ b/compiler/testData/diagnostics/tests/unsignedTypes/allowedVarargsOfUnsignedTypes.fir.kt @@ -0,0 +1,12 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER + +fun ubyte(vararg a: UByte) {} +fun ushort(vararg a: UShort) {} +fun uint(vararg a: UInt) {} +fun ulong(vararg a: ULong) {} + +class ValueParam(vararg val a: ULong) + +annotation class Ann(vararg val a: UInt) + +fun array(vararg a: UIntArray) {} diff --git a/compiler/testData/diagnostics/testsWithUnsignedTypes/allowedVarargsOfUnsignedTypes.kt b/compiler/testData/diagnostics/tests/unsignedTypes/allowedVarargsOfUnsignedTypes.kt similarity index 100% rename from compiler/testData/diagnostics/testsWithUnsignedTypes/allowedVarargsOfUnsignedTypes.kt rename to compiler/testData/diagnostics/tests/unsignedTypes/allowedVarargsOfUnsignedTypes.kt diff --git a/compiler/testData/diagnostics/testsWithUnsignedTypes/allowedVarargsOfUnsignedTypes.txt b/compiler/testData/diagnostics/tests/unsignedTypes/allowedVarargsOfUnsignedTypes.txt similarity index 100% rename from compiler/testData/diagnostics/testsWithUnsignedTypes/allowedVarargsOfUnsignedTypes.txt rename to compiler/testData/diagnostics/tests/unsignedTypes/allowedVarargsOfUnsignedTypes.txt diff --git a/compiler/testData/diagnostics/tests/unsignedTypes/callDefaultConstructorOfUnsignedType.fir.kt b/compiler/testData/diagnostics/tests/unsignedTypes/callDefaultConstructorOfUnsignedType.fir.kt new file mode 100644 index 00000000000..cb8bae9af5b --- /dev/null +++ b/compiler/testData/diagnostics/tests/unsignedTypes/callDefaultConstructorOfUnsignedType.fir.kt @@ -0,0 +1 @@ +val foo = UInt() diff --git a/compiler/testData/diagnostics/testsWithUnsignedTypes/callDefaultConstructorOfUnsignedType.kt b/compiler/testData/diagnostics/tests/unsignedTypes/callDefaultConstructorOfUnsignedType.kt similarity index 92% rename from compiler/testData/diagnostics/testsWithUnsignedTypes/callDefaultConstructorOfUnsignedType.kt rename to compiler/testData/diagnostics/tests/unsignedTypes/callDefaultConstructorOfUnsignedType.kt index dc90b5324df..a191c65a447 100644 --- a/compiler/testData/diagnostics/testsWithUnsignedTypes/callDefaultConstructorOfUnsignedType.kt +++ b/compiler/testData/diagnostics/tests/unsignedTypes/callDefaultConstructorOfUnsignedType.kt @@ -1 +1 @@ -val foo = UInt() \ No newline at end of file +val foo = UInt() diff --git a/compiler/testData/diagnostics/testsWithUnsignedTypes/callDefaultConstructorOfUnsignedType.txt b/compiler/testData/diagnostics/tests/unsignedTypes/callDefaultConstructorOfUnsignedType.txt similarity index 100% rename from compiler/testData/diagnostics/testsWithUnsignedTypes/callDefaultConstructorOfUnsignedType.txt rename to compiler/testData/diagnostics/tests/unsignedTypes/callDefaultConstructorOfUnsignedType.txt diff --git a/compiler/testData/diagnostics/tests/unsignedTypes/conversions/conversionOfSignedToUnsigned.fir.kt b/compiler/testData/diagnostics/tests/unsignedTypes/conversions/conversionOfSignedToUnsigned.fir.kt new file mode 100644 index 00000000000..41cfd451177 --- /dev/null +++ b/compiler/testData/diagnostics/tests/unsignedTypes/conversions/conversionOfSignedToUnsigned.fir.kt @@ -0,0 +1,69 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER +// !WITH_NEW_INFERENCE + +// FILE: annotation.kt + +package kotlin.internal + +annotation class ImplicitIntegerCoercion + +// FILE: test.kt + +import kotlin.internal.ImplicitIntegerCoercion + +@ImplicitIntegerCoercion +const val IMPLICIT_INT = 255 + +@ImplicitIntegerCoercion +const val EXPLICIT_INT: Int = 255 + +@ImplicitIntegerCoercion +const val LONG_CONST = 255L + +@ImplicitIntegerCoercion +val NON_CONST = 255 + +@ImplicitIntegerCoercion +const val BIGGER_THAN_UBYTE = 256 + +@ImplicitIntegerCoercion +const val UINT_CONST = 42u + +fun takeUByte(@ImplicitIntegerCoercion u: UByte) {} +fun takeUShort(@ImplicitIntegerCoercion u: UShort) {} +fun takeUInt(@ImplicitIntegerCoercion u: UInt) {} +fun takeULong(@ImplicitIntegerCoercion u: ULong) {} + +fun takeUBytes(@ImplicitIntegerCoercion vararg u: UByte) {} + +fun takeLong(@ImplicitIntegerCoercion l: Long) {} + +fun takeUIntWithoutAnnotaion(u: UInt) {} + +fun takeIntWithoutAnnotation(i: Int) {} + +fun test() { + takeUByte(IMPLICIT_INT) + takeUByte(EXPLICIT_INT) + + takeUShort(IMPLICIT_INT) + takeUShort(BIGGER_THAN_UBYTE) + + takeUInt(IMPLICIT_INT) + + takeULong(IMPLICIT_INT) + + takeUBytes(IMPLICIT_INT, EXPLICIT_INT, 42u) + + takeLong(IMPLICIT_INT) + + takeIntWithoutAnnotation(IMPLICIT_INT) + + takeUIntWithoutAnnotaion(UINT_CONST) + + takeUByte(LONG_CONST) + takeUByte(NON_CONST) + takeUByte(BIGGER_THAN_UBYTE) + takeUByte(UINT_CONST) + takeUIntWithoutAnnotaion(IMPLICIT_INT) +} diff --git a/compiler/testData/diagnostics/testsWithUnsignedTypes/conversions/conversionOfSignedToUnsigned.kt b/compiler/testData/diagnostics/tests/unsignedTypes/conversions/conversionOfSignedToUnsigned.kt similarity index 92% rename from compiler/testData/diagnostics/testsWithUnsignedTypes/conversions/conversionOfSignedToUnsigned.kt rename to compiler/testData/diagnostics/tests/unsignedTypes/conversions/conversionOfSignedToUnsigned.kt index 1f3f5ccb3b5..f3b19824d1e 100644 --- a/compiler/testData/diagnostics/testsWithUnsignedTypes/conversions/conversionOfSignedToUnsigned.kt +++ b/compiler/testData/diagnostics/tests/unsignedTypes/conversions/conversionOfSignedToUnsigned.kt @@ -55,7 +55,7 @@ fun test() { takeUBytes(IMPLICIT_INT, EXPLICIT_INT, 42u) - takeLong(IMPLICIT_INT) + takeLong(IMPLICIT_INT) takeIntWithoutAnnotation(IMPLICIT_INT) @@ -63,7 +63,7 @@ fun test() { takeUByte(LONG_CONST) takeUByte(NON_CONST) - takeUByte(BIGGER_THAN_UBYTE) + takeUByte(BIGGER_THAN_UBYTE) takeUByte(UINT_CONST) takeUIntWithoutAnnotaion(IMPLICIT_INT) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithUnsignedTypes/conversions/conversionOfSignedToUnsigned.txt b/compiler/testData/diagnostics/tests/unsignedTypes/conversions/conversionOfSignedToUnsigned.txt similarity index 100% rename from compiler/testData/diagnostics/testsWithUnsignedTypes/conversions/conversionOfSignedToUnsigned.txt rename to compiler/testData/diagnostics/tests/unsignedTypes/conversions/conversionOfSignedToUnsigned.txt diff --git a/compiler/testData/diagnostics/tests/unsignedTypes/conversions/inferenceForSignedAndUnsignedTypes.fir.kt b/compiler/testData/diagnostics/tests/unsignedTypes/conversions/inferenceForSignedAndUnsignedTypes.fir.kt new file mode 100644 index 00000000000..7b1e8c134a6 --- /dev/null +++ b/compiler/testData/diagnostics/tests/unsignedTypes/conversions/inferenceForSignedAndUnsignedTypes.fir.kt @@ -0,0 +1,20 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER, -UNUSED_VARIABLE +// !CHECK_TYPE +// !WITH_NEW_INFERENCE + +// Here we mostly trying to fix behaviour in order to track changes in inference rules for unsigned types later + +fun id(x: T): T = x +fun select(x: K, y: K): K = TODO() + +fun takeUByte(u: UByte) {} + +fun foo() { + select(1, 1u) checkType { _>() } + takeUByte(id(1)) + + 1 + 1u + (1u + 1) checkType { _() } + + id(1) +} diff --git a/compiler/testData/diagnostics/testsWithUnsignedTypes/conversions/inferenceForSignedAndUnsignedTypes.kt b/compiler/testData/diagnostics/tests/unsignedTypes/conversions/inferenceForSignedAndUnsignedTypes.kt similarity index 69% rename from compiler/testData/diagnostics/testsWithUnsignedTypes/conversions/inferenceForSignedAndUnsignedTypes.kt rename to compiler/testData/diagnostics/tests/unsignedTypes/conversions/inferenceForSignedAndUnsignedTypes.kt index 14a18f20ef5..021a76d7ccc 100644 --- a/compiler/testData/diagnostics/testsWithUnsignedTypes/conversions/inferenceForSignedAndUnsignedTypes.kt +++ b/compiler/testData/diagnostics/tests/unsignedTypes/conversions/inferenceForSignedAndUnsignedTypes.kt @@ -10,11 +10,11 @@ fun select(x: K, y: K): K = TODO() fun takeUByte(u: UByte) {} fun foo() { - select(1, 1u) checkType { _>() } - takeUByte(id(1)) + select(1, 1u) checkType { _>() } + takeUByte(id(1)) 1 + 1u (1u + 1) checkType { _() } id(1) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithUnsignedTypes/conversions/inferenceForSignedAndUnsignedTypes.txt b/compiler/testData/diagnostics/tests/unsignedTypes/conversions/inferenceForSignedAndUnsignedTypes.txt similarity index 100% rename from compiler/testData/diagnostics/testsWithUnsignedTypes/conversions/inferenceForSignedAndUnsignedTypes.txt rename to compiler/testData/diagnostics/tests/unsignedTypes/conversions/inferenceForSignedAndUnsignedTypes.txt diff --git a/compiler/testData/diagnostics/tests/unsignedTypes/conversions/noConversionForUnsignedTypesOnReceiver.fir.kt b/compiler/testData/diagnostics/tests/unsignedTypes/conversions/noConversionForUnsignedTypesOnReceiver.fir.kt new file mode 100644 index 00000000000..e99e8a597cc --- /dev/null +++ b/compiler/testData/diagnostics/tests/unsignedTypes/conversions/noConversionForUnsignedTypesOnReceiver.fir.kt @@ -0,0 +1,14 @@ +fun UInt.fUInt() {} +fun UByte.fUByte() {} +fun UShort.fUShort() {} +fun ULong.fULong() {} + +fun test() { + 1.fUInt() + 1.fUByte() + 1.fUShort() + 1.fULong() + + 3000000000 until 3000000004UL + 0 until 10u +} diff --git a/compiler/testData/diagnostics/testsWithUnsignedTypes/conversions/noConversionForUnsignedTypesOnReceiver.kt b/compiler/testData/diagnostics/tests/unsignedTypes/conversions/noConversionForUnsignedTypesOnReceiver.kt similarity index 100% rename from compiler/testData/diagnostics/testsWithUnsignedTypes/conversions/noConversionForUnsignedTypesOnReceiver.kt rename to compiler/testData/diagnostics/tests/unsignedTypes/conversions/noConversionForUnsignedTypesOnReceiver.kt diff --git a/compiler/testData/diagnostics/testsWithUnsignedTypes/conversions/noConversionForUnsignedTypesOnReceiver.txt b/compiler/testData/diagnostics/tests/unsignedTypes/conversions/noConversionForUnsignedTypesOnReceiver.txt similarity index 100% rename from compiler/testData/diagnostics/testsWithUnsignedTypes/conversions/noConversionForUnsignedTypesOnReceiver.txt rename to compiler/testData/diagnostics/tests/unsignedTypes/conversions/noConversionForUnsignedTypesOnReceiver.txt diff --git a/compiler/testData/diagnostics/tests/unsignedTypes/conversions/overloadResolutionForSignedAndUnsignedTypes.fir.kt b/compiler/testData/diagnostics/tests/unsignedTypes/conversions/overloadResolutionForSignedAndUnsignedTypes.fir.kt new file mode 100644 index 00000000000..4b5009d5183 --- /dev/null +++ b/compiler/testData/diagnostics/tests/unsignedTypes/conversions/overloadResolutionForSignedAndUnsignedTypes.fir.kt @@ -0,0 +1,35 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER +// !CHECK_TYPE + +fun foo(x: Int): Int = 0 + +fun foo(x: UInt): String = "" +fun foo(x: UByte): String = "" +fun foo(x: UShort): String = "" +fun foo(x: ULong): String = "" + +fun fooByte(x: Byte): Int = 0 +fun fooByte(x: UByte): String = "" + +fun fooShort(x: Short): Int = 0 +fun fooShort(x: UShort): String = "" + +fun fooLong(x: Long): Int = 0 +fun fooLong(x: ULong): String = "" + +fun test() { + foo(1) checkType { _() } + foo(1u) checkType { _() } + + foo(2147483648) checkType { _() } + foo(2147483647 + 1) checkType { _() } + + fooByte(1) checkType { _() } + fooByte(1u) checkType { _() } + + fooShort(1) checkType { _() } + fooShort(1u) checkType { _() } + + fooLong(1) checkType { _() } + fooLong(1u) checkType { _() } +} diff --git a/compiler/testData/diagnostics/testsWithUnsignedTypes/conversions/overloadResolutionForSignedAndUnsignedTypes.kt b/compiler/testData/diagnostics/tests/unsignedTypes/conversions/overloadResolutionForSignedAndUnsignedTypes.kt similarity index 99% rename from compiler/testData/diagnostics/testsWithUnsignedTypes/conversions/overloadResolutionForSignedAndUnsignedTypes.kt rename to compiler/testData/diagnostics/tests/unsignedTypes/conversions/overloadResolutionForSignedAndUnsignedTypes.kt index 7b625e5b14d..4d6a348c974 100644 --- a/compiler/testData/diagnostics/testsWithUnsignedTypes/conversions/overloadResolutionForSignedAndUnsignedTypes.kt +++ b/compiler/testData/diagnostics/tests/unsignedTypes/conversions/overloadResolutionForSignedAndUnsignedTypes.kt @@ -32,4 +32,4 @@ fun test() { fooLong(1) checkType { _() } fooLong(1u) checkType { _() } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithUnsignedTypes/conversions/overloadResolutionForSignedAndUnsignedTypes.txt b/compiler/testData/diagnostics/tests/unsignedTypes/conversions/overloadResolutionForSignedAndUnsignedTypes.txt similarity index 100% rename from compiler/testData/diagnostics/testsWithUnsignedTypes/conversions/overloadResolutionForSignedAndUnsignedTypes.txt rename to compiler/testData/diagnostics/tests/unsignedTypes/conversions/overloadResolutionForSignedAndUnsignedTypes.txt diff --git a/compiler/testData/diagnostics/tests/unsignedTypes/conversions/signedToUnsignedConversionWithExpectedType.fir.kt b/compiler/testData/diagnostics/tests/unsignedTypes/conversions/signedToUnsignedConversionWithExpectedType.fir.kt new file mode 100644 index 00000000000..0c918bf0301 --- /dev/null +++ b/compiler/testData/diagnostics/tests/unsignedTypes/conversions/signedToUnsignedConversionWithExpectedType.fir.kt @@ -0,0 +1,65 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER +// !WITH_NEW_INFERENCE + +fun takeUByte(u: UByte) {} +fun takeUShort(u: UShort) {} +fun takeUInt(u: UInt) {} +fun takeULong(u: ULong) {} + +fun takeUBytes(vararg u: UByte) {} + +fun takeNullableUInt(u: UInt?) {} + +fun test() { + takeUInt(1 + 2) + takeUInt(1.plus(2)) + takeNullableUInt(4) + + takeUInt(Int.MAX_VALUE * 2L) + takeUInt(-1) + takeUInt(Int.MAX_VALUE * 2L + 2) + + takeUByte(1) + takeUByte(255) + takeUByte(1.toByte()) + + takeUShort(1) + takeUInt(1) + takeULong(1) + + takeULong(18446744073709551615) + takeULong(1844674407370955161) + takeULong(18446744073709551615u) + + takeUInt(Int.MAX_VALUE * 2) + takeUInt(4294967294) + + takeUBytes(1, 2, 255, 256, 0, -1, 40 + 2) + + takeUInt(1.myPlus(2)) + + val localVariable = 42 + takeUInt(localVariable) + + var localMutableVariable = 42 + takeUInt(localMutableVariable) + + val localNegativeVariable = -1 + takeUInt(localNegativeVariable) + + takeUInt(globalVariable) + + takeUInt(constVal) + + takeUInt(globalVariableWithGetter) +} + +val globalVariable = 10 + +const val constVal = 10 + +val globalVariableWithGetter: Int get() = 0 + +val prop: UByte = 255 + +fun Int.myPlus(other: Int): Int = this + other diff --git a/compiler/testData/diagnostics/testsWithUnsignedTypes/conversions/signedToUnsignedConversionWithExpectedType.kt b/compiler/testData/diagnostics/tests/unsignedTypes/conversions/signedToUnsignedConversionWithExpectedType.kt similarity index 96% rename from compiler/testData/diagnostics/testsWithUnsignedTypes/conversions/signedToUnsignedConversionWithExpectedType.kt rename to compiler/testData/diagnostics/tests/unsignedTypes/conversions/signedToUnsignedConversionWithExpectedType.kt index 33c0b292a39..66f235dc915 100644 --- a/compiler/testData/diagnostics/testsWithUnsignedTypes/conversions/signedToUnsignedConversionWithExpectedType.kt +++ b/compiler/testData/diagnostics/tests/unsignedTypes/conversions/signedToUnsignedConversionWithExpectedType.kt @@ -27,7 +27,7 @@ fun test() { takeUInt(1) takeULong(1) - takeULong(18446744073709551615) + takeULong(18446744073709551615) takeULong(1844674407370955161) takeULong(18446744073709551615u) diff --git a/compiler/testData/diagnostics/testsWithUnsignedTypes/conversions/signedToUnsignedConversionWithExpectedType.txt b/compiler/testData/diagnostics/tests/unsignedTypes/conversions/signedToUnsignedConversionWithExpectedType.txt similarity index 100% rename from compiler/testData/diagnostics/testsWithUnsignedTypes/conversions/signedToUnsignedConversionWithExpectedType.txt rename to compiler/testData/diagnostics/tests/unsignedTypes/conversions/signedToUnsignedConversionWithExpectedType.txt diff --git a/compiler/testData/diagnostics/tests/unsignedTypes/explicitUnsignedLongTypeCheck.fir.kt b/compiler/testData/diagnostics/tests/unsignedTypes/explicitUnsignedLongTypeCheck.fir.kt new file mode 100644 index 00000000000..61cad031fbd --- /dev/null +++ b/compiler/testData/diagnostics/tests/unsignedTypes/explicitUnsignedLongTypeCheck.fir.kt @@ -0,0 +1,16 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER + +val a0: Int = 1uL +val a1: UInt = 1uL +val a3: ULong = 1uL +val a4 = 1UL + 2UL +val a5 = -1UL + +fun takeULong(u: ULong) {} + +fun test() { + takeULong(3UL) + takeULong(1UL + 3uL) + takeULong(1u + 0uL) + takeULong(1uL + 4u) +} diff --git a/compiler/testData/diagnostics/testsWithUnsignedTypes/explicitUnsignedLongTypeCheck.kt b/compiler/testData/diagnostics/tests/unsignedTypes/explicitUnsignedLongTypeCheck.kt similarity index 99% rename from compiler/testData/diagnostics/testsWithUnsignedTypes/explicitUnsignedLongTypeCheck.kt rename to compiler/testData/diagnostics/tests/unsignedTypes/explicitUnsignedLongTypeCheck.kt index ab4586d8de2..84119d21c34 100644 --- a/compiler/testData/diagnostics/testsWithUnsignedTypes/explicitUnsignedLongTypeCheck.kt +++ b/compiler/testData/diagnostics/tests/unsignedTypes/explicitUnsignedLongTypeCheck.kt @@ -13,4 +13,4 @@ fun test() { takeULong(1UL + 3uL) takeULong(1u + 0uL) takeULong(1uL + 4u) -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithUnsignedTypes/explicitUnsignedLongTypeCheck.txt b/compiler/testData/diagnostics/tests/unsignedTypes/explicitUnsignedLongTypeCheck.txt similarity index 100% rename from compiler/testData/diagnostics/testsWithUnsignedTypes/explicitUnsignedLongTypeCheck.txt rename to compiler/testData/diagnostics/tests/unsignedTypes/explicitUnsignedLongTypeCheck.txt diff --git a/compiler/testData/diagnostics/tests/unsignedTypes/forbiddenEqualsOnUnsignedTypes.fir.kt b/compiler/testData/diagnostics/tests/unsignedTypes/forbiddenEqualsOnUnsignedTypes.fir.kt new file mode 100644 index 00000000000..f46d32673a7 --- /dev/null +++ b/compiler/testData/diagnostics/tests/unsignedTypes/forbiddenEqualsOnUnsignedTypes.fir.kt @@ -0,0 +1,23 @@ +// !DIAGNOSTICS: -UNUSED_VARIABLE + +fun test( + ub1: UByte, ub2: UByte, + us1: UShort, us2: UShort, + ui1: UInt, ui2: UInt, + ul1: ULong, ul2: ULong +) { + val ub = ub1 === ub2 || ub1 !== ub2 + val us = us1 === us2 || us1 !== us2 + val ui = ui1 === ui2 || ui1 !== ui2 + val ul = ul1 === ul2 || ul1 !== ul2 + + val u = ub1 === ul1 + + val a1 = 1u === 2u || 1u !== 2u + val a2 = 0xFFFF_FFFF_FFFF_FFFFu === 0xFFFF_FFFF_FFFF_FFFFu + + val bu1 = 1u + val bu2 = 1u + + val c1 = bu1 === bu2 || bu1 !== bu2 +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/testsWithUnsignedTypes/forbiddenEqualsOnUnsignedTypes.kt b/compiler/testData/diagnostics/tests/unsignedTypes/forbiddenEqualsOnUnsignedTypes.kt similarity index 100% rename from compiler/testData/diagnostics/testsWithUnsignedTypes/forbiddenEqualsOnUnsignedTypes.kt rename to compiler/testData/diagnostics/tests/unsignedTypes/forbiddenEqualsOnUnsignedTypes.kt diff --git a/compiler/testData/diagnostics/testsWithUnsignedTypes/forbiddenEqualsOnUnsignedTypes.txt b/compiler/testData/diagnostics/tests/unsignedTypes/forbiddenEqualsOnUnsignedTypes.txt similarity index 100% rename from compiler/testData/diagnostics/testsWithUnsignedTypes/forbiddenEqualsOnUnsignedTypes.txt rename to compiler/testData/diagnostics/tests/unsignedTypes/forbiddenEqualsOnUnsignedTypes.txt diff --git a/compiler/testData/diagnostics/tests/unsignedTypes/lateinitUnsignedType.fir.kt b/compiler/testData/diagnostics/tests/unsignedTypes/lateinitUnsignedType.fir.kt new file mode 100644 index 00000000000..8a7cd8b6da2 --- /dev/null +++ b/compiler/testData/diagnostics/tests/unsignedTypes/lateinitUnsignedType.fir.kt @@ -0,0 +1,9 @@ +// !DIAGNOSTICS: -UNUSED_VARIABLE + +lateinit var a: UInt + +fun foo() { + lateinit var b: UByte + lateinit var c: UShort + lateinit var d: ULong +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/testsWithUnsignedTypes/lateinitUnsignedType.kt b/compiler/testData/diagnostics/tests/unsignedTypes/lateinitUnsignedType.kt similarity index 100% rename from compiler/testData/diagnostics/testsWithUnsignedTypes/lateinitUnsignedType.kt rename to compiler/testData/diagnostics/tests/unsignedTypes/lateinitUnsignedType.kt diff --git a/compiler/testData/diagnostics/testsWithUnsignedTypes/lateinitUnsignedType.txt b/compiler/testData/diagnostics/tests/unsignedTypes/lateinitUnsignedType.txt similarity index 100% rename from compiler/testData/diagnostics/testsWithUnsignedTypes/lateinitUnsignedType.txt rename to compiler/testData/diagnostics/tests/unsignedTypes/lateinitUnsignedType.txt diff --git a/compiler/testData/diagnostics/testsWithUnsignedTypes/overloadResolutionOfBasicOperations.kt b/compiler/testData/diagnostics/tests/unsignedTypes/overloadResolutionOfBasicOperations.kt similarity index 84% rename from compiler/testData/diagnostics/testsWithUnsignedTypes/overloadResolutionOfBasicOperations.kt rename to compiler/testData/diagnostics/tests/unsignedTypes/overloadResolutionOfBasicOperations.kt index 5ca1f23054a..099bddfc8b4 100644 --- a/compiler/testData/diagnostics/testsWithUnsignedTypes/overloadResolutionOfBasicOperations.kt +++ b/compiler/testData/diagnostics/tests/unsignedTypes/overloadResolutionOfBasicOperations.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // !DIAGNOSTICS: -UNUSED_VARIABLE fun test() { diff --git a/compiler/testData/diagnostics/testsWithUnsignedTypes/overloadResolutionOfBasicOperations.txt b/compiler/testData/diagnostics/tests/unsignedTypes/overloadResolutionOfBasicOperations.txt similarity index 100% rename from compiler/testData/diagnostics/testsWithUnsignedTypes/overloadResolutionOfBasicOperations.txt rename to compiler/testData/diagnostics/tests/unsignedTypes/overloadResolutionOfBasicOperations.txt diff --git a/compiler/testData/diagnostics/testsWithUnsignedTypes/unsignedLiteralsInsideConstVals.kt b/compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsInsideConstVals.kt similarity index 93% rename from compiler/testData/diagnostics/testsWithUnsignedTypes/unsignedLiteralsInsideConstVals.kt rename to compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsInsideConstVals.kt index e8adca0b21a..47dea5411c1 100644 --- a/compiler/testData/diagnostics/testsWithUnsignedTypes/unsignedLiteralsInsideConstVals.kt +++ b/compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsInsideConstVals.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL const val u0 = 1u const val u1: UByte = 2u diff --git a/compiler/testData/diagnostics/testsWithUnsignedTypes/unsignedLiteralsInsideConstVals.txt b/compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsInsideConstVals.txt similarity index 100% rename from compiler/testData/diagnostics/testsWithUnsignedTypes/unsignedLiteralsInsideConstVals.txt rename to compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsInsideConstVals.txt diff --git a/compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsOn1_2.fir.kt b/compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsOn1_2.fir.kt new file mode 100644 index 00000000000..383f68b2f9e --- /dev/null +++ b/compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsOn1_2.fir.kt @@ -0,0 +1,6 @@ +// !API_VERSION: 1.2 + +val a = 0u +val b = 1uL + +fun foo(u: UInt) {} \ No newline at end of file diff --git a/compiler/testData/diagnostics/testsWithUnsignedTypes/unsignedLiteralsOn1_2.kt b/compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsOn1_2.kt similarity index 100% rename from compiler/testData/diagnostics/testsWithUnsignedTypes/unsignedLiteralsOn1_2.kt rename to compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsOn1_2.kt diff --git a/compiler/testData/diagnostics/testsWithUnsignedTypes/unsignedLiteralsOn1_2.txt b/compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsOn1_2.txt similarity index 100% rename from compiler/testData/diagnostics/testsWithUnsignedTypes/unsignedLiteralsOn1_2.txt rename to compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsOn1_2.txt diff --git a/compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsOverflowSignedBorder.fir.kt b/compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsOverflowSignedBorder.fir.kt new file mode 100644 index 00000000000..e415c35032d --- /dev/null +++ b/compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsOverflowSignedBorder.fir.kt @@ -0,0 +1,25 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER + +const val u1: UByte = 0xFFu +const val u2: UShort = 0xFFFFu +const val u3: UInt = 0xFFFF_FFFFu +const val u4: ULong = 0xFFFF_FFFF_FFFF_FFFFu +const val u5: ULong = 18446744073709551615u + +const val u6 = 0xFFFF_FFFF_FFFF_FFFFu +const val u7 = 18446744073709551615u + +val u8: Comparable<*> = 0xFFFF_FFFF_FFFF_FFFFu + +const val u9 = 0xFFFF_FFFF_FFFF_FFFFUL + +fun takeUByte(ubyte: UByte) {} + +fun test() { + takeUByte(200u) + takeUByte(255u) + takeUByte(0xFFu) +} + +val s1: UByte = 256u +val s2 = 18446744073709551616u diff --git a/compiler/testData/diagnostics/testsWithUnsignedTypes/unsignedLiteralsOverflowSignedBorder.kt b/compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsOverflowSignedBorder.kt similarity index 89% rename from compiler/testData/diagnostics/testsWithUnsignedTypes/unsignedLiteralsOverflowSignedBorder.kt rename to compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsOverflowSignedBorder.kt index 15fd33ffa34..2cb71bac380 100644 --- a/compiler/testData/diagnostics/testsWithUnsignedTypes/unsignedLiteralsOverflowSignedBorder.kt +++ b/compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsOverflowSignedBorder.kt @@ -22,4 +22,4 @@ fun test() { } val s1: UByte = 256u -val s2 = 18446744073709551616u \ No newline at end of file +val s2 = 18446744073709551616u diff --git a/compiler/testData/diagnostics/testsWithUnsignedTypes/unsignedLiteralsOverflowSignedBorder.txt b/compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsOverflowSignedBorder.txt similarity index 100% rename from compiler/testData/diagnostics/testsWithUnsignedTypes/unsignedLiteralsOverflowSignedBorder.txt rename to compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsOverflowSignedBorder.txt diff --git a/compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsTypeCheck.fir.kt b/compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsTypeCheck.fir.kt new file mode 100644 index 00000000000..95efec7db89 --- /dev/null +++ b/compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsTypeCheck.fir.kt @@ -0,0 +1,23 @@ + +val a0: Any = 1u + +val n0: Number = 1u + +val c0: Comparable<*> = 1u +val c1: Comparable = 1u + +val u0: UInt = 1u +val u1: UInt? = 1u +val u2: UInt? = u0 +val u3: UInt? = u1 + +val i0: Int = 1u + +val m0 = -1u +val m1: UInt = -1u + +val h1 = 0xFFu +val h2: UShort = 0xFFu + +val b1 = 0b11u +val b2: UByte = 0b11u diff --git a/compiler/testData/diagnostics/testsWithUnsignedTypes/unsignedLiteralsTypeCheck.kt b/compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsTypeCheck.kt similarity index 95% rename from compiler/testData/diagnostics/testsWithUnsignedTypes/unsignedLiteralsTypeCheck.kt rename to compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsTypeCheck.kt index 87cd195259a..f5522208a24 100644 --- a/compiler/testData/diagnostics/testsWithUnsignedTypes/unsignedLiteralsTypeCheck.kt +++ b/compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsTypeCheck.kt @@ -20,4 +20,4 @@ val h1 = 0xFFu val h2: UShort = 0xFFu val b1 = 0b11u -val b2: UByte = 0b11u \ No newline at end of file +val b2: UByte = 0b11u diff --git a/compiler/testData/diagnostics/testsWithUnsignedTypes/unsignedLiteralsTypeCheck.txt b/compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsTypeCheck.txt similarity index 100% rename from compiler/testData/diagnostics/testsWithUnsignedTypes/unsignedLiteralsTypeCheck.txt rename to compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsTypeCheck.txt diff --git a/compiler/testData/diagnostics/tests/unsignedTypes/varargTypeToArrayTypeCheck.fir.kt b/compiler/testData/diagnostics/tests/unsignedTypes/varargTypeToArrayTypeCheck.fir.kt new file mode 100644 index 00000000000..9a96a3978f9 --- /dev/null +++ b/compiler/testData/diagnostics/tests/unsignedTypes/varargTypeToArrayTypeCheck.fir.kt @@ -0,0 +1,7 @@ + +fun ubyte(vararg a: UByte): UByteArray = a +fun ushort(vararg a: UShort): UShortArray = a +fun uint(vararg a: UInt): UIntArray = a +fun ulong(vararg a: ULong): ULongArray = a + +fun rawUInt(vararg a: UInt): IntArray = a diff --git a/compiler/testData/diagnostics/testsWithUnsignedTypes/varargTypeToArrayTypeCheck.kt b/compiler/testData/diagnostics/tests/unsignedTypes/varargTypeToArrayTypeCheck.kt similarity index 100% rename from compiler/testData/diagnostics/testsWithUnsignedTypes/varargTypeToArrayTypeCheck.kt rename to compiler/testData/diagnostics/tests/unsignedTypes/varargTypeToArrayTypeCheck.kt diff --git a/compiler/testData/diagnostics/testsWithUnsignedTypes/varargTypeToArrayTypeCheck.txt b/compiler/testData/diagnostics/tests/unsignedTypes/varargTypeToArrayTypeCheck.txt similarity index 100% rename from compiler/testData/diagnostics/testsWithUnsignedTypes/varargTypeToArrayTypeCheck.txt rename to compiler/testData/diagnostics/tests/unsignedTypes/varargTypeToArrayTypeCheck.txt diff --git a/compiler/testData/diagnostics/tests/unsignedTypes/wrongLongSuffixForULong.fir.kt b/compiler/testData/diagnostics/tests/unsignedTypes/wrongLongSuffixForULong.fir.kt new file mode 100644 index 00000000000..144f0b45fa0 --- /dev/null +++ b/compiler/testData/diagnostics/tests/unsignedTypes/wrongLongSuffixForULong.fir.kt @@ -0,0 +1,4 @@ +val a1 = 1ul +val a2 = 0x1ul +val a3 = 0B1ul +val a4 = 1Ul diff --git a/compiler/testData/diagnostics/testsWithUnsignedTypes/wrongLongSuffixForULong.kt b/compiler/testData/diagnostics/tests/unsignedTypes/wrongLongSuffixForULong.kt similarity index 100% rename from compiler/testData/diagnostics/testsWithUnsignedTypes/wrongLongSuffixForULong.kt rename to compiler/testData/diagnostics/tests/unsignedTypes/wrongLongSuffixForULong.kt diff --git a/compiler/testData/diagnostics/testsWithUnsignedTypes/wrongLongSuffixForULong.txt b/compiler/testData/diagnostics/tests/unsignedTypes/wrongLongSuffixForULong.txt similarity index 100% rename from compiler/testData/diagnostics/testsWithUnsignedTypes/wrongLongSuffixForULong.txt rename to compiler/testData/diagnostics/tests/unsignedTypes/wrongLongSuffixForULong.txt diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java index 2856c0b0511..d8d5700976e 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java @@ -29280,6 +29280,128 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { } } + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/unsignedTypes") + @TestDataPath("$PROJECT_ROOT") + public class UnsignedTypes extends AbstractDiagnosticTest { + @Test + public void testAllFilesPresentInUnsignedTypes() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/unsignedTypes"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + } + + @Test + @TestMetadata("allowedVarargsOfUnsignedTypes.kt") + public void testAllowedVarargsOfUnsignedTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/unsignedTypes/allowedVarargsOfUnsignedTypes.kt"); + } + + @Test + @TestMetadata("callDefaultConstructorOfUnsignedType.kt") + public void testCallDefaultConstructorOfUnsignedType() throws Exception { + runTest("compiler/testData/diagnostics/tests/unsignedTypes/callDefaultConstructorOfUnsignedType.kt"); + } + + @Test + @TestMetadata("explicitUnsignedLongTypeCheck.kt") + public void testExplicitUnsignedLongTypeCheck() throws Exception { + runTest("compiler/testData/diagnostics/tests/unsignedTypes/explicitUnsignedLongTypeCheck.kt"); + } + + @Test + @TestMetadata("forbiddenEqualsOnUnsignedTypes.kt") + public void testForbiddenEqualsOnUnsignedTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/unsignedTypes/forbiddenEqualsOnUnsignedTypes.kt"); + } + + @Test + @TestMetadata("lateinitUnsignedType.kt") + public void testLateinitUnsignedType() throws Exception { + runTest("compiler/testData/diagnostics/tests/unsignedTypes/lateinitUnsignedType.kt"); + } + + @Test + @TestMetadata("overloadResolutionOfBasicOperations.kt") + public void testOverloadResolutionOfBasicOperations() throws Exception { + runTest("compiler/testData/diagnostics/tests/unsignedTypes/overloadResolutionOfBasicOperations.kt"); + } + + @Test + @TestMetadata("unsignedLiteralsInsideConstVals.kt") + public void testUnsignedLiteralsInsideConstVals() throws Exception { + runTest("compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsInsideConstVals.kt"); + } + + @Test + @TestMetadata("unsignedLiteralsOn1_2.kt") + public void testUnsignedLiteralsOn1_2() throws Exception { + runTest("compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsOn1_2.kt"); + } + + @Test + @TestMetadata("unsignedLiteralsOverflowSignedBorder.kt") + public void testUnsignedLiteralsOverflowSignedBorder() throws Exception { + runTest("compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsOverflowSignedBorder.kt"); + } + + @Test + @TestMetadata("unsignedLiteralsTypeCheck.kt") + public void testUnsignedLiteralsTypeCheck() throws Exception { + runTest("compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsTypeCheck.kt"); + } + + @Test + @TestMetadata("varargTypeToArrayTypeCheck.kt") + public void testVarargTypeToArrayTypeCheck() throws Exception { + runTest("compiler/testData/diagnostics/tests/unsignedTypes/varargTypeToArrayTypeCheck.kt"); + } + + @Test + @TestMetadata("wrongLongSuffixForULong.kt") + public void testWrongLongSuffixForULong() throws Exception { + runTest("compiler/testData/diagnostics/tests/unsignedTypes/wrongLongSuffixForULong.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/unsignedTypes/conversions") + @TestDataPath("$PROJECT_ROOT") + public class Conversions extends AbstractDiagnosticTest { + @Test + public void testAllFilesPresentInConversions() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/unsignedTypes/conversions"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + } + + @Test + @TestMetadata("conversionOfSignedToUnsigned.kt") + public void testConversionOfSignedToUnsigned() throws Exception { + runTest("compiler/testData/diagnostics/tests/unsignedTypes/conversions/conversionOfSignedToUnsigned.kt"); + } + + @Test + @TestMetadata("inferenceForSignedAndUnsignedTypes.kt") + public void testInferenceForSignedAndUnsignedTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/unsignedTypes/conversions/inferenceForSignedAndUnsignedTypes.kt"); + } + + @Test + @TestMetadata("noConversionForUnsignedTypesOnReceiver.kt") + public void testNoConversionForUnsignedTypesOnReceiver() throws Exception { + runTest("compiler/testData/diagnostics/tests/unsignedTypes/conversions/noConversionForUnsignedTypesOnReceiver.kt"); + } + + @Test + @TestMetadata("overloadResolutionForSignedAndUnsignedTypes.kt") + public void testOverloadResolutionForSignedAndUnsignedTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/unsignedTypes/conversions/overloadResolutionForSignedAndUnsignedTypes.kt"); + } + + @Test + @TestMetadata("signedToUnsignedConversionWithExpectedType.kt") + public void testSignedToUnsignedConversionWithExpectedType() throws Exception { + runTest("compiler/testData/diagnostics/tests/unsignedTypes/conversions/signedToUnsignedConversionWithExpectedType.kt"); + } + } + } + @Nested @TestMetadata("compiler/testData/diagnostics/tests/valueClasses") @TestDataPath("$PROJECT_ROOT") diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java index 8e0ed34e579..110fe12682f 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java @@ -29184,6 +29184,128 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti } } + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/unsignedTypes") + @TestDataPath("$PROJECT_ROOT") + public class UnsignedTypes extends AbstractFirDiagnosticTest { + @Test + public void testAllFilesPresentInUnsignedTypes() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/unsignedTypes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + } + + @Test + @TestMetadata("allowedVarargsOfUnsignedTypes.kt") + public void testAllowedVarargsOfUnsignedTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/unsignedTypes/allowedVarargsOfUnsignedTypes.kt"); + } + + @Test + @TestMetadata("callDefaultConstructorOfUnsignedType.kt") + public void testCallDefaultConstructorOfUnsignedType() throws Exception { + runTest("compiler/testData/diagnostics/tests/unsignedTypes/callDefaultConstructorOfUnsignedType.kt"); + } + + @Test + @TestMetadata("explicitUnsignedLongTypeCheck.kt") + public void testExplicitUnsignedLongTypeCheck() throws Exception { + runTest("compiler/testData/diagnostics/tests/unsignedTypes/explicitUnsignedLongTypeCheck.kt"); + } + + @Test + @TestMetadata("forbiddenEqualsOnUnsignedTypes.kt") + public void testForbiddenEqualsOnUnsignedTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/unsignedTypes/forbiddenEqualsOnUnsignedTypes.kt"); + } + + @Test + @TestMetadata("lateinitUnsignedType.kt") + public void testLateinitUnsignedType() throws Exception { + runTest("compiler/testData/diagnostics/tests/unsignedTypes/lateinitUnsignedType.kt"); + } + + @Test + @TestMetadata("overloadResolutionOfBasicOperations.kt") + public void testOverloadResolutionOfBasicOperations() throws Exception { + runTest("compiler/testData/diagnostics/tests/unsignedTypes/overloadResolutionOfBasicOperations.kt"); + } + + @Test + @TestMetadata("unsignedLiteralsInsideConstVals.kt") + public void testUnsignedLiteralsInsideConstVals() throws Exception { + runTest("compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsInsideConstVals.kt"); + } + + @Test + @TestMetadata("unsignedLiteralsOn1_2.kt") + public void testUnsignedLiteralsOn1_2() throws Exception { + runTest("compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsOn1_2.kt"); + } + + @Test + @TestMetadata("unsignedLiteralsOverflowSignedBorder.kt") + public void testUnsignedLiteralsOverflowSignedBorder() throws Exception { + runTest("compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsOverflowSignedBorder.kt"); + } + + @Test + @TestMetadata("unsignedLiteralsTypeCheck.kt") + public void testUnsignedLiteralsTypeCheck() throws Exception { + runTest("compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsTypeCheck.kt"); + } + + @Test + @TestMetadata("varargTypeToArrayTypeCheck.kt") + public void testVarargTypeToArrayTypeCheck() throws Exception { + runTest("compiler/testData/diagnostics/tests/unsignedTypes/varargTypeToArrayTypeCheck.kt"); + } + + @Test + @TestMetadata("wrongLongSuffixForULong.kt") + public void testWrongLongSuffixForULong() throws Exception { + runTest("compiler/testData/diagnostics/tests/unsignedTypes/wrongLongSuffixForULong.kt"); + } + + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/unsignedTypes/conversions") + @TestDataPath("$PROJECT_ROOT") + public class Conversions extends AbstractFirDiagnosticTest { + @Test + public void testAllFilesPresentInConversions() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/unsignedTypes/conversions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + } + + @Test + @TestMetadata("conversionOfSignedToUnsigned.kt") + public void testConversionOfSignedToUnsigned() throws Exception { + runTest("compiler/testData/diagnostics/tests/unsignedTypes/conversions/conversionOfSignedToUnsigned.kt"); + } + + @Test + @TestMetadata("inferenceForSignedAndUnsignedTypes.kt") + public void testInferenceForSignedAndUnsignedTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/unsignedTypes/conversions/inferenceForSignedAndUnsignedTypes.kt"); + } + + @Test + @TestMetadata("noConversionForUnsignedTypesOnReceiver.kt") + public void testNoConversionForUnsignedTypesOnReceiver() throws Exception { + runTest("compiler/testData/diagnostics/tests/unsignedTypes/conversions/noConversionForUnsignedTypesOnReceiver.kt"); + } + + @Test + @TestMetadata("overloadResolutionForSignedAndUnsignedTypes.kt") + public void testOverloadResolutionForSignedAndUnsignedTypes() throws Exception { + runTest("compiler/testData/diagnostics/tests/unsignedTypes/conversions/overloadResolutionForSignedAndUnsignedTypes.kt"); + } + + @Test + @TestMetadata("signedToUnsignedConversionWithExpectedType.kt") + public void testSignedToUnsignedConversionWithExpectedType() throws Exception { + runTest("compiler/testData/diagnostics/tests/unsignedTypes/conversions/signedToUnsignedConversionWithExpectedType.kt"); + } + } + } + @Nested @TestMetadata("compiler/testData/diagnostics/tests/valueClasses") @TestDataPath("$PROJECT_ROOT") diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractDiagnosticTest.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractDiagnosticTest.kt index 327321ba7b2..983f75cd296 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractDiagnosticTest.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractDiagnosticTest.kt @@ -10,8 +10,8 @@ import org.jetbrains.kotlin.platform.jvm.JvmPlatforms import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder import org.jetbrains.kotlin.test.directives.JvmEnvironmentConfigurationDirectives.USE_PSI_CLASS_FILES_READING import org.jetbrains.kotlin.test.directives.JvmEnvironmentConfigurationDirectives.WITH_STDLIB -import org.jetbrains.kotlin.test.directives.LanguageSettingsDirectives import org.jetbrains.kotlin.test.directives.LanguageSettingsDirectives.EXPLICIT_API_MODE +import org.jetbrains.kotlin.test.directives.LanguageSettingsDirectives.USE_EXPERIMENTAL import org.jetbrains.kotlin.test.frontend.classic.ClassicFrontendFacade import org.jetbrains.kotlin.test.frontend.classic.handlers.ClassicDiagnosticsHandler import org.jetbrains.kotlin.test.frontend.classic.handlers.DeclarationsDumpHandler @@ -70,5 +70,12 @@ abstract class AbstractDiagnosticTest : AbstractKotlinCompilerTest() { EXPLICIT_API_MODE with ExplicitApiMode.STRICT } } + + forTestsMatching("compiler/testData/diagnostics/tests/unsignedTypes/*") { + defaultDirectives { + USE_EXPERIMENTAL with "kotlin.ExperimentalUnsignedTypes" + +WITH_STDLIB + } + } } } diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractFirDiagnosticTest.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractFirDiagnosticTest.kt index 1c194a73391..f44723c4ba6 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractFirDiagnosticTest.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractFirDiagnosticTest.kt @@ -9,6 +9,7 @@ import org.jetbrains.kotlin.platform.jvm.JvmPlatforms import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder import org.jetbrains.kotlin.test.directives.FirDiagnosticsDirectives import org.jetbrains.kotlin.test.directives.JvmEnvironmentConfigurationDirectives +import org.jetbrains.kotlin.test.directives.LanguageSettingsDirectives import org.jetbrains.kotlin.test.frontend.fir.FirFailingTestSuppressor import org.jetbrains.kotlin.test.frontend.fir.FirFrontendFacade import org.jetbrains.kotlin.test.frontend.fir.handlers.* @@ -60,7 +61,8 @@ abstract class AbstractFirDiagnosticTest : AbstractKotlinCompilerTest() { forTestsMatching( "compiler/testData/diagnostics/testsWithStdLib/*" or - "compiler/fir/analysis-tests/testData/resolveWithStdlib/*" + "compiler/fir/analysis-tests/testData/resolveWithStdlib/*" or + "compiler/testData/diagnostics/tests/unsignedTypes/*" ) { defaultDirectives { +JvmEnvironmentConfigurationDirectives.WITH_STDLIB diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractDiagnosticsWithUnsignedTypes.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractDiagnosticsWithUnsignedTypes.kt deleted file mode 100644 index 99f536df4ac..00000000000 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractDiagnosticsWithUnsignedTypes.kt +++ /dev/null @@ -1,27 +0,0 @@ -/* - * Copyright 2010-2018 JetBrains s.r.o. and Kotlin Programming Language contributors. - * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. - */ - -package org.jetbrains.kotlin.checkers - -import org.jetbrains.kotlin.config.AnalysisFlags -import org.jetbrains.kotlin.config.ApiVersion -import org.jetbrains.kotlin.config.LanguageVersion -import org.jetbrains.kotlin.config.LanguageVersionSettings -import org.jetbrains.kotlin.test.ConfigurationKind - -abstract class AbstractDiagnosticsWithUnsignedTypes : AbstractDiagnosticsTest() { - - override fun extractConfigurationKind(files: List): ConfigurationKind { - return ConfigurationKind.NO_KOTLIN_REFLECT - } - - override fun defaultLanguageVersionSettings(): LanguageVersionSettings = - CompilerTestLanguageVersionSettings( - DEFAULT_DIAGNOSTIC_TESTS_FEATURES, - ApiVersion.LATEST_STABLE, - LanguageVersion.LATEST_STABLE, - mapOf(AnalysisFlags.useExperimental to listOf("kotlin.ExperimentalUnsignedTypes")) - ) -} diff --git a/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsWithUnsignedTypesGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsWithUnsignedTypesGenerated.java deleted file mode 100644 index b2297d7c45f..00000000000 --- a/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsWithUnsignedTypesGenerated.java +++ /dev/null @@ -1,128 +0,0 @@ -/* - * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. - * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. - */ - -package org.jetbrains.kotlin.checkers; - -import com.intellij.testFramework.TestDataPath; -import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; -import org.jetbrains.kotlin.test.KotlinTestUtils; -import org.jetbrains.kotlin.test.TestMetadata; -import org.junit.runner.RunWith; - -import java.io.File; -import java.util.regex.Pattern; - -/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */ -@SuppressWarnings("all") -@TestMetadata("compiler/testData/diagnostics/testsWithUnsignedTypes") -@TestDataPath("$PROJECT_ROOT") -@RunWith(JUnit3RunnerWithInners.class) -public class DiagnosticsWithUnsignedTypesGenerated extends AbstractDiagnosticsWithUnsignedTypes { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - - public void testAllFilesPresentInTestsWithUnsignedTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithUnsignedTypes"), Pattern.compile("^(.+)\\.kt$"), null, true); - } - - @TestMetadata("allowedVarargsOfUnsignedTypes.kt") - public void testAllowedVarargsOfUnsignedTypes() throws Exception { - runTest("compiler/testData/diagnostics/testsWithUnsignedTypes/allowedVarargsOfUnsignedTypes.kt"); - } - - @TestMetadata("callDefaultConstructorOfUnsignedType.kt") - public void testCallDefaultConstructorOfUnsignedType() throws Exception { - runTest("compiler/testData/diagnostics/testsWithUnsignedTypes/callDefaultConstructorOfUnsignedType.kt"); - } - - @TestMetadata("explicitUnsignedLongTypeCheck.kt") - public void testExplicitUnsignedLongTypeCheck() throws Exception { - runTest("compiler/testData/diagnostics/testsWithUnsignedTypes/explicitUnsignedLongTypeCheck.kt"); - } - - @TestMetadata("forbiddenEqualsOnUnsignedTypes.kt") - public void testForbiddenEqualsOnUnsignedTypes() throws Exception { - runTest("compiler/testData/diagnostics/testsWithUnsignedTypes/forbiddenEqualsOnUnsignedTypes.kt"); - } - - @TestMetadata("lateinitUnsignedType.kt") - public void testLateinitUnsignedType() throws Exception { - runTest("compiler/testData/diagnostics/testsWithUnsignedTypes/lateinitUnsignedType.kt"); - } - - @TestMetadata("overloadResolutionOfBasicOperations.kt") - public void testOverloadResolutionOfBasicOperations() throws Exception { - runTest("compiler/testData/diagnostics/testsWithUnsignedTypes/overloadResolutionOfBasicOperations.kt"); - } - - @TestMetadata("unsignedLiteralsInsideConstVals.kt") - public void testUnsignedLiteralsInsideConstVals() throws Exception { - runTest("compiler/testData/diagnostics/testsWithUnsignedTypes/unsignedLiteralsInsideConstVals.kt"); - } - - @TestMetadata("unsignedLiteralsOn1_2.kt") - public void testUnsignedLiteralsOn1_2() throws Exception { - runTest("compiler/testData/diagnostics/testsWithUnsignedTypes/unsignedLiteralsOn1_2.kt"); - } - - @TestMetadata("unsignedLiteralsOverflowSignedBorder.kt") - public void testUnsignedLiteralsOverflowSignedBorder() throws Exception { - runTest("compiler/testData/diagnostics/testsWithUnsignedTypes/unsignedLiteralsOverflowSignedBorder.kt"); - } - - @TestMetadata("unsignedLiteralsTypeCheck.kt") - public void testUnsignedLiteralsTypeCheck() throws Exception { - runTest("compiler/testData/diagnostics/testsWithUnsignedTypes/unsignedLiteralsTypeCheck.kt"); - } - - @TestMetadata("varargTypeToArrayTypeCheck.kt") - public void testVarargTypeToArrayTypeCheck() throws Exception { - runTest("compiler/testData/diagnostics/testsWithUnsignedTypes/varargTypeToArrayTypeCheck.kt"); - } - - @TestMetadata("wrongLongSuffixForULong.kt") - public void testWrongLongSuffixForULong() throws Exception { - runTest("compiler/testData/diagnostics/testsWithUnsignedTypes/wrongLongSuffixForULong.kt"); - } - - @TestMetadata("compiler/testData/diagnostics/testsWithUnsignedTypes/conversions") - @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Conversions extends AbstractDiagnosticsWithUnsignedTypes { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - - public void testAllFilesPresentInConversions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithUnsignedTypes/conversions"), Pattern.compile("^(.+)\\.kt$"), null, true); - } - - @TestMetadata("conversionOfSignedToUnsigned.kt") - public void testConversionOfSignedToUnsigned() throws Exception { - runTest("compiler/testData/diagnostics/testsWithUnsignedTypes/conversions/conversionOfSignedToUnsigned.kt"); - } - - @TestMetadata("inferenceForSignedAndUnsignedTypes.kt") - public void testInferenceForSignedAndUnsignedTypes() throws Exception { - runTest("compiler/testData/diagnostics/testsWithUnsignedTypes/conversions/inferenceForSignedAndUnsignedTypes.kt"); - } - - @TestMetadata("noConversionForUnsignedTypesOnReceiver.kt") - public void testNoConversionForUnsignedTypesOnReceiver() throws Exception { - runTest("compiler/testData/diagnostics/testsWithUnsignedTypes/conversions/noConversionForUnsignedTypesOnReceiver.kt"); - } - - @TestMetadata("overloadResolutionForSignedAndUnsignedTypes.kt") - public void testOverloadResolutionForSignedAndUnsignedTypes() throws Exception { - runTest("compiler/testData/diagnostics/testsWithUnsignedTypes/conversions/overloadResolutionForSignedAndUnsignedTypes.kt"); - } - - @TestMetadata("signedToUnsignedConversionWithExpectedType.kt") - public void testSignedToUnsignedConversionWithExpectedType() throws Exception { - runTest("compiler/testData/diagnostics/testsWithUnsignedTypes/conversions/signedToUnsignedConversionWithExpectedType.kt"); - } - } -} diff --git a/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt b/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt index 2dce736d5c3..507974bb3f7 100644 --- a/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt +++ b/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt @@ -88,10 +88,6 @@ fun main(args: Array) { model("diagnostics/testsWithJava15") } - testClass { - model("diagnostics/testsWithUnsignedTypes") - } - testClass { model("diagnostics/testsWithJvmBackend", targetBackend = TargetBackend.JVM_OLD) } From 26d7ea6ce68d851bcc2d92e1e7ef52715ce16bcc Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Wed, 9 Dec 2020 12:45:27 +0300 Subject: [PATCH 106/196] [TEST] Migrate AbstractDiagnosticsWithModifiedMockJdkTest to new test runners --- .../newStringMethods.fir.kt | 13 ++++++ .../newStringMethods.kt | 1 + .../notConsideredMethod.fir.kt | 13 ++++++ .../notConsideredMethod.kt | 1 + .../notConsideredMethod.txt | 0 .../throwableConstructor.fir.kt | 6 +++ .../throwableConstructor.kt | 1 + .../throwableConstructor.txt | 0 .../test/runners/DiagnosticTestGenerated.java | 28 ++++++++++++ ...irOldFrontendDiagnosticsTestGenerated.java | 28 ++++++++++++ ...tractDiagnosticsWithModifiedMockJdkTest.kt | 25 ----------- ...sticsWithModifiedMockJdkTestGenerated.java | 45 ------------------- .../generators/tests/GenerateCompilerTests.kt | 5 --- 13 files changed, 91 insertions(+), 75 deletions(-) create mode 100644 compiler/testData/diagnostics/tests/testWithModifiedMockJdk/newStringMethods.fir.kt rename compiler/testData/diagnostics/{ => tests}/testWithModifiedMockJdk/newStringMethods.kt (88%) create mode 100644 compiler/testData/diagnostics/tests/testWithModifiedMockJdk/notConsideredMethod.fir.kt rename compiler/testData/diagnostics/{ => tests}/testWithModifiedMockJdk/notConsideredMethod.kt (92%) rename compiler/testData/diagnostics/{ => tests}/testWithModifiedMockJdk/notConsideredMethod.txt (100%) create mode 100644 compiler/testData/diagnostics/tests/testWithModifiedMockJdk/throwableConstructor.fir.kt rename compiler/testData/diagnostics/{ => tests}/testWithModifiedMockJdk/throwableConstructor.kt (76%) rename compiler/testData/diagnostics/{ => tests}/testWithModifiedMockJdk/throwableConstructor.txt (100%) delete mode 100644 compiler/tests-common/tests/org/jetbrains/kotlin/cfg/AbstractDiagnosticsWithModifiedMockJdkTest.kt delete mode 100644 compiler/tests-gen/org/jetbrains/kotlin/cfg/DiagnosticsWithModifiedMockJdkTestGenerated.java diff --git a/compiler/testData/diagnostics/tests/testWithModifiedMockJdk/newStringMethods.fir.kt b/compiler/testData/diagnostics/tests/testWithModifiedMockJdk/newStringMethods.fir.kt new file mode 100644 index 00000000000..b6e9ed6ce5a --- /dev/null +++ b/compiler/testData/diagnostics/tests/testWithModifiedMockJdk/newStringMethods.fir.kt @@ -0,0 +1,13 @@ +// !JDK_KIND: MODIFIED_MOCK_JDK +// !CHECK_TYPE +// SKIP_TXT +// WITH_RUNTIME + +fun foo(s: String) { + s.isBlank() + s.lines().checkType { _>() } + s.repeat(1) + + // We don't have `strip` extension, so leave it for a while in gray list + s.strip() +} diff --git a/compiler/testData/diagnostics/testWithModifiedMockJdk/newStringMethods.kt b/compiler/testData/diagnostics/tests/testWithModifiedMockJdk/newStringMethods.kt similarity index 88% rename from compiler/testData/diagnostics/testWithModifiedMockJdk/newStringMethods.kt rename to compiler/testData/diagnostics/tests/testWithModifiedMockJdk/newStringMethods.kt index c6a87538327..746b0a46c5e 100644 --- a/compiler/testData/diagnostics/testWithModifiedMockJdk/newStringMethods.kt +++ b/compiler/testData/diagnostics/tests/testWithModifiedMockJdk/newStringMethods.kt @@ -1,3 +1,4 @@ +// !JDK_KIND: MODIFIED_MOCK_JDK // !CHECK_TYPE // SKIP_TXT // WITH_RUNTIME diff --git a/compiler/testData/diagnostics/tests/testWithModifiedMockJdk/notConsideredMethod.fir.kt b/compiler/testData/diagnostics/tests/testWithModifiedMockJdk/notConsideredMethod.fir.kt new file mode 100644 index 00000000000..bba63299a6f --- /dev/null +++ b/compiler/testData/diagnostics/tests/testWithModifiedMockJdk/notConsideredMethod.fir.kt @@ -0,0 +1,13 @@ +// !JDK_KIND: MODIFIED_MOCK_JDK +// !CHECK_TYPE + +interface A : MutableCollection { + // Override of deprecated function could be marked as deprecated too + override fun nonExistingMethod(x: String) = "" +} + +fun foo(x: MutableCollection, y: Collection, z: A) { + x.nonExistingMethod(1).checkType { _() } + y.nonExistingMethod("") + z.nonExistingMethod("") +} diff --git a/compiler/testData/diagnostics/testWithModifiedMockJdk/notConsideredMethod.kt b/compiler/testData/diagnostics/tests/testWithModifiedMockJdk/notConsideredMethod.kt similarity index 92% rename from compiler/testData/diagnostics/testWithModifiedMockJdk/notConsideredMethod.kt rename to compiler/testData/diagnostics/tests/testWithModifiedMockJdk/notConsideredMethod.kt index dc97dd21b52..a9b6f81495b 100644 --- a/compiler/testData/diagnostics/testWithModifiedMockJdk/notConsideredMethod.kt +++ b/compiler/testData/diagnostics/tests/testWithModifiedMockJdk/notConsideredMethod.kt @@ -1,3 +1,4 @@ +// !JDK_KIND: MODIFIED_MOCK_JDK // !CHECK_TYPE interface A : MutableCollection { diff --git a/compiler/testData/diagnostics/testWithModifiedMockJdk/notConsideredMethod.txt b/compiler/testData/diagnostics/tests/testWithModifiedMockJdk/notConsideredMethod.txt similarity index 100% rename from compiler/testData/diagnostics/testWithModifiedMockJdk/notConsideredMethod.txt rename to compiler/testData/diagnostics/tests/testWithModifiedMockJdk/notConsideredMethod.txt diff --git a/compiler/testData/diagnostics/tests/testWithModifiedMockJdk/throwableConstructor.fir.kt b/compiler/testData/diagnostics/tests/testWithModifiedMockJdk/throwableConstructor.fir.kt new file mode 100644 index 00000000000..918ba3b6380 --- /dev/null +++ b/compiler/testData/diagnostics/tests/testWithModifiedMockJdk/throwableConstructor.fir.kt @@ -0,0 +1,6 @@ +// !JDK_KIND: MODIFIED_MOCK_JDK +abstract class A : Throwable(1.0) {} + +fun foo() { + Throwable(1.5) +} diff --git a/compiler/testData/diagnostics/testWithModifiedMockJdk/throwableConstructor.kt b/compiler/testData/diagnostics/tests/testWithModifiedMockJdk/throwableConstructor.kt similarity index 76% rename from compiler/testData/diagnostics/testWithModifiedMockJdk/throwableConstructor.kt rename to compiler/testData/diagnostics/tests/testWithModifiedMockJdk/throwableConstructor.kt index fca9ba19075..61b73c357c8 100644 --- a/compiler/testData/diagnostics/testWithModifiedMockJdk/throwableConstructor.kt +++ b/compiler/testData/diagnostics/tests/testWithModifiedMockJdk/throwableConstructor.kt @@ -1,3 +1,4 @@ +// !JDK_KIND: MODIFIED_MOCK_JDK abstract class A : Throwable(1.0) {} fun foo() { diff --git a/compiler/testData/diagnostics/testWithModifiedMockJdk/throwableConstructor.txt b/compiler/testData/diagnostics/tests/testWithModifiedMockJdk/throwableConstructor.txt similarity index 100% rename from compiler/testData/diagnostics/testWithModifiedMockJdk/throwableConstructor.txt rename to compiler/testData/diagnostics/tests/testWithModifiedMockJdk/throwableConstructor.txt diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java index d8d5700976e..f87c05e2621 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java @@ -28200,6 +28200,34 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { } } + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/testWithModifiedMockJdk") + @TestDataPath("$PROJECT_ROOT") + public class TestWithModifiedMockJdk extends AbstractDiagnosticTest { + @Test + public void testAllFilesPresentInTestWithModifiedMockJdk() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/testWithModifiedMockJdk"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + } + + @Test + @TestMetadata("newStringMethods.kt") + public void testNewStringMethods() throws Exception { + runTest("compiler/testData/diagnostics/tests/testWithModifiedMockJdk/newStringMethods.kt"); + } + + @Test + @TestMetadata("notConsideredMethod.kt") + public void testNotConsideredMethod() throws Exception { + runTest("compiler/testData/diagnostics/tests/testWithModifiedMockJdk/notConsideredMethod.kt"); + } + + @Test + @TestMetadata("throwableConstructor.kt") + public void testThrowableConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/testWithModifiedMockJdk/throwableConstructor.kt"); + } + } + @Nested @TestMetadata("compiler/testData/diagnostics/tests/testsWithExplicitApi") @TestDataPath("$PROJECT_ROOT") diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java index 110fe12682f..5fea12c2faf 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java @@ -28104,6 +28104,34 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti } } + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/testWithModifiedMockJdk") + @TestDataPath("$PROJECT_ROOT") + public class TestWithModifiedMockJdk extends AbstractFirDiagnosticTest { + @Test + public void testAllFilesPresentInTestWithModifiedMockJdk() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/testWithModifiedMockJdk"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + } + + @Test + @TestMetadata("newStringMethods.kt") + public void testNewStringMethods() throws Exception { + runTest("compiler/testData/diagnostics/tests/testWithModifiedMockJdk/newStringMethods.kt"); + } + + @Test + @TestMetadata("notConsideredMethod.kt") + public void testNotConsideredMethod() throws Exception { + runTest("compiler/testData/diagnostics/tests/testWithModifiedMockJdk/notConsideredMethod.kt"); + } + + @Test + @TestMetadata("throwableConstructor.kt") + public void testThrowableConstructor() throws Exception { + runTest("compiler/testData/diagnostics/tests/testWithModifiedMockJdk/throwableConstructor.kt"); + } + } + @Nested @TestMetadata("compiler/testData/diagnostics/tests/testsWithExplicitApi") @TestDataPath("$PROJECT_ROOT") diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/cfg/AbstractDiagnosticsWithModifiedMockJdkTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/cfg/AbstractDiagnosticsWithModifiedMockJdkTest.kt deleted file mode 100644 index c4d63444e7a..00000000000 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/cfg/AbstractDiagnosticsWithModifiedMockJdkTest.kt +++ /dev/null @@ -1,25 +0,0 @@ -/* - * 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.cfg - -import org.jetbrains.kotlin.checkers.AbstractDiagnosticsTest -import org.jetbrains.kotlin.test.TestJdkKind - -abstract class AbstractDiagnosticsWithModifiedMockJdkTest : AbstractDiagnosticsTest() { - override fun getTestJdkKind(files: List): TestJdkKind { - return TestJdkKind.MODIFIED_MOCK_JDK - } -} \ No newline at end of file diff --git a/compiler/tests-gen/org/jetbrains/kotlin/cfg/DiagnosticsWithModifiedMockJdkTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/cfg/DiagnosticsWithModifiedMockJdkTestGenerated.java deleted file mode 100644 index 46aab6a1eb5..00000000000 --- a/compiler/tests-gen/org/jetbrains/kotlin/cfg/DiagnosticsWithModifiedMockJdkTestGenerated.java +++ /dev/null @@ -1,45 +0,0 @@ -/* - * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. - * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. - */ - -package org.jetbrains.kotlin.cfg; - -import com.intellij.testFramework.TestDataPath; -import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; -import org.jetbrains.kotlin.test.KotlinTestUtils; -import org.jetbrains.kotlin.test.TestMetadata; -import org.junit.runner.RunWith; - -import java.io.File; -import java.util.regex.Pattern; - -/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */ -@SuppressWarnings("all") -@TestMetadata("compiler/testData/diagnostics/testWithModifiedMockJdk") -@TestDataPath("$PROJECT_ROOT") -@RunWith(JUnit3RunnerWithInners.class) -public class DiagnosticsWithModifiedMockJdkTestGenerated extends AbstractDiagnosticsWithModifiedMockJdkTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - - public void testAllFilesPresentInTestWithModifiedMockJdk() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testWithModifiedMockJdk"), Pattern.compile("^(.+)\\.kt$"), null, true); - } - - @TestMetadata("newStringMethods.kt") - public void testNewStringMethods() throws Exception { - runTest("compiler/testData/diagnostics/testWithModifiedMockJdk/newStringMethods.kt"); - } - - @TestMetadata("notConsideredMethod.kt") - public void testNotConsideredMethod() throws Exception { - runTest("compiler/testData/diagnostics/testWithModifiedMockJdk/notConsideredMethod.kt"); - } - - @TestMetadata("throwableConstructor.kt") - public void testThrowableConstructor() throws Exception { - runTest("compiler/testData/diagnostics/testWithModifiedMockJdk/throwableConstructor.kt"); - } -} diff --git a/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt b/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt index 507974bb3f7..fa92b5f0fc4 100644 --- a/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt +++ b/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt @@ -8,7 +8,6 @@ package org.jetbrains.kotlin.generators.tests import org.jetbrains.kotlin.asJava.AbstractCompilerLightClassTest import org.jetbrains.kotlin.cfg.AbstractControlFlowTest import org.jetbrains.kotlin.cfg.AbstractDataFlowTest -import org.jetbrains.kotlin.cfg.AbstractDiagnosticsWithModifiedMockJdkTest import org.jetbrains.kotlin.cfg.AbstractPseudoValueTest import org.jetbrains.kotlin.checkers.* import org.jetbrains.kotlin.checkers.javac.* @@ -80,10 +79,6 @@ fun main(args: Array) { model("diagnostics/nativeTests") } - testClass { - model("diagnostics/testWithModifiedMockJdk") - } - testClass { model("diagnostics/testsWithJava15") } From 8a5fc2ad2942320f02e6c0266c003cecc2942a35 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Wed, 9 Dec 2020 15:06:03 +0300 Subject: [PATCH 107/196] [Build] Split `:tests-mutes` package to common and TC integration parts This is needed because of following problem: - :tests-mutes has `implementation` dependency on khttp library - khttp has dependency on spek-junit-platform-engine library - :tests-common had `testCompile` dependency on :tests-mutes which added spek library as as a dependency to all modules which depend on :tests-common, including :tests-common-new Then, if project is configured with JPS then if user tries to run all tests in directory in module which uses JUnit 5 (like :tests-common-new) then spek library will be added to classpath and junit runner takes some platform extension from it which causes NoSuchMethodException because spek library was compiled against outdated JUnit 5 version and current version doesn't have some API. So splitting :tests-mutes for two parts fixes this issue, because common part (:compiler:tests-mutes) no longer depends on khttp, so spek library doesn't spreads to all modules --- build.gradle.kts | 2 +- compiler/tests-mutes/build.gradle.kts | 17 +----------- .../jetbrains/kotlin/test/mutes/MutedTest.kt | 2 +- .../tc-integration/build.gradle.kts | 27 +++++++++++++++++++ .../kotlin/test/mutes/MutedTestToJson.kt | 0 .../kotlin/test/mutes/MutedTestsSync.kt | 0 .../kotlin/test/mutes/TeamCityInteraction.kt | 0 settings.gradle | 1 + 8 files changed, 31 insertions(+), 18 deletions(-) create mode 100644 compiler/tests-mutes/tc-integration/build.gradle.kts rename compiler/tests-mutes/{ => tc-integration}/src/org/jetbrains/kotlin/test/mutes/MutedTestToJson.kt (100%) rename compiler/tests-mutes/{ => tc-integration}/src/org/jetbrains/kotlin/test/mutes/MutedTestsSync.kt (100%) rename compiler/tests-mutes/{ => tc-integration}/src/org/jetbrains/kotlin/test/mutes/TeamCityInteraction.kt (100%) diff --git a/build.gradle.kts b/build.gradle.kts index a0b9592cbf6..af636074a10 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -569,7 +569,7 @@ val dist = tasks.register("dist") { } val syncMutedTests = tasks.register("syncMutedTests") { - dependsOn(":compiler:tests-mutes:run") + dependsOn(":compiler:tests-mutes:tc-integration:run") } val copyCompilerToIdeaPlugin by task { diff --git a/compiler/tests-mutes/build.gradle.kts b/compiler/tests-mutes/build.gradle.kts index 69a4f6bbdca..019f8afe976 100644 --- a/compiler/tests-mutes/build.gradle.kts +++ b/compiler/tests-mutes/build.gradle.kts @@ -1,28 +1,13 @@ plugins { kotlin("jvm") id("jps-compatible") - application } dependencies { api(kotlinStdlib()) - implementation("khttp:khttp:1.0.0") - implementation("com.fasterxml.jackson.module:jackson-module-kotlin:2.11.0") } sourceSets { - "main" { - projectDefault() - } + "main" { projectDefault() } "test" {} } - -val compileKotlin: org.jetbrains.kotlin.gradle.tasks.KotlinCompile by tasks -compileKotlin.kotlinOptions.freeCompilerArgs += "-Xskip-runtime-version-check" - -val mutesPackageName = "org.jetbrains.kotlin.test.mutes" - -application { - mainClassName = "$mutesPackageName.MutedTestsSyncKt" - applicationDefaultJvmArgs = rootProject.properties.filterKeys { it.startsWith(mutesPackageName) }.map { (k, v) -> "-D$k=$v" } -} diff --git a/compiler/tests-mutes/src/org/jetbrains/kotlin/test/mutes/MutedTest.kt b/compiler/tests-mutes/src/org/jetbrains/kotlin/test/mutes/MutedTest.kt index 995336146c0..d821fd41fd6 100644 --- a/compiler/tests-mutes/src/org/jetbrains/kotlin/test/mutes/MutedTest.kt +++ b/compiler/tests-mutes/src/org/jetbrains/kotlin/test/mutes/MutedTest.kt @@ -92,4 +92,4 @@ private fun parseMutedTest(str: String): MutedTest { private class ParseError(message: String, override val cause: Throwable? = null) : IllegalArgumentException(message) -internal fun flakyTests(file: File) = loadMutedTests(file).filter { it.isFlaky } \ No newline at end of file +fun flakyTests(file: File): List = loadMutedTests(file).filter { it.isFlaky } diff --git a/compiler/tests-mutes/tc-integration/build.gradle.kts b/compiler/tests-mutes/tc-integration/build.gradle.kts new file mode 100644 index 00000000000..72ba12d6923 --- /dev/null +++ b/compiler/tests-mutes/tc-integration/build.gradle.kts @@ -0,0 +1,27 @@ +plugins { + kotlin("jvm") + id("jps-compatible") + application +} + +dependencies { + api(kotlinStdlib()) + implementation(project(":compiler:tests-mutes")) + implementation("khttp:khttp:1.0.0") + implementation("com.fasterxml.jackson.module:jackson-module-kotlin:2.11.0") +} + +sourceSets { + "main" { projectDefault() } + "test" {} +} + +val compileKotlin: org.jetbrains.kotlin.gradle.tasks.KotlinCompile by tasks +compileKotlin.kotlinOptions.freeCompilerArgs += "-Xskip-runtime-version-check" + +val mutesPackageName = "org.jetbrains.kotlin.test.mutes" + +application { + mainClassName = "$mutesPackageName.MutedTestsSyncKt" + applicationDefaultJvmArgs = rootProject.properties.filterKeys { it.startsWith(mutesPackageName) }.map { (k, v) -> "-D$k=$v" } +} diff --git a/compiler/tests-mutes/src/org/jetbrains/kotlin/test/mutes/MutedTestToJson.kt b/compiler/tests-mutes/tc-integration/src/org/jetbrains/kotlin/test/mutes/MutedTestToJson.kt similarity index 100% rename from compiler/tests-mutes/src/org/jetbrains/kotlin/test/mutes/MutedTestToJson.kt rename to compiler/tests-mutes/tc-integration/src/org/jetbrains/kotlin/test/mutes/MutedTestToJson.kt diff --git a/compiler/tests-mutes/src/org/jetbrains/kotlin/test/mutes/MutedTestsSync.kt b/compiler/tests-mutes/tc-integration/src/org/jetbrains/kotlin/test/mutes/MutedTestsSync.kt similarity index 100% rename from compiler/tests-mutes/src/org/jetbrains/kotlin/test/mutes/MutedTestsSync.kt rename to compiler/tests-mutes/tc-integration/src/org/jetbrains/kotlin/test/mutes/MutedTestsSync.kt diff --git a/compiler/tests-mutes/src/org/jetbrains/kotlin/test/mutes/TeamCityInteraction.kt b/compiler/tests-mutes/tc-integration/src/org/jetbrains/kotlin/test/mutes/TeamCityInteraction.kt similarity index 100% rename from compiler/tests-mutes/src/org/jetbrains/kotlin/test/mutes/TeamCityInteraction.kt rename to compiler/tests-mutes/tc-integration/src/org/jetbrains/kotlin/test/mutes/TeamCityInteraction.kt diff --git a/settings.gradle b/settings.gradle index 4c14693281a..637afec59da 100644 --- a/settings.gradle +++ b/settings.gradle @@ -117,6 +117,7 @@ include ":benchmarks", ":compiler:android-tests", ":compiler:tests-common", ":compiler:tests-mutes", + ":compiler:tests-mutes:tc-integration", ":compiler:tests-common-jvm6", ":compiler:tests-against-klib", ":dukat", From d9848544dc16a45ffe3d0b8239b17867a804c3db Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Mon, 14 Dec 2020 12:15:23 +0300 Subject: [PATCH 108/196] [TEST] Move auto mute wrapping utils to :compiler:tests-mutes --- .../org/jetbrains/kotlin/test/AutoMute.kt | 46 +----------- .../jetbrains/kotlin/test/muteWithDatabase.kt | 72 ++----------------- .../jetbrains/kotlin/test/mutes/AutoMute.kt | 52 ++++++++++++++ .../test/mutes/muteWithDatabaseWrapper.kt | 67 +++++++++++++++++ 4 files changed, 128 insertions(+), 109 deletions(-) create mode 100644 compiler/tests-mutes/src/org/jetbrains/kotlin/test/mutes/AutoMute.kt create mode 100644 compiler/tests-mutes/src/org/jetbrains/kotlin/test/mutes/muteWithDatabaseWrapper.kt diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/test/AutoMute.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/test/AutoMute.kt index 04d8587016a..7927354334f 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/test/AutoMute.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/test/AutoMute.kt @@ -5,55 +5,13 @@ package org.jetbrains.kotlin.test +import org.jetbrains.kotlin.test.mutes.DO_AUTO_MUTE +import org.jetbrains.kotlin.test.mutes.muteTest import org.junit.runner.notification.Failure import org.junit.runner.notification.RunListener import org.junit.runner.notification.RunNotifier import java.io.File -class AutoMute( - val file: String, - val issue: String -) - -val DO_AUTO_MUTE: AutoMute? by lazy { - val autoMuteFile = File("tests/automute") - if (autoMuteFile.exists()) { - val lines = autoMuteFile.readLines().filter { it.isNotBlank() }.map { it.trim() } - AutoMute( - lines.getOrNull(0) ?: error("A file path is expected in tne first line"), - lines.getOrNull(1) ?: error("An issue description is the second line") - ) - } else { - null - } -} - -fun AutoMute.muteTest(testKey: String) { - val file = File(file) - val lines = file.readLines() - val firstLine = lines[0] // Drop file header - val muted = lines.drop(1).toMutableList() - muted.add("$testKey, $issue") - val newMuted: List = mutableListOf() + firstLine + muted.sorted() - file.writeText(newMuted.joinToString("\n")) -} - -internal fun wrapWithAutoMute(f: () -> Unit, testKey: String): (() -> Unit)? { - val doAutoMute = DO_AUTO_MUTE - if (doAutoMute != null) { - return { - try { - f() - } catch (e: Throwable) { - doAutoMute.muteTest(testKey) - throw e - } - } - } else { - return null - } -} - internal inline fun RunNotifier.withAutoMuteListener( testKey: String, crossinline run: () -> Unit, diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/test/muteWithDatabase.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/test/muteWithDatabase.kt index dfcfd26d7b2..b7a08e1743a 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/test/muteWithDatabase.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/test/muteWithDatabase.kt @@ -6,9 +6,7 @@ package org.jetbrains.kotlin.test import junit.framework.TestCase -import org.jetbrains.kotlin.test.mutes.MutedTest -import org.jetbrains.kotlin.test.mutes.getMutedTest -import org.jetbrains.kotlin.test.mutes.mutedSet +import org.jetbrains.kotlin.test.mutes.* import org.junit.internal.runners.statements.InvokeMethod import org.junit.runner.Runner import org.junit.runner.notification.RunNotifier @@ -19,55 +17,10 @@ import org.junit.runners.parameterized.BlockJUnit4ClassRunnerWithParameters import org.junit.runners.parameterized.ParametersRunnerFactory import org.junit.runners.parameterized.TestWithParameters -private val SKIP_MUTED_TESTS = java.lang.Boolean.getBoolean("org.jetbrains.kotlin.skip.muted.tests") - -private fun isMutedInDatabase(testClass: Class<*>, methodKey: String): Boolean { - val mutedTest = mutedSet.mutedTest(testClass, methodKey) - return SKIP_MUTED_TESTS && isPresentedInDatabaseWithoutFailMarker(mutedTest) -} - -private fun isMutedInDatabaseWithLog(testClass: Class<*>, methodKey: String): Boolean { - val mutedInDatabase = isMutedInDatabase(testClass, methodKey) - - if (mutedInDatabase) { - System.err.println(mutedMessage(testClass, methodKey)) - } - - return mutedInDatabase -} - -private fun isPresentedInDatabaseWithoutFailMarker(mutedTest: MutedTest?): Boolean { - return mutedTest != null && !mutedTest.hasFailFile -} - internal fun wrapWithMuteInDatabase(testCase: TestCase, f: () -> Unit): (() -> Unit)? { - val testClass = testCase.javaClass - val methodKey = testCase.name - - val mutedTest = getMutedTest(testClass, methodKey) - val testKey = testKey(testClass, methodKey) - - if (isMutedInDatabase(testClass, methodKey)) { - return { - System.err.println(mutedMessage(testClass, methodKey)) - } - } else if (isPresentedInDatabaseWithoutFailMarker(mutedTest)) { - if (mutedTest?.isFlaky == true) { - return f - } else { - return { - invertMutedTestResultWithLog(f, testKey) - } - } - } else { - return wrapWithAutoMute(f, testKey) - } + return wrapWithMuteInDatabase(testCase.javaClass, testCase.name, f) } -private fun mutedMessage(klass: Class<*>, methodKey: String) = "MUTED TEST: ${testKey(klass, methodKey)}" - -private fun testKey(klass: Class<*>, methodKey: String) = "${klass.canonicalName}.$methodKey" - class RunnerFactoryWithMuteInDatabase : ParametersRunnerFactory { override fun createRunnerForTestWithParameters(testWithParameters: TestWithParameters?): Runner { return object : BlockJUnit4ClassRunnerWithParameters(testWithParameters) { @@ -95,7 +48,11 @@ class RunnerFactoryWithMuteInDatabase : ParametersRunnerFactory { private fun parametrizedMethodKey(child: FrameworkMethod, parametersName: String) = "${child.method.name}$parametersName" } -class MethodInvokerWithMutedTests(val method: FrameworkMethod, val test: Any?, val mainMethodKey: String? = null) : InvokeMethod(method, test) { +class MethodInvokerWithMutedTests( + val method: FrameworkMethod, + val test: Any?, + val mainMethodKey: String? = null +) : InvokeMethod(method, test) { override fun evaluate() { val methodClass = method.declaringClass val mutedTest = @@ -133,21 +90,6 @@ class RunnerWithMuteInDatabase(klass: Class<*>?) : BlockJUnit4ClassRunner(klass) } } -private fun invertMutedTestResultWithLog(f: () -> Unit, testKey: String) { - var isTestGreen = true - try { - f() - } catch (e: Throwable) { - println("MUTED TEST STILL FAILS: $testKey") - isTestGreen = false - } - - if (isTestGreen) { - System.err.println("SUCCESS RESULT OF MUTED TEST: $testKey") - throw Exception("Muted non-flaky test $testKey finished successfully. Please remove it from csv file") - } -} - fun TestCase.runTest(test: () -> Unit) { (wrapWithMuteInDatabase(this, test) ?: test).invoke() } diff --git a/compiler/tests-mutes/src/org/jetbrains/kotlin/test/mutes/AutoMute.kt b/compiler/tests-mutes/src/org/jetbrains/kotlin/test/mutes/AutoMute.kt new file mode 100644 index 00000000000..8631f3a2adc --- /dev/null +++ b/compiler/tests-mutes/src/org/jetbrains/kotlin/test/mutes/AutoMute.kt @@ -0,0 +1,52 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.mutes + +import java.io.File + +class AutoMute( + val file: String, + val issue: String +) + +val DO_AUTO_MUTE: AutoMute? by lazy { + val autoMuteFile = File("tests/automute") + if (autoMuteFile.exists()) { + val lines = autoMuteFile.readLines().filter { it.isNotBlank() }.map { it.trim() } + AutoMute( + lines.getOrNull(0) ?: error("A file path is expected in tne first line"), + lines.getOrNull(1) ?: error("An issue description is the second line") + ) + } else { + null + } +} + +fun AutoMute.muteTest(testKey: String) { + val file = File(file) + val lines = file.readLines() + val firstLine = lines[0] // Drop file header + val muted = lines.drop(1).toMutableList() + muted.add("$testKey, $issue") + val newMuted: List = mutableListOf() + firstLine + muted.sorted() + file.writeText(newMuted.joinToString("\n")) +} + +internal fun wrapWithAutoMute(f: () -> Unit, testKey: String): (() -> Unit)? { + val doAutoMute = DO_AUTO_MUTE + if (doAutoMute != null) { + return { + try { + f() + } catch (e: Throwable) { + doAutoMute.muteTest(testKey) + throw e + } + } + } else { + return null + } +} diff --git a/compiler/tests-mutes/src/org/jetbrains/kotlin/test/mutes/muteWithDatabaseWrapper.kt b/compiler/tests-mutes/src/org/jetbrains/kotlin/test/mutes/muteWithDatabaseWrapper.kt new file mode 100644 index 00000000000..43b9f5a5af6 --- /dev/null +++ b/compiler/tests-mutes/src/org/jetbrains/kotlin/test/mutes/muteWithDatabaseWrapper.kt @@ -0,0 +1,67 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.mutes + +private val SKIP_MUTED_TESTS = java.lang.Boolean.getBoolean("org.jetbrains.kotlin.skip.muted.tests") + +fun isMutedInDatabase(testClass: Class<*>, methodKey: String): Boolean { + val mutedTest = mutedSet.mutedTest(testClass, methodKey) + return SKIP_MUTED_TESTS && isPresentedInDatabaseWithoutFailMarker(mutedTest) +} + +fun isMutedInDatabaseWithLog(testClass: Class<*>, methodKey: String): Boolean { + val mutedInDatabase = isMutedInDatabase(testClass, methodKey) + + if (mutedInDatabase) { + System.err.println(mutedMessage(testClass, methodKey)) + } + + return mutedInDatabase +} + +fun isPresentedInDatabaseWithoutFailMarker(mutedTest: MutedTest?): Boolean { + return mutedTest != null && !mutedTest.hasFailFile +} + +fun mutedMessage(klass: Class<*>, methodKey: String): String = "MUTED TEST: ${testKey(klass, methodKey)}" + +fun testKey(klass: Class<*>, methodKey: String): String = "${klass.canonicalName}.$methodKey" + +fun wrapWithMuteInDatabase(testClass: Class<*>, methodName: String, f: () -> Unit): (() -> Unit)? { + val mutedTest = getMutedTest(testClass, methodName) + val testKey = testKey(testClass, methodName) + + if (isMutedInDatabase(testClass, methodName)) { + return { + System.err.println(mutedMessage(testClass, methodName)) + } + } else if (isPresentedInDatabaseWithoutFailMarker(mutedTest)) { + if (mutedTest?.isFlaky == true) { + return f + } else { + return { + invertMutedTestResultWithLog(f, testKey) + } + } + } else { + return wrapWithAutoMute(f, testKey) + } +} + +fun invertMutedTestResultWithLog(f: () -> Unit, testKey: String) { + var isTestGreen = true + try { + f() + } catch (e: Throwable) { + println("MUTED TEST STILL FAILS: $testKey") + isTestGreen = false + } + + if (isTestGreen) { + System.err.println("SUCCESS RESULT OF MUTED TEST: $testKey") + throw Exception("Muted non-flaky test $testKey finished successfully. Please remove it from csv file") + } +} From f8ad096abb41e098b6da76c06f488cc16efecf68 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Tue, 15 Dec 2020 15:45:01 +0300 Subject: [PATCH 109/196] [TEST] Mute tests in IC JS Klib tests using exclude pattern instead of .mute file --- ...ntalJsKlibCompilerRunnerTestGenerated.java | 27 +---------------- ...WithScopeExpansionRunnerTestGenerated.java | 29 +------------------ .../kotlin/generators/tests/GenerateTests.kt | 7 +++-- ...KotlinEvaluateExpressionTestGenerated.java | 2 +- .../sealedClassesAddImplements.jsklib.mute | 1 - .../sealedClassesAddInheritor.jsklib.mute | 1 - .../sealedClassesRemoveImplements.jsklib.mute | 1 - .../sealedClassesRemoveInheritor.jsklib.mute | 1 - .../sealedClassesUseSwitch.jsklib.mute | 1 - 9 files changed, 7 insertions(+), 63 deletions(-) delete mode 100644 jps-plugin/testData/incremental/pureKotlin/sealedClassesAddImplements/sealedClassesAddImplements.jsklib.mute delete mode 100644 jps-plugin/testData/incremental/pureKotlin/sealedClassesAddInheritor/sealedClassesAddInheritor.jsklib.mute delete mode 100644 jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveImplements/sealedClassesRemoveImplements.jsklib.mute delete mode 100644 jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveInheritor/sealedClassesRemoveInheritor.jsklib.mute delete mode 100644 jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/sealedClassesUseSwitch.jsklib.mute diff --git a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsKlibCompilerRunnerTestGenerated.java b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsKlibCompilerRunnerTestGenerated.java index f9b1a487a46..a2ebc94ad72 100644 --- a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsKlibCompilerRunnerTestGenerated.java +++ b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsKlibCompilerRunnerTestGenerated.java @@ -64,7 +64,7 @@ public class IncrementalJsKlibCompilerRunnerTestGenerated extends AbstractIncrem } public void testAllFilesPresentInPureKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/pureKotlin"), Pattern.compile("^([^\\.]+)$"), null, false); + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/pureKotlin"), Pattern.compile("^([^\\.]+)$"), Pattern.compile("^sealed.*"), false); } @TestMetadata("annotations") @@ -572,31 +572,6 @@ public class IncrementalJsKlibCompilerRunnerTestGenerated extends AbstractIncrem runTest("jps-plugin/testData/incremental/pureKotlin/returnTypeChanged/"); } - @TestMetadata("sealedClassesAddImplements") - public void testSealedClassesAddImplements() throws Exception { - runTest("jps-plugin/testData/incremental/pureKotlin/sealedClassesAddImplements/"); - } - - @TestMetadata("sealedClassesAddInheritor") - public void testSealedClassesAddInheritor() throws Exception { - runTest("jps-plugin/testData/incremental/pureKotlin/sealedClassesAddInheritor/"); - } - - @TestMetadata("sealedClassesRemoveImplements") - public void testSealedClassesRemoveImplements() throws Exception { - runTest("jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveImplements/"); - } - - @TestMetadata("sealedClassesRemoveInheritor") - public void testSealedClassesRemoveInheritor() throws Exception { - runTest("jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveInheritor/"); - } - - @TestMetadata("sealedClassesUseSwitch") - public void testSealedClassesUseSwitch() throws Exception { - runTest("jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/"); - } - @TestMetadata("secondaryConstructorInlined") public void testSecondaryConstructorInlined() throws Exception { runTest("jps-plugin/testData/incremental/pureKotlin/secondaryConstructorInlined/"); diff --git a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsKlibCompilerWithScopeExpansionRunnerTestGenerated.java b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsKlibCompilerWithScopeExpansionRunnerTestGenerated.java index 4e71e9f4dc3..167f494865b 100644 --- a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsKlibCompilerWithScopeExpansionRunnerTestGenerated.java +++ b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsKlibCompilerWithScopeExpansionRunnerTestGenerated.java @@ -8,7 +8,6 @@ package org.jetbrains.kotlin.incremental; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; -import org.jetbrains.kotlin.test.MuteExtraSuffix; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -20,7 +19,6 @@ import java.util.regex.Pattern; @RunWith(JUnit3RunnerWithInners.class) public class IncrementalJsKlibCompilerWithScopeExpansionRunnerTestGenerated extends AbstractIncrementalJsKlibCompilerWithScopeExpansionRunnerTest { @TestMetadata("jps-plugin/testData/incremental/pureKotlin") - @MuteExtraSuffix(".jsklib") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) public static class PureKotlin extends AbstractIncrementalJsKlibCompilerWithScopeExpansionRunnerTest { @@ -64,7 +62,7 @@ public class IncrementalJsKlibCompilerWithScopeExpansionRunnerTestGenerated exte } public void testAllFilesPresentInPureKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/pureKotlin"), Pattern.compile("^([^\\.]+)$"), null, false); + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/pureKotlin"), Pattern.compile("^([^\\.]+)$"), Pattern.compile("^sealed.*"), false); } @TestMetadata("annotations") @@ -572,31 +570,6 @@ public class IncrementalJsKlibCompilerWithScopeExpansionRunnerTestGenerated exte runTest("jps-plugin/testData/incremental/pureKotlin/returnTypeChanged/"); } - @TestMetadata("sealedClassesAddImplements") - public void testSealedClassesAddImplements() throws Exception { - runTest("jps-plugin/testData/incremental/pureKotlin/sealedClassesAddImplements/"); - } - - @TestMetadata("sealedClassesAddInheritor") - public void testSealedClassesAddInheritor() throws Exception { - runTest("jps-plugin/testData/incremental/pureKotlin/sealedClassesAddInheritor/"); - } - - @TestMetadata("sealedClassesRemoveImplements") - public void testSealedClassesRemoveImplements() throws Exception { - runTest("jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveImplements/"); - } - - @TestMetadata("sealedClassesRemoveInheritor") - public void testSealedClassesRemoveInheritor() throws Exception { - runTest("jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveInheritor/"); - } - - @TestMetadata("sealedClassesUseSwitch") - public void testSealedClassesUseSwitch() throws Exception { - runTest("jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/"); - } - @TestMetadata("secondaryConstructorInlined") public void testSecondaryConstructorInlined() throws Exception { runTest("jps-plugin/testData/incremental/pureKotlin/secondaryConstructorInlined/"); diff --git a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt index 066125041f5..9a4fe629763 100644 --- a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt +++ b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt @@ -194,7 +194,6 @@ import org.jetbrains.kotlinx.serialization.AbstractSerializationPluginDiagnostic fun main(args: Array) { System.setProperty("java.awt.headless", "true") - generateTestGroupSuite(args) { testGroup("idea/jvm-debugger/jvm-debugger-test/test", "idea/jvm-debugger/jvm-debugger-test/testData") { testClass { @@ -1530,7 +1529,8 @@ fun main(args: Array) { } testClass(annotations = listOf(muteExtraSuffix(".jsklib"))) { - model("incremental/pureKotlin", extension = null, recursive = false) + // IC of sealed interfaces are not supported in JS + model("incremental/pureKotlin", extension = null, recursive = false, excludedPattern = "^sealed.*") model("incremental/classHierarchyAffected", extension = null, recursive = false) model("incremental/js", extension = null, excludeParentDirs = true) } @@ -1542,7 +1542,8 @@ fun main(args: Array) { } testClass { - model("incremental/pureKotlin", extension = null, recursive = false) + // IC of sealed interfaces are not supported in JS + model("incremental/pureKotlin", extension = null, recursive = false, excludedPattern = "^sealed.*") model("incremental/classHierarchyAffected", extension = null, recursive = false) model("incremental/js", extension = null, excludeParentDirs = true) model("incremental/scopeExpansion", extension = null, excludeParentDirs = true) diff --git a/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/IrKotlinEvaluateExpressionTestGenerated.java b/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/IrKotlinEvaluateExpressionTestGenerated.java index 8b7ec2a5965..bb86570616d 100644 --- a/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/IrKotlinEvaluateExpressionTestGenerated.java +++ b/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/IrKotlinEvaluateExpressionTestGenerated.java @@ -606,7 +606,7 @@ public class IrKotlinEvaluateExpressionTestGenerated extends AbstractIrKotlinEva runTest("idea/jvm-debugger/jvm-debugger-test/testData/evaluation/singleBreakpoint/coroutines/anyUpdateVariable.kt"); } - @TestMetadata("capturedReceiverName.kt") + @TestMetadata("capturedReceiverName.kt") public void testCapturedReceiverName() throws Exception { runTest("idea/jvm-debugger/jvm-debugger-test/testData/evaluation/singleBreakpoint/coroutines/capturedReceiverName.kt"); } diff --git a/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddImplements/sealedClassesAddImplements.jsklib.mute b/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddImplements/sealedClassesAddImplements.jsklib.mute deleted file mode 100644 index 45f4097dd42..00000000000 --- a/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddImplements/sealedClassesAddImplements.jsklib.mute +++ /dev/null @@ -1 +0,0 @@ -IC of sealed interfaces are not supported in JS diff --git a/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddInheritor/sealedClassesAddInheritor.jsklib.mute b/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddInheritor/sealedClassesAddInheritor.jsklib.mute deleted file mode 100644 index 45f4097dd42..00000000000 --- a/jps-plugin/testData/incremental/pureKotlin/sealedClassesAddInheritor/sealedClassesAddInheritor.jsklib.mute +++ /dev/null @@ -1 +0,0 @@ -IC of sealed interfaces are not supported in JS diff --git a/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveImplements/sealedClassesRemoveImplements.jsklib.mute b/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveImplements/sealedClassesRemoveImplements.jsklib.mute deleted file mode 100644 index 45f4097dd42..00000000000 --- a/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveImplements/sealedClassesRemoveImplements.jsklib.mute +++ /dev/null @@ -1 +0,0 @@ -IC of sealed interfaces are not supported in JS diff --git a/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveInheritor/sealedClassesRemoveInheritor.jsklib.mute b/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveInheritor/sealedClassesRemoveInheritor.jsklib.mute deleted file mode 100644 index 45f4097dd42..00000000000 --- a/jps-plugin/testData/incremental/pureKotlin/sealedClassesRemoveInheritor/sealedClassesRemoveInheritor.jsklib.mute +++ /dev/null @@ -1 +0,0 @@ -IC of sealed interfaces are not supported in JS diff --git a/jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/sealedClassesUseSwitch.jsklib.mute b/jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/sealedClassesUseSwitch.jsklib.mute deleted file mode 100644 index 45f4097dd42..00000000000 --- a/jps-plugin/testData/incremental/pureKotlin/sealedClassesUseSwitch/sealedClassesUseSwitch.jsklib.mute +++ /dev/null @@ -1 +0,0 @@ -IC of sealed interfaces are not supported in JS From 64ce307f7faa1429780855727f3a5ed7ec55ba95 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Mon, 14 Dec 2020 12:27:46 +0300 Subject: [PATCH 110/196] [TEST] Drop mechanism for muting tests with .mute files This mechanism is deprecated and replaced with muting in database (.csv files) --- ...ntalJsKlibCompilerRunnerTestGenerated.java | 7 - .../kotlin/test/KotlinTestUtils.java | 2 +- .../org/jetbrains/kotlin/test/muteWithFile.kt | 129 ------------------ .../generators/model/AnnotationModel.kt | 4 - .../kotlin/generators/tests/GenerateTests.kt | 9 +- .../generators/tests/GenerateTests.kt.as41 | 9 +- .../generators/tests/GenerateTests.kt.as42 | 7 +- ...igateJavaToLibrarySourceTestGenerated.java | 2 - .../NavigateToLibrarySourceTestGenerated.java | 2 - ...ateToLibrarySourceTestWithJSGenerated.java | 2 - 10 files changed, 12 insertions(+), 161 deletions(-) delete mode 100644 compiler/tests-common/tests/org/jetbrains/kotlin/test/muteWithFile.kt diff --git a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsKlibCompilerRunnerTestGenerated.java b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsKlibCompilerRunnerTestGenerated.java index a2ebc94ad72..b34e6388890 100644 --- a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsKlibCompilerRunnerTestGenerated.java +++ b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsKlibCompilerRunnerTestGenerated.java @@ -8,7 +8,6 @@ package org.jetbrains.kotlin.incremental; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; -import org.jetbrains.kotlin.test.MuteExtraSuffix; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -21,7 +20,6 @@ import java.util.regex.Pattern; public class IncrementalJsKlibCompilerRunnerTestGenerated extends AbstractIncrementalJsKlibCompilerRunnerTest { @TestMetadata("jps-plugin/testData/incremental/pureKotlin") @TestDataPath("$PROJECT_ROOT") - @MuteExtraSuffix(".jsklib") @RunWith(JUnit3RunnerWithInners.class) public static class PureKotlin extends AbstractIncrementalJsKlibCompilerRunnerTest { private void runTest(String testDataFilePath) throws Exception { @@ -630,7 +628,6 @@ public class IncrementalJsKlibCompilerRunnerTestGenerated extends AbstractIncrem @TestMetadata("jps-plugin/testData/incremental/classHierarchyAffected") @TestDataPath("$PROJECT_ROOT") - @MuteExtraSuffix(".jsklib") @RunWith(JUnit3RunnerWithInners.class) public static class ClassHierarchyAffected extends AbstractIncrementalJsKlibCompilerRunnerTest { private void runTest(String testDataFilePath) throws Exception { @@ -844,7 +841,6 @@ public class IncrementalJsKlibCompilerRunnerTestGenerated extends AbstractIncrem @TestMetadata("jps-plugin/testData/incremental/js") @TestDataPath("$PROJECT_ROOT") - @MuteExtraSuffix(".jsklib") @RunWith(JUnit3RunnerWithInners.class) public static class Js extends AbstractIncrementalJsKlibCompilerRunnerTest { private void runTest(String testDataFilePath) throws Exception { @@ -862,7 +858,6 @@ public class IncrementalJsKlibCompilerRunnerTestGenerated extends AbstractIncrem @TestMetadata("jps-plugin/testData/incremental/js/friendsModuleDisabled") @TestDataPath("$PROJECT_ROOT") - @MuteExtraSuffix(".jsklib") @RunWith(JUnit3RunnerWithInners.class) public static class FriendsModuleDisabled extends AbstractIncrementalJsKlibCompilerRunnerTest { private void runTest(String testDataFilePath) throws Exception { @@ -880,7 +875,6 @@ public class IncrementalJsKlibCompilerRunnerTestGenerated extends AbstractIncrem @TestMetadata("jps-plugin/testData/incremental/js/friendsModuleDisabled/internalInlineFunctionIsChanged") @TestDataPath("$PROJECT_ROOT") - @MuteExtraSuffix(".jsklib") @RunWith(JUnit3RunnerWithInners.class) public static class InternalInlineFunctionIsChanged extends AbstractIncrementalJsKlibCompilerRunnerTest { private void runTest(String testDataFilePath) throws Exception { @@ -895,7 +889,6 @@ public class IncrementalJsKlibCompilerRunnerTestGenerated extends AbstractIncrem @TestMetadata("jps-plugin/testData/incremental/js/inlineFunctionLocalDeclarationChanges") @TestDataPath("$PROJECT_ROOT") - @MuteExtraSuffix(".jsklib") @RunWith(JUnit3RunnerWithInners.class) public static class InlineFunctionLocalDeclarationChanges extends AbstractIncrementalJsKlibCompilerRunnerTest { private void runTest(String testDataFilePath) throws Exception { diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/test/KotlinTestUtils.java b/compiler/tests-common/tests/org/jetbrains/kotlin/test/KotlinTestUtils.java index fd1d1ba3761..dcf3e7f19b1 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/test/KotlinTestUtils.java +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/test/KotlinTestUtils.java @@ -599,7 +599,7 @@ public class KotlinTestUtils { return; } } - MuteWithFileKt.testWithMuteInFile(test, testCase).invoke(testDataFilePath); + test.invoke(testDataFilePath); } private static boolean isRunTestOverridden(TestCase testCase) { diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/test/muteWithFile.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/test/muteWithFile.kt deleted file mode 100644 index d7d6095f271..00000000000 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/test/muteWithFile.kt +++ /dev/null @@ -1,129 +0,0 @@ -/* - * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors. - * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. - */ - -package org.jetbrains.kotlin.test - -import junit.framework.TestCase -import org.jetbrains.kotlin.test.KotlinTestUtils.DoTest -import org.junit.Assert -import java.io.File - -private val RUN_MUTED_TESTS = java.lang.Boolean.getBoolean("org.jetbrains.kotlin.run.muted.tests") -private val AUTOMATICALLY_MUTE_FAILED_TESTS_WITH_CONTENT: String? = null -private val AUTOMATICALLY_GENERATE_FAIL_FILE_FOR_FAILED_TESTS: Boolean = false - -annotation class MuteExtraSuffix(val value: String = "") - -@Throws(Exception::class) -fun testWithMuteInFile(test: DoTest, testCase: TestCase?): DoTest { - val extraSuffix = testCase?.javaClass?.getAnnotation(MuteExtraSuffix::class.java)?.value ?: "" - return testWithMuteInFile(test, extraSuffix) -} - -@Throws(Exception::class) -fun testWithMuteInFile(test: DoTest, extraSuffix: String): DoTest { - return object : DoTest { - override fun invoke(filePath: String) { - val testDataFile = File(filePath) - - val isMutedWithFile = isMutedWithFile(testDataFile, extraSuffix) - if (isMutedWithFile && !RUN_MUTED_TESTS) { - System.err.println("MUTED TEST: $filePath") - return - } - - val failFile = failFile(testDataFile, extraSuffix) - val hasFailFile = failFile != null - - try { - test.invoke(filePath) - } catch (e: Throwable) { - if (checkFailFile(e, testDataFile, extraSuffix)) { - System.err.println("MUTED TEST (FAIL): $filePath") - return - } - - if (!isMutedWithFile && !hasFailFile && AUTOMATICALLY_MUTE_FAILED_TESTS_WITH_CONTENT != null) { - createMuteFile(testDataFile, extraSuffix, AUTOMATICALLY_MUTE_FAILED_TESTS_WITH_CONTENT) - } - throw e - } - - Assert.assertNull("Test is good but there is a fail file", failFile) - } - } -} - -private fun isMutedWithFile(testPathFile: File, extraSuffix: String): Boolean { - return muteFile(testPathFile, extraSuffix) != null -} - -private fun createMuteFile(testDataFile: File, extraSuffix: String, text: String) { - require(text.isNotEmpty()) { "Mute text must not be empty" } - - muteFileNoCheck(testDataFile, extraSuffix).writeText(text) -} - -private fun rawFileNoChecks(testPathFile: File, extraSuffix: String, suffix: String): File { - return when { - testPathFile.isDirectory -> - File(testPathFile, "${testPathFile.name}$extraSuffix$suffix") - else -> - File("${testPathFile.path}$extraSuffix$suffix") - } -} - -private fun muteFileNoCheck(testPathFile: File, extraSuffix: String): File { - return rawFileNoChecks(testPathFile, extraSuffix, ".mute") -} - -private fun failFileNoCheck(testPathFile: File, extraSuffix: String): File { - return rawFileNoChecks(testPathFile, extraSuffix, ".fail") -} - -private fun muteFile(testPathFile: File, extraSuffix: String): File? { - val muteFile = muteFileNoCheck(testPathFile, extraSuffix) - - if (muteFile.exists() && muteFile.isFile) { - return muteFile - } - - return null -} - -private fun failFile(testDataFile: File, extraSuffix: String): File? { - val failFile = failFileNoCheck(testDataFile, extraSuffix) - - if (!failFile.exists() || !failFile.isFile) { - return null - } - - return failFile -} - -private fun failMessage(failure: Throwable): String { - val cause = failure.cause - return failure.message + - if (cause != null) { - "\n" + cause - } else { - "" - } -} - -private fun checkFailFile(failure: Throwable, testDataFile: File, extraSuffix: String): Boolean { - val failFile = failFile(testDataFile, extraSuffix) - - if (failFile == null) { - if (AUTOMATICALLY_GENERATE_FAIL_FILE_FOR_FAILED_TESTS) { - failFileNoCheck(testDataFile, extraSuffix).writeText(failMessage(failure)) - } - - return false - } - - KotlinTestUtils.assertEqualsToFile(failFile, failMessage(failure)) - return true -} \ No newline at end of file diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/model/AnnotationModel.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/model/AnnotationModel.kt index 79dfe7945b6..5410ea57abc 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/model/AnnotationModel.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/model/AnnotationModel.kt @@ -5,7 +5,6 @@ package org.jetbrains.kotlin.generators.model -import org.jetbrains.kotlin.test.MuteExtraSuffix import org.jetbrains.kotlin.utils.Printer class AnnotationModel( @@ -17,6 +16,3 @@ class AnnotationModel( p.print("@${annotation.simpleName}($argumentsString)") } } - -fun muteExtraSuffix(suffix: String) = AnnotationModel(MuteExtraSuffix::class.java, arguments = listOf(suffix)) - diff --git a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt index 9a4fe629763..2ee65a13b1d 100644 --- a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt +++ b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt @@ -26,7 +26,6 @@ import org.jetbrains.kotlin.formatter.AbstractFormatterTest import org.jetbrains.kotlin.formatter.AbstractTypingIndentationTestBase import org.jetbrains.kotlin.generators.TestGroup import org.jetbrains.kotlin.generators.generateTestGroupSuite -import org.jetbrains.kotlin.generators.model.muteExtraSuffix import org.jetbrains.kotlin.generators.util.TestGeneratorUtil.KT_OR_KTS import org.jetbrains.kotlin.generators.util.TestGeneratorUtil.KT_OR_KTS_WITHOUT_DOTS_IN_NAME import org.jetbrains.kotlin.generators.util.TestGeneratorUtil.KT_WITHOUT_DOTS_IN_NAME @@ -384,15 +383,15 @@ fun main(args: Array) { model("navigation/gotoSymbol", testMethod = "doSymbolTest") } - testClass(annotations = listOf(muteExtraSuffix(".libsrc"))) { + testClass() { model("decompiler/navigation/usercode") } - testClass(annotations = listOf(muteExtraSuffix(".libsrc"))) { + testClass() { model("decompiler/navigation/userJavaCode", pattern = "^(.+)\\.java$") } - testClass(annotations = listOf(muteExtraSuffix(".libsrcjs"))) { + testClass() { model("decompiler/navigation/usercode", testClassName = "UsercodeWithJSModule") } @@ -1528,7 +1527,7 @@ fun main(args: Array) { model("incremental/js", extension = null, excludeParentDirs = true) } - testClass(annotations = listOf(muteExtraSuffix(".jsklib"))) { + testClass() { // IC of sealed interfaces are not supported in JS model("incremental/pureKotlin", extension = null, recursive = false, excludedPattern = "^sealed.*") model("incremental/classHierarchyAffected", extension = null, recursive = false) diff --git a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.as41 b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.as41 index bf16f61fa92..8f42e940994 100644 --- a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.as41 +++ b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.as41 @@ -31,7 +31,6 @@ import org.jetbrains.kotlin.formatter.AbstractFormatterTest import org.jetbrains.kotlin.formatter.AbstractTypingIndentationTestBase import org.jetbrains.kotlin.generators.TestGroup import org.jetbrains.kotlin.generators.generateTestGroupSuite -import org.jetbrains.kotlin.generators.model.muteExtraSuffix import org.jetbrains.kotlin.generators.util.TestGeneratorUtil.KT_OR_KTS import org.jetbrains.kotlin.generators.util.TestGeneratorUtil.KT_OR_KTS_WITHOUT_DOTS_IN_NAME import org.jetbrains.kotlin.generators.util.TestGeneratorUtil.KT_WITHOUT_DOTS_IN_NAME @@ -306,16 +305,16 @@ fun main(args: Array) { model("navigation/gotoSymbol", testMethod = "doSymbolTest") } - testClass(annotations = listOf(muteExtraSuffix(".libsrc"))) { + testClass() { model("decompiler/navigation/usercode") } - testClass(annotations = listOf(muteExtraSuffix(".libsrc"))) { + testClass() { model("decompiler/navigation/userJavaCode", pattern = "^(.+)\\.java$") } - testClass(annotations = listOf(muteExtraSuffix(".libsrcjs"))) { - model("decompiler/navigation/usercode", testClassName ="UsercodeWithJSModule") + testClass() { + model("decompiler/navigation/usercode", testClassName = "UsercodeWithJSModule") } testClass { diff --git a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.as42 b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.as42 index 03b01f09375..8d15228c1a8 100644 --- a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.as42 +++ b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.as42 @@ -31,7 +31,6 @@ import org.jetbrains.kotlin.formatter.AbstractFormatterTest import org.jetbrains.kotlin.formatter.AbstractTypingIndentationTestBase import org.jetbrains.kotlin.generators.TestGroup import org.jetbrains.kotlin.generators.generateTestGroupSuite -import org.jetbrains.kotlin.generators.model.muteExtraSuffix import org.jetbrains.kotlin.generators.util.TestGeneratorUtil.KT_OR_KTS import org.jetbrains.kotlin.generators.util.TestGeneratorUtil.KT_OR_KTS_WITHOUT_DOTS_IN_NAME import org.jetbrains.kotlin.generators.util.TestGeneratorUtil.KT_WITHOUT_DOTS_IN_NAME @@ -302,15 +301,15 @@ fun main(args: Array) { model("navigation/gotoSymbol", testMethod = "doSymbolTest") } - testClass(annotations = listOf(muteExtraSuffix(".libsrc"))) { + testClass() { model("decompiler/navigation/usercode") } - testClass(annotations = listOf(muteExtraSuffix(".libsrc"))) { + testClass() { model("decompiler/navigation/userJavaCode", pattern = "^(.+)\\.java$") } - testClass(annotations = listOf(muteExtraSuffix(".libsrcjs"))) { + testClass() { model("decompiler/navigation/usercode", testClassName ="UsercodeWithJSModule") } diff --git a/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigateJavaToLibrarySourceTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigateJavaToLibrarySourceTestGenerated.java index 3b692be914d..d4651f82671 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigateJavaToLibrarySourceTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigateJavaToLibrarySourceTestGenerated.java @@ -8,7 +8,6 @@ package org.jetbrains.kotlin.idea.decompiler.navigation; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; -import org.jetbrains.kotlin.test.MuteExtraSuffix; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -19,7 +18,6 @@ import java.util.regex.Pattern; @SuppressWarnings("all") @TestMetadata("idea/testData/decompiler/navigation/userJavaCode") @TestDataPath("$PROJECT_ROOT") -@MuteExtraSuffix(".libsrc") @RunWith(JUnit3RunnerWithInners.class) public class NavigateJavaToLibrarySourceTestGenerated extends AbstractNavigateJavaToLibrarySourceTest { private void runTest(String testDataFilePath) throws Exception { diff --git a/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigateToLibrarySourceTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigateToLibrarySourceTestGenerated.java index f90b0c6acb1..15cefa3c1ab 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigateToLibrarySourceTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigateToLibrarySourceTestGenerated.java @@ -8,7 +8,6 @@ package org.jetbrains.kotlin.idea.decompiler.navigation; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; -import org.jetbrains.kotlin.test.MuteExtraSuffix; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -19,7 +18,6 @@ import java.util.regex.Pattern; @SuppressWarnings("all") @TestMetadata("idea/testData/decompiler/navigation/usercode") @TestDataPath("$PROJECT_ROOT") -@MuteExtraSuffix(".libsrc") @RunWith(JUnit3RunnerWithInners.class) public class NavigateToLibrarySourceTestGenerated extends AbstractNavigateToLibrarySourceTest { private void runTest(String testDataFilePath) throws Exception { diff --git a/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigateToLibrarySourceTestWithJSGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigateToLibrarySourceTestWithJSGenerated.java index 5ea7bf94c9e..ee52643950d 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigateToLibrarySourceTestWithJSGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigateToLibrarySourceTestWithJSGenerated.java @@ -8,7 +8,6 @@ package org.jetbrains.kotlin.idea.decompiler.navigation; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; -import org.jetbrains.kotlin.test.MuteExtraSuffix; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -19,7 +18,6 @@ import java.util.regex.Pattern; @SuppressWarnings("all") @TestMetadata("idea/testData/decompiler/navigation/usercode") @TestDataPath("$PROJECT_ROOT") -@MuteExtraSuffix(".libsrcjs") @RunWith(JUnit3RunnerWithInners.class) public class NavigateToLibrarySourceTestWithJSGenerated extends AbstractNavigateToLibrarySourceTestWithJS { private void runTest(String testDataFilePath) throws Exception { From 9e2d6914254055c2ed9f3b376368ee48258af433 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Mon, 14 Dec 2020 13:26:50 +0300 Subject: [PATCH 111/196] [TEST] Move utils for checking all files presented to KtTestUtil This is needed to remove dependency on :tests-common from module with abstract test generators --- .../org/jetbrains/kotlin/test/Assertions.kt | 36 ++++ .../kotlin/test/InTextDirectivesUtils.java | 3 +- .../jetbrains/kotlin/test/TargetBackend.kt | 2 +- .../jetbrains/kotlin/test/TestMetadata.java | 0 .../kotlin/test/util/KtTestUtil.java | 204 ++++++++++++++++++ .../test/generators/NewTestGeneratorImpl.kt | 3 +- .../kotlin/test/KotlinTestUtils.java | 193 +---------------- .../kotlin/generators/TestGenerationDSL.kt | 1 - ...ModelTestAllFilesPresentMethodGenerator.kt | 4 +- ...stModelAllFilesPresentedMethodGenerator.kt | 4 +- .../generators/impl/TestGeneratorImpl.kt | 2 + .../generators/model/SimpleTestClassModel.kt | 1 - ...AbstractMultiFileJvmBasicCompletionTest.kt | 6 +- ...radleConfigureProjectByChangingFileTest.kt | 3 +- ...MavenConfigureProjectByChangingFileTest.kt | 3 +- .../checkers/AbstractPsiCheckerTest.java | 4 +- .../resolve/AbstractIdeLightClassTest.kt | 3 +- .../navigation/AbstractKotlinGotoTest.java | 4 +- .../AbstractParameterInfoTest.kt | 4 +- 19 files changed, 266 insertions(+), 214 deletions(-) create mode 100644 compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/Assertions.kt rename compiler/{tests-common => test-infrastructure-utils}/tests/org/jetbrains/kotlin/test/InTextDirectivesUtils.java (98%) rename compiler/{tests-common => test-infrastructure-utils}/tests/org/jetbrains/kotlin/test/TargetBackend.kt (91%) rename compiler/{tests-common => test-infrastructure-utils}/tests/org/jetbrains/kotlin/test/TestMetadata.java (100%) diff --git a/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/Assertions.kt b/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/Assertions.kt new file mode 100644 index 00000000000..c9a1d5c38b5 --- /dev/null +++ b/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/Assertions.kt @@ -0,0 +1,36 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +@file:JvmName("KtAssert") + +package org.jetbrains.kotlin.test + +import kotlin.contracts.ExperimentalContracts +import kotlin.contracts.contract + +/* + * Those functions are needed only in this module because it has no testing framework + * with assertions in it's dependencies + */ + +internal fun fail(message: String) { + throw AssertionError(message) +} + +@OptIn(ExperimentalContracts::class) +internal fun assertNotNull(message: String, value: Any?) { + contract { + returns() implies (value != null) + } + if (value == null) { + fail(message) + } +} + +internal fun assertTrue(message: String, value: Boolean) { + if (!value) { + fail(message) + } +} diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/test/InTextDirectivesUtils.java b/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/InTextDirectivesUtils.java similarity index 98% rename from compiler/tests-common/tests/org/jetbrains/kotlin/test/InTextDirectivesUtils.java rename to compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/InTextDirectivesUtils.java index e54bc1a80fa..deed34be588 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/test/InTextDirectivesUtils.java +++ b/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/InTextDirectivesUtils.java @@ -13,7 +13,6 @@ import kotlin.text.StringsKt; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.utils.ExceptionUtilsKt; -import org.junit.Assert; import java.io.BufferedReader; import java.io.File; @@ -149,7 +148,7 @@ public final class InTextDirectivesUtils { prefixes.removeAll(cleanDirectivesFromComments(knownPrefixes)); - Assert.assertTrue("File contains some unexpected directives" + prefixes, prefixes.isEmpty()); + KtAssert.assertTrue("File contains some unexpected directives" + prefixes, prefixes.isEmpty()); } private static String probableDirective(String line) { diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/test/TargetBackend.kt b/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/TargetBackend.kt similarity index 91% rename from compiler/tests-common/tests/org/jetbrains/kotlin/test/TargetBackend.kt rename to compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/TargetBackend.kt index 450f0c4679d..93f1d5d8186 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/test/TargetBackend.kt +++ b/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/TargetBackend.kt @@ -1,5 +1,5 @@ /* - * Copyright 2010-2018 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/test/TestMetadata.java b/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/TestMetadata.java similarity index 100% rename from compiler/tests-common/tests/org/jetbrains/kotlin/test/TestMetadata.java rename to compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/TestMetadata.java diff --git a/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/util/KtTestUtil.java b/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/util/KtTestUtil.java index 1d9b56b558b..2f096006e55 100644 --- a/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/util/KtTestUtil.java +++ b/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/util/KtTestUtil.java @@ -6,6 +6,7 @@ package org.jetbrains.kotlin.test.util; import com.intellij.openapi.project.Project; +import com.intellij.openapi.util.SystemInfo; import com.intellij.openapi.util.io.FileUtil; import com.intellij.openapi.util.text.StringUtilRt; import com.intellij.openapi.vfs.CharsetToolkit; @@ -13,15 +14,26 @@ import com.intellij.psi.PsiFileFactory; import com.intellij.psi.impl.PsiFileFactoryImpl; import com.intellij.testFramework.LightVirtualFile; import com.intellij.util.PathUtil; +import com.intellij.util.containers.ContainerUtil; +import kotlin.collections.SetsKt; import org.jetbrains.annotations.NonNls; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.idea.KotlinLanguage; import org.jetbrains.kotlin.psi.KtFile; +import org.jetbrains.kotlin.test.KtAssert; +import org.jetbrains.kotlin.test.TargetBackend; +import org.jetbrains.kotlin.test.TestMetadata; import java.io.File; import java.io.FileNotFoundException; import java.io.IOException; +import java.lang.reflect.Method; +import java.util.HashSet; +import java.util.Set; +import java.util.regex.Pattern; + +import static org.jetbrains.kotlin.test.InTextDirectivesUtils.isCompatibleTarget; public class KtTestUtil { private static String homeDir = computeHomeDirectory(); @@ -193,4 +205,196 @@ public class KtTestUtil { throw new IllegalStateException("Failed to create " + file); } } + + // ---------------------- assert testdata presented by metadata ---------------------- + + private static final String PLEASE_REGENERATE_TESTS = "Please regenerate tests (GenerateTests.kt)"; + + public static void assertAllTestsPresentByMetadataWithExcluded( + @NotNull Class testCaseClass, + @NotNull File testDataDir, + @NotNull Pattern filenamePattern, + @Nullable Pattern excludedPattern, + boolean recursive, + @NotNull String... excludeDirs + ) { + assertAllTestsPresentByMetadataWithExcluded(testCaseClass, testDataDir, filenamePattern, excludedPattern, TargetBackend.ANY, recursive, excludeDirs); + } + + public static void assertAllTestsPresentByMetadata( + @NotNull Class testCaseClass, + @NotNull File testDataDir, + @NotNull Pattern filenamePattern, + boolean recursive, + @NotNull String... excludeDirs + ) { + assertAllTestsPresentByMetadata( + testCaseClass, + testDataDir, + filenamePattern, + TargetBackend.ANY, + recursive, + excludeDirs + ); + } + + public static void assertAllTestsPresentByMetadataWithExcluded( + @NotNull Class testCaseClass, + @NotNull File testDataDir, + @NotNull Pattern filenamePattern, + @Nullable Pattern excludedPattern, + @NotNull TargetBackend targetBackend, + boolean recursive, + @NotNull String... excludeDirs + ) { + File rootFile = new File(getTestsRoot(testCaseClass)); + + Set filePaths = collectPathsMetadata(testCaseClass); + Set exclude = SetsKt.setOf(excludeDirs); + + File[] files = testDataDir.listFiles(); + if (files != null) { + for (File file : files) { + if (file.isDirectory()) { + if (recursive && containsTestData(file, filenamePattern, excludedPattern) && !exclude.contains(file.getName())) { + assertTestClassPresentByMetadata(testCaseClass, file); + } + } + else { + boolean excluded = excludedPattern != null && excludedPattern.matcher(file.getName()).matches(); + if (!excluded && filenamePattern.matcher(file.getName()).matches() && isCompatibleTarget(targetBackend, file)) { + assertFilePathPresent(file, rootFile, filePaths); + } + } + } + } + } + + public static void assertAllTestsPresentByMetadata( + @NotNull Class testCaseClass, + @NotNull File testDataDir, + @NotNull Pattern filenamePattern, + @NotNull TargetBackend targetBackend, + boolean recursive, + @NotNull String... excludeDirs + ) { + assertAllTestsPresentByMetadataWithExcluded(testCaseClass, testDataDir, filenamePattern, null, targetBackend, recursive, excludeDirs); + } + + public static void assertAllTestsPresentInSingleGeneratedClass( + @NotNull Class testCaseClass, + @NotNull File testDataDir, + @NotNull Pattern filenamePattern + ) { + assertAllTestsPresentInSingleGeneratedClass(testCaseClass, testDataDir, filenamePattern, TargetBackend.ANY); + } + + public static void assertAllTestsPresentInSingleGeneratedClassWithExcluded( + @NotNull Class testCaseClass, + @NotNull File testDataDir, + @NotNull Pattern filenamePattern, + @Nullable Pattern excludePattern + ) { + assertAllTestsPresentInSingleGeneratedClass(testCaseClass, testDataDir, filenamePattern, excludePattern, TargetBackend.ANY); + } + + public static void assertAllTestsPresentInSingleGeneratedClass( + @NotNull Class testCaseClass, + @NotNull File testDataDir, + @NotNull Pattern filenamePattern, + @NotNull TargetBackend targetBackend + ) { + assertAllTestsPresentInSingleGeneratedClass(testCaseClass, testDataDir, filenamePattern, null, targetBackend); + } + + public static void assertAllTestsPresentInSingleGeneratedClass( + @NotNull Class testCaseClass, + @NotNull File testDataDir, + @NotNull Pattern filenamePattern, + @Nullable Pattern excludePattern, + @NotNull TargetBackend targetBackend + ) { + File rootFile = new File(getTestsRoot(testCaseClass)); + + Set filePaths = collectPathsMetadata(testCaseClass); + + FileUtil.processFilesRecursively(testDataDir, file -> { + boolean excluded = excludePattern != null && excludePattern.matcher(file.getName()).matches(); + if (file.isFile() && !excluded && filenamePattern.matcher(file.getName()).matches() && isCompatibleTarget(targetBackend, file)) { + assertFilePathPresent(file, rootFile, filePaths); + } + + return true; + }); + } + + private static void assertFilePathPresent(File file, File rootFile, Set filePaths) { + String path = FileUtil.getRelativePath(rootFile, file); + if (path != null) { + String relativePath = nameToCompare(path); + if (!filePaths.contains(relativePath)) { + KtAssert.fail("Test data file missing from the generated test class: " + file + "\n" + PLEASE_REGENERATE_TESTS); + } + } + } + + private static Set collectPathsMetadata(Class testCaseClass) { + return new HashSet<>(ContainerUtil.map(collectMethodsMetadata(testCaseClass), KtTestUtil::nameToCompare)); + } + + @Nullable + public static String getMethodMetadata(Method method) { + TestMetadata testMetadata = method.getAnnotation(TestMetadata.class); + return (testMetadata != null) ? testMetadata.value() : null; + } + + private static Set collectMethodsMetadata(Class testCaseClass) { + Set filePaths = new HashSet<>(); + for (Method method : testCaseClass.getDeclaredMethods()) { + String path = getMethodMetadata(method); + if (path != null) { + filePaths.add(path); + } + } + return filePaths; + } + + private static boolean containsTestData(File dir, Pattern filenamePattern, @Nullable Pattern excludedPattern) { + File[] files = dir.listFiles(); + assert files != null; + for (File file : files) { + if (file.isDirectory()) { + if (containsTestData(file, filenamePattern, excludedPattern)) { + return true; + } + } + else { + boolean excluded = excludedPattern != null && excludedPattern.matcher(file.getName()).matches(); + if (! excluded && filenamePattern.matcher(file.getName()).matches()) { + return true; + } + } + } + return false; + } + + private static void assertTestClassPresentByMetadata(@NotNull Class outerClass, @NotNull File testDataDir) { + for (Class nestedClass : outerClass.getDeclaredClasses()) { + TestMetadata testMetadata = nestedClass.getAnnotation(TestMetadata.class); + if (testMetadata != null && testMetadata.value().equals(KtTestUtil.getFilePath(testDataDir))) { + return; + } + } + KtAssert.fail("Test data directory missing from the generated test class: " + testDataDir + "\n" + PLEASE_REGENERATE_TESTS); + } + + public static String getTestsRoot(@NotNull Class testCaseClass) { + TestMetadata testClassMetadata = testCaseClass.getAnnotation(TestMetadata.class); + KtAssert.assertNotNull("No metadata for class: " + testCaseClass, testClassMetadata); + return testClassMetadata.value(); + } + + public static String nameToCompare(@NotNull String name) { + return (SystemInfo.isFileSystemCaseSensitive ? name : name.toLowerCase()).replace('\\', '/'); + } } diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/generators/NewTestGeneratorImpl.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/generators/NewTestGeneratorImpl.kt index 715155167c8..ee63c382f21 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/generators/NewTestGeneratorImpl.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/generators/NewTestGeneratorImpl.kt @@ -13,6 +13,7 @@ import org.jetbrains.kotlin.generators.model.* import org.jetbrains.kotlin.generators.util.GeneratorsFileUtil import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.TestMetadata +import org.jetbrains.kotlin.test.util.KtTestUtil import org.jetbrains.kotlin.utils.Printer import org.junit.jupiter.api.Nested import org.junit.jupiter.api.Test @@ -130,7 +131,7 @@ object NewTestGeneratorImpl : TestGenerator(METHOD_GENERATORS) { p.println("package $suiteClassPackage;") p.println() p.println("import com.intellij.testFramework.TestDataPath;") - p.println("import ${KotlinTestUtils::class.java.canonicalName};") + p.println("import ${KtTestUtil::class.java.canonicalName};") for (clazz in testClassModels.flatMapTo(mutableSetOf()) { classModel -> classModel.imports }) { p.println("import ${clazz.name};") diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/test/KotlinTestUtils.java b/compiler/tests-common/tests/org/jetbrains/kotlin/test/KotlinTestUtils.java index dcf3e7f19b1..8863c64da1b 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/test/KotlinTestUtils.java +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/test/KotlinTestUtils.java @@ -19,11 +19,9 @@ import com.intellij.openapi.vfs.CharsetToolkit; import com.intellij.psi.PsiElement; import com.intellij.rt.execution.junit.FileComparisonFailure; import com.intellij.testFramework.TestDataFile; -import com.intellij.util.containers.ContainerUtil; import junit.framework.TestCase; import kotlin.Unit; import kotlin.collections.CollectionsKt; -import kotlin.collections.SetsKt; import kotlin.jvm.functions.Function0; import kotlin.jvm.functions.Function1; import org.jetbrains.annotations.NotNull; @@ -74,7 +72,6 @@ public class KotlinTestUtils { public static String TEST_MODULE_NAME = "test-module"; public static final String TEST_GENERATOR_NAME = "org.jetbrains.kotlin.generators.tests.TestsPackage"; - private static final String PLEASE_REGENERATE_TESTS = "Please regenerate tests (GenerateTests.kt)"; private static final boolean RUN_IGNORED_TESTS_AS_REGULAR = Boolean.getBoolean("org.jetbrains.kotlin.run.ignored.tests.as.regular"); @@ -686,12 +683,6 @@ public class KotlinTestUtils { }; } - public static String getTestsRoot(@NotNull Class testCaseClass) { - TestMetadata testClassMetadata = testCaseClass.getAnnotation(TestMetadata.class); - Assert.assertNotNull("No metadata for class: " + testCaseClass, testClassMetadata); - return testClassMetadata.value(); - } - /** * @return test data file name specified in the metadata of test method */ @@ -699,191 +690,13 @@ public class KotlinTestUtils { public static String getTestDataFileName(@NotNull Class testCaseClass, @NotNull String testName) { try { Method method = testCaseClass.getDeclaredMethod(testName); - return getMethodMetadata(method); + return KtTestUtil.getMethodMetadata(method); } catch (NoSuchMethodException e) { throw new RuntimeException(e); } } - public static void assertAllTestsPresentByMetadataWithExcluded( - @NotNull Class testCaseClass, - @NotNull File testDataDir, - @NotNull Pattern filenamePattern, - @Nullable Pattern excludedPattern, - boolean recursive, - @NotNull String... excludeDirs - ) { - assertAllTestsPresentByMetadataWithExcluded(testCaseClass, testDataDir, filenamePattern, excludedPattern, TargetBackend.ANY, recursive, excludeDirs); - } - - public static void assertAllTestsPresentByMetadata( - @NotNull Class testCaseClass, - @NotNull File testDataDir, - @NotNull Pattern filenamePattern, - boolean recursive, - @NotNull String... excludeDirs - ) { - assertAllTestsPresentByMetadata( - testCaseClass, - testDataDir, - filenamePattern, - TargetBackend.ANY, - recursive, - excludeDirs - ); - } - - public static void assertAllTestsPresentByMetadataWithExcluded( - @NotNull Class testCaseClass, - @NotNull File testDataDir, - @NotNull Pattern filenamePattern, - @Nullable Pattern excludedPattern, - @NotNull TargetBackend targetBackend, - boolean recursive, - @NotNull String... excludeDirs - ) { - File rootFile = new File(getTestsRoot(testCaseClass)); - - Set filePaths = collectPathsMetadata(testCaseClass); - Set exclude = SetsKt.setOf(excludeDirs); - - File[] files = testDataDir.listFiles(); - if (files != null) { - for (File file : files) { - if (file.isDirectory()) { - if (recursive && containsTestData(file, filenamePattern, excludedPattern) && !exclude.contains(file.getName())) { - assertTestClassPresentByMetadata(testCaseClass, file); - } - } - else { - boolean excluded = excludedPattern != null && excludedPattern.matcher(file.getName()).matches(); - if (!excluded && filenamePattern.matcher(file.getName()).matches() && isCompatibleTarget(targetBackend, file)) { - assertFilePathPresent(file, rootFile, filePaths); - } - } - } - } - } - - public static void assertAllTestsPresentByMetadata( - @NotNull Class testCaseClass, - @NotNull File testDataDir, - @NotNull Pattern filenamePattern, - @NotNull TargetBackend targetBackend, - boolean recursive, - @NotNull String... excludeDirs - ) { - assertAllTestsPresentByMetadataWithExcluded(testCaseClass, testDataDir, filenamePattern, null, targetBackend, recursive, excludeDirs); - } - - public static void assertAllTestsPresentInSingleGeneratedClass( - @NotNull Class testCaseClass, - @NotNull File testDataDir, - @NotNull Pattern filenamePattern - ) { - assertAllTestsPresentInSingleGeneratedClass(testCaseClass, testDataDir, filenamePattern, TargetBackend.ANY); - } - - public static void assertAllTestsPresentInSingleGeneratedClassWithExcluded( - @NotNull Class testCaseClass, - @NotNull File testDataDir, - @NotNull Pattern filenamePattern, - @Nullable Pattern excludePattern - ) { - assertAllTestsPresentInSingleGeneratedClass(testCaseClass, testDataDir, filenamePattern, excludePattern, TargetBackend.ANY); - } - - public static void assertAllTestsPresentInSingleGeneratedClass( - @NotNull Class testCaseClass, - @NotNull File testDataDir, - @NotNull Pattern filenamePattern, - @NotNull TargetBackend targetBackend - ) { - assertAllTestsPresentInSingleGeneratedClass(testCaseClass, testDataDir, filenamePattern, null, targetBackend); - } - - public static void assertAllTestsPresentInSingleGeneratedClass( - @NotNull Class testCaseClass, - @NotNull File testDataDir, - @NotNull Pattern filenamePattern, - @Nullable Pattern excludePattern, - @NotNull TargetBackend targetBackend - ) { - File rootFile = new File(getTestsRoot(testCaseClass)); - - Set filePaths = collectPathsMetadata(testCaseClass); - - FileUtil.processFilesRecursively(testDataDir, file -> { - boolean excluded = excludePattern != null && excludePattern.matcher(file.getName()).matches(); - if (file.isFile() && !excluded && filenamePattern.matcher(file.getName()).matches() && isCompatibleTarget(targetBackend, file)) { - assertFilePathPresent(file, rootFile, filePaths); - } - - return true; - }); - } - - private static void assertFilePathPresent(File file, File rootFile, Set filePaths) { - String path = FileUtil.getRelativePath(rootFile, file); - if (path != null) { - String relativePath = nameToCompare(path); - if (!filePaths.contains(relativePath)) { - Assert.fail("Test data file missing from the generated test class: " + file + "\n" + PLEASE_REGENERATE_TESTS); - } - } - } - - private static Set collectPathsMetadata(Class testCaseClass) { - return new HashSet<>(ContainerUtil.map(collectMethodsMetadata(testCaseClass), KotlinTestUtils::nameToCompare)); - } - - @Nullable - private static String getMethodMetadata(Method method) { - TestMetadata testMetadata = method.getAnnotation(TestMetadata.class); - return (testMetadata != null) ? testMetadata.value() : null; - } - - private static Set collectMethodsMetadata(Class testCaseClass) { - Set filePaths = new HashSet<>(); - for (Method method : testCaseClass.getDeclaredMethods()) { - String path = getMethodMetadata(method); - if (path != null) { - filePaths.add(path); - } - } - return filePaths; - } - - private static boolean containsTestData(File dir, Pattern filenamePattern, @Nullable Pattern excludedPattern) { - File[] files = dir.listFiles(); - assert files != null; - for (File file : files) { - if (file.isDirectory()) { - if (containsTestData(file, filenamePattern, excludedPattern)) { - return true; - } - } - else { - boolean excluded = excludedPattern != null && excludedPattern.matcher(file.getName()).matches(); - if (! excluded && filenamePattern.matcher(file.getName()).matches()) { - return true; - } - } - } - return false; - } - - private static void assertTestClassPresentByMetadata(@NotNull Class outerClass, @NotNull File testDataDir) { - for (Class nestedClass : outerClass.getDeclaredClasses()) { - TestMetadata testMetadata = nestedClass.getAnnotation(TestMetadata.class); - if (testMetadata != null && testMetadata.value().equals(KtTestUtil.getFilePath(testDataDir))) { - return; - } - } - Assert.fail("Test data directory missing from the generated test class: " + testDataDir + "\n" + PLEASE_REGENERATE_TESTS); - } - @NotNull public static KtFile loadJetFile(@NotNull Project project, @NotNull File ioFile) throws IOException { String text = FileUtil.loadFile(ioFile, true); @@ -924,10 +737,6 @@ public class KotlinTestUtils { return testName.toLowerCase().startsWith("allfilespresentin"); } - public static String nameToCompare(@NotNull String name) { - return (SystemInfo.isFileSystemCaseSensitive ? name : name.toLowerCase()).replace('\\', '/'); - } - public static boolean isMultiExtensionName(@NotNull String name) { int firstDotIndex = name.indexOf('.'); if (firstDotIndex == -1) { diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/TestGenerationDSL.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/TestGenerationDSL.kt index 835cae4cd54..a66e9c1a13a 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/TestGenerationDSL.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/TestGenerationDSL.kt @@ -5,7 +5,6 @@ package org.jetbrains.kotlin.generators -import junit.framework.TestCase import org.jetbrains.kotlin.generators.impl.TestGeneratorImpl import org.jetbrains.kotlin.generators.model.* import org.jetbrains.kotlin.generators.InconsistencyChecker.Companion.hasDryRunArg diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/impl/SimpleTestClassModelTestAllFilesPresentMethodGenerator.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/impl/SimpleTestClassModelTestAllFilesPresentMethodGenerator.kt index 8881cbf99de..e28ded09f20 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/impl/SimpleTestClassModelTestAllFilesPresentMethodGenerator.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/impl/SimpleTestClassModelTestAllFilesPresentMethodGenerator.kt @@ -35,7 +35,7 @@ object SimpleTestClassModelTestAllFilesPresentMethodGenerator : MethodGenerator< } val assertTestsPresentStr = if (classModel.targetBackend === TargetBackend.ANY) { String.format( - "KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File(\"%s\"), Pattern.compile(\"%s\"), %s, %s%s);", + "KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File(\"%s\"), Pattern.compile(\"%s\"), %s, %s%s);", KtTestUtil.getFilePath(classModel.rootFile), StringUtil.escapeStringCharacters(classModel.filenamePattern.pattern()), excludedArgument, @@ -44,7 +44,7 @@ object SimpleTestClassModelTestAllFilesPresentMethodGenerator : MethodGenerator< ) } else { String.format( - "KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File(\"%s\"), Pattern.compile(\"%s\"), %s, %s.%s, %s%s);", + "KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File(\"%s\"), Pattern.compile(\"%s\"), %s, %s.%s, %s%s);", KtTestUtil.getFilePath(classModel.rootFile), StringUtil.escapeStringCharacters(classModel.filenamePattern.pattern()), excludedArgument, TargetBackend::class.java.simpleName, classModel.targetBackend.toString(), classModel.recursive, exclude diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/impl/SingleClassTestModelAllFilesPresentedMethodGenerator.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/impl/SingleClassTestModelAllFilesPresentedMethodGenerator.kt index e4a7efe7d4b..2c66ad2e858 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/impl/SingleClassTestModelAllFilesPresentedMethodGenerator.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/impl/SingleClassTestModelAllFilesPresentedMethodGenerator.kt @@ -36,13 +36,13 @@ object SingleClassTestModelAllFilesPresentedMethodGenerator : MethodGenerator classModel.imports }) { p.println("import ${clazz.name};") diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/model/SimpleTestClassModel.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/model/SimpleTestClassModel.kt index e0a839e3dda..13b174567aa 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/model/SimpleTestClassModel.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/model/SimpleTestClassModel.kt @@ -6,7 +6,6 @@ package org.jetbrains.kotlin.generators.model import com.intellij.openapi.util.io.FileUtil import org.jetbrains.kotlin.generators.util.TestGeneratorUtil.fileNameToJavaIdentifier -import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.TargetBackend import org.jetbrains.kotlin.test.util.KtTestUtil import java.io.File diff --git a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/AbstractMultiFileJvmBasicCompletionTest.kt b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/AbstractMultiFileJvmBasicCompletionTest.kt index 4be5fb5dedf..53893f36285 100644 --- a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/AbstractMultiFileJvmBasicCompletionTest.kt +++ b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/AbstractMultiFileJvmBasicCompletionTest.kt @@ -8,7 +8,7 @@ package org.jetbrains.kotlin.idea.completion.test import com.intellij.codeInsight.completion.CompletionType import org.jetbrains.kotlin.idea.test.AstAccessControl import org.jetbrains.kotlin.platform.jvm.JvmPlatforms -import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil abstract class AbstractMultiFileJvmBasicCompletionTest : KotlinCompletionTestCase() { protected fun doTest(testPath: String) { @@ -24,6 +24,6 @@ abstract class AbstractMultiFileJvmBasicCompletionTest : KotlinCompletionTestCas } override fun getTestDataPath(): String { - return KotlinTestUtils.getTestsRoot(this::class.java) + "/" + getTestName(false) + "/" + return KtTestUtil.getTestsRoot(this::class.java) + "/" + getTestName(false) + "/" } -} \ No newline at end of file +} diff --git a/idea/idea-gradle/tests/org/jetbrains/kotlin/idea/configuration/AbstractGradleConfigureProjectByChangingFileTest.kt b/idea/idea-gradle/tests/org/jetbrains/kotlin/idea/configuration/AbstractGradleConfigureProjectByChangingFileTest.kt index 0a76394b2f9..d5ec0350dfd 100644 --- a/idea/idea-gradle/tests/org/jetbrains/kotlin/idea/configuration/AbstractGradleConfigureProjectByChangingFileTest.kt +++ b/idea/idea-gradle/tests/org/jetbrains/kotlin/idea/configuration/AbstractGradleConfigureProjectByChangingFileTest.kt @@ -23,6 +23,7 @@ import org.jetbrains.kotlin.idea.test.PluginTestCaseBase import org.jetbrains.kotlin.psi.KtFile import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.KotlinTestUtils.isAllFilesPresentTest +import org.jetbrains.kotlin.test.util.KtTestUtil import org.jetbrains.plugins.groovy.lang.psi.GroovyFile import java.io.File @@ -34,7 +35,7 @@ abstract class AbstractGradleConfigureProjectByChangingFileTest : } private fun beforeAfterFiles(): Pair { - val root = KotlinTestUtils.getTestsRoot(this::class.java) + val root = KtTestUtil.getTestsRoot(this::class.java) val test = KotlinTestUtils.getTestDataFileName(this::class.java, name) val path = "$root/$test" val testFile = File(path) diff --git a/idea/idea-maven/test/org/jetbrains/kotlin/idea/maven/configuration/AbstractMavenConfigureProjectByChangingFileTest.kt b/idea/idea-maven/test/org/jetbrains/kotlin/idea/maven/configuration/AbstractMavenConfigureProjectByChangingFileTest.kt index 7896774b98f..b2bf38b2dd5 100644 --- a/idea/idea-maven/test/org/jetbrains/kotlin/idea/maven/configuration/AbstractMavenConfigureProjectByChangingFileTest.kt +++ b/idea/idea-maven/test/org/jetbrains/kotlin/idea/maven/configuration/AbstractMavenConfigureProjectByChangingFileTest.kt @@ -26,6 +26,7 @@ import org.jetbrains.kotlin.idea.configuration.NotificationMessageCollector import org.jetbrains.kotlin.idea.test.PluginTestCaseBase import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.KotlinTestUtils.isAllFilesPresentTest +import org.jetbrains.kotlin.test.util.KtTestUtil import java.io.File abstract class AbstractMavenConfigureProjectByChangingFileTest : AbstractConfigureProjectByChangingFileTest() { @@ -53,7 +54,7 @@ abstract class AbstractMavenConfigureProjectByChangingFileTest : AbstractConfigu override fun getProjectJDK(): Sdk { if (!isAllFilesPresentTest(getTestName(false))) { - val root = KotlinTestUtils.getTestsRoot(this::class.java) + val root = KtTestUtil.getTestsRoot(this::class.java) val dir = KotlinTestUtils.getTestDataFileName(this::class.java, name) val pomFile = File("$root/$dir", MavenConstants.POM_XML) diff --git a/idea/tests/org/jetbrains/kotlin/checkers/AbstractPsiCheckerTest.java b/idea/tests/org/jetbrains/kotlin/checkers/AbstractPsiCheckerTest.java index e1be1a519b3..98a416691c4 100644 --- a/idea/tests/org/jetbrains/kotlin/checkers/AbstractPsiCheckerTest.java +++ b/idea/tests/org/jetbrains/kotlin/checkers/AbstractPsiCheckerTest.java @@ -19,7 +19,7 @@ import org.jetbrains.kotlin.psi.KtDeclaration; import org.jetbrains.kotlin.psi.KtFile; import org.jetbrains.kotlin.psi.KtTreeVisitorVoid; import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode; -import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import java.io.File; @@ -92,7 +92,7 @@ public abstract class AbstractPsiCheckerTest extends KotlinLightCodeInsightFixtu @Override protected String getTestDataPath() { - return KotlinTestUtils.getTestsRoot(this.getClass()); + return KtTestUtil.getTestsRoot(this.getClass()); } } diff --git a/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/AbstractIdeLightClassTest.kt b/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/AbstractIdeLightClassTest.kt index efe05283eae..1e5e875117a 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/AbstractIdeLightClassTest.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/AbstractIdeLightClassTest.kt @@ -36,6 +36,7 @@ import org.jetbrains.kotlin.psi.KtClassOrObject import org.jetbrains.kotlin.psi.KtFile import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.MockLibraryUtil +import org.jetbrains.kotlin.test.util.KtTestUtil import org.jetbrains.kotlin.utils.keysToMap import org.jetbrains.plugins.groovy.lang.psi.impl.stringValue import org.junit.Assert @@ -101,7 +102,7 @@ abstract class AbstractIdeCompiledLightClassTest : KotlinDaemonAnalyzerTestCase( val testName = getTestName(false) if (KotlinTestUtils.isAllFilesPresentTest(testName)) return - val filePathWithoutExtension = "${KotlinTestUtils.getTestsRoot(this::class.java)}/${getTestName(false)}" + val filePathWithoutExtension = "${KtTestUtil.getTestsRoot(this::class.java)}/${getTestName(false)}" val testFile = File("$filePathWithoutExtension.kt").takeIf { it.exists() } ?: File("$filePathWithoutExtension.kts").takeIf { it.exists() } diff --git a/idea/tests/org/jetbrains/kotlin/idea/navigation/AbstractKotlinGotoTest.java b/idea/tests/org/jetbrains/kotlin/idea/navigation/AbstractKotlinGotoTest.java index 644b6e16496..9bb1c5a027f 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/navigation/AbstractKotlinGotoTest.java +++ b/idea/tests/org/jetbrains/kotlin/idea/navigation/AbstractKotlinGotoTest.java @@ -9,7 +9,7 @@ import com.intellij.ide.util.gotoByName.GotoClassModel2; import com.intellij.ide.util.gotoByName.GotoSymbolModel2; import org.jetbrains.annotations.NotNull; import org.jetbrains.kotlin.idea.test.KotlinLightCodeInsightFixtureTestCase; -import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import static org.jetbrains.kotlin.idea.navigation.GotoCheck.checkGotoDirectives; @@ -28,7 +28,7 @@ public abstract class AbstractKotlinGotoTest extends KotlinLightCodeInsightFixtu @Override protected void setUp() { - dirPath = KotlinTestUtils.getTestsRoot(getClass()); + dirPath = KtTestUtil.getTestsRoot(getClass()); super.setUp(); } diff --git a/idea/tests/org/jetbrains/kotlin/idea/parameterInfo/AbstractParameterInfoTest.kt b/idea/tests/org/jetbrains/kotlin/idea/parameterInfo/AbstractParameterInfoTest.kt index bc602317a36..308af343c50 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/parameterInfo/AbstractParameterInfoTest.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/parameterInfo/AbstractParameterInfoTest.kt @@ -23,13 +23,13 @@ import org.jetbrains.kotlin.lexer.KtTokens import org.jetbrains.kotlin.psi.KtFile import org.jetbrains.kotlin.psi.psiUtil.allChildren import org.jetbrains.kotlin.test.InTextDirectivesUtils -import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.KtTestUtil import org.junit.Assert import java.io.File abstract class AbstractParameterInfoTest : LightCodeInsightFixtureTestCase() { override fun getProjectDescriptor(): LightProjectDescriptor { - val root = KotlinTestUtils.getTestsRoot(this::class.java) + val root = KtTestUtil.getTestsRoot(this::class.java) if (root.contains("Lib")) { return SdkAndMockLibraryProjectDescriptor("$root/sharedLib", true, true, false, false) } From bc7e18fb8a729a9a73e72f31d76ff090b70c426e Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Mon, 14 Dec 2020 13:27:44 +0300 Subject: [PATCH 112/196] [TEST] Regenerate tests after previous commit --- .../ExtendedFirDiagnosticsTestGenerated.java | 13 +- ...WithLightTreeDiagnosticsTestGenerated.java | 13 +- ...DiagnosticsWithLightTreeTestGenerated.java | 79 +- .../fir/FirLoadCompiledKotlinGenerated.java | 85 +- ...TouchedTilContractsPhaseTestGenerated.java | 79 +- ...rOldFrontendLightClassesTestGenerated.java | 3 +- .../java/FirTypeEnhancementTestGenerated.java | 51 +- .../OwnFirTypeEnhancementTestGenerated.java | 11 +- ...mpileKotlinAgainstKotlinTestGenerated.java | 21 +- ...ackBoxAgainstJavaCodegenTestGenerated.java | 71 +- .../ir/FirBlackBoxCodegenTestGenerated.java | 793 ++++++++--------- ...FirBlackBoxInlineCodegenTestGenerated.java | 157 ++-- .../ir/FirBytecodeTextTestGenerated.java | 165 ++-- .../kotlin/fir/Fir2IrTextTestGenerated.java | 45 +- ...ghtTree2FirConverterTestCaseGenerated.java | 13 +- ...PartialRawFirBuilderTestCaseGenerated.java | 3 +- ...FirBuilderLazyBodiesTestCaseGenerated.java | 13 +- ...SourceElementMappingTestCaseGenerated.java | 3 +- .../RawFirBuilderTestCaseGenerated.java | 13 +- ...rementalJsCompilerRunnerTestGenerated.java | 13 +- ...ithFriendModulesDisabledTestGenerated.java | 3 +- ...erRunnerWithMetadataOnlyTestGenerated.java | 13 +- ...ntalJsKlibCompilerRunnerTestGenerated.java | 13 +- ...WithScopeExpansionRunnerTestGenerated.java | 19 +- ...ementalJvmCompilerRunnerTestGenerated.java | 201 ++--- ...platformJsCompilerRunnerTestGenerated.java | 7 +- ...latformJvmCompilerRunnerTestGenerated.java | 11 +- ...ementalJvmCompilerRunnerTestGenerated.java | 201 ++--- ...CompileKotlinAgainstKlibTestGenerated.java | 3 +- .../test/runners/DiagnosticTestGenerated.java | 684 +++++++-------- .../DiagnosticUsingJavacTestGenerated.java | 16 +- .../runners/FirDiagnosticTestGenerated.java | 124 +-- ...irOldFrontendDiagnosticsTestGenerated.java | 684 +++++++-------- .../CompilerLightClassTestGenerated.java | 17 +- .../kotlin/cfg/ControlFlowTestGenerated.java | 41 +- .../kotlin/cfg/DataFlowTestGenerated.java | 13 +- .../kotlin/cfg/PseudoValueTestGenerated.java | 53 +- .../DiagnosticsNativeTestGenerated.java | 3 +- ...sStdLibAndBackendCompilationGenerated.java | 7 +- .../DiagnosticsTestWithJsStdLibGenerated.java | 37 +- ...gnosticsTestWithJvmIrBackendGenerated.java | 25 +- ...nosticsTestWithOldJvmBackendGenerated.java | 25 +- .../DiagnosticsWithJdk15TestGenerated.java | 7 +- ...sNoAnnotationInClasspathTestGenerated.java | 21 +- ...spathWithPsiClassReadingTestGenerated.java | 21 +- .../ForeignAnnotationsTestGenerated.java | 21 +- .../JavacForeignAnnotationsTestGenerated.java | 21 +- .../kotlin/cli/CliTestGenerated.java | 9 +- ...smLikeInstructionListingTestGenerated.java | 7 +- ...ackBoxAgainstJavaCodegenTestGenerated.java | 75 +- .../codegen/BlackBoxCodegenTestGenerated.java | 827 +++++++++--------- .../BlackBoxInlineCodegenTestGenerated.java | 157 ++-- .../codegen/BytecodeListingTestGenerated.java | 53 +- .../codegen/BytecodeTextTestGenerated.java | 173 ++-- ...CheckLocalVariablesTableTestGenerated.java | 7 +- ...otlinAgainstInlineKotlinTestGenerated.java | 157 ++-- ...KotlinAgainstKotlinJdk15TestGenerated.java | 3 +- ...mpileKotlinAgainstKotlinTestGenerated.java | 21 +- .../CustomScriptCodegenTestGenerated.java | 3 +- .../DumpDeclarationsTestGenerated.java | 3 +- ...KotlinAgainstKotlinJdk15TestGenerated.java | 3 +- .../Jdk15BlackBoxCodegenTestGenerated.java | 5 +- .../Jdk15IrBlackBoxCodegenTestGenerated.java | 5 +- .../Jdk9BlackBoxCodegenTestGenerated.java | 3 +- ...BuilderModeBytecodeShapeTestGenerated.java | 3 +- .../LightAnalysisModeTestGenerated.java | 743 ++++++++-------- .../codegen/ScriptCodegenTestGenerated.java | 3 +- ...opLevelMembersInvocationTestGenerated.java | 3 +- .../IrLocalVariableTestGenerated.java | 7 +- .../IrSteppingTestGenerated.java | 3 +- .../LocalVariableTestGenerated.java | 7 +- .../SteppingTestGenerated.java | 3 +- ...faultArgumentsReflectionTestGenerated.java | 3 +- .../flags/WriteFlagsTestGenerated.java | 77 +- ...oseLikeIrBlackBoxCodegenTestGenerated.java | 3 +- ...omposeLikeIrBytecodeTextTestGenerated.java | 3 +- ...smLikeInstructionListingTestGenerated.java | 7 +- ...ackBoxAgainstJavaCodegenTestGenerated.java | 71 +- .../ir/IrBlackBoxCodegenTestGenerated.java | 793 ++++++++--------- .../IrBlackBoxInlineCodegenTestGenerated.java | 157 ++-- .../ir/IrBytecodeListingTestGenerated.java | 53 +- .../ir/IrBytecodeTextTestGenerated.java | 165 ++-- ...CheckLocalVariablesTableTestGenerated.java | 7 +- ...otlinAgainstInlineKotlinTestGenerated.java | 157 ++-- ...mpileKotlinAgainstKotlinTestGenerated.java | 21 +- .../ir/IrScriptCodegenTestGenerated.java | 3 +- .../codegen/ir/IrWriteFlagsTestGenerated.java | 77 +- .../ir/IrWriteSignatureTestGenerated.java | 27 +- ...JvmIrAgainstOldBoxInlineTestGenerated.java | 157 ++-- .../ir/JvmIrAgainstOldBoxTestGenerated.java | 21 +- ...JvmOldAgainstIrBoxInlineTestGenerated.java | 157 ++-- .../ir/JvmOldAgainstIrBoxTestGenerated.java | 21 +- .../integration/AntTaskTestGenerated.java | 3 +- .../kotlin/ir/IrCfgTestCaseGenerated.java | 7 +- .../kotlin/ir/IrJsTextTestCaseGenerated.java | 11 +- .../ir/IrSourceRangesTestCaseGenerated.java | 5 +- .../kotlin/ir/IrTextTestCaseGenerated.java | 45 +- ...CompileJavaAgainstKotlinTestGenerated.java | 65 +- ...CompileKotlinAgainstJavaTestGenerated.java | 5 +- .../jvm/compiler/LoadJava15TestGenerated.java | 5 +- ...ava15WithPsiClassReadingTestGenerated.java | 3 +- .../jvm/compiler/LoadJavaTestGenerated.java | 189 ++-- ...dJavaWithPsiClassReadingTestGenerated.java | 51 +- .../LoadKotlinWithTypeTableTestGenerated.java | 85 +- .../compiler/WriteSignatureTestGenerated.java | 27 +- ...CompileJavaAgainstKotlinTestGenerated.java | 65 +- ...CompileKotlinAgainstJavaTestGenerated.java | 5 +- .../compiler/ir/IrLoadJavaTestGenerated.java | 189 ++-- .../LoadJavaUsingJavacTestGenerated.java | 189 ++-- .../lexer/kdoc/KDocLexerTestGenerated.java | 3 +- .../kotlin/KotlinLexerTestGenerated.java | 17 +- .../xml/ModuleXmlParserTestGenerated.java | 3 +- ...MultiPlatformIntegrationTestGenerated.java | 89 +- .../kotlin/parsing/ParsingTestGenerated.java | 85 +- .../DescriptorRendererTestGenerated.java | 3 +- ...ptorInExpressionRendererTestGenerated.java | 3 +- .../repl/ReplInterpreterTestGenerated.java | 19 +- .../kotlin/resolve/ResolveTestGenerated.java | 15 +- .../AnnotationParameterTestGenerated.java | 5 +- .../calls/ResolvedCallsTestGenerated.java | 35 +- ...structorDelegationCallsTestsGenerated.java | 3 +- ...ileTimeConstantEvaluatorTestGenerated.java | 7 +- .../ConstraintSystemTestGenerated.java | 43 +- .../LocalClassProtoTestGenerated.java | 3 +- .../types/TypeBindingTestGenerated.java | 7 +- ...sNoAnnotationInClasspathTestGenerated.java | 7 +- ...spathWithPsiClassReadingTestGenerated.java | 7 +- .../ForeignJava8AnnotationsTestGenerated.java | 7 +- .../JspecifyAnnotationsTestGenerated.java | 7 +- ...cForeignJava8AnnotationsTestGenerated.java | 7 +- .../jvm/compiler/LoadJava8TestGenerated.java | 5 +- ...Java8WithPsiClassReadingTestGenerated.java | 3 +- .../LoadJava8UsingJavacTestGenerated.java | 5 +- ...dSignaturesResolvedCallsTestGenerated.java | 17 +- .../DiagnosticsTestSpecGenerated.java | 746 ++++++++-------- .../FirDiagnosticsTestSpecGenerated.java | 746 ++++++++-------- .../BlackBoxCodegenTestSpecGenerated.java | 472 +++++----- .../parsing/ParsingTestSpecGenerated.java | 96 +- .../FirVisualizerForRawFirDataGenerated.java | 13 +- ...irVisualizerForUncommonCasesGenerated.java | 3 +- .../PsiVisualizerForRawFirDataGenerated.java | 13 +- ...siVisualizerForUncommonCasesGenerated.java | 3 +- ...8RuntimeDescriptorLoaderTestGenerated.java | 3 +- ...mRuntimeDescriptorLoaderTestGenerated.java | 121 +-- .../AndroidGutterIconTestGenerated.java | 12 +- .../ConfigureProjectTestGenerated.java | 6 +- .../AndroidResourceFoldingTestGenerated.java | 2 +- .../AndroidIntentionTestGenerated.java | 14 +- ...AndroidResourceIntentionTestGenerated.java | 2 +- .../android/lint/KotlinLintTestGenerated.java | 2 +- .../AndroidLintQuickfixTestGenerated.java | 14 +- ...AndroidQuickFixMultiFileTestGenerated.java | 6 +- ...edKotlinInJavaCompletionTestGenerated.java | 3 +- ...letionIncrementalResolveTestGenerated.java | 3 +- .../test/JSBasicCompletionTestGenerated.java | 63 +- .../Java8BasicCompletionTestGenerated.java | 3 +- .../test/JvmBasicCompletionTestGenerated.java | 69 +- .../test/JvmSmartCompletionTestGenerated.java | 41 +- ...vmWithLibBasicCompletionTestGenerated.java | 3 +- .../test/KDocCompletionTestGenerated.java | 3 +- .../test/KeywordCompletionTestGenerated.java | 3 +- ...inSourceInJavaCompletionTestGenerated.java | 3 +- ...inStdLibInJavaCompletionTestGenerated.java | 3 +- ...tiFileJvmBasicCompletionTestGenerated.java | 3 +- ...mitiveJvmBasicCompletionTestGenerated.java | 3 +- ...MultiFileSmartCompletionTestGenerated.java | 3 +- .../MultiPlatformCompletionTestGenerated.java | 3 +- .../BasicCompletionHandlerTestGenerated.java | 27 +- .../CompletionCharFilterTestGenerated.java | 3 +- ...KeywordCompletionHandlerTestGenerated.java | 3 +- .../SmartCompletionHandlerTestGenerated.java | 9 +- .../BasicCompletionWeigherTestGenerated.java | 15 +- .../SmartCompletionWeigherTestGenerated.java | 3 +- ...rHighlightingPerformanceTestGenerated.java | 5 +- ...ceBasicCompletionHandlerTestGenerated.java | 27 +- .../classes/FirClassLoadingTestGenerated.java | 3 +- .../classes/FirLightClassTestGenerated.java | 15 +- .../FirLightFacadeClassTestGenerated.java | 3 +- .../checkers/FirPsiCheckerTestGenerated.java | 13 +- .../FindUsagesFirTestGenerated.java | 67 +- ...isableComponentSearchFirTestGenerated.java | 3 +- ...FindUsagesWithLibraryFirTestGenerated.java | 11 +- ...nFindUsagesWithStdlibFirTestGenerated.java | 3 +- ...hLevelJvmBasicCompletionTestGenerated.java | 69 +- ...elBasicCompletionHandlerTestGenerated.java | 27 +- .../HighLevelWeigherTestGenerated.java | 15 +- .../FirHighlightingTestGenerated.java | 7 +- .../FirReferenceResolveTestGenerated.java | 25 +- ...irLazyDeclarationResolveTestGenerated.java | 3 +- .../api/FirLazyResolveTestGenerated.java | 3 +- ...irMultiModuleLazyResolveTestGenerated.java | 3 +- .../FirMultiModuleResolveTestGenerated.java | 3 +- ...cationTrackerConsistencyTestGenerated.java | 3 +- .../structure/FileStructureTestGenerated.java | 3 +- .../SessionsInvalidationTestGenerated.java | 3 +- ...otlinModificationTrackerTestGenerated.java | 3 +- ...irDeclarationEqualityCheckerGenerated.java | 3 +- .../ExpectedExpressionTypeTestGenerated.java | 3 +- .../ReturnExpressionTargetTestGenerated.java | 3 +- .../api/fir/ResolveCallTestGenerated.java | 3 +- .../api/scopes/FileScopeTestGenerated.java | 3 +- .../MemberScopeByFqNameTestGenerated.java | 3 +- .../MemoryLeakInSymbolsTestGenerated.java | 3 +- ...romLibraryPointerRestoreTestGenerated.java | 3 +- ...FromSourcePointerRestoreTestGenerated.java | 3 +- .../SymbolsByFqNameBuildingTestGenerated.java | 3 +- .../SymbolsByPsiBuildingTestGenerated.java | 3 +- ...ureProjectByChangingFileTestGenerated.java | 5 +- .../KotlinMavenInspectionTestGenerated.java | 3 +- ...ureProjectByChangingFileTestGenerated.java | 5 +- ...teNewWizardProjectImportTestGenerated.java | 7 +- ...mlNewWizardProjectImportTestGenerated.java | 7 +- .../test/AsyncStackTraceTestGenerated.java | 3 +- .../BreakpointApplicabilityTestGenerated.java | 3 +- .../ContinuationStackTraceTestGenerated.java | 3 +- .../test/CoroutineDumpTestGenerated.java | 3 +- .../test/FileRankingTestGenerated.java | 3 +- ...KotlinEvaluateExpressionTestGenerated.java | 25 +- .../test/IrKotlinSteppingTestGenerated.java | 17 +- ...KotlinEvaluateExpressionTestGenerated.java | 25 +- .../test/KotlinSteppingTestGenerated.java | 17 +- .../test/PositionManagerTestGenerated.java | 5 +- ...ectExpressionForDebuggerTestGenerated.java | 5 +- .../test/SmartStepIntoTestGenerated.java | 3 +- .../XCoroutinesStackTraceTestGenerated.java | 3 +- .../exec/SequenceTraceTestCaseGenerated.java | 17 +- .../PerformanceAddImportTestGenerated.java | 3 +- ...ceBasicCompletionHandlerTestGenerated.java | 27 +- ...anceCompletionCharFilterTestGenerated.java | 3 +- ...letionIncrementalResolveTestGenerated.java | 3 +- .../PerformanceHighlightingTestGenerated.java | 5 +- ...otlinCopyPasteConversionTestGenerated.java | 3 +- ...KeywordCompletionHandlerTestGenerated.java | 3 +- ...lKotlinToKotlinCopyPasteTestGenerated.java | 3 +- ...otlinCopyPasteConversionTestGenerated.java | 3 +- ...ceSmartCompletionHandlerTestGenerated.java | 9 +- ...ormanceTypingIndentationTestGenerated.java | 21 +- .../ScratchLineMarkersTestGenerated.java | 3 +- .../ScratchRunActionTestGenerated.java | 15 +- ...emplatesFromDependenciesTestGenerated.java | 3 +- .../DataFlowValueRenderingTestGenerated.java | 3 +- .../addImport/AddImportTestGenerated.java | 3 +- .../AddImportAliasTestGenerated.java | 3 +- .../UltraLightClassLoadingTestGenerated.java | 3 +- .../UltraLightClassSanityTestGenerated.java | 19 +- .../UltraLightFacadeClassTestGenerated.java | 3 +- .../UltraLightScriptLoadingTestGenerated.java | 3 +- ...nstKotlinBinariesCheckerTestGenerated.java | 3 +- ...ainstKotlinSourceCheckerTestGenerated.java | 5 +- ...CheckerWithoutUltraLightTestGenerated.java | 5 +- .../checkers/JsCheckerTestGenerated.java | 3 +- .../checkers/PsiCheckerTestGenerated.java | 23 +- .../UpdateKotlinCopyrightTestGenerated.java | 3 +- .../findUsages/FindUsagesTestGenerated.java | 67 +- ...thDisableComponentSearchTestGenerated.java | 3 +- ...linFindUsagesWithLibraryTestGenerated.java | 11 +- ...tlinFindUsagesWithStdlibTestGenerated.java | 3 +- .../formatter/FormatterTestGenerated.java | 109 +-- .../TypingIndentationTestBaseGenerated.java | 41 +- .../ExpressionSelectionTestGenerated.java | 3 +- .../idea/SmartSelectionTestGenerated.java | 3 +- .../GotoTestOrCodeActionTestGenerated.java | 3 +- .../IdeCompiledLightClassTestGenerated.java | 15 +- .../IdeLightClassForScriptTestGenerated.java | 3 +- .../resolve/IdeLightClassTestGenerated.java | 15 +- .../MultiModuleLineMarkerTestGenerated.java | 3 +- ...ultiPlatformHighlightingTestGenerated.java | 3 +- .../MultiplatformAnalysisTestGenerated.java | 3 +- .../codeInsight/BreadcrumbsTestGenerated.java | 3 +- .../ChangeLocalityDetectorTestGenerated.java | 3 +- .../ExpressionTypeTestGenerated.java | 3 +- .../InsertImportOnPasteTestGenerated.java | 5 +- .../codeInsight/InspectionTestGenerated.java | 7 +- .../codeInsight/LineMarkersTestGenerated.java | 13 +- ...eMarkersTestInLibrarySourcesGenerated.java | 3 +- .../MoveOnCutPasteTestGenerated.java | 3 +- .../MultiFileInspectionTestGenerated.java | 3 +- .../OutOfBlockModificationTestGenerated.java | 3 +- .../RenderingKDocTestGenerated.java | 3 +- ...KotlinCodeVisionProviderTestGenerated.java | 3 +- .../CodeInsightActionTestGenerated.java | 3 +- ...eHashCodeAndEqualsActionTestGenerated.java | 3 +- ...eTestSupportMethodActionTestGenerated.java | 9 +- .../GenerateToStringActionTestGenerated.java | 9 +- ...ferenceTypeHintsProviderTestGenerated.java | 3 +- .../MoveLeftRightTestGenerated.java | 3 +- .../MoveStatementTestGenerated.java | 41 +- .../PostfixTemplateProviderTestGenerated.java | 5 +- .../SurroundWithTestGenerated.java | 51 +- .../unwrap/UnwrapRemoveTestGenerated.java | 25 +- ...otlinCopyPasteConversionTestGenerated.java | 3 +- ...lKotlinToKotlinCopyPasteTestGenerated.java | 3 +- ...ralTextToKotlinCopyPasteTestGenerated.java | 3 +- ...otlinCopyPasteConversionTestGenerated.java | 3 +- ...otlinCoverageOutputFilesTestGenerated.java | 3 +- .../CodeFragmentAutoImportTestGenerated.java | 3 +- ...ragmentCompletionHandlerTestGenerated.java | 3 +- .../CodeFragmentCompletionTestGenerated.java | 5 +- ...CodeFragmentHighlightingTestGenerated.java | 5 +- ...igateJavaToLibrarySourceTestGenerated.java | 3 +- ...igateToDecompiledLibraryTestGenerated.java | 3 +- .../NavigateToLibrarySourceTestGenerated.java | 3 +- ...ateToLibrarySourceTestWithJSGenerated.java | 3 +- .../ClsStubBuilderTestGenerated.java | 3 +- .../LoadJavaClsStubTestGenerated.java | 85 +- ...mpiledTextFromJsMetadataTestGenerated.java | 49 +- .../CommonDecompiledTextTestGenerated.java | 49 +- ...mpiledTextFromJsMetadataTestGenerated.java | 7 +- .../JvmDecompiledTextTestGenerated.java | 19 +- ...terUnmatchedBraceHandlerTestGenerated.java | 3 +- .../MultiLineStringIndentTestGenerated.java | 11 +- .../BackspaceHandlerTestGenerated.java | 5 +- .../QuickDocProviderTestGenerated.java | 3 +- .../KotlinExceptionFilterTestGenerated.java | 3 +- .../folding/KotlinFoldingTestGenerated.java | 5 +- .../hierarchy/HierarchyTestGenerated.java | 15 +- .../HierarchyWithLibTestGenerated.java | 3 +- .../DiagnosticMessageJsTestGenerated.java | 3 +- .../DiagnosticMessageTestGenerated.java | 3 +- .../DslHighlighterTestGenerated.java | 3 +- .../HighlightExitPointsTestGenerated.java | 3 +- .../HighlightingTestGenerated.java | 5 +- .../UsageHighlightingTestGenerated.java | 3 +- .../JsOptimizeImportsTestGenerated.java | 7 +- .../JvmOptimizeImportsTestGenerated.java | 9 +- ...yExpansionShortNameIndexTestGenerated.java | 3 +- .../LocalInspectionTestGenerated.java | 431 ++++----- ...MultiFileLocalInspectionTestGenerated.java | 3 +- ...catenatedStringGeneratorTestGenerated.java | 3 +- .../intentions/IntentionTest2Generated.java | 33 +- .../intentions/IntentionTestGenerated.java | 441 +++++----- .../MultiFileIntentionTestGenerated.java | 3 +- .../declarations/JoinLinesTestGenerated.java | 17 +- .../BytecodeToolWindowTestGenerated.java | 3 +- .../kdoc/KDocHighlightingTestGenerated.java | 3 +- .../idea/kdoc/KDocTypingTestGenerated.java | 3 +- .../idea/kdoc/KdocResolveTestGenerated.java | 3 +- .../GotoDeclarationTestGenerated.java | 3 +- .../navigation/GotoSuperTestGenerated.java | 3 +- .../GotoTypeDeclarationTestGenerated.java | 3 +- ...mplementationMultiModuleTestGenerated.java | 3 +- ...KotlinGotoImplementationTestGenerated.java | 3 +- ...RelatedSymbolMultiModuleTestGenerated.java | 3 +- ...tlinGotoSuperMultiModuleTestGenerated.java | 3 +- .../navigation/KotlinGotoTestGenerated.java | 5 +- .../KotlinNavBarTestGenerated.java | 3 +- .../ParameterInfoTestGenerated.java | 17 +- .../QuickFixMultiFileTestGenerated.java | 539 ++++++------ .../QuickFixMultiModuleTestGenerated.java | 23 +- .../idea/quickfix/QuickFixTestGenerated.java | 539 ++++++------ .../NameSuggestionProviderTestGenerated.java | 3 +- .../refactoring/copy/CopyTestGenerated.java | 3 +- .../copy/MultiModuleCopyTestGenerated.java | 3 +- .../inline/InlineTestGenerated.java | 27 +- .../introduce/ExtractionTestGenerated.java | 111 +-- .../refactoring/move/MoveTestGenerated.java | 3 +- .../move/MultiModuleMoveTestGenerated.java | 3 +- .../pullUp/PullUpTestGenerated.java | 7 +- .../pushDown/PushDownTestGenerated.java | 7 +- .../MultiModuleRenameTestGenerated.java | 3 +- .../rename/RenameTestGenerated.java | 3 +- .../MultiModuleSafeDeleteTestGenerated.java | 3 +- .../safeDelete/SafeDeleteTestGenerated.java | 31 +- .../repl/IdeReplCompletionTestGenerated.java | 3 +- ...esolveDescriptorRendererTestGenerated.java | 3 +- .../PartialBodyResolveTestGenerated.java | 3 +- .../ReferenceResolveInJavaTestGenerated.java | 5 +- ...eResolveInLibrarySourcesTestGenerated.java | 3 +- .../ReferenceResolveTestGenerated.java | 25 +- .../ReferenceResolveWithLibTestGenerated.java | 3 +- ...piledKotlinResolveInJavaTestGenerated.java | 3 +- ...vaWithWrongFileStructureTestGenerated.java | 3 +- .../ResolveModeComparisonTestGenerated.java | 3 +- ...tConfigurationCompletionTestGenerated.java | 3 +- ...onfigurationHighlightingTestGenerated.java | 5 +- ...ationInsertImportOnPasteTestGenerated.java | 5 +- ...tConfigurationNavigationTestGenerated.java | 3 +- .../ScriptDefinitionsOrderTestGenerated.java | 3 +- .../SlicerLeafGroupingTestGenerated.java | 3 +- .../SlicerMultiplatformTestGenerated.java | 3 +- .../SlicerNullnessGroupingTestGenerated.java | 3 +- .../idea/slicer/SlicerTreeTestGenerated.java | 7 +- .../KotlinFileStructureTestGenerated.java | 3 +- .../MultiFileHighlightingTestGenerated.java | 3 +- .../stubs/ResolveByStubTestGenerated.java | 85 +- .../idea/stubs/StubBuilderTestGenerated.java | 3 +- .../PsiUnifierTestGenerated.java | 41 +- .../AnnotatedMembersSearchTestGenerated.java | 3 +- .../search/InheritorsSearchTestGenerated.java | 3 +- .../shortenRefs/ShortenRefsTestGenerated.java | 17 +- ...otlinConverterForWebDemoTestGenerated.java | 153 ++-- ...KotlinConverterMultiFileTestGenerated.java | 3 +- ...otlinConverterSingleFileTestGenerated.java | 153 ++-- ...aContainerVersionChangedTestGenerated.java | 25 +- ...entalCacheVersionChangedTestGenerated.java | 25 +- .../build/IncrementalJsJpsTestGenerated.java | 51 +- .../build/IncrementalJvmJpsTestGenerated.java | 345 ++++---- .../IncrementalLazyCachesTestGenerated.java | 29 +- .../JsKlibLookupTrackerTestGenerated.java | 3 +- .../build/JsLookupTrackerTestGenerated.java | 3 +- .../build/JvmLookupTrackerTestGenerated.java | 3 +- ...mJpsTestWithGeneratedContentGenerated.java | 53 +- .../JsProtoComparisonTestGenerated.java | 81 +- .../JvmProtoComparisonTestGenerated.java | 87 +- .../kotlin/js/test/DceTestGenerated.java | 3 +- .../js/test/JsLineNumberTestGenerated.java | 5 +- .../semantics/IrBoxJsES6TestGenerated.java | 193 ++-- .../IrJsCodegenBoxES6TestGenerated.java | 827 +++++++++--------- .../IrJsCodegenInlineES6TestGenerated.java | 157 ++-- .../IrJsTypeScriptExportES6TestGenerated.java | 19 +- .../ir/semantics/IrBoxJsTestGenerated.java | 193 ++-- .../IrJsCodegenBoxErrorTestGenerated.java | 7 +- .../IrJsCodegenBoxTestGenerated.java | 827 +++++++++--------- .../IrJsCodegenInlineTestGenerated.java | 157 ++-- .../IrJsTypeScriptExportTestGenerated.java | 19 +- .../js/test/semantics/BoxJsTestGenerated.java | 193 ++-- .../semantics/JsCodegenBoxTestGenerated.java | 827 +++++++++--------- .../JsCodegenInlineTestGenerated.java | 157 ++-- ...LegacyPrimitiveArraysBoxTestGenerated.java | 13 +- ...LegacyJsTypeScriptExportTestGenerated.java | 19 +- .../OutputPrefixPostfixTestGenerated.java | 3 +- ...SourceMapGenerationSmokeTestGenerated.java | 3 +- .../IrCodegenBoxWasmTestGenerated.java | 569 ++++++------ .../kotlinp/test/KotlinpTestGenerated.java | 3 +- ...plateBuildFileGenerationTestGenerated.java | 3 +- .../YamlBuildFileGenerationTestGenerated.java | 3 +- ...KotlinConverterMultiFileTestGenerated.java | 3 +- ...otlinConverterSingleFileTestGenerated.java | 161 ++-- ...otlinCopyPasteConversionTestGenerated.java | 3 +- ...otlinCopyPasteConversionTestGenerated.java | 3 +- ...ommonConstraintCollectorTestGenerated.java | 3 +- .../MutabilityInferenceTestGenerated.java | 3 +- .../NullabilityInferenceTestGenerated.java | 3 +- ...ytecodeListingTestForAllOpenGenerated.java | 3 +- .../parcel/ParcelBoxTestGenerated.java | 3 +- .../ParcelBytecodeListingTestGenerated.java | 3 +- .../parcel/ParcelIrBoxTestGenerated.java | 3 +- ...lIrBoxTestWithSerializableLikeExtension.kt | 3 - .../ParcelIrBytecodeListingTestGenerated.java | 3 +- .../test/AndroidBoxTestGenerated.java | 5 +- .../AndroidBytecodeShapeTestGenerated.java | 3 +- .../test/AndroidIrBoxTestGenerated.java | 5 +- ...theticPropertyDescriptorTestGenerated.java | 3 +- .../AndroidCompletionTestGenerated.java | 2 +- .../AndroidExtractionTestGenerated.java | 2 +- .../AndroidFindUsagesTestGenerated.java | 2 +- .../android/AndroidGotoTestGenerated.java | 2 +- .../AndroidLayoutRenameTestGenerated.java | 2 +- .../android/AndroidRenameTestGenerated.java | 2 +- ...AndroidUsageHighlightingTestGenerated.java | 2 +- .../android/ParcelCheckerTestGenerated.java | 2 +- .../android/ParcelQuickFixTestGenerated.java | 18 +- .../FirAllOpenDiagnosticTestGenerated.java | 11 +- .../jvm/abi/CompareJvmAbiTestGenerated.java | 3 +- .../CompileAgainstJvmAbiTestGenerated.java | 3 +- .../jvm/abi/JvmAbiContentTestGenerated.java | 3 +- .../test/ArgumentParsingTestGenerated.java | 3 +- .../KaptToolIntegrationTestGenerated.java | 3 +- ...ileToSourceStubConverterTestGenerated.java | 3 +- ...ileToSourceStubConverterTestGenerated.java | 3 +- .../IrKotlinKaptContextTestGenerated.java | 3 +- .../test/KotlinKaptContextTestGenerated.java | 3 +- ...izationIrBytecodeListingTestGenerated.java | 3 +- ...ionPluginBytecodeListingTestGenerated.java | 3 +- ...lizationPluginDiagnosticTestGenerated.java | 3 +- .../BlackBoxCodegenTestForNoArgGenerated.java | 3 +- .../BytecodeListingTestForNoArgGenerated.java | 3 +- .../DiagnosticsTestForNoArgGenerated.java | 3 +- ...rBlackBoxCodegenTestForNoArgGenerated.java | 3 +- ...rBytecodeListingTestForNoArgGenerated.java | 3 +- .../test/ParcelizeBoxTestGenerated.java | 3 +- ...ParcelizeBytecodeListingTestGenerated.java | 3 +- .../test/ParcelizeIrBoxTestGenerated.java | 3 +- ...rcelizeIrBytecodeListingTestGenerated.java | 3 +- .../test/ParcelizeCheckerTestGenerated.java | 3 +- .../test/ParcelizeQuickFixTestGenerated.java | 19 +- ...WithReceiverScriptNewDefTestGenerated.java | 2 +- .../SamWithReceiverScriptTestGenerated.java | 3 +- .../SamWithReceiverTestGenerated.java | 3 +- 479 files changed, 11088 insertions(+), 10639 deletions(-) diff --git a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/ExtendedFirDiagnosticsTestGenerated.java b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/ExtendedFirDiagnosticsTestGenerated.java index 36e16fd4f50..e61136729ac 100644 --- a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/ExtendedFirDiagnosticsTestGenerated.java +++ b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/ExtendedFirDiagnosticsTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.fir; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class ExtendedFirDiagnosticsTestGenerated extends AbstractExtendedFirDiag } public void testAllFilesPresentInExtendedCheckers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/extendedCheckers"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/extendedCheckers"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("ArrayEqualityCanBeReplacedWithEquals.kt") @@ -77,7 +78,7 @@ public class ExtendedFirDiagnosticsTestGenerated extends AbstractExtendedFirDiag } public void testAllFilesPresentInCanBeReplacedWithOperatorAssignment() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/extendedCheckers/canBeReplacedWithOperatorAssignment"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/extendedCheckers/canBeReplacedWithOperatorAssignment"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("BasicTest.kt") @@ -185,7 +186,7 @@ public class ExtendedFirDiagnosticsTestGenerated extends AbstractExtendedFirDiag } public void testAllFilesPresentInEmptyRangeChecker() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/extendedCheckers/emptyRangeChecker"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/extendedCheckers/emptyRangeChecker"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("NoWarning.kt") @@ -208,7 +209,7 @@ public class ExtendedFirDiagnosticsTestGenerated extends AbstractExtendedFirDiag } public void testAllFilesPresentInRedundantCallOfConversionMethod() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/extendedCheckers/RedundantCallOfConversionMethod"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/extendedCheckers/RedundantCallOfConversionMethod"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("booleanToInt.kt") @@ -321,7 +322,7 @@ public class ExtendedFirDiagnosticsTestGenerated extends AbstractExtendedFirDiag } public void testAllFilesPresentInUnused() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/extendedCheckers/unused"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/extendedCheckers/unused"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("classProperty.kt") @@ -364,7 +365,7 @@ public class ExtendedFirDiagnosticsTestGenerated extends AbstractExtendedFirDiag } public void testAllFilesPresentInUselessCallOnNotNullChecker() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/extendedCheckers/UselessCallOnNotNullChecker"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/extendedCheckers/UselessCallOnNotNullChecker"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("Basic.kt") diff --git a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/ExtendedFirWithLightTreeDiagnosticsTestGenerated.java b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/ExtendedFirWithLightTreeDiagnosticsTestGenerated.java index db17af0c78f..faec62595f6 100644 --- a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/ExtendedFirWithLightTreeDiagnosticsTestGenerated.java +++ b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/ExtendedFirWithLightTreeDiagnosticsTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.fir; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class ExtendedFirWithLightTreeDiagnosticsTestGenerated extends AbstractEx } public void testAllFilesPresentInExtendedCheckers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/extendedCheckers"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/extendedCheckers"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("ArrayEqualityCanBeReplacedWithEquals.kt") @@ -77,7 +78,7 @@ public class ExtendedFirWithLightTreeDiagnosticsTestGenerated extends AbstractEx } public void testAllFilesPresentInCanBeReplacedWithOperatorAssignment() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/extendedCheckers/canBeReplacedWithOperatorAssignment"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/extendedCheckers/canBeReplacedWithOperatorAssignment"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("BasicTest.kt") @@ -185,7 +186,7 @@ public class ExtendedFirWithLightTreeDiagnosticsTestGenerated extends AbstractEx } public void testAllFilesPresentInEmptyRangeChecker() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/extendedCheckers/emptyRangeChecker"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/extendedCheckers/emptyRangeChecker"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("NoWarning.kt") @@ -208,7 +209,7 @@ public class ExtendedFirWithLightTreeDiagnosticsTestGenerated extends AbstractEx } public void testAllFilesPresentInRedundantCallOfConversionMethod() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/extendedCheckers/RedundantCallOfConversionMethod"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/extendedCheckers/RedundantCallOfConversionMethod"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("booleanToInt.kt") @@ -321,7 +322,7 @@ public class ExtendedFirWithLightTreeDiagnosticsTestGenerated extends AbstractEx } public void testAllFilesPresentInUnused() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/extendedCheckers/unused"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/extendedCheckers/unused"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("classProperty.kt") @@ -364,7 +365,7 @@ public class ExtendedFirWithLightTreeDiagnosticsTestGenerated extends AbstractEx } public void testAllFilesPresentInUselessCallOnNotNullChecker() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/extendedCheckers/UselessCallOnNotNullChecker"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/extendedCheckers/UselessCallOnNotNullChecker"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("Basic.kt") diff --git a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/FirDiagnosticsWithLightTreeTestGenerated.java b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/FirDiagnosticsWithLightTreeTestGenerated.java index fb36942a569..0c4b52b3e1a 100644 --- a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/FirDiagnosticsWithLightTreeTestGenerated.java +++ b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/FirDiagnosticsWithLightTreeTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.fir; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos } public void testAllFilesPresentInResolve() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("asImports.kt") @@ -482,7 +483,7 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos } public void testAllFilesPresentInArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/arguments"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/arguments"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("ambiguityOnJavaOverride.kt") @@ -640,7 +641,7 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos } public void testAllFilesPresentInArrays() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/arrays"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/arrays"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("arraySet.kt") @@ -663,7 +664,7 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos } public void testAllFilesPresentInBuiltins() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/builtins"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/builtins"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("lists.kt") @@ -681,7 +682,7 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos } public void testAllFilesPresentInCallResolution() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/callResolution"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/callResolution"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("companionInvoke.kt") @@ -769,7 +770,7 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos } public void testAllFilesPresentInCfg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/cfg"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/cfg"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("annotatedLocalClass.kt") @@ -907,7 +908,7 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos } public void testAllFilesPresentInConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/constructors"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/constructors"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("noSuperCallInSupertypes.kt") @@ -925,7 +926,7 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos } public void testAllFilesPresentInDelegates() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/delegates"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/delegates"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("delegateInference.kt") @@ -978,7 +979,7 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos } public void testAllFilesPresentInDiagnostics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/diagnostics"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/diagnostics"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("annotationArgumentKClassLiteralTypeError.kt") @@ -1236,7 +1237,7 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos } public void testAllFilesPresentInExpresssions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/expresssions"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/expresssions"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("annotationWithReturn.kt") @@ -1548,7 +1549,7 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos } public void testAllFilesPresentInInference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/expresssions/inference"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/expresssions/inference"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("id.kt") @@ -1576,7 +1577,7 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos } public void testAllFilesPresentInInvoke() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/expresssions/invoke"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/expresssions/invoke"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("doubleBrackets.kt") @@ -1664,7 +1665,7 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos } public void testAllFilesPresentInOperators() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/expresssions/operators"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/expresssions/operators"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("plus.kt") @@ -1693,7 +1694,7 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos } public void testAllFilesPresentInFromBuilder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/fromBuilder"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/fromBuilder"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("complexTypes.kt") @@ -1731,7 +1732,7 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos } public void testAllFilesPresentInInference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/inference"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/inference"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("callableReferenceOnInstance.kt") @@ -1839,7 +1840,7 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos } public void testAllFilesPresentInInnerClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/innerClasses"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/innerClasses"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("inner.kt") @@ -1872,7 +1873,7 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos } public void testAllFilesPresentInLocalClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/localClasses"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/localClasses"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("implicitInAnonymous.kt") @@ -1900,7 +1901,7 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos } public void testAllFilesPresentInMultifile() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/multifile"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/multifile"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("Annotations.kt") @@ -1968,7 +1969,7 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos } public void testAllFilesPresentInOverrides() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/overrides"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/overrides"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("generics.kt") @@ -2021,7 +2022,7 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos } public void testAllFilesPresentInProblems() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/problems"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/problems"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("compilerPhase.kt") @@ -2109,7 +2110,7 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos } public void testAllFilesPresentInProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/properties"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/properties"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("javaAccessorConversion.kt") @@ -2152,7 +2153,7 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos } public void testAllFilesPresentInReferences() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/references"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/references"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("integerLiteralInLhs.kt") @@ -2185,7 +2186,7 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos } public void testAllFilesPresentInSamConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/samConstructors"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/samConstructors"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("genericSam.kt") @@ -2228,7 +2229,7 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos } public void testAllFilesPresentInSamConversions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/samConversions"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/samConversions"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("genericSam.kt") @@ -2286,7 +2287,7 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos } public void testAllFilesPresentInSmartcasts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("bangbang.kt") @@ -2353,7 +2354,7 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos } public void testAllFilesPresentInBooleans() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("booleanOperators.kt") @@ -2381,7 +2382,7 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos } public void testAllFilesPresentInBoundSmartcasts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/boundSmartcasts"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/boundSmartcasts"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("boundSmartcasts.kt") @@ -2409,7 +2410,7 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos } public void testAllFilesPresentInControlStructures() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("elvis.kt") @@ -2447,7 +2448,7 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos } public void testAllFilesPresentInLambdas() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/lambdas"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/lambdas"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("inPlaceLambdas.kt") @@ -2475,7 +2476,7 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos } public void testAllFilesPresentInLoops() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/loops"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/loops"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("dataFlowInfoFromWhileCondition.kt") @@ -2498,7 +2499,7 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos } public void testAllFilesPresentInProblems() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/problems"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/problems"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("invoke.kt") @@ -2516,7 +2517,7 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos } public void testAllFilesPresentInReceivers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/receivers"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/receivers"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("implicitReceiverAsWhenSubject.kt") @@ -2549,7 +2550,7 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos } public void testAllFilesPresentInSafeCalls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("assignSafeCall.kt") @@ -2582,7 +2583,7 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos } public void testAllFilesPresentInStability() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/stability"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/stability"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("overridenOpenVal.kt") @@ -2600,7 +2601,7 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos } public void testAllFilesPresentInVariables() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/variables"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/variables"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("delayedAssignment.kt") @@ -2624,7 +2625,7 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos } public void testAllFilesPresentInStdlib() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/stdlib"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/stdlib"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("compiler/fir/analysis-tests/testData/resolve/stdlib/j+k") @@ -2636,7 +2637,7 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos } public void testAllFilesPresentInJ_k() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/stdlib/j+k"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/stdlib/j+k"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("ArrayInGenericArguments.kt") @@ -2660,7 +2661,7 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos } public void testAllFilesPresentInTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/types"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/types"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("bareWithSubjectTypeAlias.kt") @@ -2683,7 +2684,7 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos } public void testAllFilesPresentInVisibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/visibility"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/visibility"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("exposedFunctionParameterType.kt") diff --git a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/FirLoadCompiledKotlinGenerated.java b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/FirLoadCompiledKotlinGenerated.java index eeaeba1fee0..8dc5b0fc3ac 100644 --- a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/FirLoadCompiledKotlinGenerated.java +++ b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/FirLoadCompiledKotlinGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.fir; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class FirLoadCompiledKotlinGenerated extends AbstractFirLoadCompiledKotli } public void testAllFilesPresentInCompiledKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/testData/loadJava/compiledKotlin/annotations") @@ -37,7 +38,7 @@ public class FirLoadCompiledKotlinGenerated extends AbstractFirLoadCompiledKotli } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("AnnotatedAnnotation.kt") @@ -94,7 +95,7 @@ public class FirLoadCompiledKotlinGenerated extends AbstractFirLoadCompiledKotli } public void testAllFilesPresentInClassMembers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/classMembers"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/classMembers"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassObjectPropertyField.kt") @@ -162,7 +163,7 @@ public class FirLoadCompiledKotlinGenerated extends AbstractFirLoadCompiledKotli } public void testAllFilesPresentInClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/classes"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/classes"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("AnnotationInClassObject.kt") @@ -250,7 +251,7 @@ public class FirLoadCompiledKotlinGenerated extends AbstractFirLoadCompiledKotli } public void testAllFilesPresentInPackageMembers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/packageMembers"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/packageMembers"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("DelegatedProperty.kt") @@ -303,7 +304,7 @@ public class FirLoadCompiledKotlinGenerated extends AbstractFirLoadCompiledKotli } public void testAllFilesPresentInParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/parameters"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/parameters"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Constructor.kt") @@ -376,7 +377,7 @@ public class FirLoadCompiledKotlinGenerated extends AbstractFirLoadCompiledKotli } public void testAllFilesPresentInPropertiesWithoutBackingFields() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Class.kt") @@ -429,7 +430,7 @@ public class FirLoadCompiledKotlinGenerated extends AbstractFirLoadCompiledKotli } public void testAllFilesPresentInTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/types"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/types"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassLiteralArgument.kt") @@ -487,7 +488,7 @@ public class FirLoadCompiledKotlinGenerated extends AbstractFirLoadCompiledKotli } public void testAllFilesPresentInWithUseSiteTarget() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/withUseSiteTarget"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/withUseSiteTarget"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("DelegateTarget.kt") @@ -521,7 +522,7 @@ public class FirLoadCompiledKotlinGenerated extends AbstractFirLoadCompiledKotli } public void testAllFilesPresentInClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/class"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/class"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Class.kt") @@ -718,7 +719,7 @@ public class FirLoadCompiledKotlinGenerated extends AbstractFirLoadCompiledKotli } public void testAllFilesPresentInJavaBean() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/class/javaBean"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/class/javaBean"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("DifferentGetterAndSetter.kt") @@ -762,7 +763,7 @@ public class FirLoadCompiledKotlinGenerated extends AbstractFirLoadCompiledKotli } public void testAllFilesPresentInClassFun() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/classFun"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/classFun"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassInParamUsedInFun.kt") @@ -800,7 +801,7 @@ public class FirLoadCompiledKotlinGenerated extends AbstractFirLoadCompiledKotli } public void testAllFilesPresentInClassObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/classObject"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/classObject"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassObjectDeclaresVal.kt") @@ -878,7 +879,7 @@ public class FirLoadCompiledKotlinGenerated extends AbstractFirLoadCompiledKotli } public void testAllFilesPresentInConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/constructor"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/constructor"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Constructor0.kt") @@ -970,7 +971,7 @@ public class FirLoadCompiledKotlinGenerated extends AbstractFirLoadCompiledKotli } public void testAllFilesPresentInVararg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/constructor/vararg"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/constructor/vararg"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ConstructorNonLastVararg.kt") @@ -994,7 +995,7 @@ public class FirLoadCompiledKotlinGenerated extends AbstractFirLoadCompiledKotli } public void testAllFilesPresentInCoroutines() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Basic.kt") @@ -1012,7 +1013,7 @@ public class FirLoadCompiledKotlinGenerated extends AbstractFirLoadCompiledKotli } public void testAllFilesPresentInDataClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/dataClass"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/dataClass"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("MixedComponents.kt") @@ -1045,7 +1046,7 @@ public class FirLoadCompiledKotlinGenerated extends AbstractFirLoadCompiledKotli } public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/enum"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/enum"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("enumVisibility.kt") @@ -1088,7 +1089,7 @@ public class FirLoadCompiledKotlinGenerated extends AbstractFirLoadCompiledKotli } public void testAllFilesPresentInFromLoadJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ArrayTypeVariance.kt") @@ -1275,7 +1276,7 @@ public class FirLoadCompiledKotlinGenerated extends AbstractFirLoadCompiledKotli } public void testAllFilesPresentInKotlinSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ArrayType.kt") @@ -1367,7 +1368,7 @@ public class FirLoadCompiledKotlinGenerated extends AbstractFirLoadCompiledKotli } public void testAllFilesPresentInError() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ConflictingProjectionKind.kt") @@ -1510,7 +1511,7 @@ public class FirLoadCompiledKotlinGenerated extends AbstractFirLoadCompiledKotli } public void testAllFilesPresentInPropagation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("PropagateTypeArgumentNullable.kt") @@ -1527,7 +1528,7 @@ public class FirLoadCompiledKotlinGenerated extends AbstractFirLoadCompiledKotli } public void testAllFilesPresentInParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ChangeProjectionKind1.kt") @@ -1700,7 +1701,7 @@ public class FirLoadCompiledKotlinGenerated extends AbstractFirLoadCompiledKotli } public void testAllFilesPresentInReturn() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("CantMakeImmutableInSubclass.kt") @@ -1853,7 +1854,7 @@ public class FirLoadCompiledKotlinGenerated extends AbstractFirLoadCompiledKotli } public void testAllFilesPresentInTypeParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/typeParameter"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/typeParameter"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("InheritMutability.kt") @@ -1913,7 +1914,7 @@ public class FirLoadCompiledKotlinGenerated extends AbstractFirLoadCompiledKotli } public void testAllFilesPresentInLibrary() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/library"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/library"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("LoadIterable.kt") @@ -1941,7 +1942,7 @@ public class FirLoadCompiledKotlinGenerated extends AbstractFirLoadCompiledKotli } public void testAllFilesPresentInModality() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/modality"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/modality"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ModalityOfFakeOverrides.kt") @@ -1959,7 +1960,7 @@ public class FirLoadCompiledKotlinGenerated extends AbstractFirLoadCompiledKotli } public void testAllFilesPresentInNotNull() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/notNull"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/notNull"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("NotNullField.kt") @@ -1998,7 +1999,7 @@ public class FirLoadCompiledKotlinGenerated extends AbstractFirLoadCompiledKotli } public void testAllFilesPresentInFun() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Assert.kt") @@ -2065,7 +2066,7 @@ public class FirLoadCompiledKotlinGenerated extends AbstractFirLoadCompiledKotli } public void testAllFilesPresentInGenericWithTypeVariables() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/genericWithTypeVariables"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/genericWithTypeVariables"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("FunGenericParam.kt") @@ -2128,7 +2129,7 @@ public class FirLoadCompiledKotlinGenerated extends AbstractFirLoadCompiledKotli } public void testAllFilesPresentInGenericWithoutTypeVariables() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/genericWithoutTypeVariables"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/genericWithoutTypeVariables"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("FunClassParamNotNull.kt") @@ -2166,7 +2167,7 @@ public class FirLoadCompiledKotlinGenerated extends AbstractFirLoadCompiledKotli } public void testAllFilesPresentInNonGeneric() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassFun.kt") @@ -2259,7 +2260,7 @@ public class FirLoadCompiledKotlinGenerated extends AbstractFirLoadCompiledKotli } public void testAllFilesPresentInVararg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/vararg"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/vararg"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("nonLastVararg.kt") @@ -2288,7 +2289,7 @@ public class FirLoadCompiledKotlinGenerated extends AbstractFirLoadCompiledKotli } public void testAllFilesPresentInInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/inline"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/inline"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("inlineFunction.kt") @@ -2306,7 +2307,7 @@ public class FirLoadCompiledKotlinGenerated extends AbstractFirLoadCompiledKotli } public void testAllFilesPresentInMemberOrder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/memberOrder"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/memberOrder"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("callablesNameClash.kt") @@ -2349,7 +2350,7 @@ public class FirLoadCompiledKotlinGenerated extends AbstractFirLoadCompiledKotli } public void testAllFilesPresentInNested() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/nested"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/nested"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("deepInnerGeneric.kt") @@ -2377,7 +2378,7 @@ public class FirLoadCompiledKotlinGenerated extends AbstractFirLoadCompiledKotli } public void testAllFilesPresentInPlatformTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/platformTypes"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/platformTypes"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("notnullTypeArgument.kt") @@ -2400,7 +2401,7 @@ public class FirLoadCompiledKotlinGenerated extends AbstractFirLoadCompiledKotli } public void testAllFilesPresentInProp() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/prop"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/prop"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassVal.kt") @@ -2582,7 +2583,7 @@ public class FirLoadCompiledKotlinGenerated extends AbstractFirLoadCompiledKotli } public void testAllFilesPresentInDefaultAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/prop/defaultAccessors"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/prop/defaultAccessors"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassVal.kt") @@ -2646,7 +2647,7 @@ public class FirLoadCompiledKotlinGenerated extends AbstractFirLoadCompiledKotli } public void testAllFilesPresentInType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/type"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/type"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Any.kt") @@ -2814,7 +2815,7 @@ public class FirLoadCompiledKotlinGenerated extends AbstractFirLoadCompiledKotli } public void testAllFilesPresentInTypealias() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/typealias"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/typealias"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Annotations.kt") @@ -2847,7 +2848,7 @@ public class FirLoadCompiledKotlinGenerated extends AbstractFirLoadCompiledKotli } public void testAllFilesPresentInVisibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/visibility"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/visibility"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("InternalClass.kt") diff --git a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/LazyBodyIsNotTouchedTilContractsPhaseTestGenerated.java b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/LazyBodyIsNotTouchedTilContractsPhaseTestGenerated.java index 3cb1851cae2..c2daeaee160 100644 --- a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/LazyBodyIsNotTouchedTilContractsPhaseTestGenerated.java +++ b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/LazyBodyIsNotTouchedTilContractsPhaseTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.fir; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract } public void testAllFilesPresentInResolve() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("asImports.kt") @@ -482,7 +483,7 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract } public void testAllFilesPresentInArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/arguments"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/arguments"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("ambiguityOnJavaOverride.kt") @@ -640,7 +641,7 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract } public void testAllFilesPresentInArrays() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/arrays"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/arrays"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("arraySet.kt") @@ -663,7 +664,7 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract } public void testAllFilesPresentInBuiltins() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/builtins"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/builtins"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("lists.kt") @@ -681,7 +682,7 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract } public void testAllFilesPresentInCallResolution() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/callResolution"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/callResolution"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("companionInvoke.kt") @@ -769,7 +770,7 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract } public void testAllFilesPresentInCfg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/cfg"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/cfg"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("annotatedLocalClass.kt") @@ -907,7 +908,7 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract } public void testAllFilesPresentInConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/constructors"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/constructors"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("noSuperCallInSupertypes.kt") @@ -925,7 +926,7 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract } public void testAllFilesPresentInDelegates() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/delegates"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/delegates"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("delegateInference.kt") @@ -978,7 +979,7 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract } public void testAllFilesPresentInDiagnostics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/diagnostics"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/diagnostics"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("annotationArgumentKClassLiteralTypeError.kt") @@ -1236,7 +1237,7 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract } public void testAllFilesPresentInExpresssions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/expresssions"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/expresssions"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("annotationWithReturn.kt") @@ -1548,7 +1549,7 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract } public void testAllFilesPresentInInference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/expresssions/inference"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/expresssions/inference"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("id.kt") @@ -1576,7 +1577,7 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract } public void testAllFilesPresentInInvoke() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/expresssions/invoke"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/expresssions/invoke"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("doubleBrackets.kt") @@ -1664,7 +1665,7 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract } public void testAllFilesPresentInOperators() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/expresssions/operators"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/expresssions/operators"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("plus.kt") @@ -1693,7 +1694,7 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract } public void testAllFilesPresentInFromBuilder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/fromBuilder"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/fromBuilder"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("complexTypes.kt") @@ -1731,7 +1732,7 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract } public void testAllFilesPresentInInference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/inference"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/inference"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("callableReferenceOnInstance.kt") @@ -1839,7 +1840,7 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract } public void testAllFilesPresentInInnerClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/innerClasses"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/innerClasses"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("inner.kt") @@ -1872,7 +1873,7 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract } public void testAllFilesPresentInLocalClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/localClasses"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/localClasses"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("implicitInAnonymous.kt") @@ -1900,7 +1901,7 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract } public void testAllFilesPresentInMultifile() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/multifile"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/multifile"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("Annotations.kt") @@ -1968,7 +1969,7 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract } public void testAllFilesPresentInOverrides() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/overrides"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/overrides"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("generics.kt") @@ -2021,7 +2022,7 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract } public void testAllFilesPresentInProblems() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/problems"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/problems"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("compilerPhase.kt") @@ -2109,7 +2110,7 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract } public void testAllFilesPresentInProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/properties"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/properties"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("javaAccessorConversion.kt") @@ -2152,7 +2153,7 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract } public void testAllFilesPresentInReferences() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/references"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/references"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("integerLiteralInLhs.kt") @@ -2185,7 +2186,7 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract } public void testAllFilesPresentInSamConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/samConstructors"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/samConstructors"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("genericSam.kt") @@ -2228,7 +2229,7 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract } public void testAllFilesPresentInSamConversions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/samConversions"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/samConversions"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("genericSam.kt") @@ -2286,7 +2287,7 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract } public void testAllFilesPresentInSmartcasts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("bangbang.kt") @@ -2353,7 +2354,7 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract } public void testAllFilesPresentInBooleans() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("booleanOperators.kt") @@ -2381,7 +2382,7 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract } public void testAllFilesPresentInBoundSmartcasts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/boundSmartcasts"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/boundSmartcasts"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("boundSmartcasts.kt") @@ -2409,7 +2410,7 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract } public void testAllFilesPresentInControlStructures() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("elvis.kt") @@ -2447,7 +2448,7 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract } public void testAllFilesPresentInLambdas() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/lambdas"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/lambdas"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("inPlaceLambdas.kt") @@ -2475,7 +2476,7 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract } public void testAllFilesPresentInLoops() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/loops"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/loops"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("dataFlowInfoFromWhileCondition.kt") @@ -2498,7 +2499,7 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract } public void testAllFilesPresentInProblems() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/problems"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/problems"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("invoke.kt") @@ -2516,7 +2517,7 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract } public void testAllFilesPresentInReceivers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/receivers"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/receivers"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("implicitReceiverAsWhenSubject.kt") @@ -2549,7 +2550,7 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract } public void testAllFilesPresentInSafeCalls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("assignSafeCall.kt") @@ -2582,7 +2583,7 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract } public void testAllFilesPresentInStability() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/stability"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/stability"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("overridenOpenVal.kt") @@ -2600,7 +2601,7 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract } public void testAllFilesPresentInVariables() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/variables"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/variables"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("delayedAssignment.kt") @@ -2624,7 +2625,7 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract } public void testAllFilesPresentInStdlib() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/stdlib"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/stdlib"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("compiler/fir/analysis-tests/testData/resolve/stdlib/j+k") @@ -2636,7 +2637,7 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract } public void testAllFilesPresentInJ_k() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/stdlib/j+k"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/stdlib/j+k"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("ArrayInGenericArguments.kt") @@ -2660,7 +2661,7 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract } public void testAllFilesPresentInTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/types"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/types"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("bareWithSubjectTypeAlias.kt") @@ -2683,7 +2684,7 @@ public class LazyBodyIsNotTouchedTilContractsPhaseTestGenerated extends Abstract } public void testAllFilesPresentInVisibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/visibility"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/visibility"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("exposedFunctionParameterType.kt") diff --git a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/java/FirOldFrontendLightClassesTestGenerated.java b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/java/FirOldFrontendLightClassesTestGenerated.java index f384ee70085..bbc3b51fae9 100644 --- a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/java/FirOldFrontendLightClassesTestGenerated.java +++ b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/java/FirOldFrontendLightClassesTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.fir.java; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class FirOldFrontendLightClassesTestGenerated extends AbstractFirOldFront } public void testAllFilesPresentInLightClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/lightClasses"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/lightClasses"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("genericClasses.kt") diff --git a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/java/FirTypeEnhancementTestGenerated.java b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/java/FirTypeEnhancementTestGenerated.java index 06f3cf5d830..6019dee58ec 100644 --- a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/java/FirTypeEnhancementTestGenerated.java +++ b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/java/FirTypeEnhancementTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.fir.java; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class FirTypeEnhancementTestGenerated extends AbstractFirTypeEnhancementT } public void testAllFilesPresentInCompiledJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("ArrayInGenericArguments.java") @@ -267,7 +268,7 @@ public class FirTypeEnhancementTestGenerated extends AbstractFirTypeEnhancementT } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/annotations"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/annotations"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("AnnotatedAnnotation.java") @@ -470,7 +471,7 @@ public class FirTypeEnhancementTestGenerated extends AbstractFirTypeEnhancementT } public void testAllFilesPresentInConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/constructor"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/constructor"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("ConstructorGenericDeep.java") @@ -498,7 +499,7 @@ public class FirTypeEnhancementTestGenerated extends AbstractFirTypeEnhancementT } public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/enum"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/enum"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("EnumMembers.java") @@ -526,7 +527,7 @@ public class FirTypeEnhancementTestGenerated extends AbstractFirTypeEnhancementT } public void testAllFilesPresentInJavaBean() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/javaBean"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/javaBean"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("DifferentGetterAndSetter.java") @@ -574,7 +575,7 @@ public class FirTypeEnhancementTestGenerated extends AbstractFirTypeEnhancementT } public void testAllFilesPresentInKotlinSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("ArrayType.java") @@ -661,7 +662,7 @@ public class FirTypeEnhancementTestGenerated extends AbstractFirTypeEnhancementT } public void testAllFilesPresentInError() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/error"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/error"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("WrongProjectionKind.java") @@ -694,7 +695,7 @@ public class FirTypeEnhancementTestGenerated extends AbstractFirTypeEnhancementT } public void testAllFilesPresentInPropagation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("PropagateTypeArgumentNullable.java") @@ -711,7 +712,7 @@ public class FirTypeEnhancementTestGenerated extends AbstractFirTypeEnhancementT } public void testAllFilesPresentInParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("ChangeProjectionKind1.java") @@ -864,7 +865,7 @@ public class FirTypeEnhancementTestGenerated extends AbstractFirTypeEnhancementT } public void testAllFilesPresentInReturn() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("CantMakeImmutableInSubclass.java") @@ -1017,7 +1018,7 @@ public class FirTypeEnhancementTestGenerated extends AbstractFirTypeEnhancementT } public void testAllFilesPresentInTypeParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/typeParameter"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/typeParameter"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("InheritNullability.java") @@ -1067,7 +1068,7 @@ public class FirTypeEnhancementTestGenerated extends AbstractFirTypeEnhancementT } public void testAllFilesPresentInLibrary() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/library"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/library"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("LoadIterable.java") @@ -1095,7 +1096,7 @@ public class FirTypeEnhancementTestGenerated extends AbstractFirTypeEnhancementT } public void testAllFilesPresentInModality() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/modality"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/modality"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("ModalityOfFakeOverrides.java") @@ -1113,7 +1114,7 @@ public class FirTypeEnhancementTestGenerated extends AbstractFirTypeEnhancementT } public void testAllFilesPresentInMutability() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/mutability"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/mutability"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("LoadIterable.java") @@ -1151,7 +1152,7 @@ public class FirTypeEnhancementTestGenerated extends AbstractFirTypeEnhancementT } public void testAllFilesPresentInNotNull() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/notNull"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/notNull"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("NotNullField.java") @@ -1189,7 +1190,7 @@ public class FirTypeEnhancementTestGenerated extends AbstractFirTypeEnhancementT } public void testAllFilesPresentInProtectedPackage() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/protectedPackage"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/protectedPackage"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("ProtectedPackageConstructor.java") @@ -1217,7 +1218,7 @@ public class FirTypeEnhancementTestGenerated extends AbstractFirTypeEnhancementT } public void testAllFilesPresentInProtectedStatic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/protectedStatic"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/protectedStatic"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("ConstructorInProtectedStaticNestedClass.java") @@ -1235,7 +1236,7 @@ public class FirTypeEnhancementTestGenerated extends AbstractFirTypeEnhancementT } public void testAllFilesPresentInRendering() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/rendering"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/rendering"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("Rendering.java") @@ -1253,7 +1254,7 @@ public class FirTypeEnhancementTestGenerated extends AbstractFirTypeEnhancementT } public void testAllFilesPresentInSam() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/sam"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/sam"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("Comparator.java") @@ -1345,7 +1346,7 @@ public class FirTypeEnhancementTestGenerated extends AbstractFirTypeEnhancementT } public void testAllFilesPresentInAdapters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/sam/adapters"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/sam/adapters"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("AmbiguousAdapters.java") @@ -1432,7 +1433,7 @@ public class FirTypeEnhancementTestGenerated extends AbstractFirTypeEnhancementT } public void testAllFilesPresentInInheritance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/sam/adapters/inheritance"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/sam/adapters/inheritance"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("InheritedAdapterAndDeclaration.java") @@ -1492,7 +1493,7 @@ public class FirTypeEnhancementTestGenerated extends AbstractFirTypeEnhancementT } public void testAllFilesPresentInSignatureAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/signatureAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/signatureAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("StableName.java") @@ -1510,7 +1511,7 @@ public class FirTypeEnhancementTestGenerated extends AbstractFirTypeEnhancementT } public void testAllFilesPresentInSignaturePropagation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/signaturePropagation"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/signaturePropagation"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("ArraysInSubtypes.java") @@ -1568,7 +1569,7 @@ public class FirTypeEnhancementTestGenerated extends AbstractFirTypeEnhancementT } public void testAllFilesPresentInStatic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/static"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/static"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("DeeplyInnerClass.java") @@ -1636,7 +1637,7 @@ public class FirTypeEnhancementTestGenerated extends AbstractFirTypeEnhancementT } public void testAllFilesPresentInVararg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/vararg"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/vararg"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("VarargInt.java") diff --git a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/java/OwnFirTypeEnhancementTestGenerated.java b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/java/OwnFirTypeEnhancementTestGenerated.java index 457b26d4249..e5f2caf42bb 100644 --- a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/java/OwnFirTypeEnhancementTestGenerated.java +++ b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/java/OwnFirTypeEnhancementTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.fir.java; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class OwnFirTypeEnhancementTestGenerated extends AbstractOwnFirTypeEnhanc } public void testAllFilesPresentInEnhancement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/enhancement"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/enhancement"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("compiler/fir/analysis-tests/testData/enhancement/jsr305") @@ -37,7 +38,7 @@ public class OwnFirTypeEnhancementTestGenerated extends AbstractOwnFirTypeEnhanc } public void testAllFilesPresentInJsr305() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/enhancement/jsr305"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/enhancement/jsr305"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("NonNullNever.java") @@ -64,7 +65,7 @@ public class OwnFirTypeEnhancementTestGenerated extends AbstractOwnFirTypeEnhanc } public void testAllFilesPresentInTypeQualifierDefault() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/enhancement/jsr305/typeQualifierDefault"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/enhancement/jsr305/typeQualifierDefault"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("FieldsAreNullable.java") @@ -128,7 +129,7 @@ public class OwnFirTypeEnhancementTestGenerated extends AbstractOwnFirTypeEnhanc } public void testAllFilesPresentInMapping() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/enhancement/mapping"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/enhancement/mapping"), Pattern.compile("^(.+)\\.java$"), null, true); } } @@ -141,7 +142,7 @@ public class OwnFirTypeEnhancementTestGenerated extends AbstractOwnFirTypeEnhanc } public void testAllFilesPresentInSignatureAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/enhancement/signatureAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/enhancement/signatureAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("DefaultEnum.java") diff --git a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/codegen/FirCompileKotlinAgainstKotlinTestGenerated.java b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/codegen/FirCompileKotlinAgainstKotlinTestGenerated.java index 457db0f0a30..8ed3297adee 100644 --- a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/codegen/FirCompileKotlinAgainstKotlinTestGenerated.java +++ b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/codegen/FirCompileKotlinAgainstKotlinTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.codegen; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class FirCompileKotlinAgainstKotlinTestGenerated extends AbstractFirCompi } public void testAllFilesPresentInCompileKotlinAgainstKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("annotationInInterface.kt") @@ -423,7 +424,7 @@ public class FirCompileKotlinAgainstKotlinTestGenerated extends AbstractFirCompi } public void testAllFilesPresentInFir() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/fir"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/fir"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("AnonymousObjectInProperty.kt") @@ -461,7 +462,7 @@ public class FirCompileKotlinAgainstKotlinTestGenerated extends AbstractFirCompi } public void testAllFilesPresentInJvm8() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults") @@ -473,7 +474,7 @@ public class FirCompileKotlinAgainstKotlinTestGenerated extends AbstractFirCompi } public void testAllFilesPresentInDefaults() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("superCall.kt") @@ -515,7 +516,7 @@ public class FirCompileKotlinAgainstKotlinTestGenerated extends AbstractFirCompi } public void testAllFilesPresentInAllCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("callStackTrace.kt") @@ -562,7 +563,7 @@ public class FirCompileKotlinAgainstKotlinTestGenerated extends AbstractFirCompi } public void testAllFilesPresentInDelegationBy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("simple.kt") @@ -586,7 +587,7 @@ public class FirCompileKotlinAgainstKotlinTestGenerated extends AbstractFirCompi } public void testAllFilesPresentInInterop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/interop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/interop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("likeMemberClash.kt") @@ -635,7 +636,7 @@ public class FirCompileKotlinAgainstKotlinTestGenerated extends AbstractFirCompi } public void testAllFilesPresentInJvm8against6() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/jvm8against6"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/jvm8against6"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("jdk8Against6.kt") @@ -677,7 +678,7 @@ public class FirCompileKotlinAgainstKotlinTestGenerated extends AbstractFirCompi } public void testAllFilesPresentInDelegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/jvm8against6/delegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/jvm8against6/delegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("diamond.kt") @@ -707,7 +708,7 @@ public class FirCompileKotlinAgainstKotlinTestGenerated extends AbstractFirCompi } public void testAllFilesPresentInTypeAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/typeAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/typeAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("implicitReturn.kt") diff --git a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/codegen/ir/FirBlackBoxAgainstJavaCodegenTestGenerated.java b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/codegen/ir/FirBlackBoxAgainstJavaCodegenTestGenerated.java index b8e90b35bf7..24bc905559e 100644 --- a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/codegen/ir/FirBlackBoxAgainstJavaCodegenTestGenerated.java +++ b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/codegen/ir/FirBlackBoxAgainstJavaCodegenTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.codegen.ir; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class FirBlackBoxAgainstJavaCodegenTestGenerated extends AbstractFirBlack } public void testAllFilesPresentInBoxAgainstJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true, "oldLanguageVersions"); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true, "oldLanguageVersions"); } @TestMetadata("compiler/testData/codegen/boxAgainstJava/annotations") @@ -38,7 +39,7 @@ public class FirBlackBoxAgainstJavaCodegenTestGenerated extends AbstractFirBlack } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/annotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/annotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("divisionByZeroInJava.kt") @@ -95,7 +96,7 @@ public class FirBlackBoxAgainstJavaCodegenTestGenerated extends AbstractFirBlack } public void testAllFilesPresentInKClassMapping() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/annotations/kClassMapping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/annotations/kClassMapping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("arrayClassParameter.kt") @@ -138,7 +139,7 @@ public class FirBlackBoxAgainstJavaCodegenTestGenerated extends AbstractFirBlack } public void testAllFilesPresentInTypeAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/annotations/typeAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/annotations/typeAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("implicitReturn.kt") @@ -157,7 +158,7 @@ public class FirBlackBoxAgainstJavaCodegenTestGenerated extends AbstractFirBlack } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("constructor.kt") @@ -195,7 +196,7 @@ public class FirBlackBoxAgainstJavaCodegenTestGenerated extends AbstractFirBlack } public void testAllFilesPresentInConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/constructor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/constructor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("genericConstructor.kt") @@ -218,7 +219,7 @@ public class FirBlackBoxAgainstJavaCodegenTestGenerated extends AbstractFirBlack } public void testAllFilesPresentInDelegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/delegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/delegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("delegationAndInheritanceFromJava.kt") @@ -236,7 +237,7 @@ public class FirBlackBoxAgainstJavaCodegenTestGenerated extends AbstractFirBlack } public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("nameConflict.kt") @@ -284,7 +285,7 @@ public class FirBlackBoxAgainstJavaCodegenTestGenerated extends AbstractFirBlack } public void testAllFilesPresentInFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("constructor.kt") @@ -322,7 +323,7 @@ public class FirBlackBoxAgainstJavaCodegenTestGenerated extends AbstractFirBlack } public void testAllFilesPresentInIeee754() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/ieee754"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/ieee754"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("anyToReal.kt") @@ -375,7 +376,7 @@ public class FirBlackBoxAgainstJavaCodegenTestGenerated extends AbstractFirBlack } public void testAllFilesPresentInInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/inline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/inline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt19910.kt") @@ -393,7 +394,7 @@ public class FirBlackBoxAgainstJavaCodegenTestGenerated extends AbstractFirBlack } public void testAllFilesPresentInInnerClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/innerClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/innerClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt3532.kt") @@ -421,7 +422,7 @@ public class FirBlackBoxAgainstJavaCodegenTestGenerated extends AbstractFirBlack } public void testAllFilesPresentInInterfaces() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/interfaces"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/interfaces"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inheritJavaInterface.kt") @@ -439,7 +440,7 @@ public class FirBlackBoxAgainstJavaCodegenTestGenerated extends AbstractFirBlack } public void testAllFilesPresentInMultiplatform() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("annotationsViaActualTypeAliasFromBinary.kt") @@ -457,7 +458,7 @@ public class FirBlackBoxAgainstJavaCodegenTestGenerated extends AbstractFirBlack } public void testAllFilesPresentInNotNullAssertions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/notNullAssertions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/notNullAssertions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("callAssertions.kt") @@ -495,7 +496,7 @@ public class FirBlackBoxAgainstJavaCodegenTestGenerated extends AbstractFirBlack } public void testAllFilesPresentInPlatformTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/platformTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/platformTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("genericUnit.kt") @@ -528,7 +529,7 @@ public class FirBlackBoxAgainstJavaCodegenTestGenerated extends AbstractFirBlack } public void testAllFilesPresentInProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("fieldAccessFromExtensionInTraitImpl.kt") @@ -556,7 +557,7 @@ public class FirBlackBoxAgainstJavaCodegenTestGenerated extends AbstractFirBlack } public void testAllFilesPresentInRecursiveRawTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/recursiveRawTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/recursiveRawTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt16528.kt") @@ -579,7 +580,7 @@ public class FirBlackBoxAgainstJavaCodegenTestGenerated extends AbstractFirBlack } public void testAllFilesPresentInReflection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/reflection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/reflection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/codegen/boxAgainstJava/reflection/classLiterals") @@ -591,7 +592,7 @@ public class FirBlackBoxAgainstJavaCodegenTestGenerated extends AbstractFirBlack } public void testAllFilesPresentInClassLiterals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/reflection/classLiterals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/reflection/classLiterals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("javaClassLiteral.kt") @@ -609,7 +610,7 @@ public class FirBlackBoxAgainstJavaCodegenTestGenerated extends AbstractFirBlack } public void testAllFilesPresentInMapping() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/reflection/mapping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/reflection/mapping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("jClass2kClass.kt") @@ -642,7 +643,7 @@ public class FirBlackBoxAgainstJavaCodegenTestGenerated extends AbstractFirBlack } public void testAllFilesPresentInProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/reflection/properties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/reflection/properties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("equalsHashCodeToString.kt") @@ -661,7 +662,7 @@ public class FirBlackBoxAgainstJavaCodegenTestGenerated extends AbstractFirBlack } public void testAllFilesPresentInSam() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("differentFqNames.kt") @@ -713,7 +714,7 @@ public class FirBlackBoxAgainstJavaCodegenTestGenerated extends AbstractFirBlack } public void testAllFilesPresentInAdapters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/sam/adapters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/sam/adapters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("bridgesForOverridden.kt") @@ -870,7 +871,7 @@ public class FirBlackBoxAgainstJavaCodegenTestGenerated extends AbstractFirBlack } public void testAllFilesPresentInOperators() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/sam/adapters/operators"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/sam/adapters/operators"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("augmentedAssignmentPure.kt") @@ -940,7 +941,7 @@ public class FirBlackBoxAgainstJavaCodegenTestGenerated extends AbstractFirBlack } public void testAllFilesPresentInSpecialBuiltins() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/specialBuiltins"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/specialBuiltins"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("charBuffer.kt") @@ -958,7 +959,7 @@ public class FirBlackBoxAgainstJavaCodegenTestGenerated extends AbstractFirBlack } public void testAllFilesPresentInStaticFun() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/staticFun"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/staticFun"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("classWithNestedEnum.kt") @@ -976,7 +977,7 @@ public class FirBlackBoxAgainstJavaCodegenTestGenerated extends AbstractFirBlack } public void testAllFilesPresentInSyntheticExtensions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/syntheticExtensions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/syntheticExtensions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("fromTwoBases.kt") @@ -1039,7 +1040,7 @@ public class FirBlackBoxAgainstJavaCodegenTestGenerated extends AbstractFirBlack } public void testAllFilesPresentInThrows() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/throws"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/throws"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("delegationAndThrows.kt") @@ -1057,7 +1058,7 @@ public class FirBlackBoxAgainstJavaCodegenTestGenerated extends AbstractFirBlack } public void testAllFilesPresentInTypealias() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/typealias"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/typealias"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("javaStaticMembersViaTypeAlias.kt") @@ -1075,7 +1076,7 @@ public class FirBlackBoxAgainstJavaCodegenTestGenerated extends AbstractFirBlack } public void testAllFilesPresentInVarargs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/varargs"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/varargs"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("varargsOverride.kt") @@ -1103,7 +1104,7 @@ public class FirBlackBoxAgainstJavaCodegenTestGenerated extends AbstractFirBlack } public void testAllFilesPresentInVisibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/visibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/visibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/codegen/boxAgainstJava/visibility/package") @@ -1115,7 +1116,7 @@ public class FirBlackBoxAgainstJavaCodegenTestGenerated extends AbstractFirBlack } public void testAllFilesPresentInPackage() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/visibility/package"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/visibility/package"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt2781.kt") @@ -1148,7 +1149,7 @@ public class FirBlackBoxAgainstJavaCodegenTestGenerated extends AbstractFirBlack } public void testAllFilesPresentInProtectedAndPackage() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/visibility/protectedAndPackage"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/visibility/protectedAndPackage"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("overrideProtectedFunInPackage.kt") @@ -1201,7 +1202,7 @@ public class FirBlackBoxAgainstJavaCodegenTestGenerated extends AbstractFirBlack } public void testAllFilesPresentInProtectedStatic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/visibility/protectedStatic"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/visibility/protectedStatic"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("funCallInConstructor.kt") diff --git a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/codegen/ir/FirBlackBoxCodegenTestGenerated.java b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/codegen/ir/FirBlackBoxCodegenTestGenerated.java index 3f083066ccb..623d2da523c 100644 --- a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/codegen/ir/FirBlackBoxCodegenTestGenerated.java +++ b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/codegen/ir/FirBlackBoxCodegenTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.codegen.ir; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInBox() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true, "oldLanguageVersions"); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true, "oldLanguageVersions"); } @TestMetadata("compiler/testData/codegen/box/annotations") @@ -38,7 +39,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("annotatedAnnotationParameter.kt") @@ -235,7 +236,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInAnnotatedLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations/annotatedLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations/annotatedLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("funExpression.kt") @@ -273,7 +274,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInTypeAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations/typeAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations/typeAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("checkingNotincorporatedInputTypes.kt") @@ -317,7 +318,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInArgumentOrder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/argumentOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/argumentOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("argumentOrderInObjectSuperCall.kt") @@ -410,7 +411,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInArrays() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("arrayConstructorWithNonInlineLambda.kt") @@ -747,7 +748,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInArraysOfInlineClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/arraysOfInlineClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/arraysOfInlineClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("arrayOfInlineClassOfArrayOfInlineClass.kt") @@ -765,7 +766,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInForInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/forInReversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/forInReversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("reversedArrayOriginalUpdatedInLoopBody.kt") @@ -798,7 +799,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInMultiDecl() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt15560.kt") @@ -850,7 +851,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInInt() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -883,7 +884,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInLong() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -918,7 +919,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInAssert() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/assert"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/assert"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("alwaysDisable.kt") @@ -940,7 +941,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInJvm() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/assert/jvm"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/assert/jvm"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("assertionsEnabledBeforeClassInitializers.kt") @@ -1064,7 +1065,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInBinaryOp() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/binaryOp"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/binaryOp"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("bitwiseOp.kt") @@ -1207,7 +1208,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInBoxingOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/boxingOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/boxingOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("boxedIntegersCmp.kt") @@ -1380,7 +1381,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInBridges() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/bridges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/bridges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("bridgeInInterface.kt") @@ -1677,7 +1678,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInSubstitutionInSuperClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/bridges/substitutionInSuperClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/bridges/substitutionInSuperClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("boundedTypeArguments.kt") @@ -1741,7 +1742,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInBuilderInference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("callableReferenceAndCoercionToUnit.kt") @@ -1789,7 +1790,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInBuiltinStubMethods() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("Collection.kt") @@ -1926,7 +1927,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInExtendJavaCollections() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/extendJavaCollections"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/extendJavaCollections"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("arrayList.kt") @@ -1959,7 +1960,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInMapGetOrDefault() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/mapGetOrDefault"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/mapGetOrDefault"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("noTypeSafeBridge.kt") @@ -1987,7 +1988,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInMapRemove() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/mapRemove"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/mapRemove"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("noDefaultImpls.kt") @@ -2021,7 +2022,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("builtinFunctionReferenceOwner.kt") @@ -2078,7 +2079,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInAdaptedReferences() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/adaptedReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/adaptedReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("bothWithCoercionToUnit.kt") @@ -2240,7 +2241,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInSuspendConversion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("bound.kt") @@ -2319,7 +2320,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInBound() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("array.kt") @@ -2466,7 +2467,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInEquals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/bound/equals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/bound/equals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("nullableReceiverInEquals.kt") @@ -2500,7 +2501,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInEquality() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/equality"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/equality"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("capturedDefaults.kt") @@ -2578,7 +2579,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/function"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/function"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("argumentTypes.kt") @@ -2860,7 +2861,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInLocal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/function/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/function/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("captureOuter.kt") @@ -2979,7 +2980,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("delegated.kt") @@ -3142,7 +3143,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInSerializability() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/serializability"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/serializability"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("boundWithNotSerializableReceiver.kt") @@ -3181,7 +3182,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInCasts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("as.kt") @@ -3318,7 +3319,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("asFunKBig.kt") @@ -3396,7 +3397,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInJavaInterop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("castWithWrongType.kt") @@ -3479,7 +3480,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInLiteralExpressionAsGenericArgument() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/literalExpressionAsGenericArgument"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/literalExpressionAsGenericArgument"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("binaryExpressionCast.kt") @@ -3527,7 +3528,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInMutableCollections() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/mutableCollections"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/mutableCollections"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("asWithMutable.kt") @@ -3581,7 +3582,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInCheckcastOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/checkcastOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/checkcastOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt19128.kt") @@ -3604,7 +3605,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInClassLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("bareArray.kt") @@ -3626,7 +3627,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInBound() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classLiteral/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classLiteral/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("javaIntrinsicWithSideEffect.kt") @@ -3664,7 +3665,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classLiteral/java"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classLiteral/java"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("java.kt") @@ -3718,7 +3719,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("boxPrimitiveTypeInClinitOfClassObject.kt") @@ -4330,7 +4331,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInInner() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classes/inner"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classes/inner"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("extensionWithOuter.kt") @@ -4379,7 +4380,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInClosures() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("anonymousObjectAsLastExpressionInLambda.kt") @@ -4621,7 +4622,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInCaptureInSuperConstructorCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/captureInSuperConstructorCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/captureInSuperConstructorCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("constructorParameterAndLocalCapturedInLambdaInLocalClass.kt") @@ -4794,7 +4795,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInCaptureOuterProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/captureOuterProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/captureOuterProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("captureFunctionInProperty.kt") @@ -4847,7 +4848,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInCapturedVarsOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/capturedVarsOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/capturedVarsOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("capturedInCrossinline.kt") @@ -4915,7 +4916,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInClosureInsideClosure() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/closureInsideClosure"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/closureInsideClosure"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("localFunInsideLocalFun.kt") @@ -4959,7 +4960,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInCollectionLiterals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/collectionLiterals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/collectionLiterals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("collectionLiteralsInArgumentPosition.kt") @@ -4997,7 +4998,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInCollections() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/collections"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/collections"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("charSequence.kt") @@ -5170,7 +5171,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInCompanion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/companion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/companion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("delegatedPropertyOnCompanion.kt") @@ -5193,7 +5194,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/compatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/compatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("privateCompanionObject.kt") @@ -5211,7 +5212,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInConstants() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/constants"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/constants"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("comparisonFalse.kt") @@ -5274,7 +5275,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInConstructorCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/constructorCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/constructorCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("breakInConstructorArguments.kt") @@ -5372,7 +5373,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInContracts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/contracts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/contracts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("constructorArgument.kt") @@ -5445,7 +5446,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInControlStructures() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("bottles.kt") @@ -5852,7 +5853,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInBreakContinueInExpressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("breakFromOuter.kt") @@ -5955,7 +5956,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInForInArray() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInArray"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInArray"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forInArraySpecializedToUntil.kt") @@ -6018,7 +6019,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInForInArrayWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forInArrayOfObjectArrayWithIndex.kt") @@ -6131,7 +6132,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInForInCharSequenceWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInCharSequenceWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInCharSequenceWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forInCharSeqWithIndexStops.kt") @@ -6214,7 +6215,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInForInIterableWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInIterableWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInIterableWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forInEmptyListWithIndex.kt") @@ -6282,7 +6283,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInForInSequenceWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInSequenceWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInSequenceWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forInEmptySequenceWithIndex.kt") @@ -6350,7 +6351,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInReturnsNothing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/returnsNothing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/returnsNothing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("ifElse.kt") @@ -6388,7 +6389,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInTryCatchInExpressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("catch.kt") @@ -6562,7 +6563,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInCoroutines() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("async.kt") @@ -7144,7 +7145,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInBridges() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/bridges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/bridges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("interfaceSpecialization.kt") @@ -7172,7 +7173,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInControlFlow() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/controlFlow"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/controlFlow"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("breakFinally.kt") @@ -7295,7 +7296,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInDebug() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/debug"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/debug"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("debuggerMetadata.kt") @@ -7348,7 +7349,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInFeatureIntersection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("breakWithNonEmptyStack.kt") @@ -7445,7 +7446,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("bigArity.kt") @@ -7472,7 +7473,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInBound() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("emptyLHS.kt") @@ -7490,7 +7491,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/function"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/function"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("genericCallableReferenceArguments.kt") @@ -7517,7 +7518,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInLocal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/function/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/function/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("equalsHashCode.kt") @@ -7537,7 +7538,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInTailrec() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/tailrec"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/tailrec"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("controlFlowIf.kt") @@ -7616,7 +7617,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("nonLocalReturn.kt") @@ -7633,7 +7634,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInDirect() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses/direct"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses/direct"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("boxReturnValueOfSuspendFunctionReference.kt") @@ -7861,7 +7862,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInResume() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses/resume"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses/resume"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("boxReturnValueOfSuspendFunctionReference.kt") @@ -8089,7 +8090,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInResumeWithException() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("boxReturnValueOfSuspendFunctionReference.kt") @@ -8303,7 +8304,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInIntLikeVarSpilling() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/intLikeVarSpilling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/intLikeVarSpilling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("complicatedMerge.kt") @@ -8371,7 +8372,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInIntrinsicSemantics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/intrinsicSemantics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/intrinsicSemantics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("coroutineContext.kt") @@ -8424,7 +8425,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInJavaInterop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("objectWithSeveralSuspends.kt") @@ -8462,7 +8463,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInLocalFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/localFunctions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/localFunctions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/codegen/box/coroutines/localFunctions/anonymous") @@ -8474,7 +8475,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInAnonymous() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/localFunctions/anonymous"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/localFunctions/anonymous"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("simple.kt") @@ -8492,7 +8493,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInNamed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/localFunctions/named"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/localFunctions/named"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("capturedParameters.kt") @@ -8561,7 +8562,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInMultiModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inlineCrossModule.kt") @@ -8619,7 +8620,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInRedundantLocalsElimination() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/redundantLocalsElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/redundantLocalsElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("ktor_receivedMessage.kt") @@ -8637,7 +8638,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInReflect() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/reflect"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/reflect"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("bigArity.kt") @@ -8665,7 +8666,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInStackUnwinding() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/stackUnwinding"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/stackUnwinding"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("exception.kt") @@ -8708,7 +8709,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInSuspendConversion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/suspendConversion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/suspendConversion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("intersectionTypeToSubtypeConversion.kt") @@ -8741,7 +8742,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInSuspendFunctionAsCoroutine() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("dispatchResume.kt") @@ -8844,7 +8845,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInSuspendFunctionTypeCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/suspendFunctionTypeCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/suspendFunctionTypeCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("localVal.kt") @@ -8882,7 +8883,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInTailCallOptimizations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/tailCallOptimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/tailCallOptimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("also.kt") @@ -8969,7 +8970,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInUnit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/tailCallOptimizations/unit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/tailCallOptimizations/unit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("functionReference.kt") @@ -9038,7 +9039,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInTailOperations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/tailOperations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/tailOperations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("suspendWithIf.kt") @@ -9071,7 +9072,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInUnitTypeReturn() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/unitTypeReturn"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/unitTypeReturn"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("coroutineNonLocalReturn.kt") @@ -9119,7 +9120,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInVarSpilling() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/varSpilling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/varSpilling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("fakeInlinerVariables.kt") @@ -9163,7 +9164,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInDataClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("arrayParams.kt") @@ -9255,7 +9256,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInCopy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/copy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/copy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("constructorWithDefaultParam.kt") @@ -9308,7 +9309,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInEquals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/equals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/equals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("alreadyDeclared.kt") @@ -9356,7 +9357,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInHashCode() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/hashCode"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/hashCode"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("alreadyDeclared.kt") @@ -9434,7 +9435,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInToString() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/toString"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/toString"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("alreadyDeclared.kt") @@ -9483,7 +9484,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInDeadCodeElimination() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/deadCodeElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/deadCodeElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("emptyVariableRange.kt") @@ -9516,7 +9517,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInDefaultArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("callDefaultFromInitializer.kt") @@ -9613,7 +9614,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/constructor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/constructor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("annotation.kt") @@ -9711,7 +9712,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInConvention() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/convention"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/convention"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("incWithDefaultInGetter.kt") @@ -9764,7 +9765,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/function"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/function"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("complexInheritance.kt") @@ -9912,7 +9913,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInPrivate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("memberExtensionFunction.kt") @@ -9945,7 +9946,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/signature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/signature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt2789.kt") @@ -9979,7 +9980,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInDelegatedProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("beforeDeclarationContainerOptimization.kt") @@ -10226,7 +10227,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInLocal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("capturedLocalVal.kt") @@ -10324,7 +10325,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInOptimizedDelegatedProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/optimizedDelegatedProperties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/optimizedDelegatedProperties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("definedInSources.kt") @@ -10387,7 +10388,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInProvideDelegate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/provideDelegate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/provideDelegate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("delegatedPropertyWithIdProvideDelegate.kt") @@ -10511,7 +10512,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInDelegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("byMiddleInterface.kt") @@ -10599,7 +10600,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInDestructuringDeclInLambdaParam() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/destructuringDeclInLambdaParam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/destructuringDeclInLambdaParam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("extensionComponents.kt") @@ -10652,7 +10653,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInDiagnostics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/codegen/box/diagnostics/functions") @@ -10664,7 +10665,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/codegen/box/diagnostics/functions/inference") @@ -10676,7 +10677,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInInference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/inference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/inference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt6176.kt") @@ -10694,7 +10695,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInInvoke() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/invoke"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/invoke"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects") @@ -10706,7 +10707,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInOnObjects() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("invokeOnClassObject1.kt") @@ -10770,7 +10771,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInTailRecursion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/tailRecursion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/tailRecursion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("defaultArgs.kt") @@ -10989,7 +10990,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInVararg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/vararg"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/vararg"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt4172.kt") @@ -11008,7 +11009,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInElvis() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/elvis"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/elvis"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("genericElvisWithMoreSpecificLHS.kt") @@ -11066,7 +11067,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("annotatedParameter.kt") @@ -11383,7 +11384,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInDefaultCtor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/enum/defaultCtor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/enum/defaultCtor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("constructorWithDefaultArguments.kt") @@ -11427,7 +11428,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInEvaluate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/evaluate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/evaluate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("char.kt") @@ -11515,7 +11516,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInExclExcl() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/exclExcl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/exclExcl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("genericNull.kt") @@ -11538,7 +11539,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInExtensionFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/extensionFunctions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/extensionFunctions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("executionOrder.kt") @@ -11676,7 +11677,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInExtensionProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/extensionProperties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/extensionProperties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("genericValForPrimitiveType.kt") @@ -11759,7 +11760,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInExternal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/external"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/external"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("jvmStaticExternal.kt") @@ -11787,7 +11788,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInFakeOverride() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fakeOverride"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fakeOverride"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("diamondFunction.kt") @@ -11830,7 +11831,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInFieldRename() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fieldRename"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fieldRename"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("constructorAndClassObject.kt") @@ -11868,7 +11869,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInFinally() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/finally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/finally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("breakAndOuterFinally.kt") @@ -11991,7 +11992,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInFullJdk() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("charBuffer.kt") @@ -12033,7 +12034,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInNative() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk/native"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk/native"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("nativePropertyAccessors.kt") @@ -12061,7 +12062,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInRegressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk/regressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk/regressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt15112.kt") @@ -12085,7 +12086,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInFunInterface() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("basicFunInterface.kt") @@ -12202,7 +12203,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInEquality() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/funInterface/equality"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/funInterface/equality"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("functionReferencesBound.kt") @@ -12241,7 +12242,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("coerceVoidToArray.kt") @@ -12478,7 +12479,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInBigArity() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/bigArity"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/bigArity"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("callFromJava.kt") @@ -12546,7 +12547,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInFunctionExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/functionExpression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/functionExpression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("functionExpression.kt") @@ -12589,7 +12590,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInInvoke() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/invoke"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/invoke"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("castFunctionToExtension.kt") @@ -12677,7 +12678,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInLocalFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/localFunctions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/localFunctions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("boundTypeParameterInSupertype.kt") @@ -12841,7 +12842,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInHashPMap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/hashPMap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/hashPMap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("empty.kt") @@ -12884,7 +12885,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInIeee754() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ieee754"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ieee754"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("anyToReal.kt") @@ -13142,7 +13143,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInIncrement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/increment"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/increment"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("argumentWithSideEffects.kt") @@ -13285,7 +13286,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInInference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("approximateNonTopLevelCapturedTypes.kt") @@ -13453,7 +13454,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("annotatedMemberExtensionProperty.kt") @@ -14300,7 +14301,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInBoxReturnValueInLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("boxAny.kt") @@ -14373,7 +14374,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInBoxReturnValueOnOverride() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("covariantOverrideChainErasedToAny.kt") @@ -14516,7 +14517,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInCallableReferences() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/callableReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/callableReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("boundInlineClassExtensionFun.kt") @@ -14684,7 +14685,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInContextsAndAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("captureInlineClassInstanceInLambda.kt") @@ -14752,7 +14753,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInDefaultParameterValues() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/defaultParameterValues"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/defaultParameterValues"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("defaultConstructorParameterValuesOfInlineClassType.kt") @@ -14825,7 +14826,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInFunctionNameMangling() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/functionNameMangling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/functionNameMangling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("anonymousObjectInFunctionWithMangledName.kt") @@ -14928,7 +14929,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInHiddenConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/hiddenConstructor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/hiddenConstructor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("constructorReferencedFromOtherFile1.kt") @@ -15006,7 +15007,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInInterfaceDelegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/interfaceDelegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/interfaceDelegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("interfaceImplementationByDelegation.kt") @@ -15059,7 +15060,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInInterfaceMethodCalls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("complexGenericMethodWithInlineClassOverride.kt") @@ -15127,7 +15128,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInJavaInterop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inlineClasInSignature.kt") @@ -15155,7 +15156,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInJvm8DefaultInterfaceMethods() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/jvm8DefaultInterfaceMethods"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/jvm8DefaultInterfaceMethods"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("javaDefaultMethod.kt") @@ -15228,7 +15229,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInPropertyDelegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/propertyDelegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/propertyDelegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("captureLocalVarDelegatedToInlineClass.kt") @@ -15301,7 +15302,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInUnboxGenericParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface") @@ -15313,7 +15314,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInFunInterface() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("any.kt") @@ -15361,7 +15362,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("any.kt") @@ -15409,7 +15410,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInObjectLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("any.kt") @@ -15459,7 +15460,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInInnerNested() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/innerNested"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/innerNested"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("createNestedClass.kt") @@ -15611,7 +15612,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInSuperConstructorCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/innerNested/superConstructorCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/innerNested/superConstructorCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("deepInnerHierarchy.kt") @@ -15730,7 +15731,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInInstructions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/instructions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/instructions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/codegen/box/instructions/swap") @@ -15742,7 +15743,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInSwap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/instructions/swap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/instructions/swap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("swapRefToSharedVarInt.kt") @@ -15766,7 +15767,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInIntrinsics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/intrinsics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/intrinsics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("charToInt.kt") @@ -15914,7 +15915,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInIr() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("anonymousClassLeak.kt") @@ -16021,7 +16022,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInClosureConversion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/closureConversion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/closureConversion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("closureConversion1.kt") @@ -16074,7 +16075,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInPrimitiveNumberComparisons() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/primitiveNumberComparisons"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/primitiveNumberComparisons"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("comparableToDouble.kt") @@ -16107,7 +16108,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInSerializationRegressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/serializationRegressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/serializationRegressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("deepGenericDelegatedProperty.kt") @@ -16161,7 +16162,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInJavaInterop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("genericSamProjectedOut.kt") @@ -16213,7 +16214,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInGenerics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/generics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/generics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("allWildcardsOnClass.kt") @@ -16261,7 +16262,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInNotNullAssertions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("destructuringAssignmentWithNullabilityAssertionOnExtensionReceiver_lv12.kt") @@ -16363,7 +16364,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInEnhancedNullability() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions/enhancedNullability"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions/enhancedNullability"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inFunctionWithExpressionBody.kt") @@ -16416,7 +16417,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInNullCheckOnLambdaReturnValue() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions/nullCheckOnLambdaReturnValue"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions/nullCheckOnLambdaReturnValue"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("nnStringVsT.kt") @@ -16480,7 +16481,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInObjectMethods() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/objectMethods"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/objectMethods"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("cloneCallsConstructor.kt") @@ -16524,7 +16525,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInJdk() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jdk"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jdk"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("arrayList.kt") @@ -16577,7 +16578,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInJvm8() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("bridgeInClass.kt") @@ -16714,7 +16715,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInDefaults() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("bridgeInClass.kt") @@ -16871,7 +16872,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInAllCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("bridge.kt") @@ -17013,7 +17014,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInDelegationBy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("simple.kt") @@ -17037,7 +17038,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/compatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/compatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("bridge.kt") @@ -17130,7 +17131,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInDelegationBy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("simple.kt") @@ -17163,7 +17164,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInNoDefaultImpls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("bridge.kt") @@ -17300,7 +17301,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInDelegationBy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("simple.kt") @@ -17323,7 +17324,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInSpecialization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/specialization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/specialization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("basic.kt") @@ -17342,7 +17343,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInNoDelegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDelegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDelegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("noDelegationToDefaultMethodInClass.kt") @@ -17370,7 +17371,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInReflection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/reflection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/reflection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("propertyAnnotations.kt") @@ -17389,7 +17390,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInInterfaceFlag() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/interfaceFlag"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/interfaceFlag"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("superCall.kt") @@ -17412,7 +17413,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInJavaDefaults() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/javaDefaults"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/javaDefaults"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("capturedSuperCall.kt") @@ -17496,7 +17497,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInJvmField() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmField"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmField"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("annotationCompanion.kt") @@ -17634,7 +17635,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInJvmName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("annotationProperties.kt") @@ -17721,7 +17722,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInFileFacades() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmName/fileFacades"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmName/fileFacades"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("differentFiles.kt") @@ -17750,7 +17751,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInJvmOverloads() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmOverloads"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmOverloads"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("companionObject.kt") @@ -17863,7 +17864,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInJvmPackageName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmPackageName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmPackageName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("metadataField.kt") @@ -17901,7 +17902,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInJvmStatic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmStatic"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmStatic"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("annotations.kt") @@ -18079,7 +18080,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInLabels() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/labels"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/labels"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("controlLabelClashesWithFuncitonName.kt") @@ -18132,7 +18133,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInLazyCodegen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/lazyCodegen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/lazyCodegen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("exceptionInFieldInitializer.kt") @@ -18189,7 +18190,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInOptimizations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/lazyCodegen/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/lazyCodegen/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("negateConstantCompare.kt") @@ -18248,7 +18249,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInLocalClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/localClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/localClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("anonymousObjectInExtension.kt") @@ -18431,7 +18432,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInMangling() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/mangling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/mangling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("field.kt") @@ -18489,7 +18490,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInMixedNamedPosition() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/mixedNamedPosition"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/mixedNamedPosition"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("defaults.kt") @@ -18522,7 +18523,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInMultiDecl() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("ComplexInitializer.kt") @@ -18604,7 +18605,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInForIterator() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forIterator"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forIterator"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("MultiDeclFor.kt") @@ -18641,7 +18642,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInLongIterator() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forIterator/longIterator"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forIterator/longIterator"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -18675,7 +18676,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInForRange() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("MultiDeclFor.kt") @@ -18722,7 +18723,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInExplicitRangeTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("MultiDeclFor.kt") @@ -18759,7 +18760,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInInt() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -18792,7 +18793,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInLong() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -18826,7 +18827,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInExplicitRangeToWithDot() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("MultiDeclFor.kt") @@ -18863,7 +18864,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInInt() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -18896,7 +18897,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInLong() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -18930,7 +18931,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInInt() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -18963,7 +18964,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInLong() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -18998,7 +18999,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInMultifileClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("callMultifileClassMemberFromOtherPackage.kt") @@ -19080,7 +19081,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInOptimized() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multifileClasses/optimized"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multifileClasses/optimized"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("callInInlineLambda.kt") @@ -19149,7 +19150,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInMultiplatform() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("expectClassInJvmMultifileFacade.kt") @@ -19186,7 +19187,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInDefaultArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("annotations.kt") @@ -19314,7 +19315,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInMultiModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("expectActualLink.kt") @@ -19343,7 +19344,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInNonLocalReturns() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nonLocalReturns"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nonLocalReturns"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt6895.kt") @@ -19386,7 +19387,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInNothingValue() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nothingValue"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nothingValue"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inNestedCall.kt") @@ -19409,7 +19410,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInNullCheckOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nullCheckOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nullCheckOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("exclExclThrowsKnpe_1_3.kt") @@ -19482,7 +19483,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInObjectIntrinsics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objectIntrinsics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objectIntrinsics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("objects.kt") @@ -19500,7 +19501,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInObjects() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("anonymousObjectPropertyInitialization.kt") @@ -19872,7 +19873,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInCompanionObjectAccess() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt27117.kt") @@ -19969,7 +19970,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInMultipleCompanionsWithAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("anonymousObjectInPropertyInitializer.kt") @@ -20037,7 +20038,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInPrimitiveCompanion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess/primitiveCompanion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess/primitiveCompanion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("byteCompanionObject.kt") @@ -20087,7 +20088,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInOperatorConventions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/operatorConventions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/operatorConventions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("annotatedAssignment.kt") @@ -20199,7 +20200,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInCompareTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/operatorConventions/compareTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/operatorConventions/compareTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("boolean.kt") @@ -20268,7 +20269,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInOptimizations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("hashCode.kt") @@ -20291,7 +20292,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInPackage() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/package"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/package"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("boxPrimitiveTypeInClinit.kt") @@ -20364,7 +20365,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInParametersMetadata() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/parametersMetadata"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/parametersMetadata"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("defaultImpls.kt") @@ -20427,7 +20428,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInPlatformTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/platformTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/platformTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inferenceFlexibleTToNullable.kt") @@ -20454,7 +20455,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInPrimitives() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/platformTypes/primitives"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/platformTypes/primitives"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("assign.kt") @@ -20573,7 +20574,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInPolymorphicSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/polymorphicSignature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/polymorphicSignature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("anonymousSubclass.kt") @@ -20626,7 +20627,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInPrimitiveTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("comparisonWithNaN.kt") @@ -20933,7 +20934,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInEqualityWithObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes/equalityWithObject"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes/equalityWithObject"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("boxedEqPrimitiveEvaluationOrder.kt") @@ -20990,7 +20991,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInGenerated() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("boxedEqPrimitiveBoolean.kt") @@ -21095,7 +21096,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInPrivate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("arrayConvention.kt") @@ -21118,7 +21119,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInPrivateConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/privateConstructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/privateConstructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("base.kt") @@ -21226,7 +21227,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("augmentedAssignmentsAndIncrements.kt") @@ -21633,7 +21634,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInConst() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/const"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/const"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("anotherFile.kt") @@ -21701,7 +21702,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInLateinit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("exceptionField.kt") @@ -21768,7 +21769,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInIsInitializedAndDeinitialize() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/isInitializedAndDeinitialize"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/isInitializedAndDeinitialize"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("companionObjectField.kt") @@ -21826,7 +21827,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInLocal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("capturedLocalLateinit.kt") @@ -21884,7 +21885,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInTopLevel() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/topLevel"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/topLevel"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("topLevelLateinit.kt") @@ -21914,7 +21915,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInPublishedApi() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/publishedApi"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/publishedApi"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("noMangling.kt") @@ -21942,7 +21943,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInRanges() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forByteProgressionWithIntIncrement.kt") @@ -22039,7 +22040,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInContains() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/contains"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/contains"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("comparisonWithRangeBoundEliminated.kt") @@ -22251,7 +22252,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInGenerated() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/contains/generated"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/contains/generated"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("arrayIndices.kt") @@ -22335,7 +22336,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInEvaluationOrder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forInDownTo.kt") @@ -22392,7 +22393,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInStepped() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo") @@ -22404,7 +22405,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInForInDownTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forInDownToReversedStep.kt") @@ -22457,7 +22458,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInForInRangeLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInRangeLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInRangeLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forInRangeLiteralReversedStep.kt") @@ -22510,7 +22511,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInForInUntil() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInUntil"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInUntil"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forInUntilReversedStep.kt") @@ -22565,7 +22566,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("emptyDownto.kt") @@ -22728,7 +22729,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInForInDownTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInDownTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInDownTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forIntInDownTo.kt") @@ -22766,7 +22767,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInForInIndices() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInIndices"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInIndices"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forInArrayListIndices.kt") @@ -22884,7 +22885,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInForInProgressionWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInProgressionWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInProgressionWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forInDownToWithIndex.kt") @@ -22972,7 +22973,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInForInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInReversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInReversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forInReversedArrayIndices.kt") @@ -23075,7 +23076,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInForInUntil() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInUntil"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInUntil"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forInUntilChar.kt") @@ -23163,7 +23164,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInForWithPossibleOverflow() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forWithPossibleOverflow"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forWithPossibleOverflow"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forInDownToCharMinValue.kt") @@ -23241,7 +23242,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInJavaInterop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("javaArrayOfInheritedNotNull.kt") @@ -23348,7 +23349,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/javaInterop/withIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/javaInterop/withIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("javaArrayOfInheritedNotNullWithIndex.kt") @@ -23427,7 +23428,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("emptyDownto.kt") @@ -23590,7 +23591,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInNullableLoopParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/nullableLoopParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/nullableLoopParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("progressionExpression.kt") @@ -23618,7 +23619,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInStepped() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/codegen/box/ranges/stepped/expression") @@ -23630,7 +23631,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/codegen/box/ranges/stepped/expression/downTo") @@ -23642,7 +23643,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInDownTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/downTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/downTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("emptyProgression.kt") @@ -23734,7 +23735,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/downTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/downTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -23787,7 +23788,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/downTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/downTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("reversedThenStep.kt") @@ -23831,7 +23832,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInRangeTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("emptyProgression.kt") @@ -23923,7 +23924,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -23976,7 +23977,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("reversedThenStep.kt") @@ -24020,7 +24021,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInUntil() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/until"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/until"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("emptyProgression.kt") @@ -24117,7 +24118,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/until/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/until/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -24170,7 +24171,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/until/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/until/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("reversedThenStep.kt") @@ -24215,7 +24216,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/codegen/box/ranges/stepped/literal/downTo") @@ -24227,7 +24228,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInDownTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/downTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/downTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("emptyProgression.kt") @@ -24319,7 +24320,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/downTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/downTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -24372,7 +24373,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/downTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/downTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("reversedThenStep.kt") @@ -24416,7 +24417,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInRangeTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("emptyProgression.kt") @@ -24508,7 +24509,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -24561,7 +24562,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("reversedThenStep.kt") @@ -24605,7 +24606,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInUntil() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/until"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/until"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("emptyProgression.kt") @@ -24702,7 +24703,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/until/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/until/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -24755,7 +24756,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/until/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/until/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("reversedThenStep.kt") @@ -24800,7 +24801,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInUnsigned() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/expression") @@ -24812,7 +24813,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo") @@ -24824,7 +24825,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInDownTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("emptyProgression.kt") @@ -24916,7 +24917,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -24969,7 +24970,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("reversedThenStep.kt") @@ -25013,7 +25014,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInRangeTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("emptyProgression.kt") @@ -25105,7 +25106,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -25158,7 +25159,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("reversedThenStep.kt") @@ -25202,7 +25203,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInUntil() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("emptyProgression.kt") @@ -25299,7 +25300,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -25352,7 +25353,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("reversedThenStep.kt") @@ -25397,7 +25398,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo") @@ -25409,7 +25410,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInDownTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("emptyProgression.kt") @@ -25501,7 +25502,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -25554,7 +25555,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("reversedThenStep.kt") @@ -25598,7 +25599,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInRangeTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("emptyProgression.kt") @@ -25690,7 +25691,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -25743,7 +25744,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("reversedThenStep.kt") @@ -25787,7 +25788,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInUntil() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("emptyProgression.kt") @@ -25884,7 +25885,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -25937,7 +25938,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("reversedThenStep.kt") @@ -25984,7 +25985,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInUnsigned() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inMixedUnsignedRange.kt") @@ -26021,7 +26022,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("emptyDownto.kt") @@ -26184,7 +26185,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("emptyDownto.kt") @@ -26347,7 +26348,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInNullableLoopParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/nullableLoopParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/nullableLoopParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("progressionExpression.kt") @@ -26377,7 +26378,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInReflection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/codegen/box/reflection/annotations") @@ -26389,7 +26390,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/annotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/annotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("annotationRetentionAnnotation.kt") @@ -26496,7 +26497,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInOnTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/annotations/onTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/annotations/onTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("arrayKClass.kt") @@ -26530,7 +26531,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInBuiltins() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/builtins"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/builtins"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("collections.kt") @@ -26558,7 +26559,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("bigArity.kt") @@ -26690,7 +26691,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInBound() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("companionObjectPropertyAccessors.kt") @@ -26768,7 +26769,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("constructorWithInlineClassParameters.kt") @@ -26852,7 +26853,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInCallBy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/callBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/callBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("boundExtensionFunction.kt") @@ -26995,7 +26996,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInClassLiterals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/classLiterals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/classLiterals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("annotationClassLiteral.kt") @@ -27053,7 +27054,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/classes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/classes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("classSimpleName.kt") @@ -27146,7 +27147,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/constructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/constructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("annotationClass.kt") @@ -27189,7 +27190,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInCreateAnnotation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/createAnnotation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/createAnnotation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("annotationType.kt") @@ -27267,7 +27268,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInEnclosing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/enclosing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/enclosing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("anonymousObjectInInlinedLambda.kt") @@ -27405,7 +27406,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("declaredVsInheritedFunctions.kt") @@ -27483,7 +27484,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInGenericSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/genericSignature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/genericSignature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("covariantOverride.kt") @@ -27581,7 +27582,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInIsInstance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/isInstance"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/isInstance"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("isInstanceCastAndSafeCast.kt") @@ -27599,7 +27600,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInKClassInAnnotation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/kClassInAnnotation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/kClassInAnnotation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("array.kt") @@ -27657,7 +27658,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInLambdaClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/lambdaClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/lambdaClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("parameterNamesAndNullability.kt") @@ -27715,7 +27716,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInMapping() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("constructor.kt") @@ -27812,7 +27813,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInFakeOverrides() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/fakeOverrides"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/fakeOverrides"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("javaFieldGetterSetter.kt") @@ -27835,7 +27836,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inlineClassPrimaryVal.kt") @@ -27858,7 +27859,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInJvmStatic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/jvmStatic"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/jvmStatic"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("companionObjectFunction.kt") @@ -27881,7 +27882,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/types"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/types"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("allSupertypes.kt") @@ -28005,7 +28006,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInMethodsFromAny() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/methodsFromAny"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/methodsFromAny"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("builtinFunctionsToString.kt") @@ -28133,7 +28134,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInModifiers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/modifiers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/modifiers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("callableModality.kt") @@ -28191,7 +28192,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInMultifileClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("callFunctionsInMultifileClass.kt") @@ -28219,7 +28220,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInNoReflectAtRuntime() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/noReflectAtRuntime"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/noReflectAtRuntime"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("javaClass.kt") @@ -28266,7 +28267,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInMethodsFromAny() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/noReflectAtRuntime/methodsFromAny"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/noReflectAtRuntime/methodsFromAny"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("callableReferences.kt") @@ -28295,7 +28296,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/parameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/parameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("bigArity.kt") @@ -28383,7 +28384,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("allVsDeclared.kt") @@ -28550,7 +28551,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/accessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/accessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("extensionPropertyAccessors.kt") @@ -28583,7 +28584,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInGetDelegate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/getDelegate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/getDelegate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("booleanPropertyNameStartsWithIs.kt") @@ -28671,7 +28672,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInJvmField() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/jvmField"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/jvmField"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("annotationCompanionWithAnnotation.kt") @@ -28699,7 +28700,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInLocalDelegated() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/localDelegated"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/localDelegated"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("defaultImpls.kt") @@ -28753,7 +28754,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInSupertypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/supertypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/supertypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("builtInClassSupertypes.kt") @@ -28791,7 +28792,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInTypeOf() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("classes.kt") @@ -28828,7 +28829,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInJs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/js"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/js"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } } @@ -28841,7 +28842,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInNoReflect() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/noReflect"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/noReflect"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("classes.kt") @@ -28868,7 +28869,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInNonReifiedTypeParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/noReflect/nonReifiedTypeParameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/noReflect/nonReifiedTypeParameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("defaultUpperBound.kt") @@ -28932,7 +28933,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInNonReifiedTypeParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/nonReifiedTypeParameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/nonReifiedTypeParameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("defaultUpperBound.kt") @@ -29006,7 +29007,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInTypeParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeParameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeParameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("declarationSiteVariance.kt") @@ -29044,7 +29045,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/types"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/types"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("classifierIsClass.kt") @@ -29116,7 +29117,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInCreateType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/types/createType"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/types/createType"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("equality.kt") @@ -29154,7 +29155,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInSubtyping() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/types/subtyping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/types/subtyping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("platformType.kt") @@ -29189,7 +29190,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInRegressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/regressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/regressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("approximateIntersectionType.kt") @@ -29677,7 +29678,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInReified() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reified"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reified"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("anonymousObject.kt") @@ -29864,7 +29865,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInArraysReification() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reified/arraysReification"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reified/arraysReification"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("instanceOf.kt") @@ -29908,7 +29909,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInSafeCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/safeCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/safeCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("genericNull.kt") @@ -29986,7 +29987,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInSam() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("arrayAsVarargAfterSamArgument.kt") @@ -30103,7 +30104,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam/constructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam/constructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("comparator.kt") @@ -30191,7 +30192,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInEquality() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam/equality"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam/equality"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("functionReferencesBound.kt") @@ -30230,7 +30231,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInSealed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sealed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sealed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("multipleFiles_enabled.kt") @@ -30268,7 +30269,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInSecondaryConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/secondaryConstructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/secondaryConstructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("basicNoPrimaryManySinks.kt") @@ -30446,7 +30447,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInSignatureAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/signatureAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/signatureAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("defaultAndNamedCombination.kt") @@ -30524,7 +30525,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInSmap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/smap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/smap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("chainCalls.kt") @@ -30552,7 +30553,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInSmartCasts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/smartCasts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/smartCasts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("falseSmartCast.kt") @@ -30645,7 +30646,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInSpecialBuiltins() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/specialBuiltins"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/specialBuiltins"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("bridgeNotEmptyMap.kt") @@ -30793,7 +30794,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInStatics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/statics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/statics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("anonymousInitializerIObject.kt") @@ -30891,7 +30892,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInStoreStackBeforeInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/storeStackBeforeInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/storeStackBeforeInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("differentTypes.kt") @@ -30929,7 +30930,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInStrings() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/strings"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/strings"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("constInStringTemplate.kt") @@ -31062,7 +31063,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInSuper() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/super"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/super"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("basicmethodSuperClass.kt") @@ -31224,7 +31225,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInSuperConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/super/superConstructor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/super/superConstructor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt13846.kt") @@ -31273,7 +31274,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInSynchronized() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/synchronized"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/synchronized"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("changeMonitor.kt") @@ -31371,7 +31372,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInSyntheticAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/syntheticAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/syntheticAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inline.kt") @@ -31454,7 +31455,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInThrows() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/throws"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/throws"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("delegationAndThrows.kt") @@ -31477,7 +31478,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInToArray() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/toArray"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/toArray"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("incorrectToArrayDetection.kt") @@ -31535,7 +31536,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInTopLevelPrivate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/topLevelPrivate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/topLevelPrivate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("noPrivateNoAccessorsInMultiFileFacade.kt") @@ -31578,7 +31579,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInTrailingComma() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/trailingComma"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/trailingComma"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("noDisambiguation.kt") @@ -31606,7 +31607,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInTraits() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/traits"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/traits"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("defaultImplCall.kt") @@ -31799,7 +31800,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInTypeInfo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typeInfo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typeInfo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("asInLoop.kt") @@ -31847,7 +31848,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInTypeMapping() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typeMapping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typeMapping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("enhancedPrimitiveInReturnType.kt") @@ -31920,7 +31921,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInTypealias() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typealias"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typealias"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("enumEntryQualifier.kt") @@ -32028,7 +32029,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInUnaryOp() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unaryOp"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unaryOp"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("call.kt") @@ -32071,7 +32072,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInUnit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("closureReturnsNullableUnit.kt") @@ -32139,7 +32140,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInUnsignedTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unsignedTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unsignedTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("boxConstValOfUnsignedType.kt") @@ -32356,7 +32357,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInJvm8Intrinsics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unsignedTypes/jvm8Intrinsics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unsignedTypes/jvm8Intrinsics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("unsignedIntCompare_jvm8.kt") @@ -32410,7 +32411,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInValueClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/valueClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/valueClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("jvmInline.kt") @@ -32428,7 +32429,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInVararg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/vararg"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/vararg"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("assigningArrayToVarargInAnnotation.kt") @@ -32526,7 +32527,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInWhen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("callProperty.kt") @@ -32743,7 +32744,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInEnumOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/enumOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/enumOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("bigEnum.kt") @@ -32846,7 +32847,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInStringOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/stringOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/stringOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("duplicatingItems.kt") @@ -32904,7 +32905,7 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT } public void testAllFilesPresentInWhenSubjectVariable() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/whenSubjectVariable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/whenSubjectVariable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("captureSubjectVariable.kt") diff --git a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/codegen/ir/FirBlackBoxInlineCodegenTestGenerated.java b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/codegen/ir/FirBlackBoxInlineCodegenTestGenerated.java index cab38e83de3..2ad37bab4d2 100644 --- a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/codegen/ir/FirBlackBoxInlineCodegenTestGenerated.java +++ b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/codegen/ir/FirBlackBoxInlineCodegenTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.codegen.ir; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInBoxInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true, "oldLanguageVersions"); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true, "oldLanguageVersions"); } @TestMetadata("compiler/testData/codegen/boxInline/anonymousObject") @@ -38,7 +39,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInAnonymousObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("anonymousObjectInDefault.kt") @@ -340,7 +341,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInEnumWhen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/enumWhen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/enumWhen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("callSite.kt") @@ -373,7 +374,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInProperRecapturing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inlineChain.kt") @@ -416,7 +417,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInProperRecapturingInClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inlineChain.kt") @@ -489,7 +490,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInSam() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("anonymousObjectToSam.kt") @@ -537,7 +538,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInTwoCapturedReceivers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt8668.kt") @@ -576,7 +577,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInArgumentOrder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/argumentOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/argumentOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("boundFunctionReference.kt") @@ -659,7 +660,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInArrayConvention() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/arrayConvention"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/arrayConvention"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("simpleAccess.kt") @@ -702,7 +703,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInAssert() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/assert"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/assert"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("jvmAssertInlineFunctionAssertionsDisabled.kt") @@ -775,7 +776,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInBuilders() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/builders"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/builders"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("builders.kt") @@ -798,7 +799,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInBytecodePreprocessing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/bytecodePreprocessing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/bytecodePreprocessing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("apiVersionAtLeast1.kt") @@ -821,7 +822,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("classLevel.kt") @@ -908,7 +909,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInBound() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("classProperty.kt") @@ -1042,7 +1043,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInCapture() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/capture"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/capture"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("captureInlinable.kt") @@ -1085,7 +1086,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInComplex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/complex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/complex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("closureChain.kt") @@ -1133,7 +1134,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInComplexStack() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/complexStack"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/complexStack"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("asCheck.kt") @@ -1191,7 +1192,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInContracts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/contracts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/contracts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("cfgDependendValInitialization.kt") @@ -1289,7 +1290,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInDefaultValues() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("defaultInExtension.kt") @@ -1391,7 +1392,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInLambdaInlining() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("checkLambdaClassIsPresent.kt") @@ -1563,7 +1564,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInCallableReferences() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("boundFunctionReference.kt") @@ -1697,7 +1698,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInMaskElimination() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/maskElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/maskElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt18792.kt") @@ -1736,7 +1737,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInDelegatedProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/delegatedProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/delegatedProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt16864.kt") @@ -1774,7 +1775,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInEnclosingInfo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/enclosingInfo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/enclosingInfo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("anonymousInLambda.kt") @@ -1822,7 +1823,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt10569.kt") @@ -1900,7 +1901,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInFunctionExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/functionExpression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/functionExpression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("extension.kt") @@ -1918,7 +1919,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inlineClassWithInlineValReturningInlineClass.kt") @@ -1970,7 +1971,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInUnboxGenericParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/funInterface") @@ -1982,7 +1983,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInFunInterface() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("any.kt") @@ -2025,7 +2026,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/lambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/lambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("any.kt") @@ -2068,7 +2069,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInObjectLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/objectLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/objectLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("any.kt") @@ -2113,7 +2114,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInInnerClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/innerClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/innerClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("captureThisAndOuter.kt") @@ -2141,7 +2142,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInJvmPackageName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/jvmPackageName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/jvmPackageName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("simple.kt") @@ -2159,7 +2160,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInLambdaClassClash() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/lambdaClassClash"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/lambdaClassClash"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("lambdaClassClash.kt") @@ -2182,7 +2183,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInLambdaTransformation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/lambdaTransformation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/lambdaTransformation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("lambdaCloning.kt") @@ -2225,7 +2226,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInLocalFunInLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/localFunInLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/localFunInLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("defaultParam.kt") @@ -2258,7 +2259,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInMultiModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("tryCatchWithRecursiveInline.kt") @@ -2276,7 +2277,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInMultifileClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("defaultArguments.kt") @@ -2304,7 +2305,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInMultiplatform() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/codegen/boxInline/multiplatform/defaultArguments") @@ -2316,7 +2317,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInDefaultArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiplatform/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiplatform/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("receiversAndParametersInLambda.kt") @@ -2335,7 +2336,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInNoInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/noInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/noInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("extensionReceiver.kt") @@ -2383,7 +2384,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInNonLocalReturns() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("explicitLocalReturn.kt") @@ -2465,7 +2466,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInDeparenthesize() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/deparenthesize"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/deparenthesize"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("bracket.kt") @@ -2488,7 +2489,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInTryFinally() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt16417.kt") @@ -2565,7 +2566,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInCallSite() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("callSite.kt") @@ -2608,7 +2609,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInChained() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("finallyInFinally.kt") @@ -2661,7 +2662,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInDeclSite() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("complex.kt") @@ -2734,7 +2735,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInExceptionTable() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("break.kt") @@ -2852,7 +2853,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInVariables() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/variables"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/variables"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt7792.kt") @@ -2872,7 +2873,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInOptimizations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt20844.kt") @@ -2905,7 +2906,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInPrivate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("effectivePrivate.kt") @@ -2963,7 +2964,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("augAssignmentAndInc.kt") @@ -3041,7 +3042,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInReified() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("arrayConstructor.kt") @@ -3158,7 +3159,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInCheckCast() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/checkCast"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/checkCast"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("chain.kt") @@ -3221,7 +3222,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInDefaultLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/defaultLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/defaultLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("chain.kt") @@ -3274,7 +3275,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInIsCheck() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/isCheck"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/isCheck"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("chain.kt") @@ -3303,7 +3304,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/signature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/signature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inProjectionSubstitution.kt") @@ -3361,7 +3362,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInSimple() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/simple"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/simple"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("captureAndArgumentIncompatibleTypes.kt") @@ -3494,7 +3495,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInSmap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("assertion.kt") @@ -3596,7 +3597,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInAnonymous() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/anonymous"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/anonymous"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt19175.kt") @@ -3659,7 +3660,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInDefaultLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/defaultLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/defaultLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("defaultLambdaInAnonymous.kt") @@ -3717,7 +3718,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInInlineOnly() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/inlineOnly"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/inlineOnly"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("noSmap.kt") @@ -3760,7 +3761,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInNewsmap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/newsmap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/newsmap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("differentMapping.kt") @@ -3793,7 +3794,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInResolve() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/resolve"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/resolve"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inlineComponent.kt") @@ -3817,7 +3818,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInSpecial() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/special"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/special"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("identityCheck.kt") @@ -3875,7 +3876,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInStackOnReturn() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/stackOnReturn"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/stackOnReturn"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("elvis.kt") @@ -3968,7 +3969,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInSuspend() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("capturedVariables.kt") @@ -4130,7 +4131,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("isAsReified.kt") @@ -4168,7 +4169,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInDefaultParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/defaultParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/defaultParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("defaultValueCrossinline.kt") @@ -4201,7 +4202,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInInlineClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/inlineClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/inlineClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("returnUnboxedDirect.kt") @@ -4224,7 +4225,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInInlineUsedAsNoinline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/inlineUsedAsNoinline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/inlineUsedAsNoinline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inlineOnly.kt") @@ -4257,7 +4258,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInReceiver() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/receiver"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/receiver"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inlineOrdinaryOfCrossinlineSuspend.kt") @@ -4310,7 +4311,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInStateMachine() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/stateMachine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/stateMachine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("crossingCoroutineBoundaries.kt") @@ -4434,7 +4435,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInSyntheticAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/syntheticAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/syntheticAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("constField.kt") @@ -4486,7 +4487,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInWithinInlineLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("directFieldAccess.kt") @@ -4545,7 +4546,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInTrait() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/trait"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/trait"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("trait.kt") @@ -4563,7 +4564,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInTryCatchFinally() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/tryCatchFinally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/tryCatchFinally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt5863.kt") @@ -4596,7 +4597,7 @@ public class FirBlackBoxInlineCodegenTestGenerated extends AbstractFirBlackBoxIn } public void testAllFilesPresentInVarargs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/varargs"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/varargs"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt17653.kt") diff --git a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/codegen/ir/FirBytecodeTextTestGenerated.java b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/codegen/ir/FirBytecodeTextTestGenerated.java index f5a766d10f8..161da66ccdf 100644 --- a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/codegen/ir/FirBytecodeTextTestGenerated.java +++ b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/codegen/ir/FirBytecodeTextTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.codegen.ir; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -41,7 +42,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInBytecodeText() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true, "oldLanguageVersions"); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true, "oldLanguageVersions"); } @TestMetadata("annotationDefaultValue.kt") @@ -448,7 +449,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInArgumentOrder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/argumentOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/argumentOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("sameOrder.kt") @@ -471,7 +472,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInAssert() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/assert"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/assert"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("jvmCrossinline.kt") @@ -509,7 +510,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInBoxing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/boxing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/boxing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("crossinlineSuspend.kt") @@ -537,7 +538,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInBoxingOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/boxingOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/boxingOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("boxingAndEquals.kt") @@ -670,7 +671,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInBuiltinFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/builtinFunctions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/builtinFunctions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("charSequence.kt") @@ -707,7 +708,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInGenericParameterBridge() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/builtinFunctions/genericParameterBridge"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/builtinFunctions/genericParameterBridge"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("IntMC.kt") @@ -751,7 +752,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("boundFieldReferenceInInline.kt") @@ -809,7 +810,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInCapturedVarsOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/capturedVarsOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/capturedVarsOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("capturedInChainOfInlineFuns.kt") @@ -872,7 +873,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInCheckcast() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/checkcast"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/checkcast"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt14811.kt") @@ -905,7 +906,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInCoercionToUnitOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/coercionToUnitOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/coercionToUnitOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inRangeCheckWithConst.kt") @@ -963,7 +964,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInCompanion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/companion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/companion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("directAccessToBackingField.kt") @@ -1046,7 +1047,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInConditions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/conditions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/conditions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("conjunction.kt") @@ -1199,7 +1200,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInConstProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/constProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/constProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("noAccessorsForPrivateConstants.kt") @@ -1237,7 +1238,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInConstantConditions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/constantConditions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/constantConditions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("cmpIntWith0.kt") @@ -1275,7 +1276,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInConstants() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/constants"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/constants"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("byte.kt") @@ -1353,7 +1354,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/constructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/constructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("enumPrimaryDefaults.kt") @@ -1411,7 +1412,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInControlStructures() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/controlStructures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/controlStructures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("ifConsts.kt") @@ -1434,7 +1435,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInCoroutines() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("crossinlineSuspendContinuation_1_3.kt") @@ -1496,7 +1497,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInCleanup() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/coroutines/cleanup"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/coroutines/cleanup"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("backEdge.kt") @@ -1539,7 +1540,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInDebug() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/coroutines/debug"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/coroutines/debug"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("continuationInLvt.kt") @@ -1577,7 +1578,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInDestructuringInLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/coroutines/destructuringInLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/coroutines/destructuringInLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inlineSeparateFiles.kt") @@ -1595,7 +1596,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/coroutines/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/coroutines/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inlineClassBoxingInSuspendFunReturn_Primitive.kt") @@ -1643,7 +1644,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInIntLikeVarSpilling() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/coroutines/intLikeVarSpilling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/coroutines/intLikeVarSpilling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("complicatedMerge.kt") @@ -1706,7 +1707,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInStateMachine() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/coroutines/stateMachine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/coroutines/stateMachine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt25893.kt") @@ -1730,7 +1731,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInDeadCodeElimination() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/deadCodeElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/deadCodeElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("arrayConstructor.kt") @@ -1798,7 +1799,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInDefaultArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inheritedInterfaceFunction.kt") @@ -1861,7 +1862,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInDirectInvoke() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/directInvoke"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/directInvoke"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("callableReference.kt") @@ -1889,7 +1890,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInDisabledOptimizations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/disabledOptimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/disabledOptimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("noJumpInLastBranch.kt") @@ -1932,7 +1933,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("constructorAccessors.kt") @@ -1965,7 +1966,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInExclExcl() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/exclExcl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/exclExcl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("primitive.kt") @@ -1983,7 +1984,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInFieldsForCapturedValues() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/fieldsForCapturedValues"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/fieldsForCapturedValues"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("extensionLambdaExtensionReceiver.kt") @@ -2041,7 +2042,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInForLoop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forInCharSequence.kt") @@ -2178,7 +2179,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInForInArrayWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/forInArrayWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/forInArrayWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forInArrayWithIndexNoElementVar.kt") @@ -2216,7 +2217,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInForInCharSequenceWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/forInCharSequenceWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/forInCharSequenceWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forInCharSequenceWithIndex.kt") @@ -2259,7 +2260,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInForInIndices() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/forInIndices"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/forInIndices"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forInArrayListIndices.kt") @@ -2317,7 +2318,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInForInIterableWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/forInIterableWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/forInIterableWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forInEmptyListWithIndex.kt") @@ -2360,7 +2361,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInForInProgressionWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/forInProgressionWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/forInProgressionWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forInDownToWithIndex.kt") @@ -2433,7 +2434,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInForInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/forInReversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/forInReversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forInReversedArrayIndices.kt") @@ -2511,7 +2512,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInForInSequenceWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/forInSequenceWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/forInSequenceWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forInEmptySequenceWithIndex.kt") @@ -2559,7 +2560,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInForInUntil() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/forInUntil"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/forInUntil"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forInUntilChar.kt") @@ -2617,7 +2618,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInStepped() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/stepped"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/stepped"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("illegalStepConst.kt") @@ -2700,7 +2701,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInUnsigned() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/unsigned"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/unsigned"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forInDownToUIntMinValue.kt") @@ -2789,7 +2790,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInHashCode() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/hashCode"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/hashCode"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("hashCode.kt") @@ -2812,7 +2813,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInIeee754() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/ieee754"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/ieee754"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("nullableDoubleEquals.kt") @@ -2865,7 +2866,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/inline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/inline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("deleteClassOnTransformation.kt") @@ -2972,7 +2973,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/inline/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/inline/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("simple.kt") @@ -2991,7 +2992,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("asCastForInlineClass.kt") @@ -3339,7 +3340,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInInnerClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/innerClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/innerClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("nestedClassInAnnotationArgument.kt") @@ -3362,7 +3363,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInInterfaces() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/interfaces"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/interfaces"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("firstInheritedMethodIsAbstract.kt") @@ -3395,7 +3396,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInIntrinsics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/intrinsics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/intrinsics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("javaObjectType.kt") @@ -3418,7 +3419,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInIntrinsicsCompare() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/intrinsicsCompare"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/intrinsicsCompare"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("byteSmartCast_after.kt") @@ -3481,7 +3482,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInIntrinsicsTrim() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/intrinsicsTrim"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/intrinsicsTrim"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("trimIndentNegative.kt") @@ -3514,7 +3515,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInJvm8() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/jvm8"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/jvm8"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/codegen/bytecodeText/jvm8/hashCode") @@ -3526,7 +3527,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInHashCode() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/jvm8/hashCode"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/jvm8/hashCode"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("dataClass.kt") @@ -3549,7 +3550,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInJvmDefault() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/jvm8/jvmDefault"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/jvm8/jvmDefault"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/codegen/bytecodeText/jvm8/jvmDefault/allCompatibility") @@ -3561,7 +3562,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInAllCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/jvm8/jvmDefault/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/jvm8/jvmDefault/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("defaultArgs.kt") @@ -3599,7 +3600,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/jvm8/jvmDefault/compatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/jvm8/jvmDefault/compatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("defaultArgs.kt") @@ -3639,7 +3640,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInLazyCodegen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/lazyCodegen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/lazyCodegen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inlineConstInsideComparison.kt") @@ -3687,7 +3688,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInLineNumbers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/lineNumbers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/lineNumbers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("ifConsts.kt") @@ -3760,7 +3761,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInLocalInitializationLVT() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/localInitializationLVT"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/localInitializationLVT"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("boxing.kt") @@ -3868,7 +3869,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInMangling() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/mangling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/mangling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("parentheses.kt") @@ -3891,7 +3892,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInMultifileClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("defaultFunctionInMultifileClass.kt") @@ -3919,7 +3920,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInNotNullAssertions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/notNullAssertions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/notNullAssertions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("arrayListGet.kt") @@ -3987,7 +3988,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInNullCheckOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/nullCheckOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/nullCheckOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("alreadyCheckedForIs.kt") @@ -4109,7 +4110,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInLocalLateinit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/nullCheckOptimization/localLateinit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/nullCheckOptimization/localLateinit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("checkedAlways.kt") @@ -4138,7 +4139,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInOptimizedDelegatedProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/optimizedDelegatedProperties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/optimizedDelegatedProperties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("definedInSources.kt") @@ -4171,7 +4172,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInParameterlessMain() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/parameterlessMain"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/parameterlessMain"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("dontGenerateOnExtensionReceiver.kt") @@ -4219,7 +4220,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/properties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/properties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("dataClass.kt") @@ -4241,7 +4242,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInLateinit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/properties/lateinit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/properties/lateinit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("companionObject.kt") @@ -4265,7 +4266,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInRanges() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/ranges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/ranges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("ifNotInRange.kt") @@ -4338,7 +4339,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInSam() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("samWrapperForNullInitialization.kt") @@ -4381,7 +4382,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInStatements() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/statements"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/statements"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("ifSingleBranch.kt") @@ -4434,7 +4435,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInStaticFields() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/staticFields"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/staticFields"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("classObject.kt") @@ -4457,7 +4458,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInStoreStackBeforeInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/storeStackBeforeInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/storeStackBeforeInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("differentTypes.kt") @@ -4495,7 +4496,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInStringOperations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/stringOperations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/stringOperations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("concat.kt") @@ -4668,7 +4669,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInToArray() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/toArray"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/toArray"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("noAccessorForToArray.kt") @@ -4686,7 +4687,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInUnsignedTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/unsignedTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/unsignedTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("unsignedIntCompare_before.kt") @@ -4754,7 +4755,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInVarargs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/varargs"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/varargs"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("doNotCopyImmediatelyCreatedArrays.kt") @@ -4772,7 +4773,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInWhen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/when"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/when"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("edgeCases.kt") @@ -4910,7 +4911,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInWhenEnumOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/whenEnumOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/whenEnumOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("bigEnum.kt") @@ -4998,7 +4999,7 @@ public class FirBytecodeTextTestGenerated extends AbstractFirBytecodeTextTest { } public void testAllFilesPresentInWhenStringOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/whenStringOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/whenStringOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("denseHashCode.kt") diff --git a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/fir/Fir2IrTextTestGenerated.java b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/fir/Fir2IrTextTestGenerated.java index 8f879e3820d..f57fcdafeaa 100644 --- a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/fir/Fir2IrTextTestGenerated.java +++ b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/fir/Fir2IrTextTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.fir; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class Fir2IrTextTestGenerated extends AbstractFir2IrTextTest { } public void testAllFilesPresentInIrText() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/testData/ir/irText/classes") @@ -43,7 +44,7 @@ public class Fir2IrTextTestGenerated extends AbstractFir2IrTextTest { } public void testAllFilesPresentInClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/classes"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/classes"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("annotationClasses.kt") @@ -286,7 +287,7 @@ public class Fir2IrTextTestGenerated extends AbstractFir2IrTextTest { } public void testAllFilesPresentInDeclarations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/declarations"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/declarations"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("catchParameterInTopLevelProperty.kt") @@ -413,7 +414,7 @@ public class Fir2IrTextTestGenerated extends AbstractFir2IrTextTest { } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/declarations/annotations"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/declarations/annotations"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("annotationsInAnnotationArguments.kt") @@ -586,7 +587,7 @@ public class Fir2IrTextTestGenerated extends AbstractFir2IrTextTest { } public void testAllFilesPresentInMultiplatform() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/declarations/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/declarations/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("expectClassInherited.kt") @@ -614,7 +615,7 @@ public class Fir2IrTextTestGenerated extends AbstractFir2IrTextTest { } public void testAllFilesPresentInParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/declarations/parameters"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/declarations/parameters"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("class.kt") @@ -692,7 +693,7 @@ public class Fir2IrTextTestGenerated extends AbstractFir2IrTextTest { } public void testAllFilesPresentInProvideDelegate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/declarations/provideDelegate"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/declarations/provideDelegate"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("differentReceivers.kt") @@ -736,7 +737,7 @@ public class Fir2IrTextTestGenerated extends AbstractFir2IrTextTest { } public void testAllFilesPresentInErrors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/errors"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/errors"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("suppressedNonPublicCall.kt") @@ -759,7 +760,7 @@ public class Fir2IrTextTestGenerated extends AbstractFir2IrTextTest { } public void testAllFilesPresentInExpressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/expressions"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/expressions"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("argumentMappedWithError.kt") @@ -1481,7 +1482,7 @@ public class Fir2IrTextTestGenerated extends AbstractFir2IrTextTest { } public void testAllFilesPresentInCallableReferences() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/expressions/callableReferences"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/expressions/callableReferences"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("boundInlineAdaptedReference.kt") @@ -1574,7 +1575,7 @@ public class Fir2IrTextTestGenerated extends AbstractFir2IrTextTest { } public void testAllFilesPresentInFloatingPointComparisons() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/expressions/floatingPointComparisons"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/expressions/floatingPointComparisons"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("comparableWithDoubleOrFloat.kt") @@ -1642,7 +1643,7 @@ public class Fir2IrTextTestGenerated extends AbstractFir2IrTextTest { } public void testAllFilesPresentInFunInterface() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/expressions/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/expressions/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("arrayAsVarargAfterSamArgument_fi.kt") @@ -1695,7 +1696,7 @@ public class Fir2IrTextTestGenerated extends AbstractFir2IrTextTest { } public void testAllFilesPresentInSam() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/expressions/sam"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/expressions/sam"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("arrayAsVarargAfterSamArgument.kt") @@ -1774,7 +1775,7 @@ public class Fir2IrTextTestGenerated extends AbstractFir2IrTextTest { } public void testAllFilesPresentInFirProblems() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/firProblems"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/firProblems"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("AnnotationInAnnotation.kt") @@ -1892,7 +1893,7 @@ public class Fir2IrTextTestGenerated extends AbstractFir2IrTextTest { } public void testAllFilesPresentInLambdas() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/lambdas"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/lambdas"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("anonymousFunction.kt") @@ -1945,7 +1946,7 @@ public class Fir2IrTextTestGenerated extends AbstractFir2IrTextTest { } public void testAllFilesPresentInRegressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/regressions"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/regressions"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("coercionInLoop.kt") @@ -1982,7 +1983,7 @@ public class Fir2IrTextTestGenerated extends AbstractFir2IrTextTest { } public void testAllFilesPresentInNewInference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/regressions/newInference"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/regressions/newInference"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("fixationOrder1.kt") @@ -2001,7 +2002,7 @@ public class Fir2IrTextTestGenerated extends AbstractFir2IrTextTest { } public void testAllFilesPresentInSingletons() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/singletons"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/singletons"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("companion.kt") @@ -2029,7 +2030,7 @@ public class Fir2IrTextTestGenerated extends AbstractFir2IrTextTest { } public void testAllFilesPresentInStubs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/stubs"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/stubs"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("builtinMap.kt") @@ -2112,7 +2113,7 @@ public class Fir2IrTextTestGenerated extends AbstractFir2IrTextTest { } public void testAllFilesPresentInTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/types"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/types"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("asOnPlatformType.kt") @@ -2234,7 +2235,7 @@ public class Fir2IrTextTestGenerated extends AbstractFir2IrTextTest { } public void testAllFilesPresentInNullChecks() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/types/nullChecks"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/types/nullChecks"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("enhancedNullability.kt") @@ -2281,7 +2282,7 @@ public class Fir2IrTextTestGenerated extends AbstractFir2IrTextTest { } public void testAllFilesPresentInNullCheckOnLambdaResult() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/types/nullChecks/nullCheckOnLambdaResult"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/types/nullChecks/nullCheckOnLambdaResult"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("nnStringVsT.kt") diff --git a/compiler/fir/raw-fir/light-tree2fir/tests-gen/org/jetbrains/kotlin/fir/lightTree/LightTree2FirConverterTestCaseGenerated.java b/compiler/fir/raw-fir/light-tree2fir/tests-gen/org/jetbrains/kotlin/fir/lightTree/LightTree2FirConverterTestCaseGenerated.java index e57a181ef9b..7cc1e21e9cb 100644 --- a/compiler/fir/raw-fir/light-tree2fir/tests-gen/org/jetbrains/kotlin/fir/lightTree/LightTree2FirConverterTestCaseGenerated.java +++ b/compiler/fir/raw-fir/light-tree2fir/tests-gen/org/jetbrains/kotlin/fir/lightTree/LightTree2FirConverterTestCaseGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.fir.lightTree; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class LightTree2FirConverterTestCaseGenerated extends AbstractLightTree2F } public void testAllFilesPresentInRawBuilder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations") @@ -37,7 +38,7 @@ public class LightTree2FirConverterTestCaseGenerated extends AbstractLightTree2F } public void testAllFilesPresentInDeclarations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("annotation.kt") @@ -174,7 +175,7 @@ public class LightTree2FirConverterTestCaseGenerated extends AbstractLightTree2F } public void testAllFilesPresentInContracts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations/contracts"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations/contracts"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations/contracts/newSyntax") @@ -186,7 +187,7 @@ public class LightTree2FirConverterTestCaseGenerated extends AbstractLightTree2F } public void testAllFilesPresentInNewSyntax() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations/contracts/newSyntax"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations/contracts/newSyntax"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("functionWithBothOldAndNewSyntaxContractDescription.kt") @@ -214,7 +215,7 @@ public class LightTree2FirConverterTestCaseGenerated extends AbstractLightTree2F } public void testAllFilesPresentInOldSyntax() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations/contracts/oldSyntax"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations/contracts/oldSyntax"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("contractDescription.kt") @@ -234,7 +235,7 @@ public class LightTree2FirConverterTestCaseGenerated extends AbstractLightTree2F } public void testAllFilesPresentInExpressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/expressions"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/expressions"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("annotated.kt") diff --git a/compiler/fir/raw-fir/psi2fir/tests-gen/org/jetbrains/kotlin/fir/builder/PartialRawFirBuilderTestCaseGenerated.java b/compiler/fir/raw-fir/psi2fir/tests-gen/org/jetbrains/kotlin/fir/builder/PartialRawFirBuilderTestCaseGenerated.java index 98144114ff8..5af04f5c42c 100644 --- a/compiler/fir/raw-fir/psi2fir/tests-gen/org/jetbrains/kotlin/fir/builder/PartialRawFirBuilderTestCaseGenerated.java +++ b/compiler/fir/raw-fir/psi2fir/tests-gen/org/jetbrains/kotlin/fir/builder/PartialRawFirBuilderTestCaseGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.fir.builder; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class PartialRawFirBuilderTestCaseGenerated extends AbstractPartialRawFir } public void testAllFilesPresentInPartialRawBuilder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/partialRawBuilder"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/partialRawBuilder"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("localFunction.kt") diff --git a/compiler/fir/raw-fir/psi2fir/tests-gen/org/jetbrains/kotlin/fir/builder/RawFirBuilderLazyBodiesTestCaseGenerated.java b/compiler/fir/raw-fir/psi2fir/tests-gen/org/jetbrains/kotlin/fir/builder/RawFirBuilderLazyBodiesTestCaseGenerated.java index 74e61729ab3..a3fa6843cdd 100644 --- a/compiler/fir/raw-fir/psi2fir/tests-gen/org/jetbrains/kotlin/fir/builder/RawFirBuilderLazyBodiesTestCaseGenerated.java +++ b/compiler/fir/raw-fir/psi2fir/tests-gen/org/jetbrains/kotlin/fir/builder/RawFirBuilderLazyBodiesTestCaseGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.fir.builder; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class RawFirBuilderLazyBodiesTestCaseGenerated extends AbstractRawFirBuil } public void testAllFilesPresentInRawBuilder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations") @@ -37,7 +38,7 @@ public class RawFirBuilderLazyBodiesTestCaseGenerated extends AbstractRawFirBuil } public void testAllFilesPresentInDeclarations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("annotation.kt") @@ -174,7 +175,7 @@ public class RawFirBuilderLazyBodiesTestCaseGenerated extends AbstractRawFirBuil } public void testAllFilesPresentInContracts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations/contracts"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations/contracts"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations/contracts/newSyntax") @@ -186,7 +187,7 @@ public class RawFirBuilderLazyBodiesTestCaseGenerated extends AbstractRawFirBuil } public void testAllFilesPresentInNewSyntax() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations/contracts/newSyntax"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations/contracts/newSyntax"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("functionWithBothOldAndNewSyntaxContractDescription.kt") @@ -214,7 +215,7 @@ public class RawFirBuilderLazyBodiesTestCaseGenerated extends AbstractRawFirBuil } public void testAllFilesPresentInOldSyntax() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations/contracts/oldSyntax"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations/contracts/oldSyntax"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("contractDescription.kt") @@ -234,7 +235,7 @@ public class RawFirBuilderLazyBodiesTestCaseGenerated extends AbstractRawFirBuil } public void testAllFilesPresentInExpressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/expressions"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/expressions"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("annotated.kt") diff --git a/compiler/fir/raw-fir/psi2fir/tests-gen/org/jetbrains/kotlin/fir/builder/RawFirBuilderSourceElementMappingTestCaseGenerated.java b/compiler/fir/raw-fir/psi2fir/tests-gen/org/jetbrains/kotlin/fir/builder/RawFirBuilderSourceElementMappingTestCaseGenerated.java index 6e1fa89ec78..8d1e35e5481 100644 --- a/compiler/fir/raw-fir/psi2fir/tests-gen/org/jetbrains/kotlin/fir/builder/RawFirBuilderSourceElementMappingTestCaseGenerated.java +++ b/compiler/fir/raw-fir/psi2fir/tests-gen/org/jetbrains/kotlin/fir/builder/RawFirBuilderSourceElementMappingTestCaseGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.fir.builder; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class RawFirBuilderSourceElementMappingTestCaseGenerated extends Abstract } public void testAllFilesPresentInSourceElementMapping() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/sourceElementMapping"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/sourceElementMapping"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("qualifiedExpression.kt") diff --git a/compiler/fir/raw-fir/psi2fir/tests-gen/org/jetbrains/kotlin/fir/builder/RawFirBuilderTestCaseGenerated.java b/compiler/fir/raw-fir/psi2fir/tests-gen/org/jetbrains/kotlin/fir/builder/RawFirBuilderTestCaseGenerated.java index 9ee3466c300..313e88da9e3 100644 --- a/compiler/fir/raw-fir/psi2fir/tests-gen/org/jetbrains/kotlin/fir/builder/RawFirBuilderTestCaseGenerated.java +++ b/compiler/fir/raw-fir/psi2fir/tests-gen/org/jetbrains/kotlin/fir/builder/RawFirBuilderTestCaseGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.fir.builder; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class RawFirBuilderTestCaseGenerated extends AbstractRawFirBuilderTestCas } public void testAllFilesPresentInRawBuilder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations") @@ -37,7 +38,7 @@ public class RawFirBuilderTestCaseGenerated extends AbstractRawFirBuilderTestCas } public void testAllFilesPresentInDeclarations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("annotation.kt") @@ -174,7 +175,7 @@ public class RawFirBuilderTestCaseGenerated extends AbstractRawFirBuilderTestCas } public void testAllFilesPresentInContracts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations/contracts"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations/contracts"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations/contracts/newSyntax") @@ -186,7 +187,7 @@ public class RawFirBuilderTestCaseGenerated extends AbstractRawFirBuilderTestCas } public void testAllFilesPresentInNewSyntax() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations/contracts/newSyntax"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations/contracts/newSyntax"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("functionWithBothOldAndNewSyntaxContractDescription.kt") @@ -214,7 +215,7 @@ public class RawFirBuilderTestCaseGenerated extends AbstractRawFirBuilderTestCas } public void testAllFilesPresentInOldSyntax() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations/contracts/oldSyntax"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations/contracts/oldSyntax"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("contractDescription.kt") @@ -234,7 +235,7 @@ public class RawFirBuilderTestCaseGenerated extends AbstractRawFirBuilderTestCas } public void testAllFilesPresentInExpressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/expressions"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/expressions"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("annotated.kt") diff --git a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsCompilerRunnerTestGenerated.java b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsCompilerRunnerTestGenerated.java index b3db196aac5..4c56142ad4c 100644 --- a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsCompilerRunnerTestGenerated.java +++ b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsCompilerRunnerTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.incremental; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -62,7 +63,7 @@ public class IncrementalJsCompilerRunnerTestGenerated extends AbstractIncrementa } public void testAllFilesPresentInPureKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/pureKotlin"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/pureKotlin"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("annotations") @@ -660,7 +661,7 @@ public class IncrementalJsCompilerRunnerTestGenerated extends AbstractIncrementa } public void testAllFilesPresentInClassHierarchyAffected() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("annotationFlagRemoved") @@ -873,7 +874,7 @@ public class IncrementalJsCompilerRunnerTestGenerated extends AbstractIncrementa } public void testAllFilesPresentInJs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/js"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/js"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("inlineFunctionLocalDeclarationChanges") @@ -890,7 +891,7 @@ public class IncrementalJsCompilerRunnerTestGenerated extends AbstractIncrementa } public void testAllFilesPresentInFriendsModuleDisabled() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/js/friendsModuleDisabled"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/js/friendsModuleDisabled"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("internalInlineFunctionIsChanged") @@ -907,7 +908,7 @@ public class IncrementalJsCompilerRunnerTestGenerated extends AbstractIncrementa } public void testAllFilesPresentInInternalInlineFunctionIsChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/js/friendsModuleDisabled/internalInlineFunctionIsChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/js/friendsModuleDisabled/internalInlineFunctionIsChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } } @@ -921,7 +922,7 @@ public class IncrementalJsCompilerRunnerTestGenerated extends AbstractIncrementa } public void testAllFilesPresentInInlineFunctionLocalDeclarationChanges() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/js/inlineFunctionLocalDeclarationChanges"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/js/inlineFunctionLocalDeclarationChanges"), Pattern.compile("^([^\\.]+)$"), null, true); } } } diff --git a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsCompilerRunnerWithFriendModulesDisabledTestGenerated.java b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsCompilerRunnerWithFriendModulesDisabledTestGenerated.java index f964281896d..55a7494064f 100644 --- a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsCompilerRunnerWithFriendModulesDisabledTestGenerated.java +++ b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsCompilerRunnerWithFriendModulesDisabledTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.incremental; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class IncrementalJsCompilerRunnerWithFriendModulesDisabledTestGenerated e } public void testAllFilesPresentInFriendsModuleDisabled() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/js/friendsModuleDisabled"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/js/friendsModuleDisabled"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("internalInlineFunctionIsChanged") diff --git a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsCompilerRunnerWithMetadataOnlyTestGenerated.java b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsCompilerRunnerWithMetadataOnlyTestGenerated.java index 510e72b96cc..d2ece82fd52 100644 --- a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsCompilerRunnerWithMetadataOnlyTestGenerated.java +++ b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsCompilerRunnerWithMetadataOnlyTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.incremental; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -62,7 +63,7 @@ public class IncrementalJsCompilerRunnerWithMetadataOnlyTestGenerated extends Ab } public void testAllFilesPresentInPureKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/pureKotlin"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/pureKotlin"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("annotations") @@ -660,7 +661,7 @@ public class IncrementalJsCompilerRunnerWithMetadataOnlyTestGenerated extends Ab } public void testAllFilesPresentInClassHierarchyAffected() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("annotationFlagRemoved") @@ -873,7 +874,7 @@ public class IncrementalJsCompilerRunnerWithMetadataOnlyTestGenerated extends Ab } public void testAllFilesPresentInJs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/js"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/js"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("inlineFunctionLocalDeclarationChanges") @@ -890,7 +891,7 @@ public class IncrementalJsCompilerRunnerWithMetadataOnlyTestGenerated extends Ab } public void testAllFilesPresentInFriendsModuleDisabled() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/js/friendsModuleDisabled"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/js/friendsModuleDisabled"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("internalInlineFunctionIsChanged") @@ -907,7 +908,7 @@ public class IncrementalJsCompilerRunnerWithMetadataOnlyTestGenerated extends Ab } public void testAllFilesPresentInInternalInlineFunctionIsChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/js/friendsModuleDisabled/internalInlineFunctionIsChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/js/friendsModuleDisabled/internalInlineFunctionIsChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } } @@ -921,7 +922,7 @@ public class IncrementalJsCompilerRunnerWithMetadataOnlyTestGenerated extends Ab } public void testAllFilesPresentInInlineFunctionLocalDeclarationChanges() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/js/inlineFunctionLocalDeclarationChanges"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/js/inlineFunctionLocalDeclarationChanges"), Pattern.compile("^([^\\.]+)$"), null, true); } } } diff --git a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsKlibCompilerRunnerTestGenerated.java b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsKlibCompilerRunnerTestGenerated.java index b34e6388890..061ca3d6787 100644 --- a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsKlibCompilerRunnerTestGenerated.java +++ b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsKlibCompilerRunnerTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.incremental; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -62,7 +63,7 @@ public class IncrementalJsKlibCompilerRunnerTestGenerated extends AbstractIncrem } public void testAllFilesPresentInPureKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/pureKotlin"), Pattern.compile("^([^\\.]+)$"), Pattern.compile("^sealed.*"), false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/pureKotlin"), Pattern.compile("^([^\\.]+)$"), Pattern.compile("^sealed.*"), false); } @TestMetadata("annotations") @@ -635,7 +636,7 @@ public class IncrementalJsKlibCompilerRunnerTestGenerated extends AbstractIncrem } public void testAllFilesPresentInClassHierarchyAffected() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("annotationFlagRemoved") @@ -848,7 +849,7 @@ public class IncrementalJsKlibCompilerRunnerTestGenerated extends AbstractIncrem } public void testAllFilesPresentInJs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/js"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/js"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("inlineFunctionLocalDeclarationChanges") @@ -865,7 +866,7 @@ public class IncrementalJsKlibCompilerRunnerTestGenerated extends AbstractIncrem } public void testAllFilesPresentInFriendsModuleDisabled() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/js/friendsModuleDisabled"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/js/friendsModuleDisabled"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("internalInlineFunctionIsChanged") @@ -882,7 +883,7 @@ public class IncrementalJsKlibCompilerRunnerTestGenerated extends AbstractIncrem } public void testAllFilesPresentInInternalInlineFunctionIsChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/js/friendsModuleDisabled/internalInlineFunctionIsChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/js/friendsModuleDisabled/internalInlineFunctionIsChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } } @@ -896,7 +897,7 @@ public class IncrementalJsKlibCompilerRunnerTestGenerated extends AbstractIncrem } public void testAllFilesPresentInInlineFunctionLocalDeclarationChanges() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/js/inlineFunctionLocalDeclarationChanges"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/js/inlineFunctionLocalDeclarationChanges"), Pattern.compile("^([^\\.]+)$"), null, true); } } } diff --git a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsKlibCompilerWithScopeExpansionRunnerTestGenerated.java b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsKlibCompilerWithScopeExpansionRunnerTestGenerated.java index 167f494865b..7c93d7d8a45 100644 --- a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsKlibCompilerWithScopeExpansionRunnerTestGenerated.java +++ b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJsKlibCompilerWithScopeExpansionRunnerTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.incremental; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -62,7 +63,7 @@ public class IncrementalJsKlibCompilerWithScopeExpansionRunnerTestGenerated exte } public void testAllFilesPresentInPureKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/pureKotlin"), Pattern.compile("^([^\\.]+)$"), Pattern.compile("^sealed.*"), false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/pureKotlin"), Pattern.compile("^([^\\.]+)$"), Pattern.compile("^sealed.*"), false); } @TestMetadata("annotations") @@ -635,7 +636,7 @@ public class IncrementalJsKlibCompilerWithScopeExpansionRunnerTestGenerated exte } public void testAllFilesPresentInClassHierarchyAffected() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("annotationFlagRemoved") @@ -848,7 +849,7 @@ public class IncrementalJsKlibCompilerWithScopeExpansionRunnerTestGenerated exte } public void testAllFilesPresentInJs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/js"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/js"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("inlineFunctionLocalDeclarationChanges") @@ -865,7 +866,7 @@ public class IncrementalJsKlibCompilerWithScopeExpansionRunnerTestGenerated exte } public void testAllFilesPresentInFriendsModuleDisabled() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/js/friendsModuleDisabled"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/js/friendsModuleDisabled"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("internalInlineFunctionIsChanged") @@ -882,7 +883,7 @@ public class IncrementalJsKlibCompilerWithScopeExpansionRunnerTestGenerated exte } public void testAllFilesPresentInInternalInlineFunctionIsChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/js/friendsModuleDisabled/internalInlineFunctionIsChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/js/friendsModuleDisabled/internalInlineFunctionIsChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } } @@ -896,7 +897,7 @@ public class IncrementalJsKlibCompilerWithScopeExpansionRunnerTestGenerated exte } public void testAllFilesPresentInInlineFunctionLocalDeclarationChanges() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/js/inlineFunctionLocalDeclarationChanges"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/js/inlineFunctionLocalDeclarationChanges"), Pattern.compile("^([^\\.]+)$"), null, true); } } } @@ -910,7 +911,7 @@ public class IncrementalJsKlibCompilerWithScopeExpansionRunnerTestGenerated exte } public void testAllFilesPresentInScopeExpansion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/scopeExpansion"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/scopeExpansion"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("changeTypeAliasAndUsage") @@ -932,7 +933,7 @@ public class IncrementalJsKlibCompilerWithScopeExpansionRunnerTestGenerated exte } public void testAllFilesPresentInChangeTypeAliasAndUsage() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/scopeExpansion/changeTypeAliasAndUsage"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/scopeExpansion/changeTypeAliasAndUsage"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -945,7 +946,7 @@ public class IncrementalJsKlibCompilerWithScopeExpansionRunnerTestGenerated exte } public void testAllFilesPresentInProtectedBecomesPublicAccessedTroughChild() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/scopeExpansion/protectedBecomesPublicAccessedTroughChild"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/scopeExpansion/protectedBecomesPublicAccessedTroughChild"), Pattern.compile("^([^\\.]+)$"), null, true); } } } diff --git a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJvmCompilerRunnerTestGenerated.java b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJvmCompilerRunnerTestGenerated.java index ba32279d9cb..e32b8d37c7f 100644 --- a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJvmCompilerRunnerTestGenerated.java +++ b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalJvmCompilerRunnerTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.incremental; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -63,7 +64,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInPureKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/pureKotlin"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/pureKotlin"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, false); } @TestMetadata("annotations") @@ -661,7 +662,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInClassHierarchyAffected() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, false); } @TestMetadata("annotationFlagRemoved") @@ -874,7 +875,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInInlineFunCallSite() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } @TestMetadata("classProperty") @@ -956,7 +957,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInClassProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/classProperty"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/classProperty"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -969,7 +970,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInCompanionObjectProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/companionObjectProperty"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/companionObjectProperty"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -982,7 +983,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInCoroutine() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/coroutine"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/coroutine"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -995,7 +996,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/function"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/function"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -1008,7 +1009,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInGetter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/getter"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/getter"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -1021,7 +1022,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/lambda"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/lambda"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -1034,7 +1035,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInLocalFun() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/localFun"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/localFun"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -1047,7 +1048,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInMethod() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/method"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/method"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -1060,7 +1061,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInParameterDefaultValue() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/parameterDefaultValue"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/parameterDefaultValue"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -1073,7 +1074,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInPrimaryConstructorParameterDefaultValue() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/primaryConstructorParameterDefaultValue"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/primaryConstructorParameterDefaultValue"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -1086,7 +1087,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInSuperCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/superCall"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/superCall"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -1099,7 +1100,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInThisCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/thisCall"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/thisCall"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -1112,7 +1113,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInTopLevelObjectProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/topLevelObjectProperty"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/topLevelObjectProperty"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -1125,7 +1126,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInTopLevelProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/topLevelProperty"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/topLevelProperty"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } } @@ -1139,7 +1140,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInWithJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } @TestMetadata("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin") @@ -1151,7 +1152,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInConvertBetweenJavaAndKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } @TestMetadata("javaToKotlin") @@ -1183,7 +1184,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInJavaToKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlin"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlin"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -1196,7 +1197,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInJavaToKotlinAndBack() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlinAndBack"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlinAndBack"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -1209,7 +1210,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInJavaToKotlinAndRemove() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlinAndRemove"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlinAndRemove"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -1222,7 +1223,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInKotlinToJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/kotlinToJava"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/kotlinToJava"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } } @@ -1236,7 +1237,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInJavaUsedInKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } @TestMetadata("changeFieldType") @@ -1343,7 +1344,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInChangeFieldType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeFieldType"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeFieldType"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -1356,7 +1357,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInChangeNotUsedSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeNotUsedSignature"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeNotUsedSignature"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -1369,7 +1370,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInChangePropertyOverrideType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changePropertyOverrideType"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changePropertyOverrideType"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -1382,7 +1383,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInChangeSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignature"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignature"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -1395,7 +1396,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInChangeSignaturePackagePrivate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivate"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivate"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -1408,7 +1409,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInChangeSignaturePackagePrivateNonRoot() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivateNonRoot"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivateNonRoot"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -1421,7 +1422,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInChangeSignatureStatic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignatureStatic"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignatureStatic"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -1434,7 +1435,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInConstantChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -1447,7 +1448,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInConstantUnchanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantUnchanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantUnchanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -1460,7 +1461,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInEnumEntryAdded() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/enumEntryAdded"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/enumEntryAdded"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -1473,7 +1474,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInEnumEntryRemoved() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/enumEntryRemoved"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/enumEntryRemoved"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -1486,7 +1487,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInJavaAndKotlinChangedSimultaneously() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaAndKotlinChangedSimultaneously"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaAndKotlinChangedSimultaneously"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -1499,7 +1500,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInJavaFieldNullabilityChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaFieldNullabilityChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaFieldNullabilityChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -1512,7 +1513,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInJavaMethodParamNullabilityChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaMethodParamNullabilityChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaMethodParamNullabilityChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -1525,7 +1526,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInJavaMethodReturnTypeNullabilityChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaMethodReturnTypeNullabilityChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaMethodReturnTypeNullabilityChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -1538,7 +1539,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInMethodAddedInSuper() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/methodAddedInSuper"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/methodAddedInSuper"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -1551,7 +1552,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInMethodRenamed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/methodRenamed"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/methodRenamed"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -1564,7 +1565,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInMixedInheritance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/mixedInheritance"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/mixedInheritance"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -1577,7 +1578,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInNotChangeSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/notChangeSignature"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/notChangeSignature"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -1590,7 +1591,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInSamConversions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } @TestMetadata("methodAdded") @@ -1622,7 +1623,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInMethodAdded() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodAdded"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodAdded"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -1635,7 +1636,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInMethodAddedSamAdapter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodAddedSamAdapter"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodAddedSamAdapter"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -1648,7 +1649,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInMethodSignatureChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodSignatureChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodSignatureChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -1661,7 +1662,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInMethodSignatureChangedSamAdapter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodSignatureChangedSamAdapter"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodSignatureChangedSamAdapter"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } } @@ -1681,7 +1682,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInKotlinUsedInJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } @TestMetadata("changeNotUsedSignature") @@ -1758,7 +1759,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInAddOptionalParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/addOptionalParameter"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/addOptionalParameter"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -1771,7 +1772,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInChangeNotUsedSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/changeNotUsedSignature"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/changeNotUsedSignature"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -1784,7 +1785,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInChangeSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/changeSignature"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/changeSignature"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -1797,7 +1798,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInConstantChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/constantChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/constantChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -1810,7 +1811,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInConstantUnchanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/constantUnchanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/constantUnchanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -1823,7 +1824,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInFunRenamed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/funRenamed"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/funRenamed"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -1836,7 +1837,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInJvmFieldChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/jvmFieldChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/jvmFieldChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -1849,7 +1850,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInJvmFieldUnchanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/jvmFieldUnchanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/jvmFieldUnchanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -1862,7 +1863,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInMethodAddedInSuper() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/methodAddedInSuper"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/methodAddedInSuper"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -1875,7 +1876,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInNotChangeSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/notChangeSignature"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/notChangeSignature"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -1888,7 +1889,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInOnlyTopLevelFunctionInFileRemoved() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/onlyTopLevelFunctionInFileRemoved"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/onlyTopLevelFunctionInFileRemoved"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -1901,7 +1902,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInPackageFileAdded() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/packageFileAdded"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/packageFileAdded"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -1914,7 +1915,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInPrivateChanges() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/privateChanges"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/privateChanges"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -1927,7 +1928,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInPropertyRenamed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/propertyRenamed"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/propertyRenamed"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } } @@ -1946,7 +1947,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInOther() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } @TestMetadata("allKotlinFilesRemovedThenNewAdded") @@ -2103,7 +2104,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInAccessingFunctionsViaRenamedFileClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/accessingFunctionsViaRenamedFileClass"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/accessingFunctionsViaRenamedFileClass"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -2116,7 +2117,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInAllKotlinFilesRemovedThenNewAdded() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/allKotlinFilesRemovedThenNewAdded"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/allKotlinFilesRemovedThenNewAdded"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -2129,7 +2130,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInClassRedeclaration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/classRedeclaration"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/classRedeclaration"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -2142,7 +2143,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInClassToPackageFacade() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/classToPackageFacade"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/classToPackageFacade"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -2155,7 +2156,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInConflictingPlatformDeclarations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/conflictingPlatformDeclarations"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/conflictingPlatformDeclarations"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -2168,7 +2169,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInDefaultValueInConstructorAdded() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/defaultValueInConstructorAdded"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/defaultValueInConstructorAdded"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -2181,7 +2182,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInInlineFunctionWithJvmNameInClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/inlineFunctionWithJvmNameInClass"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/inlineFunctionWithJvmNameInClass"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -2194,7 +2195,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInInlineTopLevelFunctionWithJvmName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/inlineTopLevelFunctionWithJvmName"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/inlineTopLevelFunctionWithJvmName"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -2207,7 +2208,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInInlineTopLevelValPropertyWithJvmName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/inlineTopLevelValPropertyWithJvmName"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/inlineTopLevelValPropertyWithJvmName"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -2220,7 +2221,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInInnerClassNotGeneratedWhenRebuilding() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/innerClassNotGeneratedWhenRebuilding"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/innerClassNotGeneratedWhenRebuilding"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -2233,7 +2234,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInJvmNameChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/jvmNameChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/jvmNameChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -2246,7 +2247,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInMainRedeclaration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/mainRedeclaration"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/mainRedeclaration"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -2259,7 +2260,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInMultifileClassAddTopLevelFunWithDefault() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassAddTopLevelFunWithDefault"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassAddTopLevelFunWithDefault"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -2272,7 +2273,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInMultifileClassFileAdded() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassFileAdded"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassFileAdded"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -2285,7 +2286,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInMultifileClassFileChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassFileChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassFileChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -2298,7 +2299,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInMultifileClassFileMovedToAnotherMultifileClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassFileMovedToAnotherMultifileClass"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassFileMovedToAnotherMultifileClass"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -2311,7 +2312,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInMultifileClassInlineFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassInlineFunction"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassInlineFunction"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -2324,7 +2325,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInMultifileClassInlineFunctionAccessingField() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassInlineFunctionAccessingField"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassInlineFunctionAccessingField"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -2337,7 +2338,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInMultifileClassRecreated() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassRecreated"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassRecreated"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -2350,7 +2351,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInMultifileClassRecreatedAfterRenaming() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassRecreatedAfterRenaming"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassRecreatedAfterRenaming"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -2363,7 +2364,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInMultifileClassRemoved() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassRemoved"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassRemoved"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -2376,7 +2377,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInMultifilePackagePartMethodAdded() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifilePackagePartMethodAdded"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifilePackagePartMethodAdded"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -2389,7 +2390,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInMultifilePartsWithProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifilePartsWithProperties"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifilePartsWithProperties"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -2402,7 +2403,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInOptionalParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/optionalParameter"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/optionalParameter"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -2415,7 +2416,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInPackageFacadeToClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/packageFacadeToClass"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/packageFacadeToClass"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -2428,7 +2429,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInPackageMultifileClassOneFileWithPublicChanges() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/packageMultifileClassOneFileWithPublicChanges"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/packageMultifileClassOneFileWithPublicChanges"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -2441,7 +2442,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInPackageMultifileClassPrivateOnlyChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/packageMultifileClassPrivateOnlyChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/packageMultifileClassPrivateOnlyChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -2454,7 +2455,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInPublicPropertyWithPrivateSetterMultiFileFacade() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/publicPropertyWithPrivateSetterMultiFileFacade"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/publicPropertyWithPrivateSetterMultiFileFacade"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -2467,7 +2468,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInTopLevelFunctionWithJvmName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/topLevelFunctionWithJvmName"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/topLevelFunctionWithJvmName"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -2480,7 +2481,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInTopLevelPropertyWithJvmName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/topLevelPropertyWithJvmName"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/topLevelPropertyWithJvmName"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } } @@ -2505,7 +2506,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInIncrementalJvmCompilerOnly() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/incrementalJvmCompilerOnly"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/incrementalJvmCompilerOnly"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } @TestMetadata("changeAnnotationInJavaClass") @@ -2532,7 +2533,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInAddAnnotationToJavaClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addAnnotationToJavaClass"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addAnnotationToJavaClass"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -2545,7 +2546,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInAddNestedClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addNestedClass"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addNestedClass"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -2558,7 +2559,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInChangeAnnotationInJavaClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/incrementalJvmCompilerOnly/changeAnnotationInJavaClass"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/incrementalJvmCompilerOnly/changeAnnotationInJavaClass"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -2571,7 +2572,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInInlineFunctionRegeneratedObjectStability() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/incrementalJvmCompilerOnly/inlineFunctionRegeneratedObjectStability"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/incrementalJvmCompilerOnly/inlineFunctionRegeneratedObjectStability"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } @@ -2584,7 +2585,7 @@ public class IncrementalJvmCompilerRunnerTestGenerated extends AbstractIncrement } public void testAllFilesPresentInInlineFunctionSmapStability() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/incrementalJvmCompilerOnly/inlineFunctionSmapStability"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/incrementalJvmCompilerOnly/inlineFunctionSmapStability"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM, true); } } } diff --git a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalMultiplatformJsCompilerRunnerTestGenerated.java b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalMultiplatformJsCompilerRunnerTestGenerated.java index 32dc96ba243..dbb9ec8d930 100644 --- a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalMultiplatformJsCompilerRunnerTestGenerated.java +++ b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalMultiplatformJsCompilerRunnerTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.incremental; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class IncrementalMultiplatformJsCompilerRunnerTestGenerated extends Abstr } public void testAllFilesPresentInAllPlatforms() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/mpp/allPlatforms"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/mpp/allPlatforms"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("touchActual") @@ -47,7 +48,7 @@ public class IncrementalMultiplatformJsCompilerRunnerTestGenerated extends Abstr } public void testAllFilesPresentInTouchActual() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/mpp/allPlatforms/touchActual"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/mpp/allPlatforms/touchActual"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -60,7 +61,7 @@ public class IncrementalMultiplatformJsCompilerRunnerTestGenerated extends Abstr } public void testAllFilesPresentInTouchExpect() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/mpp/allPlatforms/touchExpect"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/mpp/allPlatforms/touchExpect"), Pattern.compile("^([^\\.]+)$"), null, true); } } } diff --git a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalMultiplatformJvmCompilerRunnerTestGenerated.java b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalMultiplatformJvmCompilerRunnerTestGenerated.java index 5085cba0489..d4363af84d2 100644 --- a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalMultiplatformJvmCompilerRunnerTestGenerated.java +++ b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IncrementalMultiplatformJvmCompilerRunnerTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.incremental; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -27,7 +28,7 @@ public class IncrementalMultiplatformJvmCompilerRunnerTestGenerated extends Abst } public void testAllFilesPresentInAllPlatforms() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/mpp/allPlatforms"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/mpp/allPlatforms"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("touchActual") @@ -49,7 +50,7 @@ public class IncrementalMultiplatformJvmCompilerRunnerTestGenerated extends Abst } public void testAllFilesPresentInTouchActual() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/mpp/allPlatforms/touchActual"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/mpp/allPlatforms/touchActual"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -62,7 +63,7 @@ public class IncrementalMultiplatformJvmCompilerRunnerTestGenerated extends Abst } public void testAllFilesPresentInTouchExpect() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/mpp/allPlatforms/touchExpect"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/mpp/allPlatforms/touchExpect"), Pattern.compile("^([^\\.]+)$"), null, true); } } } @@ -76,7 +77,7 @@ public class IncrementalMultiplatformJvmCompilerRunnerTestGenerated extends Abst } public void testAllFilesPresentInJvmOnly() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/mpp/jvmOnly"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/mpp/jvmOnly"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("multifilePartChanged") @@ -93,7 +94,7 @@ public class IncrementalMultiplatformJvmCompilerRunnerTestGenerated extends Abst } public void testAllFilesPresentInMultifilePartChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/mpp/jvmOnly/multifilePartChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/mpp/jvmOnly/multifilePartChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } } diff --git a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IrIncrementalJvmCompilerRunnerTestGenerated.java b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IrIncrementalJvmCompilerRunnerTestGenerated.java index 71389f82926..ad620ef392c 100644 --- a/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IrIncrementalJvmCompilerRunnerTestGenerated.java +++ b/compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/IrIncrementalJvmCompilerRunnerTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.incremental; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -63,7 +64,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInPureKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/pureKotlin"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/pureKotlin"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, false); } @TestMetadata("annotations") @@ -661,7 +662,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInClassHierarchyAffected() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, false); } @TestMetadata("annotationFlagRemoved") @@ -874,7 +875,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInInlineFunCallSite() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("classProperty") @@ -956,7 +957,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInClassProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/classProperty"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/classProperty"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -969,7 +970,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInCompanionObjectProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/companionObjectProperty"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/companionObjectProperty"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -982,7 +983,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInCoroutine() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/coroutine"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/coroutine"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -995,7 +996,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/function"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/function"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -1008,7 +1009,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInGetter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/getter"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/getter"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -1021,7 +1022,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/lambda"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/lambda"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -1034,7 +1035,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInLocalFun() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/localFun"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/localFun"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -1047,7 +1048,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInMethod() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/method"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/method"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -1060,7 +1061,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInParameterDefaultValue() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/parameterDefaultValue"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/parameterDefaultValue"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -1073,7 +1074,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInPrimaryConstructorParameterDefaultValue() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/primaryConstructorParameterDefaultValue"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/primaryConstructorParameterDefaultValue"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -1086,7 +1087,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInSuperCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/superCall"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/superCall"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -1099,7 +1100,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInThisCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/thisCall"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/thisCall"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -1112,7 +1113,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInTopLevelObjectProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/topLevelObjectProperty"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/topLevelObjectProperty"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -1125,7 +1126,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInTopLevelProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/topLevelProperty"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/topLevelProperty"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } } @@ -1139,7 +1140,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInWithJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin") @@ -1151,7 +1152,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInConvertBetweenJavaAndKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("javaToKotlin") @@ -1183,7 +1184,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInJavaToKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlin"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlin"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -1196,7 +1197,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInJavaToKotlinAndBack() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlinAndBack"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlinAndBack"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -1209,7 +1210,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInJavaToKotlinAndRemove() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlinAndRemove"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlinAndRemove"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -1222,7 +1223,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInKotlinToJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/kotlinToJava"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/kotlinToJava"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } } @@ -1236,7 +1237,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInJavaUsedInKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("changeFieldType") @@ -1343,7 +1344,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInChangeFieldType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeFieldType"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeFieldType"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -1356,7 +1357,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInChangeNotUsedSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeNotUsedSignature"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeNotUsedSignature"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -1369,7 +1370,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInChangePropertyOverrideType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changePropertyOverrideType"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changePropertyOverrideType"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -1382,7 +1383,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInChangeSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignature"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignature"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -1395,7 +1396,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInChangeSignaturePackagePrivate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivate"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivate"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -1408,7 +1409,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInChangeSignaturePackagePrivateNonRoot() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivateNonRoot"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivateNonRoot"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -1421,7 +1422,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInChangeSignatureStatic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignatureStatic"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignatureStatic"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -1434,7 +1435,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInConstantChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -1447,7 +1448,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInConstantUnchanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantUnchanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantUnchanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -1460,7 +1461,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInEnumEntryAdded() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/enumEntryAdded"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/enumEntryAdded"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -1473,7 +1474,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInEnumEntryRemoved() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/enumEntryRemoved"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/enumEntryRemoved"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -1486,7 +1487,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInJavaAndKotlinChangedSimultaneously() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaAndKotlinChangedSimultaneously"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaAndKotlinChangedSimultaneously"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -1499,7 +1500,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInJavaFieldNullabilityChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaFieldNullabilityChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaFieldNullabilityChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -1512,7 +1513,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInJavaMethodParamNullabilityChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaMethodParamNullabilityChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaMethodParamNullabilityChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -1525,7 +1526,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInJavaMethodReturnTypeNullabilityChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaMethodReturnTypeNullabilityChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaMethodReturnTypeNullabilityChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -1538,7 +1539,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInMethodAddedInSuper() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/methodAddedInSuper"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/methodAddedInSuper"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -1551,7 +1552,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInMethodRenamed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/methodRenamed"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/methodRenamed"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -1564,7 +1565,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInMixedInheritance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/mixedInheritance"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/mixedInheritance"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -1577,7 +1578,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInNotChangeSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/notChangeSignature"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/notChangeSignature"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -1590,7 +1591,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInSamConversions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("methodAdded") @@ -1622,7 +1623,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInMethodAdded() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodAdded"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodAdded"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -1635,7 +1636,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInMethodAddedSamAdapter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodAddedSamAdapter"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodAddedSamAdapter"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -1648,7 +1649,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInMethodSignatureChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodSignatureChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodSignatureChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -1661,7 +1662,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInMethodSignatureChangedSamAdapter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodSignatureChangedSamAdapter"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodSignatureChangedSamAdapter"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } } @@ -1681,7 +1682,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInKotlinUsedInJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("changeNotUsedSignature") @@ -1758,7 +1759,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInAddOptionalParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/addOptionalParameter"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/addOptionalParameter"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -1771,7 +1772,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInChangeNotUsedSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/changeNotUsedSignature"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/changeNotUsedSignature"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -1784,7 +1785,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInChangeSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/changeSignature"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/changeSignature"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -1797,7 +1798,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInConstantChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/constantChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/constantChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -1810,7 +1811,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInConstantUnchanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/constantUnchanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/constantUnchanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -1823,7 +1824,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInFunRenamed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/funRenamed"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/funRenamed"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -1836,7 +1837,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInJvmFieldChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/jvmFieldChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/jvmFieldChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -1849,7 +1850,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInJvmFieldUnchanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/jvmFieldUnchanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/jvmFieldUnchanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -1862,7 +1863,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInMethodAddedInSuper() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/methodAddedInSuper"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/methodAddedInSuper"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -1875,7 +1876,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInNotChangeSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/notChangeSignature"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/notChangeSignature"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -1888,7 +1889,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInOnlyTopLevelFunctionInFileRemoved() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/onlyTopLevelFunctionInFileRemoved"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/onlyTopLevelFunctionInFileRemoved"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -1901,7 +1902,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInPackageFileAdded() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/packageFileAdded"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/packageFileAdded"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -1914,7 +1915,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInPrivateChanges() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/privateChanges"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/privateChanges"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -1927,7 +1928,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInPropertyRenamed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/propertyRenamed"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/propertyRenamed"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } } @@ -1946,7 +1947,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInOther() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("allKotlinFilesRemovedThenNewAdded") @@ -2103,7 +2104,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInAccessingFunctionsViaRenamedFileClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/accessingFunctionsViaRenamedFileClass"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/accessingFunctionsViaRenamedFileClass"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -2116,7 +2117,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInAllKotlinFilesRemovedThenNewAdded() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/allKotlinFilesRemovedThenNewAdded"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/allKotlinFilesRemovedThenNewAdded"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -2129,7 +2130,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInClassRedeclaration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/classRedeclaration"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/classRedeclaration"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -2142,7 +2143,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInClassToPackageFacade() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/classToPackageFacade"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/classToPackageFacade"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -2155,7 +2156,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInConflictingPlatformDeclarations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/conflictingPlatformDeclarations"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/conflictingPlatformDeclarations"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -2168,7 +2169,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInDefaultValueInConstructorAdded() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/defaultValueInConstructorAdded"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/defaultValueInConstructorAdded"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -2181,7 +2182,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInInlineFunctionWithJvmNameInClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/inlineFunctionWithJvmNameInClass"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/inlineFunctionWithJvmNameInClass"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -2194,7 +2195,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInInlineTopLevelFunctionWithJvmName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/inlineTopLevelFunctionWithJvmName"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/inlineTopLevelFunctionWithJvmName"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -2207,7 +2208,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInInlineTopLevelValPropertyWithJvmName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/inlineTopLevelValPropertyWithJvmName"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/inlineTopLevelValPropertyWithJvmName"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -2220,7 +2221,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInInnerClassNotGeneratedWhenRebuilding() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/innerClassNotGeneratedWhenRebuilding"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/innerClassNotGeneratedWhenRebuilding"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -2233,7 +2234,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInJvmNameChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/jvmNameChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/jvmNameChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -2246,7 +2247,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInMainRedeclaration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/mainRedeclaration"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/mainRedeclaration"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -2259,7 +2260,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInMultifileClassAddTopLevelFunWithDefault() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassAddTopLevelFunWithDefault"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassAddTopLevelFunWithDefault"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -2272,7 +2273,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInMultifileClassFileAdded() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassFileAdded"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassFileAdded"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -2285,7 +2286,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInMultifileClassFileChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassFileChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassFileChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -2298,7 +2299,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInMultifileClassFileMovedToAnotherMultifileClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassFileMovedToAnotherMultifileClass"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassFileMovedToAnotherMultifileClass"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -2311,7 +2312,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInMultifileClassInlineFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassInlineFunction"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassInlineFunction"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -2324,7 +2325,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInMultifileClassInlineFunctionAccessingField() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassInlineFunctionAccessingField"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassInlineFunctionAccessingField"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -2337,7 +2338,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInMultifileClassRecreated() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassRecreated"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassRecreated"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -2350,7 +2351,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInMultifileClassRecreatedAfterRenaming() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassRecreatedAfterRenaming"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassRecreatedAfterRenaming"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -2363,7 +2364,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInMultifileClassRemoved() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassRemoved"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassRemoved"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -2376,7 +2377,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInMultifilePackagePartMethodAdded() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifilePackagePartMethodAdded"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifilePackagePartMethodAdded"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -2389,7 +2390,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInMultifilePartsWithProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifilePartsWithProperties"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifilePartsWithProperties"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -2402,7 +2403,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInOptionalParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/optionalParameter"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/optionalParameter"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -2415,7 +2416,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInPackageFacadeToClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/packageFacadeToClass"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/packageFacadeToClass"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -2428,7 +2429,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInPackageMultifileClassOneFileWithPublicChanges() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/packageMultifileClassOneFileWithPublicChanges"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/packageMultifileClassOneFileWithPublicChanges"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -2441,7 +2442,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInPackageMultifileClassPrivateOnlyChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/packageMultifileClassPrivateOnlyChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/packageMultifileClassPrivateOnlyChanged"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -2454,7 +2455,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInPublicPropertyWithPrivateSetterMultiFileFacade() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/publicPropertyWithPrivateSetterMultiFileFacade"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/publicPropertyWithPrivateSetterMultiFileFacade"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -2467,7 +2468,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInTopLevelFunctionWithJvmName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/topLevelFunctionWithJvmName"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/topLevelFunctionWithJvmName"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -2480,7 +2481,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInTopLevelPropertyWithJvmName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/topLevelPropertyWithJvmName"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/topLevelPropertyWithJvmName"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } } @@ -2505,7 +2506,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInIncrementalJvmCompilerOnly() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/incrementalJvmCompilerOnly"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/incrementalJvmCompilerOnly"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("changeAnnotationInJavaClass") @@ -2532,7 +2533,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInAddAnnotationToJavaClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addAnnotationToJavaClass"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addAnnotationToJavaClass"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -2545,7 +2546,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInAddNestedClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addNestedClass"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/incrementalJvmCompilerOnly/addNestedClass"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -2558,7 +2559,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInChangeAnnotationInJavaClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/incrementalJvmCompilerOnly/changeAnnotationInJavaClass"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/incrementalJvmCompilerOnly/changeAnnotationInJavaClass"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -2571,7 +2572,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInInlineFunctionRegeneratedObjectStability() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/incrementalJvmCompilerOnly/inlineFunctionRegeneratedObjectStability"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/incrementalJvmCompilerOnly/inlineFunctionRegeneratedObjectStability"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } @@ -2584,7 +2585,7 @@ public class IrIncrementalJvmCompilerRunnerTestGenerated extends AbstractIrIncre } public void testAllFilesPresentInInlineFunctionSmapStability() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/incrementalJvmCompilerOnly/inlineFunctionSmapStability"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/incrementalJvmCompilerOnly/inlineFunctionSmapStability"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, true); } } } diff --git a/compiler/tests-against-klib/tests/org/jetbrains/kotlin/codegen/ir/CompileKotlinAgainstKlibTestGenerated.java b/compiler/tests-against-klib/tests/org/jetbrains/kotlin/codegen/ir/CompileKotlinAgainstKlibTestGenerated.java index 5d6b1ba18cb..84325896427 100644 --- a/compiler/tests-against-klib/tests/org/jetbrains/kotlin/codegen/ir/CompileKotlinAgainstKlibTestGenerated.java +++ b/compiler/tests-against-klib/tests/org/jetbrains/kotlin/codegen/ir/CompileKotlinAgainstKlibTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.codegen.ir; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class CompileKotlinAgainstKlibTestGenerated extends AbstractCompileKotlin } public void testAllFilesPresentInBoxKlib() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxKlib"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxKlib"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("properties.kt") diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java index f87c05e2621..961fae208a3 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java @@ -6,7 +6,7 @@ package org.jetbrains.kotlin.test.runners; import com.intellij.testFramework.TestDataPath; -import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; @@ -53,7 +53,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInTests() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -908,7 +908,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Annotations extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -1379,7 +1379,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class AnnotationParameterMustBeConstant extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInAnnotationParameterMustBeConstant() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -1443,7 +1443,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class FunctionalTypes extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInFunctionalTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations/functionalTypes"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations/functionalTypes"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -1471,7 +1471,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Options extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInOptions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations/options"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations/options"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -1594,7 +1594,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInTargets() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations/options/targets"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations/options/targets"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -1731,7 +1731,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Rendering extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInRendering() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations/rendering"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations/rendering"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -1807,7 +1807,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class WithUseSiteTarget extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInWithUseSiteTarget() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -1962,7 +1962,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class BackingField extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInBackingField() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/backingField"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/backingField"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -2092,7 +2092,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class CallableReference extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -2383,7 +2383,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Bound extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInBound() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference/bound"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference/bound"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -2513,7 +2513,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference/function"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference/function"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -2823,7 +2823,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Generic extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInGeneric() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference/generic"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference/generic"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -2947,7 +2947,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference/property"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference/property"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -3053,7 +3053,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInResolve() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference/resolve"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference/resolve"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -3351,7 +3351,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Unsupported extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInUnsupported() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference/unsupported"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference/unsupported"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -3392,7 +3392,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Cast extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInCast() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/cast"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/cast"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -3767,7 +3767,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Bare extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInBare() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/cast/bare"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/cast/bare"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -3891,7 +3891,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class NeverSucceeds extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInNeverSucceeds() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/cast/neverSucceeds"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/cast/neverSucceeds"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -3932,7 +3932,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class CheckArguments extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInCheckArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/checkArguments"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/checkArguments"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -4002,7 +4002,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class ClassLiteral extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInClassLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/classLiteral"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/classLiteral"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -4102,7 +4102,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class ClassObjects extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInClassObjects() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/classObjects"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/classObjects"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -4238,7 +4238,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class CollectionLiterals extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInCollectionLiterals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/collectionLiterals"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/collectionLiterals"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -4326,7 +4326,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInConstructorConsistency() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/constructorConsistency"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/constructorConsistency"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -4480,7 +4480,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class ControlFlowAnalysis extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInControlFlowAnalysis() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/controlFlowAnalysis"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/controlFlowAnalysis"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -5005,7 +5005,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class DeadCode extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInDeadCode() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -5165,7 +5165,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class DefiniteReturn extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInDefiniteReturn() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/controlFlowAnalysis/definiteReturn"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/controlFlowAnalysis/definiteReturn"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -5199,7 +5199,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class UnnecessaryLateinit extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInUnnecessaryLateinit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -5282,7 +5282,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class ControlStructures extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInControlStructures() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/controlStructures"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/controlStructures"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -5556,7 +5556,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Coroutines extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInCoroutines() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/coroutines"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/coroutines"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -5577,7 +5577,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class CallableReference extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/coroutines/callableReference"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/coroutines/callableReference"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -5600,7 +5600,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class CyclicHierarchy extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInCyclicHierarchy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/cyclicHierarchy"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/cyclicHierarchy"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -5699,7 +5699,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class WithCompanion extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInWithCompanion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -5782,7 +5782,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class DataClasses extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInDataClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/dataClasses"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/dataClasses"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -5984,7 +5984,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class DataFlow extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInDataFlow() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/dataFlow"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/dataFlow"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -6017,7 +6017,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Assignment extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInAssignment() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/dataFlow/assignment"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/dataFlow/assignment"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -6057,7 +6057,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Local extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInLocal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/dataFlow/local"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/dataFlow/local"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -6140,7 +6140,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class DataFlowInfoTraversal extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInDataFlowInfoTraversal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/dataFlowInfoTraversal"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/dataFlowInfoTraversal"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -6461,7 +6461,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Smartcasts extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInSmartcasts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/smartcasts"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/smartcasts"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -6484,7 +6484,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class DeclarationChecks extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInDeclarationChecks() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/declarationChecks"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/declarationChecks"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -6703,7 +6703,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class DestructuringDeclarations extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInDestructuringDeclarations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -6797,7 +6797,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class FiniteBoundRestriction extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInFiniteBoundRestriction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/declarationChecks/finiteBoundRestriction"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/declarationChecks/finiteBoundRestriction"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -6825,7 +6825,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class NonExpansiveInheritanceRestriction extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInNonExpansiveInheritanceRestriction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/declarationChecks/nonExpansiveInheritanceRestriction"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/declarationChecks/nonExpansiveInheritanceRestriction"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -6854,7 +6854,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class DefaultArguments extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInDefaultArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/defaultArguments"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/defaultArguments"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -6894,7 +6894,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInDelegatedProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/delegatedProperty"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/delegatedProperty"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -7113,7 +7113,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Inference extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInInference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/delegatedProperty/inference"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/delegatedProperty/inference"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -7225,7 +7225,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class ProvideDelegate extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInProvideDelegate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -7338,7 +7338,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Delegation extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInDelegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/delegation"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/delegation"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -7401,7 +7401,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Clashes extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInClashes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/delegation/clashes"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/delegation/clashes"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -7435,7 +7435,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class CovariantOverrides extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInCovariantOverrides() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/delegation/covariantOverrides"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/delegation/covariantOverrides"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -7475,7 +7475,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInMemberHidesSupertypeOverride() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -7570,7 +7570,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Deparenthesize extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInDeparenthesize() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/deparenthesize"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/deparenthesize"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -7616,7 +7616,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Deprecated extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInDeprecated() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/deprecated"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/deprecated"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -7823,7 +7823,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class DeprecatedSinceKotlin extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInDeprecatedSinceKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -7888,7 +7888,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class DuplicateJvmSignature extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInDuplicateJvmSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -7921,7 +7921,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInAccidentalOverrides() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -8015,7 +8015,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Bridges extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInBridges() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/bridges"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/bridges"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -8043,7 +8043,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Erasure extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInErasure() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -8155,7 +8155,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class FinalMembersFromBuiltIns extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInFinalMembersFromBuiltIns() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/finalMembersFromBuiltIns"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/finalMembersFromBuiltIns"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -8177,7 +8177,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class FunctionAndProperty extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInFunctionAndProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -8301,7 +8301,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class SpecialNames extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInSpecialNames() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -8365,7 +8365,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Statics extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInStatics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/statics"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/statics"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -8411,7 +8411,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Synthesized extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInSynthesized() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/synthesized"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/synthesized"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -8427,7 +8427,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class TraitImpl extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInTraitImpl() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/traitImpl"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/traitImpl"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -8462,7 +8462,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class DynamicTypes extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInDynamicTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/dynamicTypes"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/dynamicTypes"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -8508,7 +8508,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/enum"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/enum"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -8859,7 +8859,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Inner extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInInner() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/enum/inner"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/enum/inner"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -8942,7 +8942,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Evaluate extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInEvaluate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/evaluate"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/evaluate"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -9089,7 +9089,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class InlineClasses extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/evaluate/inlineClasses"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/evaluate/inlineClasses"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -9106,7 +9106,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Exposed extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInExposed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/exposed"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/exposed"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -9284,7 +9284,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Extensions extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInExtensions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/extensions"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/extensions"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -9396,7 +9396,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class FunInterface extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInFunInterface() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/funInterface"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/funInterface"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -9490,7 +9490,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class FunctionAsExpression extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInFunctionAsExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/functionAsExpression"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/functionAsExpression"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -9602,7 +9602,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class FunctionLiterals extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInFunctionLiterals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/functionLiterals"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/functionLiterals"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -9791,7 +9791,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class DestructuringInLambdas extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInDestructuringInLambdas() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -9867,7 +9867,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Return extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInReturn() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/functionLiterals/return"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/functionLiterals/return"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -10040,7 +10040,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Generics extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInGenerics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -10253,7 +10253,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class CapturedParameters extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInCapturedParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/capturedParameters"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/capturedParameters"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -10299,7 +10299,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class CyclicBounds extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInCyclicBounds() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/cyclicBounds"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/cyclicBounds"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -10321,7 +10321,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class InnerClasses extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInInnerClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/innerClasses"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/innerClasses"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -10474,7 +10474,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class ImplicitArguments extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInImplicitArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -10539,7 +10539,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class MultipleBoundsMemberScope extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInMultipleBoundsMemberScope() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/multipleBoundsMemberScope"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/multipleBoundsMemberScope"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -10591,7 +10591,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Nullability extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInNullability() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/nullability"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/nullability"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -10721,7 +10721,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInProjectionsScope() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/projectionsScope"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/projectionsScope"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -10899,7 +10899,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class StarProjections extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInStarProjections() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/starProjections"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/starProjections"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -10945,7 +10945,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class TpAsReified extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInTpAsReified() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/tpAsReified"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/tpAsReified"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -11039,7 +11039,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class VarProjection extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInVarProjection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/varProjection"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/varProjection"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -11074,7 +11074,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Imports extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInImports() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/imports"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/imports"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -11420,7 +11420,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class IncompleteCode extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInIncompleteCode() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/incompleteCode"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/incompleteCode"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -11549,7 +11549,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class DiagnosticWithSyntaxError extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInDiagnosticWithSyntaxError() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -11668,7 +11668,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Inference extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInInference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -12241,7 +12241,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class CapturedTypes extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInCapturedTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/capturedTypes"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/capturedTypes"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -12443,7 +12443,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class CoercionToUnit extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInCoercionToUnit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/coercionToUnit"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/coercionToUnit"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -12537,7 +12537,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class CommonSystem extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInCommonSystem() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/commonSystem"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/commonSystem"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -12709,7 +12709,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Completion extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInCompletion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/completion"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/completion"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -12808,7 +12808,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class PostponedArgumentsAnalysis extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInPostponedArgumentsAnalysis() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/completion/postponedArgumentsAnalysis"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/completion/postponedArgumentsAnalysis"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -12879,7 +12879,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Constraints extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInConstraints() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/constraints"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/constraints"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -13051,7 +13051,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class NestedCalls extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInNestedCalls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/nestedCalls"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/nestedCalls"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -13145,7 +13145,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class NothingType extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInNothingType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/nothingType"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/nothingType"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -13299,7 +13299,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class PublicApproximation extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInPublicApproximation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/publicApproximation"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/publicApproximation"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -13387,7 +13387,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class RecursiveCalls extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInRecursiveCalls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/recursiveCalls"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/recursiveCalls"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -13403,7 +13403,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class RecursiveLocalFuns extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInRecursiveLocalFuns() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/recursiveLocalFuns"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/recursiveLocalFuns"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -13437,7 +13437,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class RecursiveTypes extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInRecursiveTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/recursiveTypes"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/recursiveTypes"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -13519,7 +13519,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Regressions extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInRegressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/regressions"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/regressions"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -13955,7 +13955,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class ReportingImprovements extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInReportingImprovements() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/reportingImprovements"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/reportingImprovements"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -14037,7 +14037,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Substitutions extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInSubstitutions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/substitutions"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/substitutions"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -14089,7 +14089,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class UpperBounds extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInUpperBounds() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/upperBounds"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/upperBounds"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -14166,7 +14166,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Infos extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInInfos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/infos"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/infos"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -14188,7 +14188,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Inline extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inline"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inline"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -14461,7 +14461,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class BinaryExpressions extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInBinaryExpressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inline/binaryExpressions"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inline/binaryExpressions"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -14519,7 +14519,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class NonLocalReturns extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInNonLocalReturns() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inline/nonLocalReturns"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inline/nonLocalReturns"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -14637,7 +14637,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class NonPublicMember extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInNonPublicMember() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inline/nonPublicMember"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inline/nonPublicMember"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -14701,7 +14701,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Property extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inline/property"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inline/property"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -14735,7 +14735,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Regressions extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInRegressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inline/regressions"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inline/regressions"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -14751,7 +14751,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class UnaryExpressions extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInUnaryExpressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inline/unaryExpressions"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inline/unaryExpressions"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -14780,7 +14780,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class InlineClasses extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inlineClasses"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inlineClasses"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -14952,7 +14952,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInInner() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inner"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inner"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -15225,7 +15225,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class QualifiedExpression extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInQualifiedExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inner/qualifiedExpression"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inner/qualifiedExpression"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -15302,7 +15302,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInJ_k() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -15773,7 +15773,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class BrokenCode extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInBrokenCode() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/brokenCode"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/brokenCode"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -15795,7 +15795,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class CollectionOverrides extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInCollectionOverrides() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/collectionOverrides"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/collectionOverrides"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -15913,7 +15913,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Deprecations extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInDeprecations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/deprecations"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/deprecations"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -15941,7 +15941,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class GenericConstructor extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInGenericConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/genericConstructor"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/genericConstructor"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -16005,7 +16005,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class PolymorphicSignature extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInPolymorphicSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/polymorphicSignature"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/polymorphicSignature"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -16027,7 +16027,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class PrimitiveOverrides extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInPrimitiveOverrides() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/primitiveOverrides"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/primitiveOverrides"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -16055,7 +16055,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class PrimitiveOverridesWithInlineClass extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInPrimitiveOverridesWithInlineClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/primitiveOverridesWithInlineClass"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/primitiveOverridesWithInlineClass"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -16071,7 +16071,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Properties extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/properties"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/properties"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -16129,7 +16129,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Sam extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInSam() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/sam"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/sam"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -16235,7 +16235,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class SamByProjectedType extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInSamByProjectedType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/samByProjectedType"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/samByProjectedType"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -16275,7 +16275,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class SignatureAnnotations extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInSignatureAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/signatureAnnotations"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/signatureAnnotations"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -16375,7 +16375,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class SpecialBuiltIns extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInSpecialBuiltIns() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/specialBuiltIns"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/specialBuiltIns"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -16397,7 +16397,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Types extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/types"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/types"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -16462,7 +16462,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInJava8Overrides() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/java8Overrides"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/java8Overrides"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -16514,7 +16514,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Javac extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInJavac() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -16529,7 +16529,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class FieldsResolution extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInFieldsResolution() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/fieldsResolution"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/fieldsResolution"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -16611,7 +16611,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Imports extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInImports() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/imports"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/imports"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -16723,7 +16723,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Inheritance extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInInheritance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/inheritance"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/inheritance"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -16835,7 +16835,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Inners extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInInners() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/inners"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/inners"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -16887,7 +16887,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class QualifiedExpression extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInQualifiedExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/qualifiedExpression"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/qualifiedExpression"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -16927,7 +16927,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class TypeParameters extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInTypeParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/typeParameters"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/typeParameters"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -16980,7 +16980,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Labels extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInLabels() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/labels"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/labels"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -17062,7 +17062,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Lateinit extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInLateinit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/lateinit"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/lateinit"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -17089,7 +17089,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Local extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInLocal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/lateinit/local"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/lateinit/local"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -17118,7 +17118,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Library extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInLibrary() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/library"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/library"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -17140,7 +17140,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class LocalClasses extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInLocalClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/localClasses"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/localClasses"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -17162,7 +17162,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Modifiers extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInModifiers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/modifiers"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/modifiers"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -17267,7 +17267,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Const extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInConst() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/modifiers/const"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/modifiers/const"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -17331,7 +17331,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class OperatorInfix extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInOperatorInfix() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/modifiers/operatorInfix"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/modifiers/operatorInfix"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -17360,7 +17360,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Multimodule extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInMultimodule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multimodule"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multimodule"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -17405,7 +17405,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class DuplicateClass extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInDuplicateClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multimodule/duplicateClass"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multimodule/duplicateClass"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -17493,7 +17493,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class DuplicateMethod extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInDuplicateMethod() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multimodule/duplicateMethod"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multimodule/duplicateMethod"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -17653,7 +17653,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class DuplicateSuper extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInDuplicateSuper() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multimodule/duplicateSuper"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multimodule/duplicateSuper"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -17687,7 +17687,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class HiddenClass extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInHiddenClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multimodule/hiddenClass"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multimodule/hiddenClass"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -17722,7 +17722,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Multiplatform extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInMultiplatform() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -17797,7 +17797,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class DefaultArguments extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInDefaultArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/defaultArguments"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/defaultArguments"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -17855,7 +17855,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Deprecated extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInDeprecated() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/deprecated"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/deprecated"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -17877,7 +17877,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/enum"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/enum"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -17917,7 +17917,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Generic extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInGeneric() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/generic"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/generic"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -17969,7 +17969,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInHeaderClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/headerClass"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/headerClass"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -18159,7 +18159,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class InlineClasses extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/inlineClasses"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/inlineClasses"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -18175,7 +18175,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Java extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/java"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/java"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -18197,7 +18197,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class TopLevelFun extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInTopLevelFun() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/topLevelFun"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/topLevelFun"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -18285,7 +18285,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class TopLevelProperty extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInTopLevelProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/topLevelProperty"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/topLevelProperty"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -18308,7 +18308,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class NamedArguments extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInNamedArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/namedArguments"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/namedArguments"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -18395,7 +18395,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class MixedNamedPosition extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInMixedNamedPosition() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/namedArguments/mixedNamedPosition"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/namedArguments/mixedNamedPosition"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -18442,7 +18442,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class NullabilityAndSmartCasts extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInNullabilityAndSmartCasts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -18680,7 +18680,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class NullableTypes extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInNullableTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/nullableTypes"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/nullableTypes"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -18786,7 +18786,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Numbers extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInNumbers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/numbers"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/numbers"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -18826,7 +18826,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Objects extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInObjects() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/objects"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/objects"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -18919,7 +18919,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Kt21515 extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInKt21515() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/objects/kt21515"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/objects/kt21515"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -19080,7 +19080,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class OperatorRem extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInOperatorRem() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/operatorRem"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/operatorRem"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -19216,7 +19216,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class OperatorsOverloading extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInOperatorsOverloading() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/operatorsOverloading"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/operatorsOverloading"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -19310,7 +19310,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Overload extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInOverload() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/overload"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/overload"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -19518,7 +19518,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInOverride() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/override"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/override"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -19821,7 +19821,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class ClashesOnInheritance extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInClashesOnInheritance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/override/clashesOnInheritance"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/override/clashesOnInheritance"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -19903,7 +19903,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class ParameterNames extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInParameterNames() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/override/parameterNames"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/override/parameterNames"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -19961,7 +19961,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class TypeParameters extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInTypeParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/override/typeParameters"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/override/typeParameters"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -19996,7 +19996,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class ParenthesizedTypes extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInParenthesizedTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/parenthesizedTypes"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/parenthesizedTypes"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -20024,7 +20024,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class PlatformTypes extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInPlatformTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -20135,7 +20135,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class CommonSupertype extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInCommonSupertype() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/commonSupertype"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/commonSupertype"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -20193,7 +20193,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class GenericVarianceViolation extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInGenericVarianceViolation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/genericVarianceViolation"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/genericVarianceViolation"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -20251,7 +20251,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class MethodCall extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInMethodCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/methodCall"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/methodCall"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -20381,7 +20381,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class NotNullTypeParameter extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInNotNullTypeParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/notNullTypeParameter"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/notNullTypeParameter"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -20433,7 +20433,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class NullabilityWarnings extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInNullabilityWarnings() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -20629,7 +20629,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class RawTypes extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInRawTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/rawTypes"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/rawTypes"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -20741,7 +20741,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class TypeEnhancement extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInTypeEnhancement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/typeEnhancement"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/typeEnhancement"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -20776,7 +20776,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class PrivateInFile extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInPrivateInFile() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/privateInFile"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/privateInFile"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -20804,7 +20804,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Properties extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/properties"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/properties"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -20825,7 +20825,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class InferenceFromGetters extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInInferenceFromGetters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/properties/inferenceFromGetters"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/properties/inferenceFromGetters"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -20908,7 +20908,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class QualifiedExpression extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInQualifiedExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/qualifiedExpression"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/qualifiedExpression"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -20978,7 +20978,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInReassignment() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/reassignment"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/reassignment"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -21042,7 +21042,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInRecovery() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/recovery"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/recovery"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -21076,7 +21076,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Redeclarations extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInRedeclarations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/redeclarations"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/redeclarations"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -21289,7 +21289,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class ShadowedExtension extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInShadowedExtension() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -21384,7 +21384,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Regressions extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInRegressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/regressions"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/regressions"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -22341,7 +22341,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Kt7585 extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInKt7585() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/regressions/kt7585"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/regressions/kt7585"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -22370,7 +22370,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Resolve extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInResolve() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -22571,7 +22571,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class DslMarker extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInDslMarker() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/dslMarker"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/dslMarker"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -22737,7 +22737,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Invoke extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInInvoke() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/invoke"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/invoke"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -22884,7 +22884,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Errors extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInErrors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/invoke/errors"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/invoke/errors"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -22943,7 +22943,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class NestedCalls extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInNestedCalls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/nestedCalls"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/nestedCalls"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -23007,7 +23007,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class NoCandidates extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInNoCandidates() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/noCandidates"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/noCandidates"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -23035,7 +23035,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class OverloadConflicts extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInOverloadConflicts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/overloadConflicts"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/overloadConflicts"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -23171,7 +23171,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Priority extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInPriority() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/priority"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/priority"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -23253,7 +23253,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class SpecialConstructions extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInSpecialConstructions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/specialConstructions"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/specialConstructions"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -23300,7 +23300,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class SamConversions extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInSamConversions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/samConversions"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/samConversions"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -23418,7 +23418,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Scopes extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInScopes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/scopes"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/scopes"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -23655,7 +23655,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class ClassHeader extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInClassHeader() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/scopes/classHeader"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/scopes/classHeader"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -23743,7 +23743,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Inheritance extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInInheritance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/scopes/inheritance"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/scopes/inheritance"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -23836,7 +23836,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Statics extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInStatics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/scopes/inheritance/statics"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/scopes/inheritance/statics"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -23965,7 +23965,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInCompanionObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -24013,7 +24013,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class ProtectedVisibility extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInProtectedVisibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/scopes/protectedVisibility"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/scopes/protectedVisibility"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -24126,7 +24126,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInScript() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/script"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/script"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -24208,7 +24208,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Sealed extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInSealed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/sealed"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/sealed"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -24463,7 +24463,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Interfaces extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInInterfaces() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/sealed/interfaces"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/sealed/interfaces"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -24492,7 +24492,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class SecondaryConstructors extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInSecondaryConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/secondaryConstructors"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/secondaryConstructors"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -24789,7 +24789,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInHeaderCallChecker() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -24890,7 +24890,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class SenselessComparison extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInSenselessComparison() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/senselessComparison"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/senselessComparison"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -24912,7 +24912,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Shadowing extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInShadowing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/shadowing"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/shadowing"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -25000,7 +25000,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInSmartCasts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -25735,7 +25735,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Castchecks extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInCastchecks() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/castchecks"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/castchecks"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -25793,7 +25793,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Elvis extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInElvis() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/elvis"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/elvis"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -25821,7 +25821,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Inference extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInInference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/inference"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/inference"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -25927,7 +25927,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class IntersectionScope extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInIntersectionScope() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/intersectionScope"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/intersectionScope"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -26021,7 +26021,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Loops extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInLoops() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/loops"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/loops"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -26367,7 +26367,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class ObjectLiterals extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInObjectLiterals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/objectLiterals"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/objectLiterals"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -26425,7 +26425,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class PublicVals extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInPublicVals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/publicVals"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/publicVals"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -26489,7 +26489,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Safecalls extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInSafecalls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/safecalls"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/safecalls"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -26679,7 +26679,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInVariables() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/variables"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/variables"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -26833,7 +26833,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Varnotnull extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInVarnotnull() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/varnotnull"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/varnotnull"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -27156,7 +27156,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class SourceCompatibility extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInSourceCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/sourceCompatibility"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/sourceCompatibility"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -27219,7 +27219,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class ApiVersion extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInApiVersion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -27295,7 +27295,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class NoBoundCallableReferences extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInNoBoundCallableReferences() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/sourceCompatibility/noBoundCallableReferences"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/sourceCompatibility/noBoundCallableReferences"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -27330,7 +27330,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Substitutions extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInSubstitutions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/substitutions"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/substitutions"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -27370,7 +27370,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Subtyping extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInSubtyping() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/subtyping"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/subtyping"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -27482,7 +27482,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Suppress extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInSuppress() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/suppress"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/suppress"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Nested @@ -27491,7 +27491,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class AllWarnings extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInAllWarnings() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/suppress/allWarnings"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/suppress/allWarnings"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -27561,7 +27561,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class ManyWarnings extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInManyWarnings() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/suppress/manyWarnings"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/suppress/manyWarnings"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -27625,7 +27625,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class OneWarning extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInOneWarning() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/suppress/oneWarning"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/suppress/oneWarning"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -27708,7 +27708,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class SuspendConversion extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInSuspendConversion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/suspendConversion"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/suspendConversion"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -27796,7 +27796,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class SyntheticExtensions extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInSyntheticExtensions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/syntheticExtensions"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/syntheticExtensions"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Nested @@ -27811,7 +27811,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInJavaProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -27995,7 +27995,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class SamAdapters extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInSamAdapters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -28108,7 +28108,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class TargetedBuiltIns extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInTargetedBuiltIns() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/targetedBuiltIns"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/targetedBuiltIns"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -28153,7 +28153,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class BackwardCompatibility extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInBackwardCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/targetedBuiltIns/backwardCompatibility"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/targetedBuiltIns/backwardCompatibility"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -28206,7 +28206,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class TestWithModifiedMockJdk extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInTestWithModifiedMockJdk() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/testWithModifiedMockJdk"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/testWithModifiedMockJdk"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -28234,7 +28234,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class TestsWithExplicitApi extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInTestsWithExplicitApi() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/testsWithExplicitApi"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/testsWithExplicitApi"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -28304,7 +28304,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class ThisAndSuper extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInThisAndSuper() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/thisAndSuper"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/thisAndSuper"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -28409,7 +28409,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class UnqualifiedSuper extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInUnqualifiedSuper() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -28498,7 +28498,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class TraitWithRequired extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInTraitWithRequired() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/traitWithRequired"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/traitWithRequired"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -28520,7 +28520,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class TypeParameters extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInTypeParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/typeParameters"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/typeParameters"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -28614,7 +28614,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInTypealias() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/typealias"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/typealias"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -29212,7 +29212,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class UnderscoresInNumericLiterals extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInUnderscoresInNumericLiterals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/underscoresInNumericLiterals"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/underscoresInNumericLiterals"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -29234,7 +29234,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Unit extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInUnit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/unit"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/unit"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -29250,7 +29250,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class UnitConversion extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInUnitConversion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/unitConversion"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/unitConversion"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -29314,7 +29314,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class UnsignedTypes extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInUnsignedTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/unsignedTypes"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/unsignedTypes"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -29395,7 +29395,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Conversions extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInConversions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/unsignedTypes/conversions"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/unsignedTypes/conversions"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -29436,7 +29436,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class ValueClasses extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInValueClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/valueClasses"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/valueClasses"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -29584,7 +29584,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Varargs extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInVarargs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/varargs"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/varargs"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -29792,7 +29792,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Variance extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInVariance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/variance"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/variance"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -29879,7 +29879,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInPrivateToThis() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/variance/privateToThis"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/variance/privateToThis"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -29932,7 +29932,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInVisibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/visibility"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/visibility"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -29960,7 +29960,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class When extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInWhen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/when"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/when"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -30347,7 +30347,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class WithSubjectVariable extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInWithSubjectVariable() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/when/withSubjectVariable"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/when/withSubjectVariable"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -30461,7 +30461,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInTestsWithStdLib() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -30626,7 +30626,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Annotations extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -30725,7 +30725,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class AnnotationApplicability extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInAnnotationApplicability() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -30777,7 +30777,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class AnnotationParameterMustBeConstant extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInAnnotationParameterMustBeConstant() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -30811,7 +30811,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class AnnotationParameters extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInAnnotationParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -30869,7 +30869,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class AnnotationWithVarargParameter extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInAnnotationWithVarargParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -30891,7 +30891,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class JavaAnnotationsWithKClassParameter extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInJavaAnnotationsWithKClassParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -30973,7 +30973,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class JvmDefault extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInJvmDefault() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -31084,7 +31084,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class AllCompatibility extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInAllCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -31100,7 +31100,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class JvmDefaultWithoutCompatibility extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInJvmDefaultWithoutCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/jvmDefaultWithoutCompatibility"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/jvmDefaultWithoutCompatibility"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -31129,7 +31129,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class JvmField extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInJvmField() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmField"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmField"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -31169,7 +31169,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class JvmOverloads extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInJvmOverloads() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -31215,7 +31215,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class JvmPackageName extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInJvmPackageName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmPackageName"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmPackageName"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -31231,7 +31231,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class JvmSpecialFunctions extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInJvmSpecialFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmSpecialFunctions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmSpecialFunctions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -31247,7 +31247,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class JvmStatic extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInJvmStatic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -31353,7 +31353,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class KClass extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInKClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/kClass"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/kClass"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -31405,7 +31405,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class ProhibitPositionedArgument extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInProhibitPositionedArgument() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -31446,7 +31446,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Assert extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInAssert() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/assert"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/assert"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -31468,7 +31468,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Builtins extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInBuiltins() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/builtins"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/builtins"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -31484,7 +31484,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Cast extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInCast() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/cast"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/cast"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -31512,7 +31512,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Contracts extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInContracts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Nested @@ -31521,7 +31521,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Controlflow extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInControlflow() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Nested @@ -31530,7 +31530,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class FlowInlining extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInFlowInlining() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -31642,7 +31642,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Initialization extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInInitialization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Nested @@ -31651,7 +31651,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class AtLeastOnce extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInAtLeastOnce() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/atLeastOnce"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/atLeastOnce"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -31679,7 +31679,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class ExactlyOnce extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInExactlyOnce() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/exactlyOnce"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/exactlyOnce"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -31725,7 +31725,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Unknown extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInUnknown() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/unknown"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/unknown"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -31743,7 +31743,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Dsl extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInDsl() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -31782,7 +31782,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInErrors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -31895,7 +31895,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class FromStdlib extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInFromStdlib() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/fromStdlib"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/fromStdlib"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -31941,7 +31941,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class NewSyntax extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInNewSyntax() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/newSyntax"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/newSyntax"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -31975,7 +31975,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Smartcasts extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInSmartcasts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -32098,7 +32098,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Multieffect extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInMultieffect() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/multieffect"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/multieffect"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -32120,7 +32120,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class OperatorsTests extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInOperatorsTests() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/operatorsTests"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/operatorsTests"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -32184,7 +32184,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class When extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInWhen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/when"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/when"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -32220,7 +32220,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Coroutines extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInCoroutines() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -32553,7 +32553,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class CallableReference extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines/callableReference"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines/callableReference"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -32587,7 +32587,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Inference extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInInference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -32921,7 +32921,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class InlineCrossinline extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInInlineCrossinline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -33003,7 +33003,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Release extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInRelease() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines/release"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines/release"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -33031,7 +33031,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class RestrictSuspension extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInRestrictSuspension() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines/restrictSuspension"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines/restrictSuspension"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -33095,7 +33095,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class SuspendFunctionType extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInSuspendFunctionType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -33189,7 +33189,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class TailCalls extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInTailCalls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines/tailCalls"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines/tailCalls"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -33242,7 +33242,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Deprecated extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInDeprecated() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/deprecated"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/deprecated"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -33264,7 +33264,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class DuplicateJvmSignature extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInDuplicateJvmSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -33309,7 +33309,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Statics extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInStatics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -33344,7 +33344,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Experimental extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInExperimental() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/experimental"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/experimental"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -33510,7 +33510,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class FactoryPattern extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInFactoryPattern() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/factoryPattern"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/factoryPattern"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -33580,7 +33580,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class ForInArrayLoop extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInForInArrayLoop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/forInArrayLoop"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/forInArrayLoop"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -33620,7 +33620,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class FunctionLiterals extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInFunctionLiterals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/functionLiterals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/functionLiterals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -33636,7 +33636,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Inference extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInInference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -33777,7 +33777,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class AnnotationsForResolve extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInAnnotationsForResolve() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -33931,7 +33931,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Completion extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInCompletion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference/completion"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference/completion"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Nested @@ -33940,7 +33940,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class PostponedArgumentsAnalysis extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInPostponedArgumentsAnalysis() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -34021,7 +34021,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Performance extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInPerformance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/performance"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/performance"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -34069,7 +34069,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Delegates extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInDelegates() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference/delegates"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference/delegates"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -34097,7 +34097,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class NothingType extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInNothingType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference/nothingType"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference/nothingType"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -34119,7 +34119,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Performance extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInPerformance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference/performance"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference/performance"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -34148,7 +34148,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Inline extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inline"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inline"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -34170,7 +34170,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Java extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/java"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/java"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -34210,7 +34210,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Kt7585 extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInKt7585() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/kt7585"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/kt7585"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -34226,7 +34226,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Lateinit extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInLateinit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/lateinit"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/lateinit"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -34242,7 +34242,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Multiplatform extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInMultiplatform() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/multiplatform"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/multiplatform"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -34264,7 +34264,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInNative() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/native"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/native"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -34322,7 +34322,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class PurelyImplementedCollection extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInPurelyImplementedCollection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -34392,7 +34392,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Reflection extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInReflection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/reflection"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/reflection"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -34408,7 +34408,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Regression extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInRegression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/regression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/regression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -34508,7 +34508,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Reified extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInReified() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/reified"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/reified"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -34548,7 +34548,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Resolve extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInResolve() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/resolve"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/resolve"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -34636,7 +34636,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Smartcasts extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInSmartcasts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/smartcasts"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/smartcasts"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -34724,7 +34724,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class SourceCompatibility extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInSourceCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/sourceCompatibility"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/sourceCompatibility"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -34740,7 +34740,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class TargetedBuiltIns extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInTargetedBuiltIns() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/targetedBuiltIns"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/targetedBuiltIns"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -34762,7 +34762,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class TrailingComma extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInTrailingComma() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/trailingComma"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/trailingComma"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -34850,7 +34850,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class TryCatch extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInTryCatch() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/tryCatch"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/tryCatch"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -34920,7 +34920,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Typealias extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInTypealias() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/typealias"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/typealias"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -34966,7 +34966,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class Varargs extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInVarargs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/varargs"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/varargs"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -34994,7 +34994,7 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { public class When extends AbstractDiagnosticTest { @Test public void testAllFilesPresentInWhen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/when"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/when"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticUsingJavacTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticUsingJavacTestGenerated.java index dad8d6856ae..70b8d92d33d 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticUsingJavacTestGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticUsingJavacTestGenerated.java @@ -6,7 +6,7 @@ package org.jetbrains.kotlin.test.runners; import com.intellij.testFramework.TestDataPath; -import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; @@ -21,7 +21,7 @@ import java.util.regex.Pattern; public class DiagnosticUsingJavacTestGenerated extends AbstractDiagnosticUsingJavacTest { @Test public void testAllFilesPresentInJavac() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -36,7 +36,7 @@ public class DiagnosticUsingJavacTestGenerated extends AbstractDiagnosticUsingJa public class FieldsResolution extends AbstractDiagnosticUsingJavacTest { @Test public void testAllFilesPresentInFieldsResolution() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/fieldsResolution"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/fieldsResolution"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -118,7 +118,7 @@ public class DiagnosticUsingJavacTestGenerated extends AbstractDiagnosticUsingJa public class Imports extends AbstractDiagnosticUsingJavacTest { @Test public void testAllFilesPresentInImports() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/imports"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/imports"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -230,7 +230,7 @@ public class DiagnosticUsingJavacTestGenerated extends AbstractDiagnosticUsingJa public class Inheritance extends AbstractDiagnosticUsingJavacTest { @Test public void testAllFilesPresentInInheritance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/inheritance"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/inheritance"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -342,7 +342,7 @@ public class DiagnosticUsingJavacTestGenerated extends AbstractDiagnosticUsingJa public class Inners extends AbstractDiagnosticUsingJavacTest { @Test public void testAllFilesPresentInInners() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/inners"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/inners"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -394,7 +394,7 @@ public class DiagnosticUsingJavacTestGenerated extends AbstractDiagnosticUsingJa public class QualifiedExpression extends AbstractDiagnosticUsingJavacTest { @Test public void testAllFilesPresentInQualifiedExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/qualifiedExpression"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/qualifiedExpression"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -434,7 +434,7 @@ public class DiagnosticUsingJavacTestGenerated extends AbstractDiagnosticUsingJa public class TypeParameters extends AbstractDiagnosticUsingJavacTest { @Test public void testAllFilesPresentInTypeParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/typeParameters"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/typeParameters"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/FirDiagnosticTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/FirDiagnosticTestGenerated.java index 8de98beff0a..bc9296a4f9d 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/FirDiagnosticTestGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/FirDiagnosticTestGenerated.java @@ -6,7 +6,7 @@ package org.jetbrains.kotlin.test.runners; import com.intellij.testFramework.TestDataPath; -import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; @@ -23,7 +23,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class Resolve extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInResolve() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -566,7 +566,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class Arguments extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/arguments"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/arguments"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -750,7 +750,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class Arrays extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInArrays() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/arrays"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/arrays"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -772,7 +772,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class Builtins extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInBuiltins() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/builtins"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/builtins"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -788,7 +788,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class CallResolution extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInCallResolution() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/callResolution"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/callResolution"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -888,7 +888,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class Cfg extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInCfg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/cfg"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/cfg"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -1048,7 +1048,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class Constructors extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/constructors"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/constructors"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -1064,7 +1064,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class Delegates extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInDelegates() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/delegates"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/delegates"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -1122,7 +1122,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInDiagnostics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/diagnostics"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/diagnostics"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -1426,7 +1426,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInExpresssions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/expresssions"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/expresssions"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -1795,7 +1795,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class Inference extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInInference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/expresssions/inference"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/expresssions/inference"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -1823,7 +1823,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class Invoke extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInInvoke() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/expresssions/invoke"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/expresssions/invoke"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -1923,7 +1923,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class Operators extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInOperators() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/expresssions/operators"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/expresssions/operators"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -1952,7 +1952,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class FromBuilder extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInFromBuilder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/fromBuilder"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/fromBuilder"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -1992,7 +1992,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class Inference extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInInference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/inference"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/inference"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -2116,7 +2116,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class InnerClasses extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInInnerClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/innerClasses"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/innerClasses"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -2150,7 +2150,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class LocalClasses extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInLocalClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/localClasses"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/localClasses"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -2178,7 +2178,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class Multifile extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInMultifile() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/multifile"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/multifile"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -2254,7 +2254,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class Overrides extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInOverrides() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/overrides"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/overrides"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -2312,7 +2312,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class Problems extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInProblems() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/problems"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/problems"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -2412,7 +2412,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class Properties extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/properties"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/properties"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -2458,7 +2458,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class References extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInReferences() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/references"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/references"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -2492,7 +2492,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class SamConstructors extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInSamConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/samConstructors"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/samConstructors"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -2538,7 +2538,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class SamConversions extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInSamConversions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/samConversions"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/samConversions"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -2602,7 +2602,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class Smartcasts extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInSmartcasts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -2677,7 +2677,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class Booleans extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInBooleans() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -2705,7 +2705,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class BoundSmartcasts extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInBoundSmartcasts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/boundSmartcasts"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/boundSmartcasts"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -2733,7 +2733,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class ControlStructures extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInControlStructures() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -2773,7 +2773,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class Lambdas extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInLambdas() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/lambdas"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/lambdas"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -2801,7 +2801,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class Loops extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInLoops() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/loops"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/loops"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -2823,7 +2823,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class Problems extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInProblems() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/problems"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/problems"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -2839,7 +2839,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class Receivers extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInReceivers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/receivers"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/receivers"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -2873,7 +2873,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class SafeCalls extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInSafeCalls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -2907,7 +2907,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class Stability extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInStability() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/stability"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/stability"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -2923,7 +2923,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class Variables extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInVariables() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/variables"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/variables"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -2946,7 +2946,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class Stdlib extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInStdlib() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/stdlib"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/stdlib"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Nested @@ -2955,7 +2955,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class J_k extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInJ_k() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/stdlib/j+k"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/stdlib/j+k"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -2978,7 +2978,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class Types extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/types"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/types"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -3000,7 +3000,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class Visibility extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInVisibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/visibility"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/visibility"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -3083,7 +3083,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInResolveWithStdlib() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -3416,7 +3416,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class CallableReferences extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInCallableReferences() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -3563,7 +3563,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class FromBasicDiagnosticTests extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInFromBasicDiagnosticTests() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/fromBasicDiagnosticTests"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/callableReferences/fromBasicDiagnosticTests"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -3652,7 +3652,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class Contracts extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInContracts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Nested @@ -3661,7 +3661,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class FromLibrary extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInFromLibrary() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromLibrary"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromLibrary"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -3689,7 +3689,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class FromSource extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInFromSource() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Nested @@ -3698,7 +3698,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class Bad extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInBad() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/bad"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/bad"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Nested @@ -3707,7 +3707,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class CallsInPlace extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInCallsInPlace() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/bad/callsInPlace"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/bad/callsInPlace"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -3741,7 +3741,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class ReturnsImplies extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInReturnsImplies() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/bad/returnsImplies"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/bad/returnsImplies"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -3764,7 +3764,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class Good extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInGood() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Nested @@ -3773,7 +3773,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class CallsInPlace extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInCallsInPlace() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/callsInPlace"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/callsInPlace"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -3831,7 +3831,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class ReturnsImplies extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInReturnsImplies() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/returnsImplies"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/returnsImplies"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -3907,7 +3907,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class VariousContracts extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInVariousContracts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/variousContracts"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/variousContracts"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Nested @@ -3916,7 +3916,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class NewSyntax extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInNewSyntax() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/variousContracts/newSyntax"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/contracts/fromSource/good/variousContracts/newSyntax"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -3936,7 +3936,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class Delegates extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInDelegates() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/delegates"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/delegates"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -3982,7 +3982,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class Inference extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInInference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/inference"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/inference"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -4034,7 +4034,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class Initialization extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInInitialization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/initialization"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/initialization"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -4050,7 +4050,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class J_k extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInJ_k() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -4342,7 +4342,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class MultiModule extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInMultiModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/multiModule"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/multiModule"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -4382,7 +4382,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class Problems extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInProblems() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/problems"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/problems"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -4446,7 +4446,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class Reinitializations extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInReinitializations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/reinitializations"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/reinitializations"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test @@ -4462,7 +4462,7 @@ public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { public class Smartcasts extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInSmartcasts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/smartcasts"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolveWithStdlib/smartcasts"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @Test diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java index 5fea12c2faf..6838d378e17 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java @@ -6,7 +6,7 @@ package org.jetbrains.kotlin.test.runners; import com.intellij.testFramework.TestDataPath; -import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; @@ -53,7 +53,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti @Test public void testAllFilesPresentInTests() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -908,7 +908,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Annotations extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -1373,7 +1373,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class AnnotationParameterMustBeConstant extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInAnnotationParameterMustBeConstant() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -1437,7 +1437,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class FunctionalTypes extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInFunctionalTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations/functionalTypes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations/functionalTypes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -1465,7 +1465,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Options extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInOptions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations/options"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations/options"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -1588,7 +1588,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti @Test public void testAllFilesPresentInTargets() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations/options/targets"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations/options/targets"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -1725,7 +1725,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Rendering extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInRendering() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations/rendering"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations/rendering"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -1801,7 +1801,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class WithUseSiteTarget extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInWithUseSiteTarget() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/annotations/withUseSiteTarget"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -1956,7 +1956,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class BackingField extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInBackingField() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/backingField"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/backingField"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -2086,7 +2086,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class CallableReference extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -2377,7 +2377,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Bound extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInBound() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -2507,7 +2507,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti @Test public void testAllFilesPresentInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference/function"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference/function"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -2817,7 +2817,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Generic extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInGeneric() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference/generic"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference/generic"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -2941,7 +2941,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti @Test public void testAllFilesPresentInProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference/property"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference/property"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -3047,7 +3047,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti @Test public void testAllFilesPresentInResolve() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference/resolve"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference/resolve"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -3345,7 +3345,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Unsupported extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInUnsupported() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference/unsupported"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/callableReference/unsupported"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -3386,7 +3386,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Cast extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInCast() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/cast"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/cast"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -3761,7 +3761,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Bare extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInBare() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/cast/bare"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/cast/bare"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -3885,7 +3885,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class NeverSucceeds extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInNeverSucceeds() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/cast/neverSucceeds"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/cast/neverSucceeds"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -3926,7 +3926,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class CheckArguments extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInCheckArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/checkArguments"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/checkArguments"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -3996,7 +3996,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class ClassLiteral extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInClassLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/classLiteral"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/classLiteral"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -4096,7 +4096,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class ClassObjects extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInClassObjects() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/classObjects"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/classObjects"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -4232,7 +4232,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class CollectionLiterals extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInCollectionLiterals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/collectionLiterals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/collectionLiterals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -4320,7 +4320,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti @Test public void testAllFilesPresentInConstructorConsistency() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/constructorConsistency"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/constructorConsistency"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -4474,7 +4474,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class ControlFlowAnalysis extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInControlFlowAnalysis() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/controlFlowAnalysis"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/controlFlowAnalysis"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -4999,7 +4999,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class DeadCode extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInDeadCode() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -5159,7 +5159,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class DefiniteReturn extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInDefiniteReturn() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/controlFlowAnalysis/definiteReturn"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/controlFlowAnalysis/definiteReturn"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -5193,7 +5193,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class UnnecessaryLateinit extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInUnnecessaryLateinit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/controlFlowAnalysis/unnecessaryLateinit"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -5276,7 +5276,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class ControlStructures extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInControlStructures() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/controlStructures"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/controlStructures"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -5550,7 +5550,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Coroutines extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInCoroutines() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/coroutines"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/coroutines"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -5571,7 +5571,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class CallableReference extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/coroutines/callableReference"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/coroutines/callableReference"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -5594,7 +5594,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class CyclicHierarchy extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInCyclicHierarchy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/cyclicHierarchy"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/cyclicHierarchy"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -5693,7 +5693,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class WithCompanion extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInWithCompanion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/cyclicHierarchy/withCompanion"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -5776,7 +5776,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class DataClasses extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInDataClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/dataClasses"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/dataClasses"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -5978,7 +5978,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class DataFlow extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInDataFlow() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/dataFlow"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/dataFlow"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -6011,7 +6011,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Assignment extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInAssignment() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/dataFlow/assignment"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/dataFlow/assignment"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -6051,7 +6051,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Local extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInLocal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/dataFlow/local"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/dataFlow/local"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -6134,7 +6134,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class DataFlowInfoTraversal extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInDataFlowInfoTraversal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/dataFlowInfoTraversal"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/dataFlowInfoTraversal"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -6455,7 +6455,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Smartcasts extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInSmartcasts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/smartcasts"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/dataFlowInfoTraversal/smartcasts"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -6478,7 +6478,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class DeclarationChecks extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInDeclarationChecks() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/declarationChecks"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/declarationChecks"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -6697,7 +6697,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class DestructuringDeclarations extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInDestructuringDeclarations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -6791,7 +6791,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class FiniteBoundRestriction extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInFiniteBoundRestriction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/declarationChecks/finiteBoundRestriction"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/declarationChecks/finiteBoundRestriction"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -6819,7 +6819,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class NonExpansiveInheritanceRestriction extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInNonExpansiveInheritanceRestriction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/declarationChecks/nonExpansiveInheritanceRestriction"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/declarationChecks/nonExpansiveInheritanceRestriction"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -6848,7 +6848,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class DefaultArguments extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInDefaultArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -6888,7 +6888,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti @Test public void testAllFilesPresentInDelegatedProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/delegatedProperty"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/delegatedProperty"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -7107,7 +7107,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Inference extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInInference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/delegatedProperty/inference"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/delegatedProperty/inference"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -7219,7 +7219,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class ProvideDelegate extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInProvideDelegate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -7332,7 +7332,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Delegation extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInDelegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/delegation"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/delegation"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -7395,7 +7395,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Clashes extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInClashes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/delegation/clashes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/delegation/clashes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -7429,7 +7429,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class CovariantOverrides extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInCovariantOverrides() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/delegation/covariantOverrides"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/delegation/covariantOverrides"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -7469,7 +7469,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti @Test public void testAllFilesPresentInMemberHidesSupertypeOverride() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/delegation/memberHidesSupertypeOverride"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -7564,7 +7564,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Deparenthesize extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInDeparenthesize() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/deparenthesize"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/deparenthesize"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -7610,7 +7610,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Deprecated extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInDeprecated() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/deprecated"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/deprecated"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -7817,7 +7817,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class DeprecatedSinceKotlin extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInDeprecatedSinceKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/deprecated/deprecatedSinceKotlin"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -7882,7 +7882,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class DuplicateJvmSignature extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInDuplicateJvmSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -7915,7 +7915,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti @Test public void testAllFilesPresentInAccidentalOverrides() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/accidentalOverrides"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -8009,7 +8009,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Bridges extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInBridges() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/bridges"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/bridges"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -8037,7 +8037,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Erasure extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInErasure() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/erasure"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -8149,7 +8149,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class FinalMembersFromBuiltIns extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInFinalMembersFromBuiltIns() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/finalMembersFromBuiltIns"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/finalMembersFromBuiltIns"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -8171,7 +8171,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class FunctionAndProperty extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInFunctionAndProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/functionAndProperty"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -8295,7 +8295,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class SpecialNames extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInSpecialNames() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -8359,7 +8359,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Statics extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInStatics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/statics"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/statics"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -8405,7 +8405,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Synthesized extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInSynthesized() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/synthesized"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/synthesized"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -8421,7 +8421,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class TraitImpl extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInTraitImpl() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/traitImpl"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/duplicateJvmSignature/traitImpl"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -8456,7 +8456,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class DynamicTypes extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInDynamicTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/dynamicTypes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/dynamicTypes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -8502,7 +8502,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti @Test public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/enum"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/enum"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -8853,7 +8853,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Inner extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInInner() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/enum/inner"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/enum/inner"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -8936,7 +8936,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Evaluate extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInEvaluate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/evaluate"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/evaluate"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -9083,7 +9083,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class InlineClasses extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/evaluate/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/evaluate/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -9100,7 +9100,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Exposed extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInExposed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/exposed"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/exposed"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -9278,7 +9278,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Extensions extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInExtensions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/extensions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/extensions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -9390,7 +9390,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class FunInterface extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInFunInterface() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/funInterface"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/funInterface"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -9484,7 +9484,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class FunctionAsExpression extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInFunctionAsExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/functionAsExpression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/functionAsExpression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -9596,7 +9596,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class FunctionLiterals extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInFunctionLiterals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/functionLiterals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/functionLiterals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -9785,7 +9785,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class DestructuringInLambdas extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInDestructuringInLambdas() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -9861,7 +9861,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Return extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInReturn() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/functionLiterals/return"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/functionLiterals/return"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -10034,7 +10034,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Generics extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInGenerics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -10247,7 +10247,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class CapturedParameters extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInCapturedParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/capturedParameters"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/capturedParameters"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -10293,7 +10293,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class CyclicBounds extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInCyclicBounds() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/cyclicBounds"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/cyclicBounds"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -10315,7 +10315,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class InnerClasses extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInInnerClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/innerClasses"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/innerClasses"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -10468,7 +10468,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class ImplicitArguments extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInImplicitArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -10533,7 +10533,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class MultipleBoundsMemberScope extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInMultipleBoundsMemberScope() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/multipleBoundsMemberScope"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/multipleBoundsMemberScope"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -10585,7 +10585,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Nullability extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInNullability() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/nullability"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/nullability"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -10715,7 +10715,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti @Test public void testAllFilesPresentInProjectionsScope() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/projectionsScope"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/projectionsScope"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -10893,7 +10893,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class StarProjections extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInStarProjections() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/starProjections"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/starProjections"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -10939,7 +10939,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class TpAsReified extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInTpAsReified() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/tpAsReified"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/tpAsReified"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -11033,7 +11033,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class VarProjection extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInVarProjection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/varProjection"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/generics/varProjection"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -11068,7 +11068,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Imports extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInImports() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/imports"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/imports"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -11414,7 +11414,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class IncompleteCode extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInIncompleteCode() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/incompleteCode"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/incompleteCode"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -11543,7 +11543,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class DiagnosticWithSyntaxError extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInDiagnosticWithSyntaxError() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -11662,7 +11662,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Inference extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInInference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -12235,7 +12235,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class CapturedTypes extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInCapturedTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/capturedTypes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/capturedTypes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -12437,7 +12437,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class CoercionToUnit extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInCoercionToUnit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/coercionToUnit"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/coercionToUnit"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -12531,7 +12531,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class CommonSystem extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInCommonSystem() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/commonSystem"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/commonSystem"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -12703,7 +12703,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Completion extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInCompletion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/completion"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/completion"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -12802,7 +12802,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class PostponedArgumentsAnalysis extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInPostponedArgumentsAnalysis() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/completion/postponedArgumentsAnalysis"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/completion/postponedArgumentsAnalysis"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -12873,7 +12873,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Constraints extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInConstraints() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/constraints"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/constraints"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -13045,7 +13045,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class NestedCalls extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInNestedCalls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/nestedCalls"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/nestedCalls"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -13139,7 +13139,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class NothingType extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInNothingType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/nothingType"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/nothingType"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -13293,7 +13293,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class PublicApproximation extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInPublicApproximation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/publicApproximation"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/publicApproximation"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -13381,7 +13381,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class RecursiveCalls extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInRecursiveCalls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/recursiveCalls"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/recursiveCalls"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -13397,7 +13397,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class RecursiveLocalFuns extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInRecursiveLocalFuns() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/recursiveLocalFuns"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/recursiveLocalFuns"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -13431,7 +13431,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class RecursiveTypes extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInRecursiveTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/recursiveTypes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/recursiveTypes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -13513,7 +13513,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Regressions extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInRegressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/regressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/regressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -13949,7 +13949,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class ReportingImprovements extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInReportingImprovements() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/reportingImprovements"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/reportingImprovements"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -14031,7 +14031,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Substitutions extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInSubstitutions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/substitutions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/substitutions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -14083,7 +14083,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class UpperBounds extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInUpperBounds() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/upperBounds"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inference/upperBounds"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -14160,7 +14160,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Infos extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInInfos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/infos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/infos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -14182,7 +14182,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Inline extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inline"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inline"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -14455,7 +14455,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class BinaryExpressions extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInBinaryExpressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inline/binaryExpressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inline/binaryExpressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -14513,7 +14513,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class NonLocalReturns extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInNonLocalReturns() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inline/nonLocalReturns"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inline/nonLocalReturns"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -14631,7 +14631,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class NonPublicMember extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInNonPublicMember() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inline/nonPublicMember"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inline/nonPublicMember"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -14695,7 +14695,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Property extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inline/property"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inline/property"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -14729,7 +14729,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Regressions extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInRegressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inline/regressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inline/regressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -14745,7 +14745,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class UnaryExpressions extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInUnaryExpressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inline/unaryExpressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inline/unaryExpressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -14774,7 +14774,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class InlineClasses extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -14946,7 +14946,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti @Test public void testAllFilesPresentInInner() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inner"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inner"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -15219,7 +15219,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class QualifiedExpression extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInQualifiedExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inner/qualifiedExpression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/inner/qualifiedExpression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -15296,7 +15296,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti @Test public void testAllFilesPresentInJ_k() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -15767,7 +15767,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class BrokenCode extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInBrokenCode() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/brokenCode"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/brokenCode"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -15789,7 +15789,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class CollectionOverrides extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInCollectionOverrides() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/collectionOverrides"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/collectionOverrides"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -15907,7 +15907,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Deprecations extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInDeprecations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/deprecations"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/deprecations"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -15935,7 +15935,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class GenericConstructor extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInGenericConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/genericConstructor"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/genericConstructor"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -15999,7 +15999,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class PolymorphicSignature extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInPolymorphicSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/polymorphicSignature"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/polymorphicSignature"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -16021,7 +16021,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class PrimitiveOverrides extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInPrimitiveOverrides() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/primitiveOverrides"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/primitiveOverrides"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -16049,7 +16049,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class PrimitiveOverridesWithInlineClass extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInPrimitiveOverridesWithInlineClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/primitiveOverridesWithInlineClass"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/primitiveOverridesWithInlineClass"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -16065,7 +16065,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Properties extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/properties"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/properties"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -16123,7 +16123,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Sam extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInSam() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/sam"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/sam"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -16229,7 +16229,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class SamByProjectedType extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInSamByProjectedType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/samByProjectedType"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/samByProjectedType"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -16269,7 +16269,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class SignatureAnnotations extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInSignatureAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/signatureAnnotations"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/signatureAnnotations"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -16369,7 +16369,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class SpecialBuiltIns extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInSpecialBuiltIns() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/specialBuiltIns"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/specialBuiltIns"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -16391,7 +16391,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Types extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/types"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/j+k/types"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -16456,7 +16456,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti @Test public void testAllFilesPresentInJava8Overrides() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/java8Overrides"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/java8Overrides"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -16508,7 +16508,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Javac extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInJavac() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -16523,7 +16523,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class FieldsResolution extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInFieldsResolution() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/fieldsResolution"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/fieldsResolution"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -16605,7 +16605,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Imports extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInImports() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/imports"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/imports"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -16717,7 +16717,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Inheritance extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInInheritance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/inheritance"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/inheritance"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -16829,7 +16829,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Inners extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInInners() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/inners"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/inners"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -16881,7 +16881,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class QualifiedExpression extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInQualifiedExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/qualifiedExpression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/qualifiedExpression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -16921,7 +16921,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class TypeParameters extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInTypeParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/typeParameters"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/javac/typeParameters"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -16974,7 +16974,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Labels extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInLabels() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/labels"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/labels"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -17056,7 +17056,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Lateinit extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInLateinit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/lateinit"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/lateinit"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -17083,7 +17083,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Local extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInLocal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/lateinit/local"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/lateinit/local"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -17112,7 +17112,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Library extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInLibrary() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/library"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/library"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -17134,7 +17134,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class LocalClasses extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInLocalClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/localClasses"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/localClasses"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -17156,7 +17156,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Modifiers extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInModifiers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/modifiers"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/modifiers"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -17261,7 +17261,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Const extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInConst() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/modifiers/const"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/modifiers/const"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -17325,7 +17325,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class OperatorInfix extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInOperatorInfix() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/modifiers/operatorInfix"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/modifiers/operatorInfix"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -17354,7 +17354,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Multimodule extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInMultimodule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multimodule"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multimodule"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -17399,7 +17399,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class DuplicateClass extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInDuplicateClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multimodule/duplicateClass"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multimodule/duplicateClass"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -17487,7 +17487,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class DuplicateMethod extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInDuplicateMethod() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multimodule/duplicateMethod"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multimodule/duplicateMethod"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -17647,7 +17647,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class DuplicateSuper extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInDuplicateSuper() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multimodule/duplicateSuper"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multimodule/duplicateSuper"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -17681,7 +17681,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class HiddenClass extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInHiddenClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multimodule/hiddenClass"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multimodule/hiddenClass"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -17716,7 +17716,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Multiplatform extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInMultiplatform() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -17791,7 +17791,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class DefaultArguments extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInDefaultArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -17849,7 +17849,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Deprecated extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInDeprecated() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/deprecated"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/deprecated"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -17871,7 +17871,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti @Test public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/enum"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/enum"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -17911,7 +17911,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Generic extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInGeneric() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/generic"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/generic"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -17963,7 +17963,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti @Test public void testAllFilesPresentInHeaderClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/headerClass"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/headerClass"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -18153,7 +18153,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class InlineClasses extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -18169,7 +18169,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Java extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/java"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/java"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -18191,7 +18191,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class TopLevelFun extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInTopLevelFun() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/topLevelFun"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/topLevelFun"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -18279,7 +18279,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class TopLevelProperty extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInTopLevelProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/topLevelProperty"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/multiplatform/topLevelProperty"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -18302,7 +18302,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class NamedArguments extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInNamedArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/namedArguments"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/namedArguments"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -18389,7 +18389,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class MixedNamedPosition extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInMixedNamedPosition() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/namedArguments/mixedNamedPosition"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/namedArguments/mixedNamedPosition"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -18436,7 +18436,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class NullabilityAndSmartCasts extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInNullabilityAndSmartCasts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/nullabilityAndSmartCasts"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -18674,7 +18674,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class NullableTypes extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInNullableTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/nullableTypes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/nullableTypes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -18780,7 +18780,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Numbers extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInNumbers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/numbers"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/numbers"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -18820,7 +18820,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Objects extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInObjects() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/objects"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/objects"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -18913,7 +18913,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Kt21515 extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInKt21515() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/objects/kt21515"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/objects/kt21515"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -19074,7 +19074,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class OperatorRem extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInOperatorRem() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/operatorRem"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/operatorRem"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -19210,7 +19210,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class OperatorsOverloading extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInOperatorsOverloading() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/operatorsOverloading"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/operatorsOverloading"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -19304,7 +19304,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Overload extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInOverload() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/overload"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/overload"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -19512,7 +19512,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti @Test public void testAllFilesPresentInOverride() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/override"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/override"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -19815,7 +19815,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class ClashesOnInheritance extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInClashesOnInheritance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/override/clashesOnInheritance"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/override/clashesOnInheritance"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -19897,7 +19897,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class ParameterNames extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInParameterNames() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/override/parameterNames"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/override/parameterNames"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -19955,7 +19955,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class TypeParameters extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInTypeParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/override/typeParameters"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/override/typeParameters"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -19990,7 +19990,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class ParenthesizedTypes extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInParenthesizedTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/parenthesizedTypes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/parenthesizedTypes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -20018,7 +20018,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class PlatformTypes extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInPlatformTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -20129,7 +20129,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class CommonSupertype extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInCommonSupertype() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/commonSupertype"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/commonSupertype"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -20187,7 +20187,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class GenericVarianceViolation extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInGenericVarianceViolation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/genericVarianceViolation"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/genericVarianceViolation"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -20245,7 +20245,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class MethodCall extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInMethodCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/methodCall"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/methodCall"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -20375,7 +20375,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class NotNullTypeParameter extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInNotNullTypeParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/notNullTypeParameter"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/notNullTypeParameter"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -20427,7 +20427,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class NullabilityWarnings extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInNullabilityWarnings() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -20623,7 +20623,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class RawTypes extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInRawTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/rawTypes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/rawTypes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -20735,7 +20735,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class TypeEnhancement extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInTypeEnhancement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/typeEnhancement"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/platformTypes/typeEnhancement"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -20770,7 +20770,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class PrivateInFile extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInPrivateInFile() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/privateInFile"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/privateInFile"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -20798,7 +20798,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Properties extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/properties"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/properties"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -20819,7 +20819,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class InferenceFromGetters extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInInferenceFromGetters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/properties/inferenceFromGetters"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/properties/inferenceFromGetters"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -20902,7 +20902,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class QualifiedExpression extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInQualifiedExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/qualifiedExpression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/qualifiedExpression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -20972,7 +20972,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti @Test public void testAllFilesPresentInReassignment() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/reassignment"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/reassignment"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -21036,7 +21036,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti @Test public void testAllFilesPresentInRecovery() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/recovery"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/recovery"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -21070,7 +21070,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Redeclarations extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInRedeclarations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/redeclarations"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/redeclarations"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -21277,7 +21277,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class ShadowedExtension extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInShadowedExtension() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/redeclarations/shadowedExtension"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -21372,7 +21372,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Regressions extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInRegressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/regressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/regressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -22329,7 +22329,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Kt7585 extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInKt7585() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/regressions/kt7585"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/regressions/kt7585"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -22358,7 +22358,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Resolve extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInResolve() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -22559,7 +22559,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class DslMarker extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInDslMarker() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/dslMarker"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/dslMarker"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -22725,7 +22725,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Invoke extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInInvoke() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/invoke"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/invoke"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -22872,7 +22872,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Errors extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInErrors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/invoke/errors"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/invoke/errors"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -22931,7 +22931,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class NestedCalls extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInNestedCalls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/nestedCalls"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/nestedCalls"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -22995,7 +22995,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class NoCandidates extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInNoCandidates() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/noCandidates"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/noCandidates"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -23023,7 +23023,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class OverloadConflicts extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInOverloadConflicts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/overloadConflicts"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/overloadConflicts"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -23159,7 +23159,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Priority extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInPriority() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/priority"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/priority"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -23241,7 +23241,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class SpecialConstructions extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInSpecialConstructions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/specialConstructions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/specialConstructions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -23288,7 +23288,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class SamConversions extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInSamConversions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/samConversions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/samConversions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -23406,7 +23406,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Scopes extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInScopes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/scopes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/scopes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -23643,7 +23643,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class ClassHeader extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInClassHeader() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/scopes/classHeader"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/scopes/classHeader"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -23731,7 +23731,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Inheritance extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInInheritance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/scopes/inheritance"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/scopes/inheritance"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -23824,7 +23824,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Statics extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInStatics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/scopes/inheritance/statics"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/scopes/inheritance/statics"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -23953,7 +23953,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti @Test public void testAllFilesPresentInCompanionObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/scopes/inheritance/statics/companionObject"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -24001,7 +24001,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class ProtectedVisibility extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInProtectedVisibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/scopes/protectedVisibility"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/scopes/protectedVisibility"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -24108,7 +24108,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Script extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInScript() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/script"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/script"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -24118,7 +24118,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Sealed extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInSealed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/sealed"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/sealed"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -24373,7 +24373,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Interfaces extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInInterfaces() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/sealed/interfaces"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/sealed/interfaces"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -24402,7 +24402,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class SecondaryConstructors extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInSecondaryConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/secondaryConstructors"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/secondaryConstructors"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -24699,7 +24699,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti @Test public void testAllFilesPresentInHeaderCallChecker() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -24800,7 +24800,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class SenselessComparison extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInSenselessComparison() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/senselessComparison"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/senselessComparison"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -24822,7 +24822,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Shadowing extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInShadowing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/shadowing"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/shadowing"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -24910,7 +24910,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti @Test public void testAllFilesPresentInSmartCasts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -25645,7 +25645,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Castchecks extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInCastchecks() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/castchecks"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/castchecks"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -25703,7 +25703,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Elvis extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInElvis() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/elvis"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/elvis"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -25731,7 +25731,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Inference extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInInference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/inference"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/inference"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -25837,7 +25837,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class IntersectionScope extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInIntersectionScope() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/intersectionScope"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/intersectionScope"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -25931,7 +25931,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Loops extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInLoops() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/loops"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/loops"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -26277,7 +26277,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class ObjectLiterals extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInObjectLiterals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/objectLiterals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/objectLiterals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -26335,7 +26335,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class PublicVals extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInPublicVals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/publicVals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/publicVals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -26399,7 +26399,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Safecalls extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInSafecalls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/safecalls"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/safecalls"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -26589,7 +26589,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti @Test public void testAllFilesPresentInVariables() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/variables"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/variables"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -26743,7 +26743,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Varnotnull extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInVarnotnull() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/varnotnull"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/smartCasts/varnotnull"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -27066,7 +27066,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class SourceCompatibility extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInSourceCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/sourceCompatibility"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/sourceCompatibility"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -27123,7 +27123,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class ApiVersion extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInApiVersion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/sourceCompatibility/apiVersion"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -27199,7 +27199,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class NoBoundCallableReferences extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInNoBoundCallableReferences() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/sourceCompatibility/noBoundCallableReferences"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/sourceCompatibility/noBoundCallableReferences"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -27234,7 +27234,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Substitutions extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInSubstitutions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/substitutions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/substitutions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -27274,7 +27274,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Subtyping extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInSubtyping() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/subtyping"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/subtyping"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -27386,7 +27386,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Suppress extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInSuppress() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/suppress"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/suppress"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Nested @@ -27395,7 +27395,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class AllWarnings extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInAllWarnings() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/suppress/allWarnings"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/suppress/allWarnings"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -27465,7 +27465,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class ManyWarnings extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInManyWarnings() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/suppress/manyWarnings"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/suppress/manyWarnings"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -27529,7 +27529,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class OneWarning extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInOneWarning() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/suppress/oneWarning"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/suppress/oneWarning"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -27612,7 +27612,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class SuspendConversion extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInSuspendConversion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/suspendConversion"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/suspendConversion"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -27700,7 +27700,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class SyntheticExtensions extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInSyntheticExtensions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/syntheticExtensions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/syntheticExtensions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Nested @@ -27715,7 +27715,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti @Test public void testAllFilesPresentInJavaProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -27899,7 +27899,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class SamAdapters extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInSamAdapters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -28012,7 +28012,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class TargetedBuiltIns extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInTargetedBuiltIns() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/targetedBuiltIns"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/targetedBuiltIns"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -28057,7 +28057,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class BackwardCompatibility extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInBackwardCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/targetedBuiltIns/backwardCompatibility"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/targetedBuiltIns/backwardCompatibility"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -28110,7 +28110,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class TestWithModifiedMockJdk extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInTestWithModifiedMockJdk() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/testWithModifiedMockJdk"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/testWithModifiedMockJdk"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -28138,7 +28138,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class TestsWithExplicitApi extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInTestsWithExplicitApi() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/testsWithExplicitApi"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/testsWithExplicitApi"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -28208,7 +28208,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class ThisAndSuper extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInThisAndSuper() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/thisAndSuper"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/thisAndSuper"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -28313,7 +28313,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class UnqualifiedSuper extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInUnqualifiedSuper() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/thisAndSuper/unqualifiedSuper"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -28402,7 +28402,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class TraitWithRequired extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInTraitWithRequired() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/traitWithRequired"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/traitWithRequired"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -28424,7 +28424,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class TypeParameters extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInTypeParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/typeParameters"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/typeParameters"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -28518,7 +28518,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti @Test public void testAllFilesPresentInTypealias() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/typealias"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/typealias"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -29116,7 +29116,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class UnderscoresInNumericLiterals extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInUnderscoresInNumericLiterals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/underscoresInNumericLiterals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/underscoresInNumericLiterals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -29138,7 +29138,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Unit extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInUnit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/unit"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/unit"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -29154,7 +29154,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class UnitConversion extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInUnitConversion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/unitConversion"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/unitConversion"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -29218,7 +29218,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class UnsignedTypes extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInUnsignedTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/unsignedTypes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/unsignedTypes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -29299,7 +29299,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Conversions extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInConversions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/unsignedTypes/conversions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/unsignedTypes/conversions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -29340,7 +29340,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class ValueClasses extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInValueClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/valueClasses"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/valueClasses"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -29488,7 +29488,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Varargs extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInVarargs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/varargs"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/varargs"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -29696,7 +29696,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Variance extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInVariance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/variance"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/variance"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -29783,7 +29783,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti @Test public void testAllFilesPresentInPrivateToThis() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/variance/privateToThis"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/variance/privateToThis"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -29836,7 +29836,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti @Test public void testAllFilesPresentInVisibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/visibility"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/visibility"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -29864,7 +29864,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class When extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInWhen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/when"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/when"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -30251,7 +30251,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class WithSubjectVariable extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInWithSubjectVariable() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/when/withSubjectVariable"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/when/withSubjectVariable"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -30365,7 +30365,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti @Test public void testAllFilesPresentInTestsWithStdLib() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -30530,7 +30530,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Annotations extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -30629,7 +30629,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class AnnotationApplicability extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInAnnotationApplicability() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -30681,7 +30681,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class AnnotationParameterMustBeConstant extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInAnnotationParameterMustBeConstant() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -30715,7 +30715,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class AnnotationParameters extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInAnnotationParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -30773,7 +30773,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class AnnotationWithVarargParameter extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInAnnotationWithVarargParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -30795,7 +30795,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class JavaAnnotationsWithKClassParameter extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInJavaAnnotationsWithKClassParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -30877,7 +30877,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class JvmDefault extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInJvmDefault() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -30988,7 +30988,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class AllCompatibility extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInAllCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -31004,7 +31004,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class JvmDefaultWithoutCompatibility extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInJvmDefaultWithoutCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/jvmDefaultWithoutCompatibility"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmDefault/jvmDefaultWithoutCompatibility"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -31033,7 +31033,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class JvmField extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInJvmField() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmField"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmField"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -31073,7 +31073,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class JvmOverloads extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInJvmOverloads() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -31119,7 +31119,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class JvmPackageName extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInJvmPackageName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmPackageName"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmPackageName"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -31135,7 +31135,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class JvmSpecialFunctions extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInJvmSpecialFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmSpecialFunctions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmSpecialFunctions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -31151,7 +31151,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class JvmStatic extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInJvmStatic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -31257,7 +31257,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class KClass extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInKClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/kClass"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/kClass"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -31309,7 +31309,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class ProhibitPositionedArgument extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInProhibitPositionedArgument() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -31350,7 +31350,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Assert extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInAssert() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/assert"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/assert"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -31372,7 +31372,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Builtins extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInBuiltins() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/builtins"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/builtins"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -31388,7 +31388,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Cast extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInCast() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/cast"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/cast"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -31416,7 +31416,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Contracts extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInContracts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Nested @@ -31425,7 +31425,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Controlflow extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInControlflow() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Nested @@ -31434,7 +31434,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class FlowInlining extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInFlowInlining() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/flowInlining"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -31546,7 +31546,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Initialization extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInInitialization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Nested @@ -31555,7 +31555,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class AtLeastOnce extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInAtLeastOnce() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/atLeastOnce"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/atLeastOnce"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -31583,7 +31583,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class ExactlyOnce extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInExactlyOnce() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/exactlyOnce"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/exactlyOnce"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -31629,7 +31629,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Unknown extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInUnknown() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/unknown"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/controlflow/initialization/unknown"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -31647,7 +31647,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Dsl extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInDsl() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -31686,7 +31686,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti @Test public void testAllFilesPresentInErrors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -31799,7 +31799,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class FromStdlib extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInFromStdlib() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/fromStdlib"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/fromStdlib"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -31845,7 +31845,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class NewSyntax extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInNewSyntax() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/newSyntax"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/newSyntax"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -31879,7 +31879,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Smartcasts extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInSmartcasts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -32002,7 +32002,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Multieffect extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInMultieffect() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/multieffect"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/multieffect"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -32024,7 +32024,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class OperatorsTests extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInOperatorsTests() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/operatorsTests"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/operatorsTests"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -32088,7 +32088,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class When extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInWhen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/when"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/contracts/smartcasts/when"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -32124,7 +32124,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Coroutines extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInCoroutines() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -32457,7 +32457,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class CallableReference extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines/callableReference"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines/callableReference"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -32491,7 +32491,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Inference extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInInference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines/inference"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -32825,7 +32825,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class InlineCrossinline extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInInlineCrossinline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -32907,7 +32907,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Release extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInRelease() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines/release"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines/release"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -32935,7 +32935,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class RestrictSuspension extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInRestrictSuspension() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines/restrictSuspension"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines/restrictSuspension"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -32999,7 +32999,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class SuspendFunctionType extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInSuspendFunctionType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendFunctionType"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -33093,7 +33093,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class TailCalls extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInTailCalls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines/tailCalls"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines/tailCalls"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -33146,7 +33146,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Deprecated extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInDeprecated() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/deprecated"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/deprecated"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -33168,7 +33168,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class DuplicateJvmSignature extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInDuplicateJvmSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -33213,7 +33213,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Statics extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInStatics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/duplicateJvmSignature/statics"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -33248,7 +33248,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Experimental extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInExperimental() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/experimental"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/experimental"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -33414,7 +33414,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class FactoryPattern extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInFactoryPattern() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/factoryPattern"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/factoryPattern"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -33484,7 +33484,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class ForInArrayLoop extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInForInArrayLoop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/forInArrayLoop"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/forInArrayLoop"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -33524,7 +33524,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class FunctionLiterals extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInFunctionLiterals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/functionLiterals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/functionLiterals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -33540,7 +33540,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Inference extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInInference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -33681,7 +33681,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class AnnotationsForResolve extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInAnnotationsForResolve() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -33835,7 +33835,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Completion extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInCompletion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference/completion"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference/completion"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Nested @@ -33844,7 +33844,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class PostponedArgumentsAnalysis extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInPostponedArgumentsAnalysis() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -33925,7 +33925,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Performance extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInPerformance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/performance"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference/completion/postponedArgumentsAnalysis/performance"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -33973,7 +33973,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Delegates extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInDelegates() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference/delegates"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference/delegates"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -34001,7 +34001,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class NothingType extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInNothingType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference/nothingType"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference/nothingType"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -34023,7 +34023,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Performance extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInPerformance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference/performance"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inference/performance"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -34052,7 +34052,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Inline extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inline"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/inline"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -34074,7 +34074,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Java extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/java"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/java"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -34114,7 +34114,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Kt7585 extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInKt7585() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/kt7585"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/kt7585"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -34130,7 +34130,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Lateinit extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInLateinit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/lateinit"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/lateinit"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -34146,7 +34146,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Multiplatform extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInMultiplatform() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/multiplatform"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/multiplatform"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -34168,7 +34168,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti @Test public void testAllFilesPresentInNative() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/native"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/native"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -34226,7 +34226,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class PurelyImplementedCollection extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInPurelyImplementedCollection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/purelyImplementedCollection"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -34296,7 +34296,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Reflection extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInReflection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/reflection"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/reflection"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -34312,7 +34312,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Regression extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInRegression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/regression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/regression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -34412,7 +34412,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Reified extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInReified() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/reified"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/reified"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -34452,7 +34452,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Resolve extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInResolve() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/resolve"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/resolve"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -34540,7 +34540,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Smartcasts extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInSmartcasts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/smartcasts"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/smartcasts"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -34628,7 +34628,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class SourceCompatibility extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInSourceCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/sourceCompatibility"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/sourceCompatibility"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -34644,7 +34644,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class TargetedBuiltIns extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInTargetedBuiltIns() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/targetedBuiltIns"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/targetedBuiltIns"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -34666,7 +34666,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class TrailingComma extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInTrailingComma() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/trailingComma"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/trailingComma"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -34754,7 +34754,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class TryCatch extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInTryCatch() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/tryCatch"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/tryCatch"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -34824,7 +34824,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Typealias extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInTypealias() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/typealias"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/typealias"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -34870,7 +34870,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class Varargs extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInVarargs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/varargs"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/varargs"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test @@ -34898,7 +34898,7 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti public class When extends AbstractFirDiagnosticTest { @Test public void testAllFilesPresentInWhen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/when"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/when"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @Test diff --git a/compiler/tests-gen/org/jetbrains/kotlin/asJava/CompilerLightClassTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/asJava/CompilerLightClassTestGenerated.java index e481e317067..7a64a9b008a 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/asJava/CompilerLightClassTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/asJava/CompilerLightClassTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.asJava; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class CompilerLightClassTestGenerated extends AbstractCompilerLightClassT } public void testAllFilesPresentInLightClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true, "local", "ideRegression"); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true, "local", "ideRegression"); } @TestMetadata("AnnotatedParameterInEnumConstructor.kt") @@ -177,7 +178,7 @@ public class CompilerLightClassTestGenerated extends AbstractCompilerLightClassT } public void testAllFilesPresentInCompilationErrors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/compilationErrors"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/compilationErrors"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); } @TestMetadata("AllInlineOnly.kt") @@ -270,7 +271,7 @@ public class CompilerLightClassTestGenerated extends AbstractCompilerLightClassT } public void testAllFilesPresentInDelegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/delegation"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/delegation"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); } @TestMetadata("Function.kt") @@ -293,7 +294,7 @@ public class CompilerLightClassTestGenerated extends AbstractCompilerLightClassT } public void testAllFilesPresentInFacades() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/facades"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/facades"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); } @TestMetadata("AllPrivate.kt") @@ -326,7 +327,7 @@ public class CompilerLightClassTestGenerated extends AbstractCompilerLightClassT } public void testAllFilesPresentInNullabilityAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/nullabilityAnnotations"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/nullabilityAnnotations"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); } @TestMetadata("Class.kt") @@ -429,7 +430,7 @@ public class CompilerLightClassTestGenerated extends AbstractCompilerLightClassT } public void testAllFilesPresentInObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/object"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/object"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); } @TestMetadata("SimpleObject.kt") @@ -447,7 +448,7 @@ public class CompilerLightClassTestGenerated extends AbstractCompilerLightClassT } public void testAllFilesPresentInPublicField() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/publicField"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/publicField"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); } @TestMetadata("CompanionObject.kt") @@ -470,7 +471,7 @@ public class CompilerLightClassTestGenerated extends AbstractCompilerLightClassT } public void testAllFilesPresentInScript() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/script"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/script"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); } @TestMetadata("HelloWorld.kts") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/cfg/ControlFlowTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/cfg/ControlFlowTestGenerated.java index 5150fe84efd..92945984282 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/cfg/ControlFlowTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/cfg/ControlFlowTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.cfg; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -27,7 +28,7 @@ public class ControlFlowTestGenerated extends AbstractControlFlowTest { } public void testAllFilesPresentInCfg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/testData/cfg/arrays") @@ -39,7 +40,7 @@ public class ControlFlowTestGenerated extends AbstractControlFlowTest { } public void testAllFilesPresentInArrays() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/arrays"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/arrays"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ArrayAccess.kt") @@ -102,7 +103,7 @@ public class ControlFlowTestGenerated extends AbstractControlFlowTest { } public void testAllFilesPresentInBasic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/basic"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/basic"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Basic.kt") @@ -130,7 +131,7 @@ public class ControlFlowTestGenerated extends AbstractControlFlowTest { } public void testAllFilesPresentInBugs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/bugs"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/bugs"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("functionalCallInEnumEntry.kt") @@ -178,7 +179,7 @@ public class ControlFlowTestGenerated extends AbstractControlFlowTest { } public void testAllFilesPresentInControlStructures() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/controlStructures"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/controlStructures"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("breakContinueInTryFinally.kt") @@ -281,7 +282,7 @@ public class ControlFlowTestGenerated extends AbstractControlFlowTest { } public void testAllFilesPresentInConventions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/conventions"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/conventions"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("bothReceivers.kt") @@ -319,7 +320,7 @@ public class ControlFlowTestGenerated extends AbstractControlFlowTest { } public void testAllFilesPresentInDeadCode() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/deadCode"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/deadCode"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("DeadCode.kt") @@ -362,7 +363,7 @@ public class ControlFlowTestGenerated extends AbstractControlFlowTest { } public void testAllFilesPresentInDeclarations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/declarations"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/declarations"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/testData/cfg/declarations/classesAndObjects") @@ -374,7 +375,7 @@ public class ControlFlowTestGenerated extends AbstractControlFlowTest { } public void testAllFilesPresentInClassesAndObjects() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/declarations/classesAndObjects"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/declarations/classesAndObjects"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("AnonymousInitializers.kt") @@ -417,7 +418,7 @@ public class ControlFlowTestGenerated extends AbstractControlFlowTest { } public void testAllFilesPresentInFunctionLiterals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/declarations/functionLiterals"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/declarations/functionLiterals"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("unusedFunctionLiteral.kt") @@ -435,7 +436,7 @@ public class ControlFlowTestGenerated extends AbstractControlFlowTest { } public void testAllFilesPresentInFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/declarations/functions"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/declarations/functions"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("anonymousFunctionInBlock.kt") @@ -473,7 +474,7 @@ public class ControlFlowTestGenerated extends AbstractControlFlowTest { } public void testAllFilesPresentInLocal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/declarations/local"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/declarations/local"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("localClass.kt") @@ -516,7 +517,7 @@ public class ControlFlowTestGenerated extends AbstractControlFlowTest { } public void testAllFilesPresentInMultiDeclaration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/declarations/multiDeclaration"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/declarations/multiDeclaration"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("MultiDecl.kt") @@ -539,7 +540,7 @@ public class ControlFlowTestGenerated extends AbstractControlFlowTest { } public void testAllFilesPresentInProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/declarations/properties"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/declarations/properties"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("DelegatedProperty.kt") @@ -563,7 +564,7 @@ public class ControlFlowTestGenerated extends AbstractControlFlowTest { } public void testAllFilesPresentInExpressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/expressions"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/expressions"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("assignmentToThis.kt") @@ -691,7 +692,7 @@ public class ControlFlowTestGenerated extends AbstractControlFlowTest { } public void testAllFilesPresentInFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/functions"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/functions"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("DefaultValuesForArguments.kt") @@ -714,7 +715,7 @@ public class ControlFlowTestGenerated extends AbstractControlFlowTest { } public void testAllFilesPresentInSecondaryConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/secondaryConstructors"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/secondaryConstructors"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("withPrimary.kt") @@ -752,7 +753,7 @@ public class ControlFlowTestGenerated extends AbstractControlFlowTest { } public void testAllFilesPresentInTailCalls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/tailCalls"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/tailCalls"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("finally.kt") @@ -791,7 +792,7 @@ public class ControlFlowTestGenerated extends AbstractControlFlowTest { } public void testAllFilesPresentInCfgWithStdLib() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfgWithStdLib"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfgWithStdLib"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/testData/cfgWithStdLib/contracts") @@ -803,7 +804,7 @@ public class ControlFlowTestGenerated extends AbstractControlFlowTest { } public void testAllFilesPresentInContracts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfgWithStdLib/contracts"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfgWithStdLib/contracts"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("labeledReturns.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/cfg/DataFlowTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/cfg/DataFlowTestGenerated.java index 08f16b2b775..dcd027fadc0 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/cfg/DataFlowTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/cfg/DataFlowTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.cfg; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -27,7 +28,7 @@ public class DataFlowTestGenerated extends AbstractDataFlowTest { } public void testAllFilesPresentInCfg_variables() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg-variables"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg-variables"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/testData/cfg-variables/basic") @@ -39,7 +40,7 @@ public class DataFlowTestGenerated extends AbstractDataFlowTest { } public void testAllFilesPresentInBasic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg-variables/basic"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg-variables/basic"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ExhaustiveInitialization.kt") @@ -87,7 +88,7 @@ public class DataFlowTestGenerated extends AbstractDataFlowTest { } public void testAllFilesPresentInBugs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg-variables/bugs"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg-variables/bugs"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("doWhileAssignment.kt") @@ -155,7 +156,7 @@ public class DataFlowTestGenerated extends AbstractDataFlowTest { } public void testAllFilesPresentInLexicalScopes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg-variables/lexicalScopes"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg-variables/lexicalScopes"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("doWhileScope.kt") @@ -229,7 +230,7 @@ public class DataFlowTestGenerated extends AbstractDataFlowTest { } public void testAllFilesPresentInCfgVariablesWithStdLib() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfgVariablesWithStdLib"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfgVariablesWithStdLib"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/testData/cfgVariablesWithStdLib/contracts") @@ -241,7 +242,7 @@ public class DataFlowTestGenerated extends AbstractDataFlowTest { } public void testAllFilesPresentInContracts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfgVariablesWithStdLib/contracts"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfgVariablesWithStdLib/contracts"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("breakContinuesInInlinedLambda.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/cfg/PseudoValueTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/cfg/PseudoValueTestGenerated.java index da92e9ce193..91a4f5357c2 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/cfg/PseudoValueTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/cfg/PseudoValueTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.cfg; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -27,7 +28,7 @@ public class PseudoValueTestGenerated extends AbstractPseudoValueTest { } public void testAllFilesPresentInCfg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/testData/cfg/arrays") @@ -39,7 +40,7 @@ public class PseudoValueTestGenerated extends AbstractPseudoValueTest { } public void testAllFilesPresentInArrays() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/arrays"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/arrays"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ArrayAccess.kt") @@ -102,7 +103,7 @@ public class PseudoValueTestGenerated extends AbstractPseudoValueTest { } public void testAllFilesPresentInBasic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/basic"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/basic"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Basic.kt") @@ -130,7 +131,7 @@ public class PseudoValueTestGenerated extends AbstractPseudoValueTest { } public void testAllFilesPresentInBugs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/bugs"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/bugs"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("functionalCallInEnumEntry.kt") @@ -178,7 +179,7 @@ public class PseudoValueTestGenerated extends AbstractPseudoValueTest { } public void testAllFilesPresentInControlStructures() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/controlStructures"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/controlStructures"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("breakContinueInTryFinally.kt") @@ -281,7 +282,7 @@ public class PseudoValueTestGenerated extends AbstractPseudoValueTest { } public void testAllFilesPresentInConventions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/conventions"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/conventions"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("bothReceivers.kt") @@ -319,7 +320,7 @@ public class PseudoValueTestGenerated extends AbstractPseudoValueTest { } public void testAllFilesPresentInDeadCode() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/deadCode"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/deadCode"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("DeadCode.kt") @@ -362,7 +363,7 @@ public class PseudoValueTestGenerated extends AbstractPseudoValueTest { } public void testAllFilesPresentInDeclarations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/declarations"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/declarations"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/testData/cfg/declarations/classesAndObjects") @@ -374,7 +375,7 @@ public class PseudoValueTestGenerated extends AbstractPseudoValueTest { } public void testAllFilesPresentInClassesAndObjects() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/declarations/classesAndObjects"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/declarations/classesAndObjects"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("AnonymousInitializers.kt") @@ -417,7 +418,7 @@ public class PseudoValueTestGenerated extends AbstractPseudoValueTest { } public void testAllFilesPresentInFunctionLiterals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/declarations/functionLiterals"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/declarations/functionLiterals"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("unusedFunctionLiteral.kt") @@ -435,7 +436,7 @@ public class PseudoValueTestGenerated extends AbstractPseudoValueTest { } public void testAllFilesPresentInFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/declarations/functions"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/declarations/functions"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("anonymousFunctionInBlock.kt") @@ -473,7 +474,7 @@ public class PseudoValueTestGenerated extends AbstractPseudoValueTest { } public void testAllFilesPresentInLocal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/declarations/local"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/declarations/local"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("localClass.kt") @@ -516,7 +517,7 @@ public class PseudoValueTestGenerated extends AbstractPseudoValueTest { } public void testAllFilesPresentInMultiDeclaration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/declarations/multiDeclaration"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/declarations/multiDeclaration"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("MultiDecl.kt") @@ -539,7 +540,7 @@ public class PseudoValueTestGenerated extends AbstractPseudoValueTest { } public void testAllFilesPresentInProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/declarations/properties"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/declarations/properties"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("DelegatedProperty.kt") @@ -563,7 +564,7 @@ public class PseudoValueTestGenerated extends AbstractPseudoValueTest { } public void testAllFilesPresentInExpressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/expressions"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/expressions"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("assignmentToThis.kt") @@ -691,7 +692,7 @@ public class PseudoValueTestGenerated extends AbstractPseudoValueTest { } public void testAllFilesPresentInFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/functions"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/functions"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("DefaultValuesForArguments.kt") @@ -714,7 +715,7 @@ public class PseudoValueTestGenerated extends AbstractPseudoValueTest { } public void testAllFilesPresentInSecondaryConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/secondaryConstructors"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/secondaryConstructors"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("withPrimary.kt") @@ -752,7 +753,7 @@ public class PseudoValueTestGenerated extends AbstractPseudoValueTest { } public void testAllFilesPresentInTailCalls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/tailCalls"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg/tailCalls"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("finally.kt") @@ -791,7 +792,7 @@ public class PseudoValueTestGenerated extends AbstractPseudoValueTest { } public void testAllFilesPresentInCfgWithStdLib() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfgWithStdLib"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfgWithStdLib"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/testData/cfgWithStdLib/contracts") @@ -803,7 +804,7 @@ public class PseudoValueTestGenerated extends AbstractPseudoValueTest { } public void testAllFilesPresentInContracts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfgWithStdLib/contracts"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfgWithStdLib/contracts"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("labeledReturns.kt") @@ -847,7 +848,7 @@ public class PseudoValueTestGenerated extends AbstractPseudoValueTest { } public void testAllFilesPresentInCfg_variables() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg-variables"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg-variables"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/testData/cfg-variables/basic") @@ -859,7 +860,7 @@ public class PseudoValueTestGenerated extends AbstractPseudoValueTest { } public void testAllFilesPresentInBasic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg-variables/basic"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg-variables/basic"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ExhaustiveInitialization.kt") @@ -907,7 +908,7 @@ public class PseudoValueTestGenerated extends AbstractPseudoValueTest { } public void testAllFilesPresentInBugs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg-variables/bugs"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg-variables/bugs"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("doWhileAssignment.kt") @@ -975,7 +976,7 @@ public class PseudoValueTestGenerated extends AbstractPseudoValueTest { } public void testAllFilesPresentInLexicalScopes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg-variables/lexicalScopes"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfg-variables/lexicalScopes"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("doWhileScope.kt") @@ -1049,7 +1050,7 @@ public class PseudoValueTestGenerated extends AbstractPseudoValueTest { } public void testAllFilesPresentInCfgVariablesWithStdLib() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfgVariablesWithStdLib"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfgVariablesWithStdLib"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/testData/cfgVariablesWithStdLib/contracts") @@ -1061,7 +1062,7 @@ public class PseudoValueTestGenerated extends AbstractPseudoValueTest { } public void testAllFilesPresentInContracts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfgVariablesWithStdLib/contracts"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cfgVariablesWithStdLib/contracts"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("breakContinuesInInlinedLambda.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsNativeTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsNativeTestGenerated.java index f0b1e5bb565..ea672d9b2e1 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsNativeTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsNativeTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.checkers; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class DiagnosticsNativeTestGenerated extends AbstractDiagnosticsNativeTes } public void testAllFilesPresentInNativeTests() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/nativeTests"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/nativeTests"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("sharedImmutable.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsTestWithJsStdLibAndBackendCompilationGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsTestWithJsStdLibAndBackendCompilationGenerated.java index 54b4cb27f17..1152bbf53f5 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsTestWithJsStdLibAndBackendCompilationGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsTestWithJsStdLibAndBackendCompilationGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.checkers; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class DiagnosticsTestWithJsStdLibAndBackendCompilationGenerated extends A } public void testAllFilesPresentInTestsWithJsStdLibAndBackendCompilation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLibAndBackendCompilation"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLibAndBackendCompilation"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/testData/diagnostics/testsWithJsStdLibAndBackendCompilation/inline") @@ -37,7 +38,7 @@ public class DiagnosticsTestWithJsStdLibAndBackendCompilationGenerated extends A } public void testAllFilesPresentInInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLibAndBackendCompilation/inline"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLibAndBackendCompilation/inline"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("recursionCycle.kt") @@ -70,7 +71,7 @@ public class DiagnosticsTestWithJsStdLibAndBackendCompilationGenerated extends A } public void testAllFilesPresentInUnsupportedFeatures() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLibAndBackendCompilation/unsupportedFeatures"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLibAndBackendCompilation/unsupportedFeatures"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("annotations.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsTestWithJsStdLibGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsTestWithJsStdLibGenerated.java index a9836316b29..d49b371fdea 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsTestWithJsStdLibGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsTestWithJsStdLibGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.checkers; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class DiagnosticsTestWithJsStdLibGenerated extends AbstractDiagnosticsTes } public void testAllFilesPresentInTestsWithJsStdLib() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("funConstructorCallJS.kt") @@ -77,7 +78,7 @@ public class DiagnosticsTestWithJsStdLibGenerated extends AbstractDiagnosticsTes } public void testAllFilesPresentInClassLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/classLiteral"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/classLiteral"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("arrays_after.kt") @@ -100,7 +101,7 @@ public class DiagnosticsTestWithJsStdLibGenerated extends AbstractDiagnosticsTes } public void testAllFilesPresentInDynamicTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("allowedDynamicFunctionType.kt") @@ -343,7 +344,7 @@ public class DiagnosticsTestWithJsStdLibGenerated extends AbstractDiagnosticsTes } public void testAllFilesPresentInExport() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/export"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/export"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("extendingNonExportedType.kt") @@ -391,7 +392,7 @@ public class DiagnosticsTestWithJsStdLibGenerated extends AbstractDiagnosticsTes } public void testAllFilesPresentInInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/inline"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/inline"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Reified.kt") @@ -409,7 +410,7 @@ public class DiagnosticsTestWithJsStdLibGenerated extends AbstractDiagnosticsTes } public void testAllFilesPresentInJsCode() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/jsCode"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/jsCode"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("argumentIsLiteral.kt") @@ -452,7 +453,7 @@ public class DiagnosticsTestWithJsStdLibGenerated extends AbstractDiagnosticsTes } public void testAllFilesPresentInJvmDeclarations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/jvmDeclarations"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/jvmDeclarations"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("cloneable.kt") @@ -470,7 +471,7 @@ public class DiagnosticsTestWithJsStdLibGenerated extends AbstractDiagnosticsTes } public void testAllFilesPresentInModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/module"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/module"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("dualModuleFromUmd.kt") @@ -528,7 +529,7 @@ public class DiagnosticsTestWithJsStdLibGenerated extends AbstractDiagnosticsTes } public void testAllFilesPresentInName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/name"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/name"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("bridgeClash.kt") @@ -696,7 +697,7 @@ public class DiagnosticsTestWithJsStdLibGenerated extends AbstractDiagnosticsTes } public void testAllFilesPresentInNative() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/native"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/native"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("anonymousInitializer.kt") @@ -813,7 +814,7 @@ public class DiagnosticsTestWithJsStdLibGenerated extends AbstractDiagnosticsTes } public void testAllFilesPresentInNativeGetter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/native/nativeGetter"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/native/nativeGetter"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("onLocalExtensionFun.kt") @@ -871,7 +872,7 @@ public class DiagnosticsTestWithJsStdLibGenerated extends AbstractDiagnosticsTes } public void testAllFilesPresentInNativeInvoke() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/native/nativeInvoke"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/native/nativeInvoke"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("onLocalExtensionFun.kt") @@ -929,7 +930,7 @@ public class DiagnosticsTestWithJsStdLibGenerated extends AbstractDiagnosticsTes } public void testAllFilesPresentInNativeSetter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/native/nativeSetter"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/native/nativeSetter"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("onLocalExtensionFun.kt") @@ -987,7 +988,7 @@ public class DiagnosticsTestWithJsStdLibGenerated extends AbstractDiagnosticsTes } public void testAllFilesPresentInOptionlBody() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/native/optionlBody"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/native/optionlBody"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("native.kt") @@ -1020,7 +1021,7 @@ public class DiagnosticsTestWithJsStdLibGenerated extends AbstractDiagnosticsTes } public void testAllFilesPresentInRtti() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/native/rtti"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/native/rtti"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("castToNativeInterface.kt") @@ -1058,7 +1059,7 @@ public class DiagnosticsTestWithJsStdLibGenerated extends AbstractDiagnosticsTes } public void testAllFilesPresentInUnusedParam() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/native/unusedParam"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/native/unusedParam"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("native.kt") @@ -1092,7 +1093,7 @@ public class DiagnosticsTestWithJsStdLibGenerated extends AbstractDiagnosticsTes } public void testAllFilesPresentInQualifier() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/qualifier"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/qualifier"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("jsQualifierNonExternal.kt") @@ -1115,7 +1116,7 @@ public class DiagnosticsTestWithJsStdLibGenerated extends AbstractDiagnosticsTes } public void testAllFilesPresentInReflection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/reflection"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/reflection"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("reflectionApi.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsTestWithJvmIrBackendGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsTestWithJvmIrBackendGenerated.java index 4a14b006062..e830e031ba1 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsTestWithJvmIrBackendGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsTestWithJvmIrBackendGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.checkers; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class DiagnosticsTestWithJvmIrBackendGenerated extends AbstractDiagnostic } public void testAllFilesPresentInTestsWithJvmBackend() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("indirectInlineCycle_ir.kt") @@ -58,7 +59,7 @@ public class DiagnosticsTestWithJvmIrBackendGenerated extends AbstractDiagnostic } public void testAllFilesPresentInDuplicateJvmSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("caseInProperties.kt") @@ -90,7 +91,7 @@ public class DiagnosticsTestWithJvmIrBackendGenerated extends AbstractDiagnostic } public void testAllFilesPresentInAccidentalOverrides() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("classFunctionOverriddenByProperty.kt") @@ -173,7 +174,7 @@ public class DiagnosticsTestWithJvmIrBackendGenerated extends AbstractDiagnostic } public void testAllFilesPresentInBridges() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/bridges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/bridges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("class_ir.kt") @@ -201,7 +202,7 @@ public class DiagnosticsTestWithJvmIrBackendGenerated extends AbstractDiagnostic } public void testAllFilesPresentInErasure() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("clashFromInterfaceAndSuperClass_ir.kt") @@ -299,7 +300,7 @@ public class DiagnosticsTestWithJvmIrBackendGenerated extends AbstractDiagnostic } public void testAllFilesPresentInFinalMembersFromBuiltIns() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/finalMembersFromBuiltIns"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/finalMembersFromBuiltIns"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("enumMembers.kt") @@ -322,7 +323,7 @@ public class DiagnosticsTestWithJvmIrBackendGenerated extends AbstractDiagnostic } public void testAllFilesPresentInFunctionAndProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/functionAndProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/functionAndProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("class.kt") @@ -425,7 +426,7 @@ public class DiagnosticsTestWithJvmIrBackendGenerated extends AbstractDiagnostic } public void testAllFilesPresentInSpecialNames() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/specialNames"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/specialNames"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("classObjectCopiedField.kt") @@ -488,7 +489,7 @@ public class DiagnosticsTestWithJvmIrBackendGenerated extends AbstractDiagnostic } public void testAllFilesPresentInStatics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/statics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/statics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("jkjk.kt") @@ -531,7 +532,7 @@ public class DiagnosticsTestWithJvmIrBackendGenerated extends AbstractDiagnostic } public void testAllFilesPresentInSynthesized() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/synthesized"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/synthesized"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("enumValuesValueOf.kt") @@ -549,7 +550,7 @@ public class DiagnosticsTestWithJvmIrBackendGenerated extends AbstractDiagnostic } public void testAllFilesPresentInTraitImpl() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/traitImpl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/traitImpl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("defaultVsNonDefault_ir.kt") @@ -593,7 +594,7 @@ public class DiagnosticsTestWithJvmIrBackendGenerated extends AbstractDiagnostic } public void testAllFilesPresentInValueClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/valueClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/valueClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("cloneable.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsTestWithOldJvmBackendGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsTestWithOldJvmBackendGenerated.java index 1e3f91bf185..cfd13fb6f8f 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsTestWithOldJvmBackendGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsTestWithOldJvmBackendGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.checkers; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class DiagnosticsTestWithOldJvmBackendGenerated extends AbstractDiagnosti } public void testAllFilesPresentInTestsWithJvmBackend() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_OLD, true); } @TestMetadata("indirectInlineCycle.kt") @@ -58,7 +59,7 @@ public class DiagnosticsTestWithOldJvmBackendGenerated extends AbstractDiagnosti } public void testAllFilesPresentInDuplicateJvmSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_OLD, true); } @TestMetadata("caseInProperties.kt") @@ -90,7 +91,7 @@ public class DiagnosticsTestWithOldJvmBackendGenerated extends AbstractDiagnosti } public void testAllFilesPresentInAccidentalOverrides() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_OLD, true); } @TestMetadata("classFunctionOverriddenByProperty.kt") @@ -163,7 +164,7 @@ public class DiagnosticsTestWithOldJvmBackendGenerated extends AbstractDiagnosti } public void testAllFilesPresentInBridges() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/bridges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/bridges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_OLD, true); } @TestMetadata("class_old.kt") @@ -191,7 +192,7 @@ public class DiagnosticsTestWithOldJvmBackendGenerated extends AbstractDiagnosti } public void testAllFilesPresentInErasure() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_OLD, true); } @TestMetadata("clashFromInterfaceAndSuperClass_old.kt") @@ -289,7 +290,7 @@ public class DiagnosticsTestWithOldJvmBackendGenerated extends AbstractDiagnosti } public void testAllFilesPresentInFinalMembersFromBuiltIns() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/finalMembersFromBuiltIns"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/finalMembersFromBuiltIns"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_OLD, true); } @TestMetadata("enumMembers.kt") @@ -312,7 +313,7 @@ public class DiagnosticsTestWithOldJvmBackendGenerated extends AbstractDiagnosti } public void testAllFilesPresentInFunctionAndProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/functionAndProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/functionAndProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_OLD, true); } @TestMetadata("class.kt") @@ -415,7 +416,7 @@ public class DiagnosticsTestWithOldJvmBackendGenerated extends AbstractDiagnosti } public void testAllFilesPresentInSpecialNames() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/specialNames"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/specialNames"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_OLD, true); } @TestMetadata("classObjectCopiedField.kt") @@ -478,7 +479,7 @@ public class DiagnosticsTestWithOldJvmBackendGenerated extends AbstractDiagnosti } public void testAllFilesPresentInStatics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/statics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/statics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_OLD, true); } @TestMetadata("jkjk.kt") @@ -521,7 +522,7 @@ public class DiagnosticsTestWithOldJvmBackendGenerated extends AbstractDiagnosti } public void testAllFilesPresentInSynthesized() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/synthesized"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/synthesized"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_OLD, true); } @TestMetadata("enumValuesValueOf.kt") @@ -539,7 +540,7 @@ public class DiagnosticsTestWithOldJvmBackendGenerated extends AbstractDiagnosti } public void testAllFilesPresentInTraitImpl() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/traitImpl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/traitImpl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_OLD, true); } @TestMetadata("defaultVsNonDefault_old.kt") @@ -583,7 +584,7 @@ public class DiagnosticsTestWithOldJvmBackendGenerated extends AbstractDiagnosti } public void testAllFilesPresentInValueClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/valueClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/valueClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_OLD, true); } @TestMetadata("cloneable.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsWithJdk15TestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsWithJdk15TestGenerated.java index 1a4c5ea600f..275adc5c870 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsWithJdk15TestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsWithJdk15TestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.checkers; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class DiagnosticsWithJdk15TestGenerated extends AbstractDiagnosticsWithJd } public void testAllFilesPresentInTestsWithJava15() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJava15"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJava15"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/testData/diagnostics/testsWithJava15/jvmRecord") @@ -37,7 +38,7 @@ public class DiagnosticsWithJdk15TestGenerated extends AbstractDiagnosticsWithJd } public void testAllFilesPresentInJvmRecord() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJava15/jvmRecord"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJava15/jvmRecord"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("diagnostics.kt") @@ -80,7 +81,7 @@ public class DiagnosticsWithJdk15TestGenerated extends AbstractDiagnosticsWithJd } public void testAllFilesPresentInSealedClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJava15/sealedClasses"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJava15/sealedClasses"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("javaSealedClassExhaustiveness.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/checkers/ForeignAnnotationsNoAnnotationInClasspathTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/checkers/ForeignAnnotationsNoAnnotationInClasspathTestGenerated.java index 254949c9bd3..16dd45aa7ac 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/checkers/ForeignAnnotationsNoAnnotationInClasspathTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/checkers/ForeignAnnotationsNoAnnotationInClasspathTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.checkers; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class ForeignAnnotationsNoAnnotationInClasspathTestGenerated extends Abst } public void testAllFilesPresentInTests() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("androidRecently.kt") @@ -92,7 +93,7 @@ public class ForeignAnnotationsNoAnnotationInClasspathTestGenerated extends Abst } public void testAllFilesPresentInJsr305() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("nonNullNever.kt") @@ -124,7 +125,7 @@ public class ForeignAnnotationsNoAnnotationInClasspathTestGenerated extends Abst } public void testAllFilesPresentInIgnore() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/ignore"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/ignore"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("parametersAreNonnullByDefault.kt") @@ -142,7 +143,7 @@ public class ForeignAnnotationsNoAnnotationInClasspathTestGenerated extends Abst } public void testAllFilesPresentInNullabilityWarnings() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("elvis.kt") @@ -189,7 +190,7 @@ public class ForeignAnnotationsNoAnnotationInClasspathTestGenerated extends Abst } public void testAllFilesPresentInFromPlatformTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("arithmetic.kt") @@ -302,7 +303,7 @@ public class ForeignAnnotationsNoAnnotationInClasspathTestGenerated extends Abst } public void testAllFilesPresentInTypeQualifierDefault() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("equalsOnNonNull.kt") @@ -356,7 +357,7 @@ public class ForeignAnnotationsNoAnnotationInClasspathTestGenerated extends Abst } public void testAllFilesPresentInTypeQualifierDefault() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("fieldsAreNullable.kt") @@ -415,7 +416,7 @@ public class ForeignAnnotationsNoAnnotationInClasspathTestGenerated extends Abst } public void testAllFilesPresentInJsr305NullabilityWarnings() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration") @@ -427,7 +428,7 @@ public class ForeignAnnotationsNoAnnotationInClasspathTestGenerated extends Abst } public void testAllFilesPresentInMigration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("customMigration.kt") @@ -486,7 +487,7 @@ public class ForeignAnnotationsNoAnnotationInClasspathTestGenerated extends Abst } public void testAllFilesPresentInTypeQualifierDefault() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/typeQualifierDefault"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/typeQualifierDefault"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("defaultAndNicknameMigrationPolicy.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/checkers/ForeignAnnotationsNoAnnotationInClasspathWithPsiClassReadingTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/checkers/ForeignAnnotationsNoAnnotationInClasspathWithPsiClassReadingTestGenerated.java index 491abbac8eb..d104f7a21e4 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/checkers/ForeignAnnotationsNoAnnotationInClasspathWithPsiClassReadingTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/checkers/ForeignAnnotationsNoAnnotationInClasspathWithPsiClassReadingTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.checkers; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class ForeignAnnotationsNoAnnotationInClasspathWithPsiClassReadingTestGen } public void testAllFilesPresentInTests() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("androidRecently.kt") @@ -92,7 +93,7 @@ public class ForeignAnnotationsNoAnnotationInClasspathWithPsiClassReadingTestGen } public void testAllFilesPresentInJsr305() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("nonNullNever.kt") @@ -124,7 +125,7 @@ public class ForeignAnnotationsNoAnnotationInClasspathWithPsiClassReadingTestGen } public void testAllFilesPresentInIgnore() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/ignore"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/ignore"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("parametersAreNonnullByDefault.kt") @@ -142,7 +143,7 @@ public class ForeignAnnotationsNoAnnotationInClasspathWithPsiClassReadingTestGen } public void testAllFilesPresentInNullabilityWarnings() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("elvis.kt") @@ -189,7 +190,7 @@ public class ForeignAnnotationsNoAnnotationInClasspathWithPsiClassReadingTestGen } public void testAllFilesPresentInFromPlatformTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("arithmetic.kt") @@ -302,7 +303,7 @@ public class ForeignAnnotationsNoAnnotationInClasspathWithPsiClassReadingTestGen } public void testAllFilesPresentInTypeQualifierDefault() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("equalsOnNonNull.kt") @@ -356,7 +357,7 @@ public class ForeignAnnotationsNoAnnotationInClasspathWithPsiClassReadingTestGen } public void testAllFilesPresentInTypeQualifierDefault() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("fieldsAreNullable.kt") @@ -415,7 +416,7 @@ public class ForeignAnnotationsNoAnnotationInClasspathWithPsiClassReadingTestGen } public void testAllFilesPresentInJsr305NullabilityWarnings() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration") @@ -427,7 +428,7 @@ public class ForeignAnnotationsNoAnnotationInClasspathWithPsiClassReadingTestGen } public void testAllFilesPresentInMigration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("customMigration.kt") @@ -486,7 +487,7 @@ public class ForeignAnnotationsNoAnnotationInClasspathWithPsiClassReadingTestGen } public void testAllFilesPresentInTypeQualifierDefault() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/typeQualifierDefault"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/typeQualifierDefault"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("defaultAndNicknameMigrationPolicy.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/checkers/ForeignAnnotationsTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/checkers/ForeignAnnotationsTestGenerated.java index 18c05265edf..ab7127e5112 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/checkers/ForeignAnnotationsTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/checkers/ForeignAnnotationsTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.checkers; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class ForeignAnnotationsTestGenerated extends AbstractForeignAnnotationsT } public void testAllFilesPresentInTests() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("androidRecently.kt") @@ -92,7 +93,7 @@ public class ForeignAnnotationsTestGenerated extends AbstractForeignAnnotationsT } public void testAllFilesPresentInJsr305() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("nonNullNever.kt") @@ -124,7 +125,7 @@ public class ForeignAnnotationsTestGenerated extends AbstractForeignAnnotationsT } public void testAllFilesPresentInIgnore() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/ignore"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/ignore"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("parametersAreNonnullByDefault.kt") @@ -142,7 +143,7 @@ public class ForeignAnnotationsTestGenerated extends AbstractForeignAnnotationsT } public void testAllFilesPresentInNullabilityWarnings() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("elvis.kt") @@ -189,7 +190,7 @@ public class ForeignAnnotationsTestGenerated extends AbstractForeignAnnotationsT } public void testAllFilesPresentInFromPlatformTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("arithmetic.kt") @@ -302,7 +303,7 @@ public class ForeignAnnotationsTestGenerated extends AbstractForeignAnnotationsT } public void testAllFilesPresentInTypeQualifierDefault() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("equalsOnNonNull.kt") @@ -356,7 +357,7 @@ public class ForeignAnnotationsTestGenerated extends AbstractForeignAnnotationsT } public void testAllFilesPresentInTypeQualifierDefault() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("fieldsAreNullable.kt") @@ -415,7 +416,7 @@ public class ForeignAnnotationsTestGenerated extends AbstractForeignAnnotationsT } public void testAllFilesPresentInJsr305NullabilityWarnings() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration") @@ -427,7 +428,7 @@ public class ForeignAnnotationsTestGenerated extends AbstractForeignAnnotationsT } public void testAllFilesPresentInMigration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("customMigration.kt") @@ -486,7 +487,7 @@ public class ForeignAnnotationsTestGenerated extends AbstractForeignAnnotationsT } public void testAllFilesPresentInTypeQualifierDefault() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/typeQualifierDefault"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/typeQualifierDefault"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("defaultAndNicknameMigrationPolicy.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/checkers/javac/JavacForeignAnnotationsTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/checkers/javac/JavacForeignAnnotationsTestGenerated.java index 60e36b32c1d..d71e182c849 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/checkers/javac/JavacForeignAnnotationsTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/checkers/javac/JavacForeignAnnotationsTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.checkers.javac; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class JavacForeignAnnotationsTestGenerated extends AbstractJavacForeignAn } public void testAllFilesPresentInTests() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("androidRecently.kt") @@ -92,7 +93,7 @@ public class JavacForeignAnnotationsTestGenerated extends AbstractJavacForeignAn } public void testAllFilesPresentInJsr305() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("nonNullNever.kt") @@ -124,7 +125,7 @@ public class JavacForeignAnnotationsTestGenerated extends AbstractJavacForeignAn } public void testAllFilesPresentInIgnore() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/ignore"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/ignore"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("parametersAreNonnullByDefault.kt") @@ -142,7 +143,7 @@ public class JavacForeignAnnotationsTestGenerated extends AbstractJavacForeignAn } public void testAllFilesPresentInNullabilityWarnings() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("elvis.kt") @@ -189,7 +190,7 @@ public class JavacForeignAnnotationsTestGenerated extends AbstractJavacForeignAn } public void testAllFilesPresentInFromPlatformTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/fromPlatformTypes"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("arithmetic.kt") @@ -302,7 +303,7 @@ public class JavacForeignAnnotationsTestGenerated extends AbstractJavacForeignAn } public void testAllFilesPresentInTypeQualifierDefault() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/nullabilityWarnings/typeQualifierDefault"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("equalsOnNonNull.kt") @@ -356,7 +357,7 @@ public class JavacForeignAnnotationsTestGenerated extends AbstractJavacForeignAn } public void testAllFilesPresentInTypeQualifierDefault() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305/typeQualifierDefault"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("fieldsAreNullable.kt") @@ -415,7 +416,7 @@ public class JavacForeignAnnotationsTestGenerated extends AbstractJavacForeignAn } public void testAllFilesPresentInJsr305NullabilityWarnings() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration") @@ -427,7 +428,7 @@ public class JavacForeignAnnotationsTestGenerated extends AbstractJavacForeignAn } public void testAllFilesPresentInMigration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/jsr305NullabilityWarnings/migration"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("customMigration.kt") @@ -486,7 +487,7 @@ public class JavacForeignAnnotationsTestGenerated extends AbstractJavacForeignAn } public void testAllFilesPresentInTypeQualifierDefault() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/typeQualifierDefault"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotations/tests/typeQualifierDefault"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("defaultAndNicknameMigrationPolicy.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/cli/CliTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/cli/CliTestGenerated.java index 0887e77bfdd..0811666f4d4 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/cli/CliTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/cli/CliTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.cli; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -27,7 +28,7 @@ public class CliTestGenerated extends AbstractCliTest { } public void testAllFilesPresentInJvm() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cli/jvm"), Pattern.compile("^(.+)\\.args$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cli/jvm"), Pattern.compile("^(.+)\\.args$"), null, false); } @TestMetadata("apiAndLanguageVersionsUnsupported.args") @@ -885,7 +886,7 @@ public class CliTestGenerated extends AbstractCliTest { } public void testAllFilesPresentInJs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cli/js"), Pattern.compile("^(.+)\\.args$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cli/js"), Pattern.compile("^(.+)\\.args$"), null, false); } @TestMetadata("createMetadata.args") @@ -1078,7 +1079,7 @@ public class CliTestGenerated extends AbstractCliTest { } public void testAllFilesPresentInJs_dce() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cli/js-dce"), Pattern.compile("^(.+)\\.args$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cli/js-dce"), Pattern.compile("^(.+)\\.args$"), null, false); } @TestMetadata("dceExtraHelp.args") @@ -1151,7 +1152,7 @@ public class CliTestGenerated extends AbstractCliTest { } public void testAllFilesPresentInMetadata() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cli/metadata"), Pattern.compile("^(.+)\\.args$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/cli/metadata"), Pattern.compile("^(.+)\\.args$"), null, false); } @TestMetadata("kotlinPackage.args") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/AsmLikeInstructionListingTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/AsmLikeInstructionListingTestGenerated.java index e4b4f5340f9..c79a89316ac 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/AsmLikeInstructionListingTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/AsmLikeInstructionListingTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.codegen; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class AsmLikeInstructionListingTestGenerated extends AbstractAsmLikeInstr } public void testAllFilesPresentInAsmLike() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/asmLike"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/asmLike"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/codegen/asmLike/receiverMangling") @@ -38,7 +39,7 @@ public class AsmLikeInstructionListingTestGenerated extends AbstractAsmLikeInstr } public void testAllFilesPresentInReceiverMangling() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/asmLike/receiverMangling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/asmLike/receiverMangling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("deepInline.kt") @@ -111,7 +112,7 @@ public class AsmLikeInstructionListingTestGenerated extends AbstractAsmLikeInstr } public void testAllFilesPresentInTypeAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/asmLike/typeAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/asmLike/typeAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("complex.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/BlackBoxAgainstJavaCodegenTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/BlackBoxAgainstJavaCodegenTestGenerated.java index bf6e05f1343..34d34562a2f 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/BlackBoxAgainstJavaCodegenTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/BlackBoxAgainstJavaCodegenTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.codegen; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class BlackBoxAgainstJavaCodegenTestGenerated extends AbstractBlackBoxAga } public void testAllFilesPresentInBoxAgainstJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/testData/codegen/boxAgainstJava/annotations") @@ -37,7 +38,7 @@ public class BlackBoxAgainstJavaCodegenTestGenerated extends AbstractBlackBoxAga } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/annotations"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/annotations"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("divisionByZeroInJava.kt") @@ -94,7 +95,7 @@ public class BlackBoxAgainstJavaCodegenTestGenerated extends AbstractBlackBoxAga } public void testAllFilesPresentInKClassMapping() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/annotations/kClassMapping"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/annotations/kClassMapping"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("arrayClassParameter.kt") @@ -137,7 +138,7 @@ public class BlackBoxAgainstJavaCodegenTestGenerated extends AbstractBlackBoxAga } public void testAllFilesPresentInTypeAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/annotations/typeAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/annotations/typeAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("implicitReturn.kt") @@ -156,7 +157,7 @@ public class BlackBoxAgainstJavaCodegenTestGenerated extends AbstractBlackBoxAga } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("constructor.kt") @@ -194,7 +195,7 @@ public class BlackBoxAgainstJavaCodegenTestGenerated extends AbstractBlackBoxAga } public void testAllFilesPresentInConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/constructor"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/constructor"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("genericConstructor.kt") @@ -217,7 +218,7 @@ public class BlackBoxAgainstJavaCodegenTestGenerated extends AbstractBlackBoxAga } public void testAllFilesPresentInDelegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/delegation"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/delegation"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("delegationAndInheritanceFromJava.kt") @@ -235,7 +236,7 @@ public class BlackBoxAgainstJavaCodegenTestGenerated extends AbstractBlackBoxAga } public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/enum"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/enum"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("nameConflict.kt") @@ -283,7 +284,7 @@ public class BlackBoxAgainstJavaCodegenTestGenerated extends AbstractBlackBoxAga } public void testAllFilesPresentInFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/functions"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/functions"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("constructor.kt") @@ -321,7 +322,7 @@ public class BlackBoxAgainstJavaCodegenTestGenerated extends AbstractBlackBoxAga } public void testAllFilesPresentInIeee754() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/ieee754"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/ieee754"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("anyToReal.kt") @@ -374,7 +375,7 @@ public class BlackBoxAgainstJavaCodegenTestGenerated extends AbstractBlackBoxAga } public void testAllFilesPresentInInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/inline"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/inline"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("kt19910.kt") @@ -392,7 +393,7 @@ public class BlackBoxAgainstJavaCodegenTestGenerated extends AbstractBlackBoxAga } public void testAllFilesPresentInInnerClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/innerClass"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/innerClass"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("kt3532.kt") @@ -420,7 +421,7 @@ public class BlackBoxAgainstJavaCodegenTestGenerated extends AbstractBlackBoxAga } public void testAllFilesPresentInInterfaces() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/interfaces"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/interfaces"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("inheritJavaInterface.kt") @@ -438,7 +439,7 @@ public class BlackBoxAgainstJavaCodegenTestGenerated extends AbstractBlackBoxAga } public void testAllFilesPresentInMultiplatform() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("annotationsViaActualTypeAliasFromBinary.kt") @@ -456,7 +457,7 @@ public class BlackBoxAgainstJavaCodegenTestGenerated extends AbstractBlackBoxAga } public void testAllFilesPresentInNotNullAssertions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/notNullAssertions"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/notNullAssertions"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("callAssertions.kt") @@ -494,7 +495,7 @@ public class BlackBoxAgainstJavaCodegenTestGenerated extends AbstractBlackBoxAga } public void testAllFilesPresentInOldLanguageVersions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/oldLanguageVersions"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/oldLanguageVersions"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/testData/codegen/boxAgainstJava/oldLanguageVersions/ieee754") @@ -506,7 +507,7 @@ public class BlackBoxAgainstJavaCodegenTestGenerated extends AbstractBlackBoxAga } public void testAllFilesPresentInIeee754() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/oldLanguageVersions/ieee754"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/oldLanguageVersions/ieee754"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("explicitEqualsCallNull.kt") @@ -525,7 +526,7 @@ public class BlackBoxAgainstJavaCodegenTestGenerated extends AbstractBlackBoxAga } public void testAllFilesPresentInPlatformTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/platformTypes"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/platformTypes"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("genericUnit.kt") @@ -558,7 +559,7 @@ public class BlackBoxAgainstJavaCodegenTestGenerated extends AbstractBlackBoxAga } public void testAllFilesPresentInProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/property"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/property"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("fieldAccessFromExtensionInTraitImpl.kt") @@ -586,7 +587,7 @@ public class BlackBoxAgainstJavaCodegenTestGenerated extends AbstractBlackBoxAga } public void testAllFilesPresentInRecursiveRawTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/recursiveRawTypes"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/recursiveRawTypes"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("kt16528.kt") @@ -609,7 +610,7 @@ public class BlackBoxAgainstJavaCodegenTestGenerated extends AbstractBlackBoxAga } public void testAllFilesPresentInReflection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/reflection"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/reflection"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/testData/codegen/boxAgainstJava/reflection/classLiterals") @@ -621,7 +622,7 @@ public class BlackBoxAgainstJavaCodegenTestGenerated extends AbstractBlackBoxAga } public void testAllFilesPresentInClassLiterals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/reflection/classLiterals"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/reflection/classLiterals"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("javaClassLiteral.kt") @@ -639,7 +640,7 @@ public class BlackBoxAgainstJavaCodegenTestGenerated extends AbstractBlackBoxAga } public void testAllFilesPresentInMapping() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/reflection/mapping"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/reflection/mapping"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("jClass2kClass.kt") @@ -672,7 +673,7 @@ public class BlackBoxAgainstJavaCodegenTestGenerated extends AbstractBlackBoxAga } public void testAllFilesPresentInProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/reflection/properties"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/reflection/properties"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("equalsHashCodeToString.kt") @@ -691,7 +692,7 @@ public class BlackBoxAgainstJavaCodegenTestGenerated extends AbstractBlackBoxAga } public void testAllFilesPresentInSam() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/sam"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/sam"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("differentFqNames.kt") @@ -743,7 +744,7 @@ public class BlackBoxAgainstJavaCodegenTestGenerated extends AbstractBlackBoxAga } public void testAllFilesPresentInAdapters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/sam/adapters"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/sam/adapters"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("bridgesForOverridden.kt") @@ -900,7 +901,7 @@ public class BlackBoxAgainstJavaCodegenTestGenerated extends AbstractBlackBoxAga } public void testAllFilesPresentInOperators() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/sam/adapters/operators"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/sam/adapters/operators"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("augmentedAssignmentPure.kt") @@ -970,7 +971,7 @@ public class BlackBoxAgainstJavaCodegenTestGenerated extends AbstractBlackBoxAga } public void testAllFilesPresentInSpecialBuiltins() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/specialBuiltins"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/specialBuiltins"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("charBuffer.kt") @@ -988,7 +989,7 @@ public class BlackBoxAgainstJavaCodegenTestGenerated extends AbstractBlackBoxAga } public void testAllFilesPresentInStaticFun() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/staticFun"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/staticFun"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("classWithNestedEnum.kt") @@ -1006,7 +1007,7 @@ public class BlackBoxAgainstJavaCodegenTestGenerated extends AbstractBlackBoxAga } public void testAllFilesPresentInSyntheticExtensions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/syntheticExtensions"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/syntheticExtensions"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("fromTwoBases.kt") @@ -1069,7 +1070,7 @@ public class BlackBoxAgainstJavaCodegenTestGenerated extends AbstractBlackBoxAga } public void testAllFilesPresentInThrows() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/throws"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/throws"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("delegationAndThrows.kt") @@ -1087,7 +1088,7 @@ public class BlackBoxAgainstJavaCodegenTestGenerated extends AbstractBlackBoxAga } public void testAllFilesPresentInTypealias() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/typealias"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/typealias"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("javaStaticMembersViaTypeAlias.kt") @@ -1105,7 +1106,7 @@ public class BlackBoxAgainstJavaCodegenTestGenerated extends AbstractBlackBoxAga } public void testAllFilesPresentInVarargs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/varargs"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/varargs"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("varargsOverride.kt") @@ -1133,7 +1134,7 @@ public class BlackBoxAgainstJavaCodegenTestGenerated extends AbstractBlackBoxAga } public void testAllFilesPresentInVisibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/visibility"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/visibility"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/testData/codegen/boxAgainstJava/visibility/package") @@ -1145,7 +1146,7 @@ public class BlackBoxAgainstJavaCodegenTestGenerated extends AbstractBlackBoxAga } public void testAllFilesPresentInPackage() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/visibility/package"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/visibility/package"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("kt2781.kt") @@ -1178,7 +1179,7 @@ public class BlackBoxAgainstJavaCodegenTestGenerated extends AbstractBlackBoxAga } public void testAllFilesPresentInProtectedAndPackage() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/visibility/protectedAndPackage"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/visibility/protectedAndPackage"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("overrideProtectedFunInPackage.kt") @@ -1231,7 +1232,7 @@ public class BlackBoxAgainstJavaCodegenTestGenerated extends AbstractBlackBoxAga } public void testAllFilesPresentInProtectedStatic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/visibility/protectedStatic"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/visibility/protectedStatic"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("funCallInConstructor.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java index 89a1e8aa068..a06f0587e26 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.codegen; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInBox() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/codegen/box/annotations") @@ -38,7 +39,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("annotatedAnnotationParameter.kt") @@ -235,7 +236,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInAnnotatedLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations/annotatedLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations/annotatedLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("funExpression.kt") @@ -273,7 +274,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInTypeAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations/typeAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations/typeAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("checkingNotincorporatedInputTypes.kt") @@ -317,7 +318,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInArgumentOrder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/argumentOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/argumentOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("argumentOrderInObjectSuperCall.kt") @@ -410,7 +411,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInArrays() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("arrayConstructorWithNonInlineLambda.kt") @@ -747,7 +748,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInArraysOfInlineClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/arraysOfInlineClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/arraysOfInlineClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("arrayOfInlineClassOfArrayOfInlineClass.kt") @@ -765,7 +766,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInForInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/forInReversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/forInReversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("reversedArrayOriginalUpdatedInLoopBody.kt") @@ -798,7 +799,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInMultiDecl() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("kt15560.kt") @@ -850,7 +851,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInInt() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -883,7 +884,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInLong() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -918,7 +919,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInAssert() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/assert"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/assert"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("alwaysDisable.kt") @@ -940,7 +941,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInJvm() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/assert/jvm"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/assert/jvm"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("assertionsEnabledBeforeClassInitializers.kt") @@ -1064,7 +1065,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInBinaryOp() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/binaryOp"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/binaryOp"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("bitwiseOp.kt") @@ -1207,7 +1208,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInBoxingOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/boxingOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/boxingOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("boxedIntegersCmp.kt") @@ -1380,7 +1381,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInBridges() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/bridges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/bridges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("bridgeInInterface.kt") @@ -1677,7 +1678,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInSubstitutionInSuperClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/bridges/substitutionInSuperClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/bridges/substitutionInSuperClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("boundedTypeArguments.kt") @@ -1741,7 +1742,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInBuilderInference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("callableReferenceAndCoercionToUnit.kt") @@ -1789,7 +1790,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInBuiltinStubMethods() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("Collection.kt") @@ -1926,7 +1927,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInExtendJavaCollections() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/extendJavaCollections"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/extendJavaCollections"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("arrayList.kt") @@ -1959,7 +1960,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInMapGetOrDefault() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/mapGetOrDefault"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/mapGetOrDefault"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("noTypeSafeBridge.kt") @@ -1987,7 +1988,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInMapRemove() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/mapRemove"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/mapRemove"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("noDefaultImpls.kt") @@ -2021,7 +2022,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("builtinFunctionReferenceOwner.kt") @@ -2078,7 +2079,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInAdaptedReferences() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/adaptedReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/adaptedReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("bothWithCoercionToUnit.kt") @@ -2240,7 +2241,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInSuspendConversion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("bound.kt") @@ -2319,7 +2320,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInBound() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("array.kt") @@ -2466,7 +2467,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInEquals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/bound/equals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/bound/equals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("nullableReceiverInEquals.kt") @@ -2500,7 +2501,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInEquality() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/equality"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/equality"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("capturedDefaults.kt") @@ -2578,7 +2579,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/function"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/function"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("argumentTypes.kt") @@ -2860,7 +2861,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInLocal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/function/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/function/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("captureOuter.kt") @@ -2979,7 +2980,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("delegated.kt") @@ -3142,7 +3143,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInSerializability() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/serializability"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/serializability"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("boundWithNotSerializableReceiver.kt") @@ -3181,7 +3182,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInCasts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("as.kt") @@ -3318,7 +3319,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("asFunKBig.kt") @@ -3396,7 +3397,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInJavaInterop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("castWithWrongType.kt") @@ -3479,7 +3480,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInLiteralExpressionAsGenericArgument() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/literalExpressionAsGenericArgument"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/literalExpressionAsGenericArgument"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("binaryExpressionCast.kt") @@ -3527,7 +3528,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInMutableCollections() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/mutableCollections"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/mutableCollections"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("asWithMutable.kt") @@ -3581,7 +3582,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInCheckcastOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/checkcastOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/checkcastOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("kt19128.kt") @@ -3604,7 +3605,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInClassLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("bareArray.kt") @@ -3626,7 +3627,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInBound() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classLiteral/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classLiteral/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("javaIntrinsicWithSideEffect.kt") @@ -3664,7 +3665,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classLiteral/java"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classLiteral/java"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("java.kt") @@ -3718,7 +3719,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("boxPrimitiveTypeInClinitOfClassObject.kt") @@ -4330,7 +4331,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInInner() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classes/inner"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classes/inner"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("extensionWithOuter.kt") @@ -4379,7 +4380,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInClosures() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("anonymousObjectAsLastExpressionInLambda.kt") @@ -4621,7 +4622,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInCaptureInSuperConstructorCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/captureInSuperConstructorCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/captureInSuperConstructorCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("constructorParameterAndLocalCapturedInLambdaInLocalClass.kt") @@ -4794,7 +4795,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInCaptureOuterProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/captureOuterProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/captureOuterProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("captureFunctionInProperty.kt") @@ -4847,7 +4848,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInCapturedVarsOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/capturedVarsOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/capturedVarsOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("capturedInCrossinline.kt") @@ -4915,7 +4916,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInClosureInsideClosure() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/closureInsideClosure"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/closureInsideClosure"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("localFunInsideLocalFun.kt") @@ -4959,7 +4960,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInCollectionLiterals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/collectionLiterals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/collectionLiterals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("collectionLiteralsInArgumentPosition.kt") @@ -4997,7 +4998,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInCollections() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/collections"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/collections"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("charSequence.kt") @@ -5170,7 +5171,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInCompanion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/companion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/companion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("delegatedPropertyOnCompanion.kt") @@ -5193,7 +5194,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/compatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/compatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("privateCompanionObject.kt") @@ -5211,7 +5212,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInConstants() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/constants"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/constants"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("comparisonFalse.kt") @@ -5274,7 +5275,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInConstructorCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/constructorCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/constructorCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("breakInConstructorArguments.kt") @@ -5372,7 +5373,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInContracts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/contracts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/contracts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("constructorArgument.kt") @@ -5445,7 +5446,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInControlStructures() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("bottles.kt") @@ -5852,7 +5853,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInBreakContinueInExpressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("breakFromOuter.kt") @@ -5955,7 +5956,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInForInArray() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInArray"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInArray"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("forInArraySpecializedToUntil.kt") @@ -6018,7 +6019,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInForInArrayWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("forInArrayOfObjectArrayWithIndex.kt") @@ -6131,7 +6132,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInForInCharSequenceWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInCharSequenceWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInCharSequenceWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("forInCharSeqWithIndexStops.kt") @@ -6214,7 +6215,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInForInIterableWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInIterableWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInIterableWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("forInEmptyListWithIndex.kt") @@ -6282,7 +6283,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInForInSequenceWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInSequenceWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInSequenceWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("forInEmptySequenceWithIndex.kt") @@ -6350,7 +6351,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInReturnsNothing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/returnsNothing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/returnsNothing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("ifElse.kt") @@ -6388,7 +6389,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInTryCatchInExpressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("catch.kt") @@ -6562,7 +6563,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInCoroutines() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("async.kt") @@ -7144,7 +7145,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInBridges() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/bridges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/bridges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("interfaceSpecialization.kt") @@ -7172,7 +7173,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInControlFlow() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/controlFlow"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/controlFlow"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("breakFinally.kt") @@ -7295,7 +7296,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInDebug() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/debug"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/debug"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("debuggerMetadata.kt") @@ -7348,7 +7349,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInFeatureIntersection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("breakWithNonEmptyStack.kt") @@ -7445,7 +7446,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("bigArity.kt") @@ -7472,7 +7473,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInBound() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("emptyLHS.kt") @@ -7490,7 +7491,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/function"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/function"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("genericCallableReferenceArguments.kt") @@ -7517,7 +7518,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInLocal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/function/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/function/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("equalsHashCode.kt") @@ -7537,7 +7538,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInTailrec() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/tailrec"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/tailrec"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("controlFlowIf.kt") @@ -7616,7 +7617,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("nonLocalReturn.kt") @@ -7633,7 +7634,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInDirect() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses/direct"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses/direct"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("boxReturnValueOfSuspendFunctionReference.kt") @@ -7861,7 +7862,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInResume() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses/resume"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses/resume"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("boxReturnValueOfSuspendFunctionReference.kt") @@ -8089,7 +8090,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInResumeWithException() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("boxReturnValueOfSuspendFunctionReference.kt") @@ -8303,7 +8304,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInIntLikeVarSpilling() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/intLikeVarSpilling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/intLikeVarSpilling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("complicatedMerge.kt") @@ -8371,7 +8372,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInIntrinsicSemantics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/intrinsicSemantics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/intrinsicSemantics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("coroutineContext.kt") @@ -8424,7 +8425,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInJavaInterop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("objectWithSeveralSuspends.kt") @@ -8462,7 +8463,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInLocalFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/localFunctions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/localFunctions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/codegen/box/coroutines/localFunctions/anonymous") @@ -8474,7 +8475,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInAnonymous() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/localFunctions/anonymous"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/localFunctions/anonymous"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("simple.kt") @@ -8492,7 +8493,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInNamed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/localFunctions/named"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/localFunctions/named"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("capturedParameters.kt") @@ -8561,7 +8562,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInMultiModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("inlineCrossModule.kt") @@ -8619,7 +8620,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInRedundantLocalsElimination() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/redundantLocalsElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/redundantLocalsElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("ktor_receivedMessage.kt") @@ -8637,7 +8638,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInReflect() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/reflect"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/reflect"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("bigArity.kt") @@ -8665,7 +8666,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInStackUnwinding() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/stackUnwinding"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/stackUnwinding"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("exception.kt") @@ -8708,7 +8709,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInSuspendConversion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/suspendConversion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/suspendConversion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("intersectionTypeToSubtypeConversion.kt") @@ -8741,7 +8742,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInSuspendFunctionAsCoroutine() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("dispatchResume.kt") @@ -8844,7 +8845,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInSuspendFunctionTypeCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/suspendFunctionTypeCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/suspendFunctionTypeCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("localVal.kt") @@ -8882,7 +8883,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInTailCallOptimizations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/tailCallOptimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/tailCallOptimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("also.kt") @@ -8969,7 +8970,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInUnit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/tailCallOptimizations/unit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/tailCallOptimizations/unit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("functionReference.kt") @@ -9038,7 +9039,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInTailOperations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/tailOperations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/tailOperations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("suspendWithIf.kt") @@ -9071,7 +9072,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInUnitTypeReturn() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/unitTypeReturn"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/unitTypeReturn"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("coroutineNonLocalReturn.kt") @@ -9119,7 +9120,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInVarSpilling() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/varSpilling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/varSpilling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("fakeInlinerVariables.kt") @@ -9163,7 +9164,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInDataClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("arrayParams.kt") @@ -9255,7 +9256,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInCopy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/copy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/copy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("constructorWithDefaultParam.kt") @@ -9308,7 +9309,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInEquals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/equals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/equals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("alreadyDeclared.kt") @@ -9356,7 +9357,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInHashCode() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/hashCode"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/hashCode"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("alreadyDeclared.kt") @@ -9434,7 +9435,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInToString() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/toString"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/toString"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("alreadyDeclared.kt") @@ -9483,7 +9484,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInDeadCodeElimination() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/deadCodeElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/deadCodeElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("emptyVariableRange.kt") @@ -9516,7 +9517,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInDefaultArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("callDefaultFromInitializer.kt") @@ -9613,7 +9614,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/constructor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/constructor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("annotation.kt") @@ -9711,7 +9712,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInConvention() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/convention"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/convention"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("incWithDefaultInGetter.kt") @@ -9764,7 +9765,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/function"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/function"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("complexInheritance.kt") @@ -9912,7 +9913,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInPrivate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("memberExtensionFunction.kt") @@ -9945,7 +9946,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/signature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/signature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("kt2789.kt") @@ -9979,7 +9980,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInDelegatedProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("beforeDeclarationContainerOptimization.kt") @@ -10226,7 +10227,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInLocal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("capturedLocalVal.kt") @@ -10324,7 +10325,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInOptimizedDelegatedProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/optimizedDelegatedProperties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/optimizedDelegatedProperties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("definedInSources.kt") @@ -10387,7 +10388,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInProvideDelegate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/provideDelegate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/provideDelegate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("delegatedPropertyWithIdProvideDelegate.kt") @@ -10511,7 +10512,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInDelegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("byMiddleInterface.kt") @@ -10599,7 +10600,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInDestructuringDeclInLambdaParam() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/destructuringDeclInLambdaParam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/destructuringDeclInLambdaParam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("extensionComponents.kt") @@ -10652,7 +10653,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInDiagnostics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/codegen/box/diagnostics/functions") @@ -10664,7 +10665,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/codegen/box/diagnostics/functions/inference") @@ -10676,7 +10677,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInInference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/inference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/inference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("kt6176.kt") @@ -10694,7 +10695,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInInvoke() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/invoke"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/invoke"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects") @@ -10706,7 +10707,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInOnObjects() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("invokeOnClassObject1.kt") @@ -10770,7 +10771,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInTailRecursion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/tailRecursion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/tailRecursion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("defaultArgs.kt") @@ -10989,7 +10990,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInVararg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/vararg"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/vararg"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("kt4172.kt") @@ -11008,7 +11009,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInElvis() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/elvis"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/elvis"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("genericElvisWithMoreSpecificLHS.kt") @@ -11066,7 +11067,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("annotatedParameter.kt") @@ -11383,7 +11384,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInDefaultCtor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/enum/defaultCtor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/enum/defaultCtor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("constructorWithDefaultArguments.kt") @@ -11427,7 +11428,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInEvaluate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/evaluate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/evaluate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("char.kt") @@ -11515,7 +11516,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInExclExcl() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/exclExcl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/exclExcl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("genericNull.kt") @@ -11538,7 +11539,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInExtensionFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/extensionFunctions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/extensionFunctions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("executionOrder.kt") @@ -11676,7 +11677,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInExtensionProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/extensionProperties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/extensionProperties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("genericValForPrimitiveType.kt") @@ -11759,7 +11760,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInExternal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/external"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/external"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("jvmStaticExternal.kt") @@ -11787,7 +11788,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInFakeOverride() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fakeOverride"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fakeOverride"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("diamondFunction.kt") @@ -11830,7 +11831,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInFieldRename() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fieldRename"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fieldRename"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("constructorAndClassObject.kt") @@ -11868,7 +11869,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInFinally() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/finally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/finally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("breakAndOuterFinally.kt") @@ -11991,7 +11992,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInFullJdk() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("charBuffer.kt") @@ -12033,7 +12034,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInNative() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk/native"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk/native"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("nativePropertyAccessors.kt") @@ -12061,7 +12062,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInRegressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk/regressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk/regressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("kt15112.kt") @@ -12085,7 +12086,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInFunInterface() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("basicFunInterface.kt") @@ -12202,7 +12203,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInEquality() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/funInterface/equality"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/funInterface/equality"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("functionReferencesBound.kt") @@ -12241,7 +12242,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("coerceVoidToArray.kt") @@ -12478,7 +12479,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInBigArity() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/bigArity"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/bigArity"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("callFromJava.kt") @@ -12546,7 +12547,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInFunctionExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/functionExpression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/functionExpression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("functionExpression.kt") @@ -12589,7 +12590,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInInvoke() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/invoke"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/invoke"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("castFunctionToExtension.kt") @@ -12677,7 +12678,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInLocalFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/localFunctions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/localFunctions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("boundTypeParameterInSupertype.kt") @@ -12841,7 +12842,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInHashPMap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/hashPMap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/hashPMap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("empty.kt") @@ -12884,7 +12885,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInIeee754() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ieee754"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ieee754"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("anyToReal.kt") @@ -13142,7 +13143,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInIncrement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/increment"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/increment"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("argumentWithSideEffects.kt") @@ -13285,7 +13286,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInInference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("approximateNonTopLevelCapturedTypes.kt") @@ -13453,7 +13454,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("annotatedMemberExtensionProperty.kt") @@ -14300,7 +14301,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInBoxReturnValueInLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("boxAny.kt") @@ -14373,7 +14374,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInBoxReturnValueOnOverride() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("covariantOverrideChainErasedToAny.kt") @@ -14516,7 +14517,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInCallableReferences() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/callableReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/callableReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("boundInlineClassExtensionFun.kt") @@ -14684,7 +14685,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInContextsAndAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("captureInlineClassInstanceInLambda.kt") @@ -14752,7 +14753,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInDefaultParameterValues() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/defaultParameterValues"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/defaultParameterValues"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("defaultConstructorParameterValuesOfInlineClassType.kt") @@ -14825,7 +14826,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInFunctionNameMangling() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/functionNameMangling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/functionNameMangling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("anonymousObjectInFunctionWithMangledName.kt") @@ -14928,7 +14929,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInHiddenConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/hiddenConstructor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/hiddenConstructor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("constructorReferencedFromOtherFile1.kt") @@ -15006,7 +15007,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInInterfaceDelegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/interfaceDelegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/interfaceDelegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("interfaceImplementationByDelegation.kt") @@ -15059,7 +15060,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInInterfaceMethodCalls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("complexGenericMethodWithInlineClassOverride.kt") @@ -15127,7 +15128,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInJavaInterop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("inlineClasInSignature.kt") @@ -15155,7 +15156,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInJvm8DefaultInterfaceMethods() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/jvm8DefaultInterfaceMethods"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/jvm8DefaultInterfaceMethods"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("javaDefaultMethod.kt") @@ -15228,7 +15229,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInPropertyDelegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/propertyDelegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/propertyDelegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("captureLocalVarDelegatedToInlineClass.kt") @@ -15301,7 +15302,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInUnboxGenericParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface") @@ -15313,7 +15314,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInFunInterface() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("any.kt") @@ -15361,7 +15362,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("any.kt") @@ -15409,7 +15410,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInObjectLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("any.kt") @@ -15459,7 +15460,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInInnerNested() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/innerNested"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/innerNested"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("createNestedClass.kt") @@ -15611,7 +15612,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInSuperConstructorCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/innerNested/superConstructorCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/innerNested/superConstructorCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("deepInnerHierarchy.kt") @@ -15730,7 +15731,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInInstructions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/instructions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/instructions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/codegen/box/instructions/swap") @@ -15742,7 +15743,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInSwap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/instructions/swap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/instructions/swap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("swapRefToSharedVarInt.kt") @@ -15766,7 +15767,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInIntrinsics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/intrinsics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/intrinsics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("charToInt.kt") @@ -15914,7 +15915,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInIr() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("anonymousClassLeak.kt") @@ -16021,7 +16022,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInClosureConversion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/closureConversion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/closureConversion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("closureConversion1.kt") @@ -16074,7 +16075,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInPrimitiveNumberComparisons() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/primitiveNumberComparisons"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/primitiveNumberComparisons"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("comparableToDouble.kt") @@ -16107,7 +16108,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInSerializationRegressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/serializationRegressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/serializationRegressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("deepGenericDelegatedProperty.kt") @@ -16161,7 +16162,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInJavaInterop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("genericSamProjectedOut.kt") @@ -16213,7 +16214,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInGenerics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/generics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/generics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("allWildcardsOnClass.kt") @@ -16261,7 +16262,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInNotNullAssertions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("destructuringAssignmentWithNullabilityAssertionOnExtensionReceiver_lv12.kt") @@ -16363,7 +16364,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInEnhancedNullability() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions/enhancedNullability"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions/enhancedNullability"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("inFunctionWithExpressionBody.kt") @@ -16416,7 +16417,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInNullCheckOnLambdaReturnValue() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions/nullCheckOnLambdaReturnValue"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions/nullCheckOnLambdaReturnValue"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("nnStringVsT.kt") @@ -16480,7 +16481,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInObjectMethods() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/objectMethods"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/objectMethods"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("cloneCallsConstructor.kt") @@ -16524,7 +16525,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInJdk() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jdk"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jdk"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("arrayList.kt") @@ -16577,7 +16578,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInJvm8() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("bridgeInClass.kt") @@ -16714,7 +16715,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInDefaults() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("bridgeInClass.kt") @@ -16871,7 +16872,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInAllCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("bridge.kt") @@ -17013,7 +17014,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInDelegationBy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("simple.kt") @@ -17037,7 +17038,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/compatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/compatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("bridge.kt") @@ -17130,7 +17131,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInDelegationBy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("simple.kt") @@ -17163,7 +17164,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInNoDefaultImpls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("bridge.kt") @@ -17300,7 +17301,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInDelegationBy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("simple.kt") @@ -17323,7 +17324,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInSpecialization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/specialization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/specialization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("basic.kt") @@ -17342,7 +17343,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInNoDelegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDelegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDelegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("noDelegationToDefaultMethodInClass.kt") @@ -17370,7 +17371,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInReflection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/reflection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/reflection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("propertyAnnotations.kt") @@ -17389,7 +17390,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInInterfaceFlag() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/interfaceFlag"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/interfaceFlag"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("superCall.kt") @@ -17412,7 +17413,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInJavaDefaults() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/javaDefaults"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/javaDefaults"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("capturedSuperCall.kt") @@ -17496,7 +17497,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInJvmField() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmField"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmField"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("annotationCompanion.kt") @@ -17634,7 +17635,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInJvmName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("annotationProperties.kt") @@ -17721,7 +17722,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInFileFacades() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmName/fileFacades"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmName/fileFacades"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("differentFiles.kt") @@ -17750,7 +17751,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInJvmOverloads() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmOverloads"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmOverloads"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("companionObject.kt") @@ -17863,7 +17864,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInJvmPackageName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmPackageName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmPackageName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("metadataField.kt") @@ -17901,7 +17902,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInJvmStatic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmStatic"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmStatic"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("annotations.kt") @@ -18079,7 +18080,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInLabels() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/labels"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/labels"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("controlLabelClashesWithFuncitonName.kt") @@ -18132,7 +18133,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInLazyCodegen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/lazyCodegen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/lazyCodegen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("exceptionInFieldInitializer.kt") @@ -18189,7 +18190,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInOptimizations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/lazyCodegen/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/lazyCodegen/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("negateConstantCompare.kt") @@ -18248,7 +18249,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInLocalClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/localClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/localClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("anonymousObjectInExtension.kt") @@ -18431,7 +18432,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInMangling() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/mangling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/mangling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("field.kt") @@ -18489,7 +18490,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInMixedNamedPosition() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/mixedNamedPosition"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/mixedNamedPosition"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("defaults.kt") @@ -18522,7 +18523,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInMultiDecl() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("ComplexInitializer.kt") @@ -18604,7 +18605,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInForIterator() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forIterator"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forIterator"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("MultiDeclFor.kt") @@ -18641,7 +18642,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInLongIterator() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forIterator/longIterator"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forIterator/longIterator"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -18675,7 +18676,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInForRange() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("MultiDeclFor.kt") @@ -18722,7 +18723,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInExplicitRangeTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("MultiDeclFor.kt") @@ -18759,7 +18760,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInInt() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -18792,7 +18793,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInLong() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -18826,7 +18827,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInExplicitRangeToWithDot() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("MultiDeclFor.kt") @@ -18863,7 +18864,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInInt() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -18896,7 +18897,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInLong() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -18930,7 +18931,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInInt() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -18963,7 +18964,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInLong() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -18998,7 +18999,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInMultifileClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("callMultifileClassMemberFromOtherPackage.kt") @@ -19080,7 +19081,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInOptimized() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multifileClasses/optimized"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multifileClasses/optimized"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("callInInlineLambda.kt") @@ -19149,7 +19150,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInMultiplatform() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("expectClassInJvmMultifileFacade.kt") @@ -19186,7 +19187,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInDefaultArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("annotations.kt") @@ -19314,7 +19315,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInMultiModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("expectActualLink.kt") @@ -19343,7 +19344,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInNonLocalReturns() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nonLocalReturns"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nonLocalReturns"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("kt6895.kt") @@ -19386,7 +19387,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInNothingValue() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nothingValue"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nothingValue"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("inNestedCall.kt") @@ -19409,7 +19410,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInNullCheckOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nullCheckOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nullCheckOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("exclExclThrowsKnpe_1_3.kt") @@ -19482,7 +19483,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInObjectIntrinsics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objectIntrinsics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objectIntrinsics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("objects.kt") @@ -19500,7 +19501,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInObjects() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("anonymousObjectPropertyInitialization.kt") @@ -19872,7 +19873,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInCompanionObjectAccess() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("kt27117.kt") @@ -19969,7 +19970,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInMultipleCompanionsWithAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("anonymousObjectInPropertyInitializer.kt") @@ -20037,7 +20038,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInPrimitiveCompanion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess/primitiveCompanion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess/primitiveCompanion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("byteCompanionObject.kt") @@ -20087,7 +20088,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInOldLanguageVersions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("dataClassEqualsHashCodeToString.kt") @@ -20104,7 +20105,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInControlStructures() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/controlStructures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/controlStructures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/codegen/box/oldLanguageVersions/controlStructures/forInArray") @@ -20116,7 +20117,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInForInArray() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/controlStructures/forInArray"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/controlStructures/forInArray"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("forInArrayWithArrayVarUpdatedInLoopBody12.kt") @@ -20135,7 +20136,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInCoroutines() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("asyncIteratorNullMerge_1_2.kt") @@ -20187,7 +20188,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInControlFlow() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines/controlFlow"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines/controlFlow"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("kt22694_1_2.kt") @@ -20205,7 +20206,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInFeatureIntersection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines/featureIntersection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines/featureIntersection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("suspendFunction_1_2.kt") @@ -20223,7 +20224,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInMultiModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("inlineWithJava_1_2.kt") @@ -20241,7 +20242,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInReflect() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines/reflect"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines/reflect"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("isSuspend_1_2.kt") @@ -20259,7 +20260,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInSuspendFunctionAsCoroutine() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines/suspendFunctionAsCoroutine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines/suspendFunctionAsCoroutine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("ifExpressionInsideCoroutine_1_2.kt") @@ -20283,7 +20284,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/codegen/box/oldLanguageVersions/functions/bigArity") @@ -20295,7 +20296,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInBigArity() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/functions/bigArity"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/functions/bigArity"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("noBigFunctionTypes.kt") @@ -20314,7 +20315,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInIeee754() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/ieee754"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/ieee754"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("nullableDoubleEquals10.kt") @@ -20357,7 +20358,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInJavaInterop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/codegen/box/oldLanguageVersions/javaInterop/notNullAssertions") @@ -20369,7 +20370,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInNotNullAssertions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/javaInterop/notNullAssertions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/javaInterop/notNullAssertions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("incWithNullabilityAssertionOnExtensionReceiverInPrivateOperator_lv11.kt") @@ -20403,7 +20404,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInOperatorConventions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/operatorConventions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/operatorConventions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("percentAsModOnBigIntegerWithoutRem.kt") @@ -20421,7 +20422,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInPlatformTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/platformTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/platformTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/codegen/box/oldLanguageVersions/platformTypes/primitives") @@ -20433,7 +20434,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInPrimitives() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/platformTypes/primitives"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/platformTypes/primitives"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("equalsNull_lv11.kt") @@ -20453,7 +20454,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInOperatorConventions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/operatorConventions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/operatorConventions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("annotatedAssignment.kt") @@ -20565,7 +20566,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInCompareTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/operatorConventions/compareTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/operatorConventions/compareTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("boolean.kt") @@ -20634,7 +20635,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInOptimizations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("hashCode.kt") @@ -20657,7 +20658,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInPackage() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/package"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/package"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("boxPrimitiveTypeInClinit.kt") @@ -20730,7 +20731,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInParametersMetadata() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/parametersMetadata"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/parametersMetadata"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("defaultImpls.kt") @@ -20793,7 +20794,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInPlatformTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/platformTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/platformTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("inferenceFlexibleTToNullable.kt") @@ -20820,7 +20821,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInPrimitives() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/platformTypes/primitives"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/platformTypes/primitives"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("assign.kt") @@ -20939,7 +20940,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInPolymorphicSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/polymorphicSignature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/polymorphicSignature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("anonymousSubclass.kt") @@ -20992,7 +20993,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInPrimitiveTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("comparisonWithNaN.kt") @@ -21299,7 +21300,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInEqualityWithObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes/equalityWithObject"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes/equalityWithObject"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("boxedEqPrimitiveEvaluationOrder.kt") @@ -21356,7 +21357,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInGenerated() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("boxedEqPrimitiveBoolean.kt") @@ -21461,7 +21462,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInPrivate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("arrayConvention.kt") @@ -21484,7 +21485,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInPrivateConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/privateConstructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/privateConstructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("base.kt") @@ -21592,7 +21593,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("augmentedAssignmentsAndIncrements.kt") @@ -21999,7 +22000,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInConst() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/const"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/const"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("anotherFile.kt") @@ -22067,7 +22068,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInLateinit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("exceptionField.kt") @@ -22134,7 +22135,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInIsInitializedAndDeinitialize() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/isInitializedAndDeinitialize"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/isInitializedAndDeinitialize"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("companionObjectField.kt") @@ -22192,7 +22193,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInLocal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("capturedLocalLateinit.kt") @@ -22250,7 +22251,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInTopLevel() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/topLevel"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/topLevel"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("topLevelLateinit.kt") @@ -22280,7 +22281,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInPublishedApi() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/publishedApi"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/publishedApi"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("noMangling.kt") @@ -22308,7 +22309,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInRanges() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("forByteProgressionWithIntIncrement.kt") @@ -22405,7 +22406,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInContains() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/contains"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/contains"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("comparisonWithRangeBoundEliminated.kt") @@ -22617,7 +22618,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInGenerated() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/contains/generated"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/contains/generated"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("arrayIndices.kt") @@ -22701,7 +22702,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInEvaluationOrder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("forInDownTo.kt") @@ -22758,7 +22759,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInStepped() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo") @@ -22770,7 +22771,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInForInDownTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("forInDownToReversedStep.kt") @@ -22823,7 +22824,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInForInRangeLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInRangeLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInRangeLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("forInRangeLiteralReversedStep.kt") @@ -22876,7 +22877,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInForInUntil() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInUntil"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInUntil"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("forInUntilReversedStep.kt") @@ -22931,7 +22932,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("emptyDownto.kt") @@ -23094,7 +23095,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInForInDownTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInDownTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInDownTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("forIntInDownTo.kt") @@ -23132,7 +23133,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInForInIndices() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInIndices"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInIndices"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("forInArrayListIndices.kt") @@ -23250,7 +23251,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInForInProgressionWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInProgressionWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInProgressionWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("forInDownToWithIndex.kt") @@ -23338,7 +23339,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInForInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInReversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInReversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("forInReversedArrayIndices.kt") @@ -23441,7 +23442,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInForInUntil() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInUntil"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInUntil"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("forInUntilChar.kt") @@ -23529,7 +23530,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInForWithPossibleOverflow() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forWithPossibleOverflow"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forWithPossibleOverflow"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("forInDownToCharMinValue.kt") @@ -23607,7 +23608,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInJavaInterop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("javaArrayOfInheritedNotNull.kt") @@ -23714,7 +23715,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/javaInterop/withIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/javaInterop/withIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("javaArrayOfInheritedNotNullWithIndex.kt") @@ -23793,7 +23794,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("emptyDownto.kt") @@ -23956,7 +23957,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInNullableLoopParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/nullableLoopParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/nullableLoopParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("progressionExpression.kt") @@ -23984,7 +23985,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInStepped() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/codegen/box/ranges/stepped/expression") @@ -23996,7 +23997,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/codegen/box/ranges/stepped/expression/downTo") @@ -24008,7 +24009,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInDownTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/downTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/downTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("emptyProgression.kt") @@ -24100,7 +24101,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/downTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/downTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -24153,7 +24154,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/downTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/downTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("reversedThenStep.kt") @@ -24197,7 +24198,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInRangeTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("emptyProgression.kt") @@ -24289,7 +24290,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -24342,7 +24343,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("reversedThenStep.kt") @@ -24386,7 +24387,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInUntil() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/until"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/until"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("emptyProgression.kt") @@ -24483,7 +24484,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/until/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/until/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -24536,7 +24537,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/until/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/until/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("reversedThenStep.kt") @@ -24581,7 +24582,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/codegen/box/ranges/stepped/literal/downTo") @@ -24593,7 +24594,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInDownTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/downTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/downTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("emptyProgression.kt") @@ -24685,7 +24686,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/downTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/downTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -24738,7 +24739,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/downTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/downTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("reversedThenStep.kt") @@ -24782,7 +24783,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInRangeTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("emptyProgression.kt") @@ -24874,7 +24875,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -24927,7 +24928,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("reversedThenStep.kt") @@ -24971,7 +24972,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInUntil() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/until"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/until"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("emptyProgression.kt") @@ -25068,7 +25069,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/until/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/until/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -25121,7 +25122,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/until/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/until/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("reversedThenStep.kt") @@ -25166,7 +25167,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInUnsigned() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/expression") @@ -25178,7 +25179,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo") @@ -25190,7 +25191,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInDownTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("emptyProgression.kt") @@ -25282,7 +25283,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -25335,7 +25336,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("reversedThenStep.kt") @@ -25379,7 +25380,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInRangeTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("emptyProgression.kt") @@ -25471,7 +25472,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -25524,7 +25525,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("reversedThenStep.kt") @@ -25568,7 +25569,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInUntil() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("emptyProgression.kt") @@ -25665,7 +25666,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -25718,7 +25719,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("reversedThenStep.kt") @@ -25763,7 +25764,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo") @@ -25775,7 +25776,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInDownTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("emptyProgression.kt") @@ -25867,7 +25868,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -25920,7 +25921,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("reversedThenStep.kt") @@ -25964,7 +25965,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInRangeTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("emptyProgression.kt") @@ -26056,7 +26057,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -26109,7 +26110,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("reversedThenStep.kt") @@ -26153,7 +26154,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInUntil() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("emptyProgression.kt") @@ -26250,7 +26251,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -26303,7 +26304,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("reversedThenStep.kt") @@ -26350,7 +26351,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInUnsigned() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("inMixedUnsignedRange.kt") @@ -26387,7 +26388,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("emptyDownto.kt") @@ -26550,7 +26551,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("emptyDownto.kt") @@ -26713,7 +26714,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInNullableLoopParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/nullableLoopParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/nullableLoopParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("progressionExpression.kt") @@ -26743,7 +26744,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInReflection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/codegen/box/reflection/annotations") @@ -26755,7 +26756,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/annotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/annotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("annotationRetentionAnnotation.kt") @@ -26862,7 +26863,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInOnTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/annotations/onTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/annotations/onTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("arrayKClass.kt") @@ -26896,7 +26897,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInBuiltins() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/builtins"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/builtins"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("collections.kt") @@ -26924,7 +26925,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("bigArity.kt") @@ -27056,7 +27057,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInBound() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("companionObjectPropertyAccessors.kt") @@ -27134,7 +27135,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("constructorWithInlineClassParameters.kt") @@ -27218,7 +27219,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInCallBy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/callBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/callBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("boundExtensionFunction.kt") @@ -27361,7 +27362,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInClassLiterals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/classLiterals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/classLiterals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("annotationClassLiteral.kt") @@ -27419,7 +27420,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/classes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/classes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("classSimpleName.kt") @@ -27512,7 +27513,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/constructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/constructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("annotationClass.kt") @@ -27555,7 +27556,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInCreateAnnotation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/createAnnotation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/createAnnotation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("annotationType.kt") @@ -27633,7 +27634,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInEnclosing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/enclosing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/enclosing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("anonymousObjectInInlinedLambda.kt") @@ -27771,7 +27772,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("declaredVsInheritedFunctions.kt") @@ -27849,7 +27850,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInGenericSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/genericSignature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/genericSignature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("covariantOverride.kt") @@ -27947,7 +27948,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInIsInstance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/isInstance"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/isInstance"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("isInstanceCastAndSafeCast.kt") @@ -27965,7 +27966,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInKClassInAnnotation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/kClassInAnnotation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/kClassInAnnotation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("array.kt") @@ -28023,7 +28024,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInLambdaClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/lambdaClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/lambdaClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("parameterNamesAndNullability.kt") @@ -28081,7 +28082,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInMapping() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("constructor.kt") @@ -28178,7 +28179,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInFakeOverrides() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/fakeOverrides"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/fakeOverrides"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("javaFieldGetterSetter.kt") @@ -28201,7 +28202,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("inlineClassPrimaryVal.kt") @@ -28224,7 +28225,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInJvmStatic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/jvmStatic"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/jvmStatic"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("companionObjectFunction.kt") @@ -28247,7 +28248,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/types"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/types"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("allSupertypes.kt") @@ -28371,7 +28372,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInMethodsFromAny() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/methodsFromAny"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/methodsFromAny"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("builtinFunctionsToString.kt") @@ -28499,7 +28500,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInModifiers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/modifiers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/modifiers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("callableModality.kt") @@ -28557,7 +28558,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInMultifileClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("callFunctionsInMultifileClass.kt") @@ -28585,7 +28586,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInNoReflectAtRuntime() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/noReflectAtRuntime"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/noReflectAtRuntime"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("javaClass.kt") @@ -28632,7 +28633,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInMethodsFromAny() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/noReflectAtRuntime/methodsFromAny"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/noReflectAtRuntime/methodsFromAny"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("callableReferences.kt") @@ -28661,7 +28662,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/parameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/parameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("bigArity.kt") @@ -28749,7 +28750,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("allVsDeclared.kt") @@ -28916,7 +28917,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/accessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/accessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("extensionPropertyAccessors.kt") @@ -28949,7 +28950,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInGetDelegate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/getDelegate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/getDelegate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("booleanPropertyNameStartsWithIs.kt") @@ -29037,7 +29038,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInJvmField() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/jvmField"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/jvmField"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("annotationCompanionWithAnnotation.kt") @@ -29065,7 +29066,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInLocalDelegated() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/localDelegated"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/localDelegated"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("defaultImpls.kt") @@ -29119,7 +29120,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInSupertypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/supertypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/supertypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("builtInClassSupertypes.kt") @@ -29157,7 +29158,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInTypeOf() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("classes.kt") @@ -29194,7 +29195,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInJs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/js"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/js"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } } @@ -29207,7 +29208,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInNoReflect() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/noReflect"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/noReflect"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("classes.kt") @@ -29234,7 +29235,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInNonReifiedTypeParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/noReflect/nonReifiedTypeParameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/noReflect/nonReifiedTypeParameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("defaultUpperBound.kt") @@ -29298,7 +29299,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInNonReifiedTypeParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/nonReifiedTypeParameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/nonReifiedTypeParameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("defaultUpperBound.kt") @@ -29372,7 +29373,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInTypeParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeParameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeParameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("declarationSiteVariance.kt") @@ -29410,7 +29411,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/types"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/types"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("classifierIsClass.kt") @@ -29482,7 +29483,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInCreateType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/types/createType"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/types/createType"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("equality.kt") @@ -29520,7 +29521,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInSubtyping() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/types/subtyping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/types/subtyping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("platformType.kt") @@ -29555,7 +29556,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInRegressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/regressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/regressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("approximateIntersectionType.kt") @@ -30043,7 +30044,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInReified() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reified"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reified"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("anonymousObject.kt") @@ -30230,7 +30231,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInArraysReification() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reified/arraysReification"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reified/arraysReification"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("instanceOf.kt") @@ -30274,7 +30275,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInSafeCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/safeCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/safeCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("genericNull.kt") @@ -30352,7 +30353,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInSam() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("arrayAsVarargAfterSamArgument.kt") @@ -30469,7 +30470,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam/constructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam/constructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("comparator.kt") @@ -30557,7 +30558,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInEquality() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam/equality"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam/equality"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("functionReferencesBound.kt") @@ -30596,7 +30597,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInSealed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sealed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sealed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("multipleFiles_enabled.kt") @@ -30634,7 +30635,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInSecondaryConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/secondaryConstructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/secondaryConstructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("basicNoPrimaryManySinks.kt") @@ -30812,7 +30813,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInSignatureAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/signatureAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/signatureAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("defaultAndNamedCombination.kt") @@ -30890,7 +30891,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInSmap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/smap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/smap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("chainCalls.kt") @@ -30918,7 +30919,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInSmartCasts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/smartCasts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/smartCasts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("falseSmartCast.kt") @@ -31011,7 +31012,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInSpecialBuiltins() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/specialBuiltins"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/specialBuiltins"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("bridgeNotEmptyMap.kt") @@ -31159,7 +31160,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInStatics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/statics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/statics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("anonymousInitializerIObject.kt") @@ -31257,7 +31258,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInStoreStackBeforeInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/storeStackBeforeInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/storeStackBeforeInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("differentTypes.kt") @@ -31295,7 +31296,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInStrings() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/strings"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/strings"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("constInStringTemplate.kt") @@ -31428,7 +31429,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInSuper() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/super"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/super"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("basicmethodSuperClass.kt") @@ -31590,7 +31591,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInSuperConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/super/superConstructor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/super/superConstructor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("kt13846.kt") @@ -31639,7 +31640,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInSynchronized() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/synchronized"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/synchronized"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("changeMonitor.kt") @@ -31737,7 +31738,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInSyntheticAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/syntheticAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/syntheticAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("inline.kt") @@ -31820,7 +31821,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInThrows() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/throws"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/throws"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("delegationAndThrows.kt") @@ -31843,7 +31844,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInToArray() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/toArray"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/toArray"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("incorrectToArrayDetection.kt") @@ -31901,7 +31902,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInTopLevelPrivate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/topLevelPrivate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/topLevelPrivate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("noPrivateNoAccessorsInMultiFileFacade.kt") @@ -31944,7 +31945,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInTrailingComma() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/trailingComma"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/trailingComma"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("noDisambiguation.kt") @@ -31972,7 +31973,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInTraits() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/traits"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/traits"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("defaultImplCall.kt") @@ -32165,7 +32166,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInTypeInfo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typeInfo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typeInfo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("asInLoop.kt") @@ -32213,7 +32214,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInTypeMapping() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typeMapping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typeMapping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("enhancedPrimitiveInReturnType.kt") @@ -32286,7 +32287,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInTypealias() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typealias"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typealias"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("enumEntryQualifier.kt") @@ -32394,7 +32395,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInUnaryOp() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unaryOp"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unaryOp"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("call.kt") @@ -32437,7 +32438,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInUnit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("closureReturnsNullableUnit.kt") @@ -32505,7 +32506,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInUnsignedTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unsignedTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unsignedTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("boxConstValOfUnsignedType.kt") @@ -32722,7 +32723,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInJvm8Intrinsics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unsignedTypes/jvm8Intrinsics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unsignedTypes/jvm8Intrinsics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("unsignedIntCompare_jvm8.kt") @@ -32776,7 +32777,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInValueClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/valueClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/valueClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("jvmInline.kt") @@ -32794,7 +32795,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInVararg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/vararg"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/vararg"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("assigningArrayToVarargInAnnotation.kt") @@ -32892,7 +32893,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInWhen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("callProperty.kt") @@ -33109,7 +33110,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInEnumOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/enumOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/enumOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("bigEnum.kt") @@ -33212,7 +33213,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInStringOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/stringOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/stringOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("duplicatingItems.kt") @@ -33270,7 +33271,7 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { } public void testAllFilesPresentInWhenSubjectVariable() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/whenSubjectVariable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/whenSubjectVariable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("captureSubjectVariable.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/BlackBoxInlineCodegenTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/BlackBoxInlineCodegenTestGenerated.java index 560468424e3..51ef18238d7 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/BlackBoxInlineCodegenTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/BlackBoxInlineCodegenTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.codegen; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInBoxInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/codegen/boxInline/anonymousObject") @@ -38,7 +39,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInAnonymousObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("anonymousObjectInDefault.kt") @@ -340,7 +341,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInEnumWhen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/enumWhen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/enumWhen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("callSite.kt") @@ -373,7 +374,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInProperRecapturing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("inlineChain.kt") @@ -416,7 +417,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInProperRecapturingInClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("inlineChain.kt") @@ -489,7 +490,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInSam() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("anonymousObjectToSam.kt") @@ -537,7 +538,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInTwoCapturedReceivers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("kt8668.kt") @@ -576,7 +577,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInArgumentOrder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/argumentOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/argumentOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("boundFunctionReference.kt") @@ -659,7 +660,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInArrayConvention() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/arrayConvention"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/arrayConvention"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("simpleAccess.kt") @@ -702,7 +703,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInAssert() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/assert"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/assert"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("jvmAssertInlineFunctionAssertionsDisabled.kt") @@ -775,7 +776,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInBuilders() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/builders"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/builders"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("builders.kt") @@ -798,7 +799,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInBytecodePreprocessing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/bytecodePreprocessing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/bytecodePreprocessing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("apiVersionAtLeast1.kt") @@ -821,7 +822,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("classLevel.kt") @@ -908,7 +909,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInBound() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("classProperty.kt") @@ -1042,7 +1043,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInCapture() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/capture"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/capture"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("captureInlinable.kt") @@ -1085,7 +1086,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInComplex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/complex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/complex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("closureChain.kt") @@ -1133,7 +1134,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInComplexStack() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/complexStack"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/complexStack"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("asCheck.kt") @@ -1191,7 +1192,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInContracts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/contracts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/contracts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("cfgDependendValInitialization.kt") @@ -1289,7 +1290,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInDefaultValues() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("defaultInExtension.kt") @@ -1391,7 +1392,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInLambdaInlining() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("checkLambdaClassIsPresent.kt") @@ -1563,7 +1564,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInCallableReferences() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("boundFunctionReference.kt") @@ -1697,7 +1698,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInMaskElimination() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/maskElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/maskElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("kt18792.kt") @@ -1736,7 +1737,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInDelegatedProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/delegatedProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/delegatedProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("kt16864.kt") @@ -1774,7 +1775,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInEnclosingInfo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/enclosingInfo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/enclosingInfo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("anonymousInLambda.kt") @@ -1822,7 +1823,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("kt10569.kt") @@ -1900,7 +1901,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInFunctionExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/functionExpression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/functionExpression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("extension.kt") @@ -1918,7 +1919,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("inlineClassWithInlineValReturningInlineClass.kt") @@ -1970,7 +1971,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInUnboxGenericParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/funInterface") @@ -1982,7 +1983,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInFunInterface() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("any.kt") @@ -2025,7 +2026,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/lambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/lambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("any.kt") @@ -2068,7 +2069,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInObjectLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/objectLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/objectLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("any.kt") @@ -2113,7 +2114,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInInnerClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/innerClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/innerClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("captureThisAndOuter.kt") @@ -2141,7 +2142,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInJvmPackageName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/jvmPackageName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/jvmPackageName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("simple.kt") @@ -2159,7 +2160,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInLambdaClassClash() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/lambdaClassClash"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/lambdaClassClash"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("lambdaClassClash.kt") @@ -2182,7 +2183,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInLambdaTransformation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/lambdaTransformation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/lambdaTransformation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("lambdaCloning.kt") @@ -2225,7 +2226,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInLocalFunInLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/localFunInLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/localFunInLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("defaultParam.kt") @@ -2258,7 +2259,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInMultiModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("tryCatchWithRecursiveInline.kt") @@ -2276,7 +2277,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInMultifileClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("defaultArguments.kt") @@ -2304,7 +2305,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInMultiplatform() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/codegen/boxInline/multiplatform/defaultArguments") @@ -2316,7 +2317,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInDefaultArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiplatform/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiplatform/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("receiversAndParametersInLambda.kt") @@ -2335,7 +2336,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInNoInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/noInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/noInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("extensionReceiver.kt") @@ -2383,7 +2384,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInNonLocalReturns() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("explicitLocalReturn.kt") @@ -2465,7 +2466,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInDeparenthesize() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/deparenthesize"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/deparenthesize"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("bracket.kt") @@ -2488,7 +2489,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInTryFinally() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("kt16417.kt") @@ -2565,7 +2566,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInCallSite() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("callSite.kt") @@ -2608,7 +2609,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInChained() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("finallyInFinally.kt") @@ -2661,7 +2662,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInDeclSite() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("complex.kt") @@ -2734,7 +2735,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInExceptionTable() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("break.kt") @@ -2852,7 +2853,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInVariables() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/variables"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/variables"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("kt7792.kt") @@ -2872,7 +2873,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInOptimizations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("kt20844.kt") @@ -2905,7 +2906,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInPrivate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("effectivePrivate.kt") @@ -2963,7 +2964,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("augAssignmentAndInc.kt") @@ -3041,7 +3042,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInReified() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("arrayConstructor.kt") @@ -3158,7 +3159,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInCheckCast() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/checkCast"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/checkCast"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("chain.kt") @@ -3221,7 +3222,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInDefaultLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/defaultLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/defaultLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("chain.kt") @@ -3274,7 +3275,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInIsCheck() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/isCheck"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/isCheck"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("chain.kt") @@ -3303,7 +3304,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/signature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/signature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("inProjectionSubstitution.kt") @@ -3361,7 +3362,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInSimple() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/simple"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/simple"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("captureAndArgumentIncompatibleTypes.kt") @@ -3494,7 +3495,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInSmap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("assertion.kt") @@ -3596,7 +3597,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInAnonymous() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/anonymous"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/anonymous"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("kt19175.kt") @@ -3659,7 +3660,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInDefaultLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/defaultLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/defaultLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("defaultLambdaInAnonymous.kt") @@ -3717,7 +3718,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInInlineOnly() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/inlineOnly"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/inlineOnly"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("noSmap.kt") @@ -3760,7 +3761,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInNewsmap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/newsmap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/newsmap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("differentMapping.kt") @@ -3793,7 +3794,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInResolve() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/resolve"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/resolve"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("inlineComponent.kt") @@ -3817,7 +3818,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInSpecial() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/special"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/special"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("identityCheck.kt") @@ -3875,7 +3876,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInStackOnReturn() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/stackOnReturn"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/stackOnReturn"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("elvis.kt") @@ -3968,7 +3969,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInSuspend() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("capturedVariables.kt") @@ -4130,7 +4131,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("isAsReified.kt") @@ -4168,7 +4169,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInDefaultParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/defaultParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/defaultParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("defaultValueCrossinline.kt") @@ -4201,7 +4202,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInInlineClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/inlineClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/inlineClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("returnUnboxedDirect.kt") @@ -4224,7 +4225,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInInlineUsedAsNoinline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/inlineUsedAsNoinline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/inlineUsedAsNoinline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("inlineOnly.kt") @@ -4257,7 +4258,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInReceiver() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/receiver"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/receiver"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("inlineOrdinaryOfCrossinlineSuspend.kt") @@ -4310,7 +4311,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInStateMachine() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/stateMachine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/stateMachine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("crossingCoroutineBoundaries.kt") @@ -4434,7 +4435,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInSyntheticAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/syntheticAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/syntheticAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("constField.kt") @@ -4486,7 +4487,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInWithinInlineLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("directFieldAccess.kt") @@ -4545,7 +4546,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInTrait() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/trait"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/trait"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("trait.kt") @@ -4563,7 +4564,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInTryCatchFinally() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/tryCatchFinally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/tryCatchFinally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("kt5863.kt") @@ -4596,7 +4597,7 @@ public class BlackBoxInlineCodegenTestGenerated extends AbstractBlackBoxInlineCo } public void testAllFilesPresentInVarargs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/varargs"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/varargs"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("kt17653.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/BytecodeListingTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/BytecodeListingTestGenerated.java index ac103ade528..42e3cc1e7ac 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/BytecodeListingTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/BytecodeListingTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.codegen; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -36,7 +37,7 @@ public class BytecodeListingTestGenerated extends AbstractBytecodeListingTest { } public void testAllFilesPresentInBytecodeListing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("anonymousObjectInGenericFun.kt") @@ -238,7 +239,7 @@ public class BytecodeListingTestGenerated extends AbstractBytecodeListingTest { } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/annotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/annotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("annotationsOnDelegatedMembers.kt") @@ -331,7 +332,7 @@ public class BytecodeListingTestGenerated extends AbstractBytecodeListingTest { } public void testAllFilesPresentInCollectionStubs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/collectionStubs"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/collectionStubs"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("collectionByDelegation.kt") @@ -498,7 +499,7 @@ public class BytecodeListingTestGenerated extends AbstractBytecodeListingTest { } public void testAllFilesPresentInAbstractStubSignatures() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("byteShortMap.kt") @@ -646,7 +647,7 @@ public class BytecodeListingTestGenerated extends AbstractBytecodeListingTest { } public void testAllFilesPresentInToArray() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/collectionStubs/toArray"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/collectionStubs/toArray"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("customNonGenericToArray.kt") @@ -675,7 +676,7 @@ public class BytecodeListingTestGenerated extends AbstractBytecodeListingTest { } public void testAllFilesPresentInCoroutines() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("coroutineContextIntrinsic.kt") @@ -727,7 +728,7 @@ public class BytecodeListingTestGenerated extends AbstractBytecodeListingTest { } public void testAllFilesPresentInSpilling() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/coroutines/spilling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/coroutines/spilling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("booleanParameter.kt") @@ -776,7 +777,7 @@ public class BytecodeListingTestGenerated extends AbstractBytecodeListingTest { } public void testAllFilesPresentInDefaultArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("functionInMultifileClass.kt") @@ -804,7 +805,7 @@ public class BytecodeListingTestGenerated extends AbstractBytecodeListingTest { } public void testAllFilesPresentInDeprecated() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/deprecated"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/deprecated"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("deprecatedClass.kt") @@ -862,7 +863,7 @@ public class BytecodeListingTestGenerated extends AbstractBytecodeListingTest { } public void testAllFilesPresentInInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/inline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/inline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("inlineOnly.kt") @@ -919,7 +920,7 @@ public class BytecodeListingTestGenerated extends AbstractBytecodeListingTest { } public void testAllFilesPresentInEnclosingInfo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/inline/enclosingInfo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/inline/enclosingInfo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("crossinlineLambdaChain.kt") @@ -963,7 +964,7 @@ public class BytecodeListingTestGenerated extends AbstractBytecodeListingTest { } public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("annotatedPropertyWithInlineClassTypeInSignature.kt") @@ -1105,7 +1106,7 @@ public class BytecodeListingTestGenerated extends AbstractBytecodeListingTest { } public void testAllFilesPresentInDefaultInterfaceMembers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/inlineClasses/defaultInterfaceMembers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/inlineClasses/defaultInterfaceMembers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("javaDefaultInterfaceMember.kt") @@ -1133,7 +1134,7 @@ public class BytecodeListingTestGenerated extends AbstractBytecodeListingTest { } public void testAllFilesPresentInInlineCollection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("collection.kt") @@ -1221,7 +1222,7 @@ public class BytecodeListingTestGenerated extends AbstractBytecodeListingTest { } public void testAllFilesPresentInInlineCollectionOfInlineClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("collection.kt") @@ -1309,7 +1310,7 @@ public class BytecodeListingTestGenerated extends AbstractBytecodeListingTest { } public void testAllFilesPresentInStdlibManglingIn1430() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/inlineClasses/stdlibManglingIn1430"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/inlineClasses/stdlibManglingIn1430"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("new.kt") @@ -1333,7 +1334,7 @@ public class BytecodeListingTestGenerated extends AbstractBytecodeListingTest { } public void testAllFilesPresentInJvm8() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/jvm8"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/jvm8"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/codegen/bytecodeListing/jvm8/defaults") @@ -1345,7 +1346,7 @@ public class BytecodeListingTestGenerated extends AbstractBytecodeListingTest { } public void testAllFilesPresentInDefaults() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/jvm8/defaults"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/jvm8/defaults"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/codegen/bytecodeListing/jvm8/defaults/allCompatibility") @@ -1357,7 +1358,7 @@ public class BytecodeListingTestGenerated extends AbstractBytecodeListingTest { } public void testAllFilesPresentInAllCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/jvm8/defaults/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/jvm8/defaults/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("deprecation.kt") @@ -1389,7 +1390,7 @@ public class BytecodeListingTestGenerated extends AbstractBytecodeListingTest { } public void testAllFilesPresentInSpecialization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/jvm8/defaults/allCompatibility/specialization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/jvm8/defaults/allCompatibility/specialization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("primitiveAndAny.kt") @@ -1415,7 +1416,7 @@ public class BytecodeListingTestGenerated extends AbstractBytecodeListingTest { } public void testAllFilesPresentInMain() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/main"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/main"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("multifileSuspend.kt") @@ -1453,7 +1454,7 @@ public class BytecodeListingTestGenerated extends AbstractBytecodeListingTest { } public void testAllFilesPresentInMultiplatform() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("optionalExpectation.kt") @@ -1471,7 +1472,7 @@ public class BytecodeListingTestGenerated extends AbstractBytecodeListingTest { } public void testAllFilesPresentInNullabilityAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/nullabilityAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/nullabilityAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("lateInitNotNull.kt") @@ -1509,7 +1510,7 @@ public class BytecodeListingTestGenerated extends AbstractBytecodeListingTest { } public void testAllFilesPresentInSam() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("callableRefGenericFunInterface.kt") @@ -1627,7 +1628,7 @@ public class BytecodeListingTestGenerated extends AbstractBytecodeListingTest { } public void testAllFilesPresentInSpecialBridges() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/specialBridges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/specialBridges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("charSequence.kt") @@ -1694,7 +1695,7 @@ public class BytecodeListingTestGenerated extends AbstractBytecodeListingTest { } public void testAllFilesPresentInSignatures() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/specialBridges/signatures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/specialBridges/signatures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("genericClass.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/BytecodeTextTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/BytecodeTextTestGenerated.java index 7659e7ae60e..268bb258845 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/BytecodeTextTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/BytecodeTextTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.codegen; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -41,7 +42,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInBytecodeText() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("annotationDefaultValue.kt") @@ -448,7 +449,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInArgumentOrder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/argumentOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/argumentOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("sameOrder.kt") @@ -471,7 +472,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInAssert() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/assert"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/assert"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("jvmCrossinline.kt") @@ -509,7 +510,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInBoxing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/boxing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/boxing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("crossinlineSuspend.kt") @@ -537,7 +538,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInBoxingOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/boxingOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/boxingOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("boxingAndEquals.kt") @@ -670,7 +671,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInBuiltinFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/builtinFunctions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/builtinFunctions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("charSequence.kt") @@ -707,7 +708,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInGenericParameterBridge() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/builtinFunctions/genericParameterBridge"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/builtinFunctions/genericParameterBridge"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("IntMC.kt") @@ -751,7 +752,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("boundFieldReferenceInInline.kt") @@ -809,7 +810,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInCapturedVarsOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/capturedVarsOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/capturedVarsOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("capturedInChainOfInlineFuns.kt") @@ -872,7 +873,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInCheckcast() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/checkcast"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/checkcast"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("kt14811.kt") @@ -905,7 +906,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInCoercionToUnitOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/coercionToUnitOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/coercionToUnitOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("inRangeCheckWithConst.kt") @@ -963,7 +964,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInCompanion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/companion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/companion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("directAccessToBackingField.kt") @@ -1046,7 +1047,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInConditions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/conditions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/conditions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("conjunction.kt") @@ -1199,7 +1200,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInConstProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/constProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/constProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("noAccessorsForPrivateConstants.kt") @@ -1237,7 +1238,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInConstantConditions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/constantConditions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/constantConditions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("cmpIntWith0.kt") @@ -1275,7 +1276,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInConstants() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/constants"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/constants"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("byte.kt") @@ -1343,7 +1344,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/constructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/constructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("enumPrimaryDefaults.kt") @@ -1401,7 +1402,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInControlStructures() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/controlStructures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/controlStructures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("ifConsts.kt") @@ -1424,7 +1425,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInCoroutines() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("crossinlineSuspendContinuation_1_3.kt") @@ -1486,7 +1487,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInCleanup() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/coroutines/cleanup"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/coroutines/cleanup"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("backEdge.kt") @@ -1529,7 +1530,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInDebug() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/coroutines/debug"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/coroutines/debug"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("continuationInLvt.kt") @@ -1567,7 +1568,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInDestructuringInLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/coroutines/destructuringInLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/coroutines/destructuringInLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("inlineSeparateFiles.kt") @@ -1585,7 +1586,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/coroutines/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/coroutines/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("inlineClassBoxingInSuspendFunReturn_Primitive.kt") @@ -1633,7 +1634,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInIntLikeVarSpilling() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/coroutines/intLikeVarSpilling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/coroutines/intLikeVarSpilling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("complicatedMerge.kt") @@ -1696,7 +1697,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInStateMachine() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/coroutines/stateMachine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/coroutines/stateMachine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("kt25893.kt") @@ -1720,7 +1721,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInDeadCodeElimination() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/deadCodeElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/deadCodeElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("arrayConstructor.kt") @@ -1788,7 +1789,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInDefaultArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("inheritedInterfaceFunction.kt") @@ -1851,7 +1852,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInDirectInvoke() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/directInvoke"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/directInvoke"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("callableReference.kt") @@ -1879,7 +1880,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInDisabledOptimizations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/disabledOptimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/disabledOptimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("noJumpInLastBranch.kt") @@ -1922,7 +1923,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("constructorAccessors.kt") @@ -1955,7 +1956,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInExclExcl() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/exclExcl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/exclExcl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("primitive.kt") @@ -1973,7 +1974,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInFieldsForCapturedValues() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/fieldsForCapturedValues"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/fieldsForCapturedValues"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("extensionLambdaExtensionReceiver.kt") @@ -2031,7 +2032,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInForLoop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("forInCharSequence.kt") @@ -2168,7 +2169,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInForInArrayWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/forInArrayWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/forInArrayWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("forInArrayWithIndexNoElementVar.kt") @@ -2206,7 +2207,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInForInCharSequenceWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/forInCharSequenceWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/forInCharSequenceWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("forInCharSequenceWithIndex.kt") @@ -2249,7 +2250,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInForInIndices() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/forInIndices"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/forInIndices"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("forInArrayListIndices.kt") @@ -2307,7 +2308,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInForInIterableWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/forInIterableWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/forInIterableWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("forInEmptyListWithIndex.kt") @@ -2350,7 +2351,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInForInProgressionWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/forInProgressionWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/forInProgressionWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("forInDownToWithIndex.kt") @@ -2423,7 +2424,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInForInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/forInReversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/forInReversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("forInReversedArrayIndices.kt") @@ -2501,7 +2502,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInForInSequenceWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/forInSequenceWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/forInSequenceWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("forInEmptySequenceWithIndex.kt") @@ -2549,7 +2550,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInForInUntil() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/forInUntil"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/forInUntil"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("forInUntilChar.kt") @@ -2607,7 +2608,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInStepped() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/stepped"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/stepped"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } } @@ -2620,7 +2621,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInUnsigned() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/unsigned"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/unsigned"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("forInDownToUIntMinValue.kt") @@ -2679,7 +2680,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInHashCode() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/hashCode"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/hashCode"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("hashCode.kt") @@ -2702,7 +2703,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInIeee754() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/ieee754"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/ieee754"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("nullableDoubleEquals.kt") @@ -2755,7 +2756,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/inline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/inline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("deleteClassOnTransformation.kt") @@ -2862,7 +2863,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/inline/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/inline/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("simple.kt") @@ -2881,7 +2882,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("asCastForInlineClass.kt") @@ -3229,7 +3230,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInInnerClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/innerClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/innerClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("nestedClassInAnnotationArgument.kt") @@ -3252,7 +3253,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInInterfaces() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/interfaces"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/interfaces"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("firstInheritedMethodIsAbstract.kt") @@ -3285,7 +3286,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInIntrinsics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/intrinsics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/intrinsics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("javaObjectType.kt") @@ -3308,7 +3309,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInIntrinsicsCompare() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/intrinsicsCompare"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/intrinsicsCompare"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("byteSmartCast_after.kt") @@ -3371,7 +3372,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInIntrinsicsTrim() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/intrinsicsTrim"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/intrinsicsTrim"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("trimIndentNegative.kt") @@ -3404,7 +3405,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInJvm8() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/jvm8"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/jvm8"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/codegen/bytecodeText/jvm8/hashCode") @@ -3416,7 +3417,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInHashCode() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/jvm8/hashCode"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/jvm8/hashCode"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("dataClass.kt") @@ -3439,7 +3440,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInJvmDefault() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/jvm8/jvmDefault"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/jvm8/jvmDefault"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/codegen/bytecodeText/jvm8/jvmDefault/allCompatibility") @@ -3451,7 +3452,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInAllCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/jvm8/jvmDefault/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/jvm8/jvmDefault/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("defaultArgs.kt") @@ -3489,7 +3490,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/jvm8/jvmDefault/compatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/jvm8/jvmDefault/compatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("defaultArgs.kt") @@ -3529,7 +3530,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInLazyCodegen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/lazyCodegen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/lazyCodegen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("inlineConstInsideComparison.kt") @@ -3577,7 +3578,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInLineNumbers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/lineNumbers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/lineNumbers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("ifConsts.kt") @@ -3650,7 +3651,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInLocalInitializationLVT() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/localInitializationLVT"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/localInitializationLVT"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("boxing.kt") @@ -3758,7 +3759,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInMangling() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/mangling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/mangling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("parentheses.kt") @@ -3781,7 +3782,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInMultifileClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("defaultFunctionInMultifileClass.kt") @@ -3809,7 +3810,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInNotNullAssertions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/notNullAssertions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/notNullAssertions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("arrayListGet.kt") @@ -3877,7 +3878,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInNullCheckOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/nullCheckOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/nullCheckOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("alreadyCheckedForIs.kt") @@ -3999,7 +4000,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInLocalLateinit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/nullCheckOptimization/localLateinit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/nullCheckOptimization/localLateinit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("checkedAlways.kt") @@ -4028,7 +4029,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInOldLanguageVersions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/oldLanguageVersions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/oldLanguageVersions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("constCoroutine.kt") @@ -4055,7 +4056,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInConstProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/oldLanguageVersions/constProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/oldLanguageVersions/constProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } } @@ -4068,7 +4069,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInCoroutines() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/oldLanguageVersions/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/oldLanguageVersions/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("crossinlineSuspendContinuation_1_2.kt") @@ -4101,7 +4102,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInIeee754() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/oldLanguageVersions/ieee754"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/oldLanguageVersions/ieee754"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("nullableDoubleEquals10.kt") @@ -4155,7 +4156,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInOptimizedDelegatedProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/optimizedDelegatedProperties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/optimizedDelegatedProperties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("definedInSources.kt") @@ -4188,7 +4189,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInParameterlessMain() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/parameterlessMain"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/parameterlessMain"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("dontGenerateOnExtensionReceiver.kt") @@ -4236,7 +4237,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/properties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/properties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("dataClass.kt") @@ -4258,7 +4259,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInLateinit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/properties/lateinit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/properties/lateinit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("companionObject.kt") @@ -4282,7 +4283,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInRanges() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/ranges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/ranges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("ifNotInRange.kt") @@ -4355,7 +4356,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInSam() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("samWrapperForNullInitialization.kt") @@ -4398,7 +4399,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInStatements() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/statements"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/statements"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("ifSingleBranch.kt") @@ -4451,7 +4452,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInStaticFields() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/staticFields"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/staticFields"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("classObject.kt") @@ -4474,7 +4475,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInStoreStackBeforeInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/storeStackBeforeInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/storeStackBeforeInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("differentTypes.kt") @@ -4512,7 +4513,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInStringOperations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/stringOperations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/stringOperations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("concat.kt") @@ -4685,7 +4686,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInToArray() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/toArray"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/toArray"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("noAccessorForToArray.kt") @@ -4703,7 +4704,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInUnsignedTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/unsignedTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/unsignedTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("unsignedIntCompare_before.kt") @@ -4771,7 +4772,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInVarargs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/varargs"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/varargs"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("doNotCopyImmediatelyCreatedArrays.kt") @@ -4789,7 +4790,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInWhen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/when"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/when"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("edgeCases.kt") @@ -4927,7 +4928,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInWhenEnumOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/whenEnumOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/whenEnumOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("bigEnum.kt") @@ -5015,7 +5016,7 @@ public class BytecodeTextTestGenerated extends AbstractBytecodeTextTest { } public void testAllFilesPresentInWhenStringOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/whenStringOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/whenStringOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("denseHashCode.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/CheckLocalVariablesTableTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/CheckLocalVariablesTableTestGenerated.java index 45d7ff1000d..9f0b18bd6a9 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/CheckLocalVariablesTableTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/CheckLocalVariablesTableTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.codegen; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class CheckLocalVariablesTableTestGenerated extends AbstractCheckLocalVar } public void testAllFilesPresentInCheckLocalVariablesTable() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/checkLocalVariablesTable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/checkLocalVariablesTable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("copyFunction.kt") @@ -113,7 +114,7 @@ public class CheckLocalVariablesTableTestGenerated extends AbstractCheckLocalVar } public void testAllFilesPresentInCompletionInSuspendFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/checkLocalVariablesTable/completionInSuspendFunction"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/checkLocalVariablesTable/completionInSuspendFunction"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("nonStaticSimple.kt") @@ -156,7 +157,7 @@ public class CheckLocalVariablesTableTestGenerated extends AbstractCheckLocalVar } public void testAllFilesPresentInParametersInSuspendLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/checkLocalVariablesTable/parametersInSuspendLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/checkLocalVariablesTable/parametersInSuspendLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("dataClass.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/CompileKotlinAgainstInlineKotlinTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/CompileKotlinAgainstInlineKotlinTestGenerated.java index bd4dcd72c7e..35ae32f1b0f 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/CompileKotlinAgainstInlineKotlinTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/CompileKotlinAgainstInlineKotlinTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.codegen; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInBoxInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/codegen/boxInline/anonymousObject") @@ -38,7 +39,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInAnonymousObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("anonymousObjectInDefault.kt") @@ -340,7 +341,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInEnumWhen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/enumWhen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/enumWhen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("callSite.kt") @@ -373,7 +374,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInProperRecapturing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("inlineChain.kt") @@ -416,7 +417,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInProperRecapturingInClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("inlineChain.kt") @@ -489,7 +490,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInSam() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("anonymousObjectToSam.kt") @@ -537,7 +538,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInTwoCapturedReceivers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("kt8668.kt") @@ -576,7 +577,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInArgumentOrder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/argumentOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/argumentOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("boundFunctionReference.kt") @@ -659,7 +660,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInArrayConvention() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/arrayConvention"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/arrayConvention"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("simpleAccess.kt") @@ -702,7 +703,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInAssert() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/assert"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/assert"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("jvmAssertInlineFunctionAssertionsDisabled.kt") @@ -775,7 +776,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInBuilders() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/builders"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/builders"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("builders.kt") @@ -798,7 +799,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInBytecodePreprocessing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/bytecodePreprocessing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/bytecodePreprocessing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("apiVersionAtLeast1.kt") @@ -821,7 +822,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("classLevel.kt") @@ -908,7 +909,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInBound() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("classProperty.kt") @@ -1042,7 +1043,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInCapture() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/capture"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/capture"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("captureInlinable.kt") @@ -1085,7 +1086,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInComplex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/complex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/complex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("closureChain.kt") @@ -1133,7 +1134,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInComplexStack() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/complexStack"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/complexStack"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("asCheck.kt") @@ -1191,7 +1192,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInContracts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/contracts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/contracts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("cfgDependendValInitialization.kt") @@ -1289,7 +1290,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInDefaultValues() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("defaultInExtension.kt") @@ -1391,7 +1392,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInLambdaInlining() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("checkLambdaClassIsPresent.kt") @@ -1563,7 +1564,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInCallableReferences() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("boundFunctionReference.kt") @@ -1697,7 +1698,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInMaskElimination() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/maskElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/maskElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("kt18792.kt") @@ -1736,7 +1737,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInDelegatedProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/delegatedProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/delegatedProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("kt16864.kt") @@ -1774,7 +1775,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInEnclosingInfo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/enclosingInfo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/enclosingInfo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("anonymousInLambda.kt") @@ -1822,7 +1823,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("kt10569.kt") @@ -1900,7 +1901,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInFunctionExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/functionExpression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/functionExpression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("extension.kt") @@ -1918,7 +1919,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("inlineClassWithInlineValReturningInlineClass.kt") @@ -1970,7 +1971,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInUnboxGenericParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/funInterface") @@ -1982,7 +1983,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInFunInterface() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("any.kt") @@ -2025,7 +2026,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/lambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/lambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("any.kt") @@ -2068,7 +2069,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInObjectLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/objectLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/objectLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("any.kt") @@ -2113,7 +2114,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInInnerClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/innerClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/innerClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("captureThisAndOuter.kt") @@ -2141,7 +2142,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInJvmPackageName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/jvmPackageName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/jvmPackageName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("simple.kt") @@ -2159,7 +2160,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInLambdaClassClash() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/lambdaClassClash"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/lambdaClassClash"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("lambdaClassClash.kt") @@ -2182,7 +2183,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInLambdaTransformation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/lambdaTransformation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/lambdaTransformation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("lambdaCloning.kt") @@ -2225,7 +2226,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInLocalFunInLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/localFunInLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/localFunInLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("defaultParam.kt") @@ -2258,7 +2259,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInMultiModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("tryCatchWithRecursiveInline.kt") @@ -2276,7 +2277,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInMultifileClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("defaultArguments.kt") @@ -2304,7 +2305,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInMultiplatform() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/codegen/boxInline/multiplatform/defaultArguments") @@ -2316,7 +2317,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInDefaultArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiplatform/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiplatform/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("receiversAndParametersInLambda.kt") @@ -2335,7 +2336,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInNoInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/noInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/noInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("extensionReceiver.kt") @@ -2383,7 +2384,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInNonLocalReturns() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("explicitLocalReturn.kt") @@ -2465,7 +2466,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInDeparenthesize() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/deparenthesize"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/deparenthesize"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("bracket.kt") @@ -2488,7 +2489,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInTryFinally() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("kt16417.kt") @@ -2565,7 +2566,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInCallSite() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("callSite.kt") @@ -2608,7 +2609,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInChained() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("finallyInFinally.kt") @@ -2661,7 +2662,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInDeclSite() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("complex.kt") @@ -2734,7 +2735,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInExceptionTable() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("break.kt") @@ -2852,7 +2853,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInVariables() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/variables"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/variables"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("kt7792.kt") @@ -2872,7 +2873,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInOptimizations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("kt20844.kt") @@ -2905,7 +2906,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInPrivate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("effectivePrivate.kt") @@ -2963,7 +2964,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("augAssignmentAndInc.kt") @@ -3041,7 +3042,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInReified() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("arrayConstructor.kt") @@ -3158,7 +3159,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInCheckCast() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/checkCast"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/checkCast"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("chain.kt") @@ -3221,7 +3222,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInDefaultLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/defaultLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/defaultLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("chain.kt") @@ -3274,7 +3275,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInIsCheck() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/isCheck"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/isCheck"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("chain.kt") @@ -3303,7 +3304,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/signature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/signature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("inProjectionSubstitution.kt") @@ -3361,7 +3362,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInSimple() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/simple"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/simple"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("captureAndArgumentIncompatibleTypes.kt") @@ -3494,7 +3495,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInSmap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("assertion.kt") @@ -3596,7 +3597,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInAnonymous() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/anonymous"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/anonymous"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("kt19175.kt") @@ -3659,7 +3660,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInDefaultLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/defaultLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/defaultLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("defaultLambdaInAnonymous.kt") @@ -3717,7 +3718,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInInlineOnly() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/inlineOnly"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/inlineOnly"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("noSmap.kt") @@ -3760,7 +3761,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInNewsmap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/newsmap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/newsmap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("differentMapping.kt") @@ -3793,7 +3794,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInResolve() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/resolve"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/resolve"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("inlineComponent.kt") @@ -3817,7 +3818,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInSpecial() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/special"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/special"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("identityCheck.kt") @@ -3875,7 +3876,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInStackOnReturn() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/stackOnReturn"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/stackOnReturn"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("elvis.kt") @@ -3968,7 +3969,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInSuspend() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("capturedVariables.kt") @@ -4130,7 +4131,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("isAsReified.kt") @@ -4168,7 +4169,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInDefaultParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/defaultParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/defaultParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("defaultValueCrossinline.kt") @@ -4201,7 +4202,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInInlineClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/inlineClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/inlineClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("returnUnboxedDirect.kt") @@ -4224,7 +4225,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInInlineUsedAsNoinline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/inlineUsedAsNoinline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/inlineUsedAsNoinline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("inlineOnly.kt") @@ -4257,7 +4258,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInReceiver() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/receiver"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/receiver"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("inlineOrdinaryOfCrossinlineSuspend.kt") @@ -4310,7 +4311,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInStateMachine() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/stateMachine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/stateMachine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("crossingCoroutineBoundaries.kt") @@ -4434,7 +4435,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInSyntheticAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/syntheticAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/syntheticAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("constField.kt") @@ -4486,7 +4487,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInWithinInlineLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("directFieldAccess.kt") @@ -4545,7 +4546,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInTrait() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/trait"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/trait"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("trait.kt") @@ -4563,7 +4564,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInTryCatchFinally() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/tryCatchFinally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/tryCatchFinally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("kt5863.kt") @@ -4596,7 +4597,7 @@ public class CompileKotlinAgainstInlineKotlinTestGenerated extends AbstractCompi } public void testAllFilesPresentInVarargs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/varargs"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/varargs"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("kt17653.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/CompileKotlinAgainstKotlinJdk15TestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/CompileKotlinAgainstKotlinJdk15TestGenerated.java index bdaf5dfa80c..5f39c3daaa3 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/CompileKotlinAgainstKotlinJdk15TestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/CompileKotlinAgainstKotlinJdk15TestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.codegen; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class CompileKotlinAgainstKotlinJdk15TestGenerated extends AbstractCompil } public void testAllFilesPresentInCompileKotlinAgainstKotlinJdk15() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlinJdk15"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlinJdk15"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("jvmRecordBinary.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/CompileKotlinAgainstKotlinTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/CompileKotlinAgainstKotlinTestGenerated.java index 742bc9735a6..ea79b31bb8c 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/CompileKotlinAgainstKotlinTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/CompileKotlinAgainstKotlinTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.codegen; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class CompileKotlinAgainstKotlinTestGenerated extends AbstractCompileKotl } public void testAllFilesPresentInCompileKotlinAgainstKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("annotationInInterface.kt") @@ -422,7 +423,7 @@ public class CompileKotlinAgainstKotlinTestGenerated extends AbstractCompileKotl } public void testAllFilesPresentInFir() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/fir"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/fir"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("AnonymousObjectInProperty.kt") @@ -460,7 +461,7 @@ public class CompileKotlinAgainstKotlinTestGenerated extends AbstractCompileKotl } public void testAllFilesPresentInJvm8() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults") @@ -472,7 +473,7 @@ public class CompileKotlinAgainstKotlinTestGenerated extends AbstractCompileKotl } public void testAllFilesPresentInDefaults() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("superCall.kt") @@ -514,7 +515,7 @@ public class CompileKotlinAgainstKotlinTestGenerated extends AbstractCompileKotl } public void testAllFilesPresentInAllCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("callStackTrace.kt") @@ -561,7 +562,7 @@ public class CompileKotlinAgainstKotlinTestGenerated extends AbstractCompileKotl } public void testAllFilesPresentInDelegationBy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("simple.kt") @@ -585,7 +586,7 @@ public class CompileKotlinAgainstKotlinTestGenerated extends AbstractCompileKotl } public void testAllFilesPresentInInterop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/interop"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/interop"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("likeMemberClash.kt") @@ -634,7 +635,7 @@ public class CompileKotlinAgainstKotlinTestGenerated extends AbstractCompileKotl } public void testAllFilesPresentInJvm8against6() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/jvm8against6"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/jvm8against6"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("jdk8Against6.kt") @@ -676,7 +677,7 @@ public class CompileKotlinAgainstKotlinTestGenerated extends AbstractCompileKotl } public void testAllFilesPresentInDelegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/jvm8against6/delegation"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/jvm8against6/delegation"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("diamond.kt") @@ -706,7 +707,7 @@ public class CompileKotlinAgainstKotlinTestGenerated extends AbstractCompileKotl } public void testAllFilesPresentInTypeAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/typeAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/typeAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("implicitReturn.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/CustomScriptCodegenTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/CustomScriptCodegenTestGenerated.java index 7e34a50055c..4868c93e3e5 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/CustomScriptCodegenTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/CustomScriptCodegenTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.codegen; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class CustomScriptCodegenTestGenerated extends AbstractCustomScriptCodege } public void testAllFilesPresentInCustomScript() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/customScript"), Pattern.compile("^(.*)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/customScript"), Pattern.compile("^(.*)$"), null, true); } @TestMetadata("pathPattern5.kts") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/DumpDeclarationsTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/DumpDeclarationsTestGenerated.java index fd4943cfd87..6d0cae0462c 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/DumpDeclarationsTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/DumpDeclarationsTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.codegen; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class DumpDeclarationsTestGenerated extends AbstractDumpDeclarationsTest } public void testAllFilesPresentInDumpDeclarations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/dumpDeclarations"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/dumpDeclarations"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("annotation.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/IrCompileKotlinAgainstKotlinJdk15TestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/IrCompileKotlinAgainstKotlinJdk15TestGenerated.java index dd2e73bf317..29b79ac56b4 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/IrCompileKotlinAgainstKotlinJdk15TestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/IrCompileKotlinAgainstKotlinJdk15TestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.codegen; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class IrCompileKotlinAgainstKotlinJdk15TestGenerated extends AbstractIrCo } public void testAllFilesPresentInCompileKotlinAgainstKotlinJdk15() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlinJdk15"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlinJdk15"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("jvmRecordBinary.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/Jdk15BlackBoxCodegenTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/Jdk15BlackBoxCodegenTestGenerated.java index f61ed7795cc..f9502bd03a7 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/Jdk15BlackBoxCodegenTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/Jdk15BlackBoxCodegenTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.codegen; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class Jdk15BlackBoxCodegenTestGenerated extends AbstractJdk15BlackBoxCode } public void testAllFilesPresentInBox() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/java15/box"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/java15/box"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/testData/codegen/java15/box/records") @@ -37,7 +38,7 @@ public class Jdk15BlackBoxCodegenTestGenerated extends AbstractJdk15BlackBoxCode } public void testAllFilesPresentInRecords() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/java15/box/records"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/java15/box/records"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("bytecodeShapeForJava.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/Jdk15IrBlackBoxCodegenTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/Jdk15IrBlackBoxCodegenTestGenerated.java index 189c1344a69..d6030f1024d 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/Jdk15IrBlackBoxCodegenTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/Jdk15IrBlackBoxCodegenTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.codegen; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class Jdk15IrBlackBoxCodegenTestGenerated extends AbstractJdk15IrBlackBox } public void testAllFilesPresentInBox() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/java15/box"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/java15/box"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/codegen/java15/box/records") @@ -38,7 +39,7 @@ public class Jdk15IrBlackBoxCodegenTestGenerated extends AbstractJdk15IrBlackBox } public void testAllFilesPresentInRecords() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/java15/box/records"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/java15/box/records"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("bytecodeShapeForJava.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/Jdk9BlackBoxCodegenTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/Jdk9BlackBoxCodegenTestGenerated.java index 59349e24c79..527f0f839e1 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/Jdk9BlackBoxCodegenTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/Jdk9BlackBoxCodegenTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.codegen; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class Jdk9BlackBoxCodegenTestGenerated extends AbstractJdk9BlackBoxCodege } public void testAllFilesPresentInBox() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/java9/box"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/java9/box"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("concatDynamic.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/Kapt3BuilderModeBytecodeShapeTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/Kapt3BuilderModeBytecodeShapeTestGenerated.java index 1ba3b5b334f..a6a4018d610 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/Kapt3BuilderModeBytecodeShapeTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/Kapt3BuilderModeBytecodeShapeTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.codegen; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class Kapt3BuilderModeBytecodeShapeTestGenerated extends AbstractKapt3Bui } public void testAllFilesPresentInKapt() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/kapt"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/kapt"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("dataClass.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java index cfc78f96461..d99b2c153c9 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.codegen; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInBox() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true, "ranges/stepped"); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true, "ranges/stepped"); } @TestMetadata("compiler/testData/codegen/box/annotations") @@ -38,7 +39,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("annotatedAnnotationParameter.kt") @@ -235,7 +236,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInAnnotatedLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations/annotatedLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations/annotatedLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("funExpression.kt") @@ -273,7 +274,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInTypeAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations/typeAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations/typeAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("checkingNotincorporatedInputTypes.kt") @@ -317,7 +318,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInArgumentOrder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/argumentOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/argumentOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("argumentOrderInObjectSuperCall.kt") @@ -410,7 +411,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInArrays() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("arrayConstructorWithNonInlineLambda.kt") @@ -747,7 +748,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInArraysOfInlineClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/arraysOfInlineClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/arraysOfInlineClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("arrayOfInlineClassOfArrayOfInlineClass.kt") @@ -765,7 +766,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInForInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/forInReversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/forInReversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("reversedArrayOriginalUpdatedInLoopBody.kt") @@ -798,7 +799,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInMultiDecl() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("kt15560.kt") @@ -850,7 +851,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInInt() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -883,7 +884,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInLong() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -918,7 +919,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInAssert() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/assert"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/assert"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("alwaysDisable.kt") @@ -955,7 +956,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInJvm() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/assert/jvm"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/assert/jvm"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("assertionsEnabledBeforeClassInitializers.kt") @@ -1064,7 +1065,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInBinaryOp() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/binaryOp"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/binaryOp"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("bitwiseOp.kt") @@ -1207,7 +1208,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInBoxingOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/boxingOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/boxingOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("boxedIntegersCmp.kt") @@ -1380,7 +1381,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInBridges() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/bridges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/bridges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("bridgeInInterface.kt") @@ -1677,7 +1678,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInSubstitutionInSuperClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/bridges/substitutionInSuperClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/bridges/substitutionInSuperClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("boundedTypeArguments.kt") @@ -1741,7 +1742,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInBuilderInference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("callableReferenceAndCoercionToUnit.kt") @@ -1789,7 +1790,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInBuiltinStubMethods() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("Collection.kt") @@ -1926,7 +1927,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInExtendJavaCollections() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/extendJavaCollections"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/extendJavaCollections"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("arrayList.kt") @@ -1959,7 +1960,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInMapGetOrDefault() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/mapGetOrDefault"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/mapGetOrDefault"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("noTypeSafeBridge.kt") @@ -1987,7 +1988,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInMapRemove() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/mapRemove"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/mapRemove"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("noDefaultImpls.kt") @@ -2021,7 +2022,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("builtinFunctionReferenceOwner.kt") @@ -2078,7 +2079,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInAdaptedReferences() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/adaptedReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/adaptedReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("bothWithCoercionToUnit.kt") @@ -2240,7 +2241,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInSuspendConversion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("bound.kt") @@ -2319,7 +2320,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInBound() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("array.kt") @@ -2466,7 +2467,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInEquals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/bound/equals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/bound/equals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("nullableReceiverInEquals.kt") @@ -2500,7 +2501,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInEquality() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/equality"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/equality"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("capturedDefaults.kt") @@ -2578,7 +2579,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/function"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/function"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("argumentTypes.kt") @@ -2860,7 +2861,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInLocal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/function/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/function/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("captureOuter.kt") @@ -2979,7 +2980,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("delegated.kt") @@ -3142,7 +3143,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInSerializability() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/serializability"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/serializability"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("boundWithNotSerializableReceiver.kt") @@ -3181,7 +3182,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInCasts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("as.kt") @@ -3318,7 +3319,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("asFunKBig.kt") @@ -3396,7 +3397,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInJavaInterop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("castWithWrongType.kt") @@ -3479,7 +3480,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInLiteralExpressionAsGenericArgument() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/literalExpressionAsGenericArgument"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/literalExpressionAsGenericArgument"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("binaryExpressionCast.kt") @@ -3527,7 +3528,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInMutableCollections() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/mutableCollections"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/mutableCollections"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("asWithMutable.kt") @@ -3581,7 +3582,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInCheckcastOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/checkcastOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/checkcastOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("kt19128.kt") @@ -3604,7 +3605,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInClassLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("bareArray.kt") @@ -3626,7 +3627,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInBound() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classLiteral/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classLiteral/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("javaIntrinsicWithSideEffect.kt") @@ -3664,7 +3665,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classLiteral/java"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classLiteral/java"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("java.kt") @@ -3723,7 +3724,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("boxPrimitiveTypeInClinitOfClassObject.kt") @@ -4330,7 +4331,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInInner() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classes/inner"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classes/inner"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("extensionWithOuter.kt") @@ -4379,7 +4380,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInClosures() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("anonymousObjectAsLastExpressionInLambda.kt") @@ -4621,7 +4622,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInCaptureInSuperConstructorCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/captureInSuperConstructorCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/captureInSuperConstructorCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("constructorParameterAndLocalCapturedInLambdaInLocalClass.kt") @@ -4794,7 +4795,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInCaptureOuterProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/captureOuterProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/captureOuterProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("captureFunctionInProperty.kt") @@ -4847,7 +4848,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInCapturedVarsOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/capturedVarsOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/capturedVarsOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("capturedInCrossinline.kt") @@ -4915,7 +4916,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInClosureInsideClosure() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/closureInsideClosure"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/closureInsideClosure"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("localFunInsideLocalFun.kt") @@ -4959,7 +4960,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInCollectionLiterals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/collectionLiterals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/collectionLiterals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("collectionLiteralsInArgumentPosition.kt") @@ -5002,7 +5003,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInCollections() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/collections"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/collections"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("charSequence.kt") @@ -5170,7 +5171,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInCompanion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/companion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/companion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("delegatedPropertyOnCompanion.kt") @@ -5193,7 +5194,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/compatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/compatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("privateCompanionObject.kt") @@ -5211,7 +5212,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInConstants() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/constants"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/constants"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("comparisonFalse.kt") @@ -5274,7 +5275,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInConstructorCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/constructorCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/constructorCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("breakInConstructorArguments.kt") @@ -5372,7 +5373,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInContracts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/contracts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/contracts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("constructorArgument.kt") @@ -5445,7 +5446,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInControlStructures() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("bottles.kt") @@ -5852,7 +5853,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInBreakContinueInExpressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("breakFromOuter.kt") @@ -5955,7 +5956,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInForInArray() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInArray"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInArray"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("forInArraySpecializedToUntil.kt") @@ -6018,7 +6019,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInForInArrayWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("forInArrayOfObjectArrayWithIndex.kt") @@ -6131,7 +6132,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInForInCharSequenceWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInCharSequenceWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInCharSequenceWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("forInCharSeqWithIndexStops.kt") @@ -6214,7 +6215,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInForInIterableWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInIterableWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInIterableWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("forInEmptyListWithIndex.kt") @@ -6282,7 +6283,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInForInSequenceWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInSequenceWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInSequenceWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("forInEmptySequenceWithIndex.kt") @@ -6350,7 +6351,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInReturnsNothing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/returnsNothing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/returnsNothing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("ifElse.kt") @@ -6388,7 +6389,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInTryCatchInExpressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("catch.kt") @@ -6562,7 +6563,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInCoroutines() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("async.kt") @@ -7144,7 +7145,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInBridges() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/bridges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/bridges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("interfaceSpecialization.kt") @@ -7172,7 +7173,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInControlFlow() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/controlFlow"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/controlFlow"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("breakFinally.kt") @@ -7300,7 +7301,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInDebug() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/debug"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/debug"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("debuggerMetadata.kt") @@ -7353,7 +7354,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInFeatureIntersection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("breakWithNonEmptyStack.kt") @@ -7445,7 +7446,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("bigArity.kt") @@ -7472,7 +7473,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInBound() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("emptyLHS.kt") @@ -7490,7 +7491,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/function"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/function"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("genericCallableReferenceArguments.kt") @@ -7517,7 +7518,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInLocal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/function/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/function/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("equalsHashCode.kt") @@ -7537,7 +7538,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInTailrec() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/tailrec"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/tailrec"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("controlFlowIf.kt") @@ -7616,7 +7617,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("nonLocalReturn.kt") @@ -7633,7 +7634,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInDirect() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses/direct"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses/direct"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("boxReturnValueOfSuspendFunctionReference.kt") @@ -7861,7 +7862,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInResume() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses/resume"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses/resume"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("boxReturnValueOfSuspendFunctionReference.kt") @@ -8089,7 +8090,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInResumeWithException() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("boxReturnValueOfSuspendFunctionReference.kt") @@ -8303,7 +8304,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInIntLikeVarSpilling() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/intLikeVarSpilling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/intLikeVarSpilling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("complicatedMerge.kt") @@ -8371,7 +8372,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInIntrinsicSemantics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/intrinsicSemantics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/intrinsicSemantics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("coroutineContext.kt") @@ -8424,7 +8425,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInJavaInterop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("objectWithSeveralSuspends.kt") @@ -8462,7 +8463,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInLocalFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/localFunctions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/localFunctions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/codegen/box/coroutines/localFunctions/anonymous") @@ -8479,7 +8480,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInAnonymous() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/localFunctions/anonymous"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/localFunctions/anonymous"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } } @@ -8492,7 +8493,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInNamed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/localFunctions/named"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/localFunctions/named"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("capturedParameters.kt") @@ -8561,7 +8562,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInMultiModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("inlineCrossModule.kt") @@ -8619,7 +8620,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInRedundantLocalsElimination() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/redundantLocalsElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/redundantLocalsElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("ktor_receivedMessage.kt") @@ -8637,7 +8638,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInReflect() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/reflect"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/reflect"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("bigArity.kt") @@ -8665,7 +8666,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInStackUnwinding() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/stackUnwinding"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/stackUnwinding"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("exception.kt") @@ -8728,7 +8729,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInSuspendConversion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/suspendConversion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/suspendConversion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } } @@ -8741,7 +8742,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInSuspendFunctionAsCoroutine() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("dispatchResume.kt") @@ -8844,7 +8845,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInSuspendFunctionTypeCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/suspendFunctionTypeCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/suspendFunctionTypeCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("localVal.kt") @@ -8882,7 +8883,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInTailCallOptimizations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/tailCallOptimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/tailCallOptimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("also.kt") @@ -8969,7 +8970,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInUnit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/tailCallOptimizations/unit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/tailCallOptimizations/unit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("functionReference.kt") @@ -9038,7 +9039,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInTailOperations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/tailOperations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/tailOperations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("suspendWithIf.kt") @@ -9071,7 +9072,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInUnitTypeReturn() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/unitTypeReturn"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/unitTypeReturn"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("coroutineNonLocalReturn.kt") @@ -9119,7 +9120,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInVarSpilling() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/varSpilling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/varSpilling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("fakeInlinerVariables.kt") @@ -9163,7 +9164,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInDataClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("arrayParams.kt") @@ -9255,7 +9256,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInCopy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/copy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/copy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("constructorWithDefaultParam.kt") @@ -9308,7 +9309,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInEquals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/equals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/equals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("alreadyDeclared.kt") @@ -9356,7 +9357,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInHashCode() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/hashCode"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/hashCode"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("alreadyDeclared.kt") @@ -9434,7 +9435,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInToString() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/toString"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/toString"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("alreadyDeclared.kt") @@ -9483,7 +9484,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInDeadCodeElimination() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/deadCodeElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/deadCodeElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("emptyVariableRange.kt") @@ -9516,7 +9517,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInDefaultArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("callDefaultFromInitializer.kt") @@ -9613,7 +9614,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/constructor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/constructor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("annotation.kt") @@ -9711,7 +9712,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInConvention() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/convention"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/convention"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("incWithDefaultInGetter.kt") @@ -9764,7 +9765,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/function"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/function"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("complexInheritance.kt") @@ -9912,7 +9913,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInPrivate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("memberExtensionFunction.kt") @@ -9945,7 +9946,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/signature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/signature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("kt2789.kt") @@ -9984,7 +9985,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInDelegatedProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("beforeDeclarationContainerOptimization.kt") @@ -10226,7 +10227,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInLocal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("capturedLocalVal.kt") @@ -10324,7 +10325,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInOptimizedDelegatedProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/optimizedDelegatedProperties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/optimizedDelegatedProperties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("definedInSources.kt") @@ -10387,7 +10388,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInProvideDelegate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/provideDelegate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/provideDelegate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("delegatedPropertyWithIdProvideDelegate.kt") @@ -10511,7 +10512,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInDelegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("byMiddleInterface.kt") @@ -10599,7 +10600,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInDestructuringDeclInLambdaParam() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/destructuringDeclInLambdaParam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/destructuringDeclInLambdaParam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("extensionComponents.kt") @@ -10652,7 +10653,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInDiagnostics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/codegen/box/diagnostics/functions") @@ -10664,7 +10665,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/codegen/box/diagnostics/functions/inference") @@ -10676,7 +10677,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInInference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/inference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/inference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("kt6176.kt") @@ -10694,7 +10695,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInInvoke() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/invoke"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/invoke"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects") @@ -10706,7 +10707,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInOnObjects() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("invokeOnClassObject1.kt") @@ -10770,7 +10771,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInTailRecursion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/tailRecursion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/tailRecursion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("defaultArgs.kt") @@ -10989,7 +10990,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInVararg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/vararg"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/vararg"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("kt4172.kt") @@ -11008,7 +11009,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInElvis() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/elvis"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/elvis"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("genericElvisWithMoreSpecificLHS.kt") @@ -11066,7 +11067,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("annotatedParameter.kt") @@ -11383,7 +11384,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInDefaultCtor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/enum/defaultCtor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/enum/defaultCtor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("constructorWithDefaultArguments.kt") @@ -11427,7 +11428,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInEvaluate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/evaluate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/evaluate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("char.kt") @@ -11515,7 +11516,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInExclExcl() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/exclExcl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/exclExcl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("genericNull.kt") @@ -11538,7 +11539,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInExtensionFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/extensionFunctions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/extensionFunctions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("executionOrder.kt") @@ -11676,7 +11677,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInExtensionProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/extensionProperties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/extensionProperties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("genericValForPrimitiveType.kt") @@ -11759,7 +11760,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInExternal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/external"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/external"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("jvmStaticExternal.kt") @@ -11787,7 +11788,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInFakeOverride() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fakeOverride"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fakeOverride"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("diamondFunction.kt") @@ -11835,7 +11836,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInFieldRename() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fieldRename"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fieldRename"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("constructorAndClassObject.kt") @@ -11868,7 +11869,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInFinally() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/finally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/finally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("breakAndOuterFinally.kt") @@ -11991,7 +11992,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInFullJdk() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("charBuffer.kt") @@ -12033,7 +12034,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInNative() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk/native"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk/native"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("nativePropertyAccessors.kt") @@ -12061,7 +12062,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInRegressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk/regressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk/regressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("kt15112.kt") @@ -12085,7 +12086,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInFunInterface() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("basicFunInterface.kt") @@ -12202,7 +12203,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInEquality() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/funInterface/equality"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/funInterface/equality"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("functionReferencesBound.kt") @@ -12241,7 +12242,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("coerceVoidToArray.kt") @@ -12478,7 +12479,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInBigArity() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/bigArity"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/bigArity"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("callFromJava.kt") @@ -12546,7 +12547,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInFunctionExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/functionExpression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/functionExpression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("functionExpression.kt") @@ -12589,7 +12590,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInInvoke() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/invoke"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/invoke"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("castFunctionToExtension.kt") @@ -12677,7 +12678,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInLocalFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/localFunctions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/localFunctions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("boundTypeParameterInSupertype.kt") @@ -12841,7 +12842,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInHashPMap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/hashPMap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/hashPMap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("empty.kt") @@ -12884,7 +12885,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInIeee754() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ieee754"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ieee754"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("anyToReal.kt") @@ -13142,7 +13143,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInIncrement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/increment"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/increment"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("argumentWithSideEffects.kt") @@ -13285,7 +13286,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInInference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("approximateNonTopLevelCapturedTypes.kt") @@ -13478,7 +13479,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("annotatedMemberExtensionProperty.kt") @@ -14300,7 +14301,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInBoxReturnValueInLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("boxAny.kt") @@ -14373,7 +14374,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInBoxReturnValueOnOverride() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("covariantOverrideChainErasedToAny.kt") @@ -14516,7 +14517,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInCallableReferences() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/callableReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/callableReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("boundInlineClassExtensionFun.kt") @@ -14684,7 +14685,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInContextsAndAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("captureInlineClassInstanceInLambda.kt") @@ -14752,7 +14753,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInDefaultParameterValues() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/defaultParameterValues"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/defaultParameterValues"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("defaultConstructorParameterValuesOfInlineClassType.kt") @@ -14825,7 +14826,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInFunctionNameMangling() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/functionNameMangling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/functionNameMangling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("anonymousObjectInFunctionWithMangledName.kt") @@ -14928,7 +14929,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInHiddenConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/hiddenConstructor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/hiddenConstructor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("constructorReferencedFromOtherFile1.kt") @@ -15006,7 +15007,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInInterfaceDelegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/interfaceDelegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/interfaceDelegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("interfaceImplementationByDelegation.kt") @@ -15059,7 +15060,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInInterfaceMethodCalls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("complexGenericMethodWithInlineClassOverride.kt") @@ -15127,7 +15128,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInJavaInterop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("inlineClasInSignature.kt") @@ -15155,7 +15156,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInJvm8DefaultInterfaceMethods() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/jvm8DefaultInterfaceMethods"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/jvm8DefaultInterfaceMethods"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("javaDefaultMethod.kt") @@ -15228,7 +15229,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInPropertyDelegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/propertyDelegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/propertyDelegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("captureLocalVarDelegatedToInlineClass.kt") @@ -15301,7 +15302,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInUnboxGenericParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface") @@ -15313,7 +15314,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInFunInterface() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("any.kt") @@ -15361,7 +15362,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("any.kt") @@ -15409,7 +15410,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInObjectLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("any.kt") @@ -15459,7 +15460,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInInnerNested() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/innerNested"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/innerNested"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("createNestedClass.kt") @@ -15611,7 +15612,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInSuperConstructorCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/innerNested/superConstructorCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/innerNested/superConstructorCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("deepInnerHierarchy.kt") @@ -15730,7 +15731,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInInstructions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/instructions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/instructions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/codegen/box/instructions/swap") @@ -15742,7 +15743,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInSwap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/instructions/swap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/instructions/swap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("swapRefToSharedVarInt.kt") @@ -15766,7 +15767,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInIntrinsics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/intrinsics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/intrinsics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("charToInt.kt") @@ -15914,7 +15915,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInIr() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("anonymousClassLeak.kt") @@ -16021,7 +16022,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInClosureConversion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/closureConversion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/closureConversion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("closureConversion1.kt") @@ -16074,7 +16075,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInPrimitiveNumberComparisons() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/primitiveNumberComparisons"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/primitiveNumberComparisons"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("comparableToDouble.kt") @@ -16112,7 +16113,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInSerializationRegressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/serializationRegressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/serializationRegressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("deepGenericDelegatedProperty.kt") @@ -16161,7 +16162,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInJavaInterop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("genericSamProjectedOut.kt") @@ -16213,7 +16214,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInGenerics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/generics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/generics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("allWildcardsOnClass.kt") @@ -16261,7 +16262,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInNotNullAssertions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("destructuringAssignmentWithNullabilityAssertionOnExtensionReceiver_lv12.kt") @@ -16363,7 +16364,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInEnhancedNullability() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions/enhancedNullability"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions/enhancedNullability"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("inFunctionWithExpressionBody.kt") @@ -16416,7 +16417,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInNullCheckOnLambdaReturnValue() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions/nullCheckOnLambdaReturnValue"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions/nullCheckOnLambdaReturnValue"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("nnStringVsT.kt") @@ -16480,7 +16481,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInObjectMethods() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/objectMethods"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/objectMethods"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("cloneCallsConstructor.kt") @@ -16524,7 +16525,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInJdk() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jdk"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jdk"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("arrayList.kt") @@ -16577,7 +16578,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInJvm8() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("bridgeInClass.kt") @@ -16714,7 +16715,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInDefaults() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("bridgeInClass.kt") @@ -16871,7 +16872,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInAllCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("bridge.kt") @@ -17013,7 +17014,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInDelegationBy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("simple.kt") @@ -17037,7 +17038,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/compatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/compatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("bridge.kt") @@ -17130,7 +17131,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInDelegationBy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("simple.kt") @@ -17163,7 +17164,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInNoDefaultImpls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("bridge.kt") @@ -17300,7 +17301,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInDelegationBy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("simple.kt") @@ -17323,7 +17324,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInSpecialization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/specialization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/specialization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("basic.kt") @@ -17342,7 +17343,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInNoDelegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDelegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDelegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("noDelegationToDefaultMethodInClass.kt") @@ -17370,7 +17371,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInReflection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/reflection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/reflection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("propertyAnnotations.kt") @@ -17389,7 +17390,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInInterfaceFlag() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/interfaceFlag"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/interfaceFlag"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("superCall.kt") @@ -17412,7 +17413,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInJavaDefaults() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/javaDefaults"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/javaDefaults"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("capturedSuperCall.kt") @@ -17496,7 +17497,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInJvmField() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmField"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmField"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("annotationCompanion.kt") @@ -17634,7 +17635,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInJvmName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("annotationProperties.kt") @@ -17721,7 +17722,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInFileFacades() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmName/fileFacades"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmName/fileFacades"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("differentFiles.kt") @@ -17750,7 +17751,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInJvmOverloads() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmOverloads"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmOverloads"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("companionObject.kt") @@ -17863,7 +17864,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInJvmPackageName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmPackageName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmPackageName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("metadataField.kt") @@ -17901,7 +17902,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInJvmStatic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmStatic"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmStatic"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("annotations.kt") @@ -18079,7 +18080,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInLabels() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/labels"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/labels"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("controlLabelClashesWithFuncitonName.kt") @@ -18132,7 +18133,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInLazyCodegen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/lazyCodegen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/lazyCodegen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("exceptionInFieldInitializer.kt") @@ -18189,7 +18190,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInOptimizations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/lazyCodegen/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/lazyCodegen/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("negateConstantCompare.kt") @@ -18263,7 +18264,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInLocalClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/localClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/localClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("anonymousObjectInExtension.kt") @@ -18431,7 +18432,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInMangling() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/mangling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/mangling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("field.kt") @@ -18494,7 +18495,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInMixedNamedPosition() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/mixedNamedPosition"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/mixedNamedPosition"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("defaults.kt") @@ -18522,7 +18523,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInMultiDecl() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("ComplexInitializer.kt") @@ -18604,7 +18605,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInForIterator() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forIterator"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forIterator"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("MultiDeclFor.kt") @@ -18641,7 +18642,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInLongIterator() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forIterator/longIterator"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forIterator/longIterator"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -18675,7 +18676,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInForRange() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("MultiDeclFor.kt") @@ -18722,7 +18723,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInExplicitRangeTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("MultiDeclFor.kt") @@ -18759,7 +18760,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInInt() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -18792,7 +18793,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInLong() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -18826,7 +18827,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInExplicitRangeToWithDot() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("MultiDeclFor.kt") @@ -18863,7 +18864,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInInt() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -18896,7 +18897,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInLong() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -18930,7 +18931,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInInt() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -18963,7 +18964,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInLong() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -18998,7 +18999,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInMultifileClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("callMultifileClassMemberFromOtherPackage.kt") @@ -19085,7 +19086,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInOptimized() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multifileClasses/optimized"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multifileClasses/optimized"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("callInInlineLambda.kt") @@ -19149,7 +19150,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInMultiplatform() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("expectClassInJvmMultifileFacade.kt") @@ -19191,7 +19192,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInDefaultArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("annotations.kt") @@ -19314,7 +19315,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInMultiModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("expectActualLink.kt") @@ -19343,7 +19344,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInNonLocalReturns() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nonLocalReturns"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nonLocalReturns"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("kt6895.kt") @@ -19386,7 +19387,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInNothingValue() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nothingValue"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nothingValue"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("inNestedCall.kt") @@ -19409,7 +19410,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInNullCheckOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nullCheckOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nullCheckOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("exclExclThrowsKnpe_1_3.kt") @@ -19482,7 +19483,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInObjectIntrinsics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objectIntrinsics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objectIntrinsics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("objects.kt") @@ -19500,7 +19501,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInObjects() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("anonymousObjectPropertyInitialization.kt") @@ -19872,7 +19873,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInCompanionObjectAccess() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("kt27117.kt") @@ -19969,7 +19970,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInMultipleCompanionsWithAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("anonymousObjectInPropertyInitializer.kt") @@ -20037,7 +20038,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInPrimitiveCompanion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess/primitiveCompanion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess/primitiveCompanion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("byteCompanionObject.kt") @@ -20087,7 +20088,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInOldLanguageVersions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("dataClassEqualsHashCodeToString.kt") @@ -20104,7 +20105,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInControlStructures() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/controlStructures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/controlStructures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/codegen/box/oldLanguageVersions/controlStructures/forInArray") @@ -20116,7 +20117,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInForInArray() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/controlStructures/forInArray"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/controlStructures/forInArray"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("forInArrayWithArrayVarUpdatedInLoopBody12.kt") @@ -20135,7 +20136,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInCoroutines() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("asyncIteratorNullMerge_1_2.kt") @@ -20187,7 +20188,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInControlFlow() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines/controlFlow"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines/controlFlow"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("kt22694_1_2.kt") @@ -20205,7 +20206,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInFeatureIntersection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines/featureIntersection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines/featureIntersection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("suspendFunction_1_2.kt") @@ -20223,7 +20224,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInMultiModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("inlineWithJava_1_2.kt") @@ -20241,7 +20242,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInReflect() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines/reflect"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines/reflect"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("isSuspend_1_2.kt") @@ -20259,7 +20260,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInSuspendFunctionAsCoroutine() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines/suspendFunctionAsCoroutine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines/suspendFunctionAsCoroutine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("ifExpressionInsideCoroutine_1_2.kt") @@ -20283,7 +20284,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/codegen/box/oldLanguageVersions/functions/bigArity") @@ -20300,7 +20301,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInBigArity() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/functions/bigArity"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/functions/bigArity"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } } } @@ -20314,7 +20315,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInIeee754() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/ieee754"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/ieee754"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("nullableDoubleEquals10.kt") @@ -20357,7 +20358,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInJavaInterop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/codegen/box/oldLanguageVersions/javaInterop/notNullAssertions") @@ -20369,7 +20370,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInNotNullAssertions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/javaInterop/notNullAssertions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/javaInterop/notNullAssertions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("incWithNullabilityAssertionOnExtensionReceiverInPrivateOperator_lv11.kt") @@ -20403,7 +20404,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInOperatorConventions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/operatorConventions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/operatorConventions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("percentAsModOnBigIntegerWithoutRem.kt") @@ -20421,7 +20422,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInPlatformTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/platformTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/platformTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/codegen/box/oldLanguageVersions/platformTypes/primitives") @@ -20433,7 +20434,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInPrimitives() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/platformTypes/primitives"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/platformTypes/primitives"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("equalsNull_lv11.kt") @@ -20453,7 +20454,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInOperatorConventions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/operatorConventions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/operatorConventions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("annotatedAssignment.kt") @@ -20565,7 +20566,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInCompareTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/operatorConventions/compareTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/operatorConventions/compareTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("boolean.kt") @@ -20634,7 +20635,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInOptimizations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("hashCode.kt") @@ -20657,7 +20658,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInPackage() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/package"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/package"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("boxPrimitiveTypeInClinit.kt") @@ -20730,7 +20731,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInParametersMetadata() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/parametersMetadata"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/parametersMetadata"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("defaultImpls.kt") @@ -20793,7 +20794,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInPlatformTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/platformTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/platformTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("inferenceFlexibleTToNullable.kt") @@ -20820,7 +20821,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInPrimitives() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/platformTypes/primitives"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/platformTypes/primitives"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("assign.kt") @@ -20939,7 +20940,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInPolymorphicSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/polymorphicSignature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/polymorphicSignature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("anonymousSubclass.kt") @@ -20992,7 +20993,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInPrimitiveTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("comparisonWithNaN.kt") @@ -21299,7 +21300,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInEqualityWithObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes/equalityWithObject"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes/equalityWithObject"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("boxedEqPrimitiveEvaluationOrder.kt") @@ -21356,7 +21357,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInGenerated() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("boxedEqPrimitiveBoolean.kt") @@ -21461,7 +21462,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInPrivate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("arrayConvention.kt") @@ -21484,7 +21485,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInPrivateConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/privateConstructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/privateConstructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("base.kt") @@ -21607,7 +21608,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("classArtificialFieldInsideNested.kt") @@ -21999,7 +22000,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInConst() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/const"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/const"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("anotherFile.kt") @@ -22067,7 +22068,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInLateinit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("exceptionField.kt") @@ -22139,7 +22140,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInIsInitializedAndDeinitialize() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/isInitializedAndDeinitialize"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/isInitializedAndDeinitialize"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("companionObjectField.kt") @@ -22192,7 +22193,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInLocal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("capturedLocalLateinit.kt") @@ -22250,7 +22251,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInTopLevel() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/topLevel"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/topLevel"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("topLevelLateinit.kt") @@ -22280,7 +22281,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInPublishedApi() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/publishedApi"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/publishedApi"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("noMangling.kt") @@ -22308,7 +22309,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInRanges() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true, "stepped"); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true, "stepped"); } @TestMetadata("forByteProgressionWithIntIncrement.kt") @@ -22405,7 +22406,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInContains() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/contains"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/contains"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("comparisonWithRangeBoundEliminated.kt") @@ -22617,7 +22618,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInGenerated() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/contains/generated"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/contains/generated"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("arrayIndices.kt") @@ -22701,7 +22702,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInEvaluationOrder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("forInDownTo.kt") @@ -22758,7 +22759,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInStepped() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo") @@ -22770,7 +22771,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInForInDownTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("forInDownToReversedStep.kt") @@ -22823,7 +22824,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInForInRangeLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInRangeLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInRangeLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("forInRangeLiteralReversedStep.kt") @@ -22876,7 +22877,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInForInUntil() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInUntil"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInUntil"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("forInUntilReversedStep.kt") @@ -22931,7 +22932,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("emptyDownto.kt") @@ -23094,7 +23095,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInForInDownTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInDownTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInDownTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("forIntInDownTo.kt") @@ -23137,7 +23138,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInForInIndices() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInIndices"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInIndices"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("forInArrayListIndices.kt") @@ -23250,7 +23251,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInForInProgressionWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInProgressionWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInProgressionWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("forInDownToWithIndex.kt") @@ -23338,7 +23339,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInForInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInReversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInReversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("forInReversedArrayIndices.kt") @@ -23446,7 +23447,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInForInUntil() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInUntil"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInUntil"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("forInUntilChar.kt") @@ -23529,7 +23530,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInForWithPossibleOverflow() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forWithPossibleOverflow"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forWithPossibleOverflow"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("forInDownToCharMinValue.kt") @@ -23632,7 +23633,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInJavaInterop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("javaArrayOfInheritedNotNull.kt") @@ -23739,7 +23740,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/javaInterop/withIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/javaInterop/withIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("javaArrayOfInheritedNotNullWithIndex.kt") @@ -23793,7 +23794,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("emptyDownto.kt") @@ -23956,7 +23957,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInNullableLoopParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/nullableLoopParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/nullableLoopParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("progressionExpression.kt") @@ -23984,7 +23985,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInUnsigned() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("inMixedUnsignedRange.kt") @@ -24021,7 +24022,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("emptyDownto.kt") @@ -24184,7 +24185,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("emptyDownto.kt") @@ -24362,7 +24363,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInNullableLoopParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/nullableLoopParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/nullableLoopParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } } } @@ -24377,7 +24378,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInReflection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/codegen/box/reflection/annotations") @@ -24389,7 +24390,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/annotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/annotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("annotationRetentionAnnotation.kt") @@ -24496,7 +24497,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInOnTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/annotations/onTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/annotations/onTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("arrayKClass.kt") @@ -24530,7 +24531,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInBuiltins() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/builtins"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/builtins"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("collections.kt") @@ -24558,7 +24559,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("bigArity.kt") @@ -24690,7 +24691,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInBound() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("companionObjectPropertyAccessors.kt") @@ -24768,7 +24769,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("constructorWithInlineClassParameters.kt") @@ -24852,7 +24853,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInCallBy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/callBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/callBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("boundExtensionFunction.kt") @@ -24995,7 +24996,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInClassLiterals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/classLiterals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/classLiterals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("annotationClassLiteral.kt") @@ -25053,7 +25054,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/classes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/classes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("classSimpleName.kt") @@ -25146,7 +25147,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/constructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/constructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("annotationClass.kt") @@ -25189,7 +25190,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInCreateAnnotation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/createAnnotation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/createAnnotation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("annotationType.kt") @@ -25267,7 +25268,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInEnclosing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/enclosing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/enclosing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("anonymousObjectInInlinedLambda.kt") @@ -25405,7 +25406,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("declaredVsInheritedFunctions.kt") @@ -25483,7 +25484,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInGenericSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/genericSignature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/genericSignature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("covariantOverride.kt") @@ -25581,7 +25582,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInIsInstance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/isInstance"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/isInstance"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("isInstanceCastAndSafeCast.kt") @@ -25599,7 +25600,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInKClassInAnnotation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/kClassInAnnotation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/kClassInAnnotation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("array.kt") @@ -25657,7 +25658,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInLambdaClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/lambdaClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/lambdaClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("parameterNamesAndNullability.kt") @@ -25715,7 +25716,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInMapping() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("constructor.kt") @@ -25812,7 +25813,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInFakeOverrides() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/fakeOverrides"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/fakeOverrides"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("javaFieldGetterSetter.kt") @@ -25835,7 +25836,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("inlineClassPrimaryVal.kt") @@ -25858,7 +25859,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInJvmStatic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/jvmStatic"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/jvmStatic"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("companionObjectFunction.kt") @@ -25881,7 +25882,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/types"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/types"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("allSupertypes.kt") @@ -26005,7 +26006,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInMethodsFromAny() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/methodsFromAny"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/methodsFromAny"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("builtinFunctionsToString.kt") @@ -26133,7 +26134,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInModifiers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/modifiers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/modifiers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("callableModality.kt") @@ -26191,7 +26192,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInMultifileClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("callFunctionsInMultifileClass.kt") @@ -26219,7 +26220,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInNoReflectAtRuntime() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/noReflectAtRuntime"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/noReflectAtRuntime"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("javaClass.kt") @@ -26266,7 +26267,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInMethodsFromAny() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/noReflectAtRuntime/methodsFromAny"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/noReflectAtRuntime/methodsFromAny"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("callableReferences.kt") @@ -26295,7 +26296,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/parameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/parameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("bigArity.kt") @@ -26383,7 +26384,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("allVsDeclared.kt") @@ -26550,7 +26551,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/accessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/accessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("extensionPropertyAccessors.kt") @@ -26583,7 +26584,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInGetDelegate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/getDelegate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/getDelegate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("booleanPropertyNameStartsWithIs.kt") @@ -26671,7 +26672,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInJvmField() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/jvmField"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/jvmField"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("annotationCompanionWithAnnotation.kt") @@ -26704,7 +26705,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInLocalDelegated() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/localDelegated"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/localDelegated"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("defaultImpls.kt") @@ -26753,7 +26754,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInSupertypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/supertypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/supertypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("builtInClassSupertypes.kt") @@ -26791,7 +26792,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInTypeOf() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("classes.kt") @@ -26828,7 +26829,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInJs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/js"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/js"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } } @@ -26841,7 +26842,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInNoReflect() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/noReflect"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/noReflect"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("classes.kt") @@ -26868,7 +26869,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInNonReifiedTypeParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/noReflect/nonReifiedTypeParameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/noReflect/nonReifiedTypeParameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("defaultUpperBound.kt") @@ -26932,7 +26933,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInNonReifiedTypeParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/nonReifiedTypeParameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/nonReifiedTypeParameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("defaultUpperBound.kt") @@ -27006,7 +27007,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInTypeParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeParameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeParameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("declarationSiteVariance.kt") @@ -27044,7 +27045,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/types"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/types"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("classifierIsClass.kt") @@ -27116,7 +27117,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInCreateType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/types/createType"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/types/createType"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("equality.kt") @@ -27154,7 +27155,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInSubtyping() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/types/subtyping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/types/subtyping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("platformType.kt") @@ -27189,7 +27190,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInRegressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/regressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/regressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("approximateIntersectionType.kt") @@ -27677,7 +27678,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInReified() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reified"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reified"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("anonymousObject.kt") @@ -27864,7 +27865,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInArraysReification() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reified/arraysReification"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reified/arraysReification"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("instanceOf.kt") @@ -27908,7 +27909,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInSafeCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/safeCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/safeCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("genericNull.kt") @@ -27986,7 +27987,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInSam() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("arrayAsVarargAfterSamArgument.kt") @@ -28103,7 +28104,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam/constructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam/constructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("comparator.kt") @@ -28191,7 +28192,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInEquality() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam/equality"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam/equality"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("functionReferencesBound.kt") @@ -28230,7 +28231,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInSealed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sealed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sealed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("multipleFiles_enabled.kt") @@ -28273,7 +28274,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInSecondaryConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/secondaryConstructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/secondaryConstructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("basicNoPrimaryManySinks.kt") @@ -28446,7 +28447,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInSignatureAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/signatureAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/signatureAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("defaultAndNamedCombination.kt") @@ -28524,7 +28525,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInSmap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/smap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/smap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("chainCalls.kt") @@ -28552,7 +28553,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInSmartCasts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/smartCasts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/smartCasts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("falseSmartCast.kt") @@ -28645,7 +28646,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInSpecialBuiltins() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/specialBuiltins"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/specialBuiltins"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("bridgeNotEmptyMap.kt") @@ -28798,7 +28799,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInStatics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/statics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/statics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("anonymousInitializerIObject.kt") @@ -28891,7 +28892,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInStoreStackBeforeInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/storeStackBeforeInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/storeStackBeforeInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("differentTypes.kt") @@ -28929,7 +28930,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInStrings() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/strings"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/strings"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("constInStringTemplate.kt") @@ -29062,7 +29063,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInSuper() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/super"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/super"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("basicmethodSuperClass.kt") @@ -29224,7 +29225,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInSuperConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/super/superConstructor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/super/superConstructor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("kt13846.kt") @@ -29273,7 +29274,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInSynchronized() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/synchronized"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/synchronized"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("changeMonitor.kt") @@ -29371,7 +29372,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInSyntheticAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/syntheticAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/syntheticAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("inline.kt") @@ -29454,7 +29455,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInThrows() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/throws"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/throws"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("delegationAndThrows.kt") @@ -29477,7 +29478,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInToArray() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/toArray"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/toArray"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("incorrectToArrayDetection.kt") @@ -29535,7 +29536,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInTopLevelPrivate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/topLevelPrivate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/topLevelPrivate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("noPrivateNoAccessorsInMultiFileFacade.kt") @@ -29578,7 +29579,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInTrailingComma() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/trailingComma"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/trailingComma"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("noDisambiguation.kt") @@ -29606,7 +29607,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInTraits() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/traits"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/traits"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("defaultImplCall.kt") @@ -29799,7 +29800,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInTypeInfo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typeInfo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typeInfo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("asInLoop.kt") @@ -29847,7 +29848,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInTypeMapping() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typeMapping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typeMapping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("enhancedPrimitiveInReturnType.kt") @@ -29920,7 +29921,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInTypealias() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typealias"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typealias"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("enumEntryQualifier.kt") @@ -30028,7 +30029,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInUnaryOp() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unaryOp"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unaryOp"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("call.kt") @@ -30071,7 +30072,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInUnit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("closureReturnsNullableUnit.kt") @@ -30139,7 +30140,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInUnsignedTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unsignedTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unsignedTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("boxConstValOfUnsignedType.kt") @@ -30356,7 +30357,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInJvm8Intrinsics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unsignedTypes/jvm8Intrinsics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unsignedTypes/jvm8Intrinsics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("unsignedIntCompare_jvm8.kt") @@ -30410,7 +30411,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInValueClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/valueClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/valueClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("jvmInline.kt") @@ -30428,7 +30429,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInVararg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/vararg"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/vararg"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("assigningArrayToVarargInAnnotation.kt") @@ -30526,7 +30527,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInWhen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("callProperty.kt") @@ -30743,7 +30744,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInEnumOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/enumOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/enumOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("bigEnum.kt") @@ -30846,7 +30847,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInStringOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/stringOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/stringOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("duplicatingItems.kt") @@ -30904,7 +30905,7 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes } public void testAllFilesPresentInWhenSubjectVariable() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/whenSubjectVariable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/whenSubjectVariable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("captureSubjectVariable.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ScriptCodegenTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ScriptCodegenTestGenerated.java index 1c8629d76ef..bec7ecb14f7 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ScriptCodegenTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ScriptCodegenTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.codegen; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -30,7 +31,7 @@ public class ScriptCodegenTestGenerated extends AbstractScriptCodegenTest { } public void testAllFilesPresentInScript() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/script"), Pattern.compile("^(.+)\\.kts$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/script"), Pattern.compile("^(.+)\\.kts$"), null, true); } @TestMetadata("classLiteralInsideFunction.kts") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/TopLevelMembersInvocationTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/TopLevelMembersInvocationTestGenerated.java index 589da8ba4a1..5025adb2c56 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/TopLevelMembersInvocationTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/TopLevelMembersInvocationTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.codegen; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class TopLevelMembersInvocationTestGenerated extends AbstractTopLevelMemb } public void testAllFilesPresentInTopLevelMemberInvocation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/topLevelMemberInvocation"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/topLevelMemberInvocation"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("extensionFunction") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/debugInformation/IrLocalVariableTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/debugInformation/IrLocalVariableTestGenerated.java index 9cff4f76673..6021fe30a2d 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/debugInformation/IrLocalVariableTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/debugInformation/IrLocalVariableTestGenerated.java @@ -7,6 +7,7 @@ package org.jetbrains.kotlin.codegen.debugInformation; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -28,7 +29,7 @@ public class IrLocalVariableTestGenerated extends AbstractIrLocalVariableTest { @Test public void testAllFilesPresentInLocalVariables() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/debug/localVariables"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/debug/localVariables"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @Test @@ -89,7 +90,7 @@ public class IrLocalVariableTestGenerated extends AbstractIrLocalVariableTest { @Test public void testAllFilesPresentInReceiverMangling() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/debug/localVariables/receiverMangling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/debug/localVariables/receiverMangling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @Test @@ -151,7 +152,7 @@ public class IrLocalVariableTestGenerated extends AbstractIrLocalVariableTest { @Test public void testAllFilesPresentInSuspend() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/debug/localVariables/suspend"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/debug/localVariables/suspend"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @Test diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/debugInformation/IrSteppingTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/debugInformation/IrSteppingTestGenerated.java index 86f69ce6205..b089af0a384 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/debugInformation/IrSteppingTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/debugInformation/IrSteppingTestGenerated.java @@ -7,6 +7,7 @@ package org.jetbrains.kotlin.codegen.debugInformation; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -28,7 +29,7 @@ public class IrSteppingTestGenerated extends AbstractIrSteppingTest { @Test public void testAllFilesPresentInStepping() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/debug/stepping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/debug/stepping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @Test diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/debugInformation/LocalVariableTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/debugInformation/LocalVariableTestGenerated.java index 588933c69fd..b89c0c9a6d1 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/debugInformation/LocalVariableTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/debugInformation/LocalVariableTestGenerated.java @@ -7,6 +7,7 @@ package org.jetbrains.kotlin.codegen.debugInformation; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -28,7 +29,7 @@ public class LocalVariableTestGenerated extends AbstractLocalVariableTest { @Test public void testAllFilesPresentInLocalVariables() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/debug/localVariables"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/debug/localVariables"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @Test @@ -89,7 +90,7 @@ public class LocalVariableTestGenerated extends AbstractLocalVariableTest { @Test public void testAllFilesPresentInReceiverMangling() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/debug/localVariables/receiverMangling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/debug/localVariables/receiverMangling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @Test @@ -151,7 +152,7 @@ public class LocalVariableTestGenerated extends AbstractLocalVariableTest { @Test public void testAllFilesPresentInSuspend() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/debug/localVariables/suspend"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/debug/localVariables/suspend"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @Test diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/debugInformation/SteppingTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/debugInformation/SteppingTestGenerated.java index 6fde0447a82..c0a7f115a9d 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/debugInformation/SteppingTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/debugInformation/SteppingTestGenerated.java @@ -7,6 +7,7 @@ package org.jetbrains.kotlin.codegen.debugInformation; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -28,7 +29,7 @@ public class SteppingTestGenerated extends AbstractSteppingTest { @Test public void testAllFilesPresentInStepping() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/debug/stepping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/debug/stepping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @Test diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/defaultConstructor/DefaultArgumentsReflectionTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/defaultConstructor/DefaultArgumentsReflectionTestGenerated.java index 8511a6568f7..887e75fab5c 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/defaultConstructor/DefaultArgumentsReflectionTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/defaultConstructor/DefaultArgumentsReflectionTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.codegen.defaultConstructor; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class DefaultArgumentsReflectionTestGenerated extends AbstractDefaultArgu } public void testAllFilesPresentInReflection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/defaultArguments/reflection"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/defaultArguments/reflection"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("classInClassObject.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/flags/WriteFlagsTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/flags/WriteFlagsTestGenerated.java index 45c5350c65b..c682ce69a4e 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/flags/WriteFlagsTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/flags/WriteFlagsTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.codegen.flags; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest { } public void testAllFilesPresentInWriteFlags() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("protectedAccessToBaseMethod.kt") @@ -48,7 +49,7 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest { } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/writeFlags/callableReference/flags") @@ -60,7 +61,7 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest { } public void testAllFilesPresentInFlags() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/callableReference/flags"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/callableReference/flags"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("functionReference.kt") @@ -94,7 +95,7 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest { } public void testAllFilesPresentInClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/class"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/class"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/writeFlags/class/accessFlags") @@ -106,7 +107,7 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest { } public void testAllFilesPresentInAccessFlags() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/class/accessFlags"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/class/accessFlags"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("defaultImpls.kt") @@ -169,7 +170,7 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest { } public void testAllFilesPresentInDeprecatedFlag() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/class/deprecatedFlag"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/class/deprecatedFlag"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("class.kt") @@ -207,7 +208,7 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest { } public void testAllFilesPresentInVisibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/class/visibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/class/visibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/writeFlags/class/visibility/internal") @@ -219,7 +220,7 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest { } public void testAllFilesPresentInInternal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/class/visibility/internal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/class/visibility/internal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("class.kt") @@ -272,7 +273,7 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest { } public void testAllFilesPresentInPackageprivate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/class/visibility/packageprivate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/class/visibility/packageprivate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("enumEntry.kt") @@ -290,7 +291,7 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest { } public void testAllFilesPresentInPrivate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/class/visibility/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/class/visibility/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("class.kt") @@ -343,7 +344,7 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest { } public void testAllFilesPresentInPublic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/class/visibility/public"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/class/visibility/public"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("class.kt") @@ -398,7 +399,7 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest { } public void testAllFilesPresentInDelegatedProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/delegatedProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/delegatedProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/writeFlags/delegatedProperty/visibility") @@ -410,7 +411,7 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest { } public void testAllFilesPresentInVisibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/delegatedProperty/visibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/delegatedProperty/visibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("privateSet.kt") @@ -429,7 +430,7 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest { } public void testAllFilesPresentInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/function"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/function"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/writeFlags/function/classObjectPrivate") @@ -441,7 +442,7 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest { } public void testAllFilesPresentInClassObjectPrivate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/function/classObjectPrivate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/function/classObjectPrivate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("privateFun.kt") @@ -469,7 +470,7 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest { } public void testAllFilesPresentInConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/function/constructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/function/constructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("classObject.kt") @@ -517,7 +518,7 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest { } public void testAllFilesPresentInDeprecatedFlag() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/function/deprecatedFlag"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/function/deprecatedFlag"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("deprecatedSinceKotlin.kt") @@ -595,7 +596,7 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest { } public void testAllFilesPresentInWithDefaultArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/function/withDefaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/function/withDefaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("funInClass.kt") @@ -634,7 +635,7 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest { } public void testAllFilesPresentInHidden() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/hidden"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/hidden"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("function.kt") @@ -662,7 +663,7 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest { } public void testAllFilesPresentInInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/inline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/inline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("inlineOnly.kt") @@ -695,7 +696,7 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest { } public void testAllFilesPresentInInnerClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/innerClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/innerClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/writeFlags/innerClass/visibility") @@ -707,7 +708,7 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest { } public void testAllFilesPresentInVisibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/innerClass/visibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/innerClass/visibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("internal.kt") @@ -751,7 +752,7 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest { } public void testAllFilesPresentInJvm8() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/jvm8"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/jvm8"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("interfaceMethod.kt") @@ -773,7 +774,7 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest { } public void testAllFilesPresentInDefaults() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/jvm8/defaults"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/jvm8/defaults"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("defaultMethod.kt") @@ -810,7 +811,7 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest { } public void testAllFilesPresentInCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/jvm8/defaults/compatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/jvm8/defaults/compatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("defaultImplementations.kt") @@ -840,7 +841,7 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest { } public void testAllFilesPresentInJvmOverloads() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/jvmOverloads"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/jvmOverloads"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("openFunction.kt") @@ -863,7 +864,7 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest { } public void testAllFilesPresentInLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/lambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/lambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("lambdaInInlineFunction.kt") @@ -886,7 +887,7 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest { } public void testAllFilesPresentInLateinit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/lateinit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/lateinit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("lateinitGetter.kt") @@ -914,7 +915,7 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest { } public void testAllFilesPresentInProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("enumFields.kt") @@ -931,7 +932,7 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest { } public void testAllFilesPresentInClassObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/property/classObject"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/property/classObject"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/writeFlags/property/classObject/class") @@ -943,7 +944,7 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest { } public void testAllFilesPresentInClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/property/classObject/class"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/property/classObject/class"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("delegatedProtectedVar.kt") @@ -1041,7 +1042,7 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest { } public void testAllFilesPresentInRename() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/property/classObject/rename"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/property/classObject/rename"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("constructorAndClassObject.kt") @@ -1074,7 +1075,7 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest { } public void testAllFilesPresentInTrait() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/property/classObject/trait"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/property/classObject/trait"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("delegatedProtectedVar.kt") @@ -1193,7 +1194,7 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest { } public void testAllFilesPresentInDeprecatedFlag() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/property/deprecatedFlag"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/property/deprecatedFlag"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("propertyInClass.kt") @@ -1216,7 +1217,7 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest { } public void testAllFilesPresentInSyntheticAnnotationsMethod() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/property/syntheticAnnotationsMethod"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/property/syntheticAnnotationsMethod"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("doNotUseGetterName.kt") @@ -1254,7 +1255,7 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest { } public void testAllFilesPresentInVisibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/property/visibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/property/visibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("internal.kt") @@ -1283,7 +1284,7 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest { } public void testAllFilesPresentInTypealias() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/typealias"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/typealias"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/writeFlags/typealias/syntheticAnnotationsMethod") @@ -1295,7 +1296,7 @@ public class WriteFlagsTestGenerated extends AbstractWriteFlagsTest { } public void testAllFilesPresentInSyntheticAnnotationsMethod() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/typealias/syntheticAnnotationsMethod"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/typealias/syntheticAnnotationsMethod"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("privateTypealias.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/ComposeLikeIrBlackBoxCodegenTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/ComposeLikeIrBlackBoxCodegenTestGenerated.java index 3a3a08e1fe1..36df2565845 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/ComposeLikeIrBlackBoxCodegenTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/ComposeLikeIrBlackBoxCodegenTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.codegen.ir; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class ComposeLikeIrBlackBoxCodegenTestGenerated extends AbstractComposeLi } public void testAllFilesPresentInComposeLike() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/composeLike"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/composeLike"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("default.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/ComposeLikeIrBytecodeTextTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/ComposeLikeIrBytecodeTextTestGenerated.java index 0db1026e44e..3c2c159df45 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/ComposeLikeIrBytecodeTextTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/ComposeLikeIrBytecodeTextTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.codegen.ir; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class ComposeLikeIrBytecodeTextTestGenerated extends AbstractComposeLikeI } public void testAllFilesPresentInComposeLikeBytecodeText() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/composeLikeBytecodeText"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/composeLikeBytecodeText"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("default.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrAsmLikeInstructionListingTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrAsmLikeInstructionListingTestGenerated.java index c8cadd0b059..d89d851beb2 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrAsmLikeInstructionListingTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrAsmLikeInstructionListingTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.codegen.ir; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class IrAsmLikeInstructionListingTestGenerated extends AbstractIrAsmLikeI } public void testAllFilesPresentInAsmLike() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/asmLike"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/asmLike"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/codegen/asmLike/receiverMangling") @@ -38,7 +39,7 @@ public class IrAsmLikeInstructionListingTestGenerated extends AbstractIrAsmLikeI } public void testAllFilesPresentInReceiverMangling() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/asmLike/receiverMangling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/asmLike/receiverMangling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("deepInline.kt") @@ -111,7 +112,7 @@ public class IrAsmLikeInstructionListingTestGenerated extends AbstractIrAsmLikeI } public void testAllFilesPresentInTypeAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/asmLike/typeAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/asmLike/typeAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("complex.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrBlackBoxAgainstJavaCodegenTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrBlackBoxAgainstJavaCodegenTestGenerated.java index e77d6e67d6a..e748f3b8cc6 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrBlackBoxAgainstJavaCodegenTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrBlackBoxAgainstJavaCodegenTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.codegen.ir; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class IrBlackBoxAgainstJavaCodegenTestGenerated extends AbstractIrBlackBo } public void testAllFilesPresentInBoxAgainstJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true, "oldLanguageVersions"); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true, "oldLanguageVersions"); } @TestMetadata("compiler/testData/codegen/boxAgainstJava/annotations") @@ -38,7 +39,7 @@ public class IrBlackBoxAgainstJavaCodegenTestGenerated extends AbstractIrBlackBo } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/annotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/annotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("divisionByZeroInJava.kt") @@ -95,7 +96,7 @@ public class IrBlackBoxAgainstJavaCodegenTestGenerated extends AbstractIrBlackBo } public void testAllFilesPresentInKClassMapping() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/annotations/kClassMapping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/annotations/kClassMapping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("arrayClassParameter.kt") @@ -138,7 +139,7 @@ public class IrBlackBoxAgainstJavaCodegenTestGenerated extends AbstractIrBlackBo } public void testAllFilesPresentInTypeAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/annotations/typeAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/annotations/typeAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("implicitReturn.kt") @@ -157,7 +158,7 @@ public class IrBlackBoxAgainstJavaCodegenTestGenerated extends AbstractIrBlackBo } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("constructor.kt") @@ -195,7 +196,7 @@ public class IrBlackBoxAgainstJavaCodegenTestGenerated extends AbstractIrBlackBo } public void testAllFilesPresentInConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/constructor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/constructor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("genericConstructor.kt") @@ -218,7 +219,7 @@ public class IrBlackBoxAgainstJavaCodegenTestGenerated extends AbstractIrBlackBo } public void testAllFilesPresentInDelegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/delegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/delegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("delegationAndInheritanceFromJava.kt") @@ -236,7 +237,7 @@ public class IrBlackBoxAgainstJavaCodegenTestGenerated extends AbstractIrBlackBo } public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("nameConflict.kt") @@ -284,7 +285,7 @@ public class IrBlackBoxAgainstJavaCodegenTestGenerated extends AbstractIrBlackBo } public void testAllFilesPresentInFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("constructor.kt") @@ -322,7 +323,7 @@ public class IrBlackBoxAgainstJavaCodegenTestGenerated extends AbstractIrBlackBo } public void testAllFilesPresentInIeee754() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/ieee754"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/ieee754"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("anyToReal.kt") @@ -375,7 +376,7 @@ public class IrBlackBoxAgainstJavaCodegenTestGenerated extends AbstractIrBlackBo } public void testAllFilesPresentInInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/inline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/inline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt19910.kt") @@ -393,7 +394,7 @@ public class IrBlackBoxAgainstJavaCodegenTestGenerated extends AbstractIrBlackBo } public void testAllFilesPresentInInnerClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/innerClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/innerClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt3532.kt") @@ -421,7 +422,7 @@ public class IrBlackBoxAgainstJavaCodegenTestGenerated extends AbstractIrBlackBo } public void testAllFilesPresentInInterfaces() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/interfaces"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/interfaces"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inheritJavaInterface.kt") @@ -439,7 +440,7 @@ public class IrBlackBoxAgainstJavaCodegenTestGenerated extends AbstractIrBlackBo } public void testAllFilesPresentInMultiplatform() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("annotationsViaActualTypeAliasFromBinary.kt") @@ -457,7 +458,7 @@ public class IrBlackBoxAgainstJavaCodegenTestGenerated extends AbstractIrBlackBo } public void testAllFilesPresentInNotNullAssertions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/notNullAssertions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/notNullAssertions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("callAssertions.kt") @@ -495,7 +496,7 @@ public class IrBlackBoxAgainstJavaCodegenTestGenerated extends AbstractIrBlackBo } public void testAllFilesPresentInPlatformTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/platformTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/platformTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("genericUnit.kt") @@ -528,7 +529,7 @@ public class IrBlackBoxAgainstJavaCodegenTestGenerated extends AbstractIrBlackBo } public void testAllFilesPresentInProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("fieldAccessFromExtensionInTraitImpl.kt") @@ -556,7 +557,7 @@ public class IrBlackBoxAgainstJavaCodegenTestGenerated extends AbstractIrBlackBo } public void testAllFilesPresentInRecursiveRawTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/recursiveRawTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/recursiveRawTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt16528.kt") @@ -579,7 +580,7 @@ public class IrBlackBoxAgainstJavaCodegenTestGenerated extends AbstractIrBlackBo } public void testAllFilesPresentInReflection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/reflection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/reflection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/codegen/boxAgainstJava/reflection/classLiterals") @@ -591,7 +592,7 @@ public class IrBlackBoxAgainstJavaCodegenTestGenerated extends AbstractIrBlackBo } public void testAllFilesPresentInClassLiterals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/reflection/classLiterals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/reflection/classLiterals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("javaClassLiteral.kt") @@ -609,7 +610,7 @@ public class IrBlackBoxAgainstJavaCodegenTestGenerated extends AbstractIrBlackBo } public void testAllFilesPresentInMapping() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/reflection/mapping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/reflection/mapping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("jClass2kClass.kt") @@ -642,7 +643,7 @@ public class IrBlackBoxAgainstJavaCodegenTestGenerated extends AbstractIrBlackBo } public void testAllFilesPresentInProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/reflection/properties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/reflection/properties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("equalsHashCodeToString.kt") @@ -661,7 +662,7 @@ public class IrBlackBoxAgainstJavaCodegenTestGenerated extends AbstractIrBlackBo } public void testAllFilesPresentInSam() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("differentFqNames.kt") @@ -713,7 +714,7 @@ public class IrBlackBoxAgainstJavaCodegenTestGenerated extends AbstractIrBlackBo } public void testAllFilesPresentInAdapters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/sam/adapters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/sam/adapters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("bridgesForOverridden.kt") @@ -870,7 +871,7 @@ public class IrBlackBoxAgainstJavaCodegenTestGenerated extends AbstractIrBlackBo } public void testAllFilesPresentInOperators() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/sam/adapters/operators"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/sam/adapters/operators"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("augmentedAssignmentPure.kt") @@ -940,7 +941,7 @@ public class IrBlackBoxAgainstJavaCodegenTestGenerated extends AbstractIrBlackBo } public void testAllFilesPresentInSpecialBuiltins() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/specialBuiltins"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/specialBuiltins"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("charBuffer.kt") @@ -958,7 +959,7 @@ public class IrBlackBoxAgainstJavaCodegenTestGenerated extends AbstractIrBlackBo } public void testAllFilesPresentInStaticFun() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/staticFun"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/staticFun"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("classWithNestedEnum.kt") @@ -976,7 +977,7 @@ public class IrBlackBoxAgainstJavaCodegenTestGenerated extends AbstractIrBlackBo } public void testAllFilesPresentInSyntheticExtensions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/syntheticExtensions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/syntheticExtensions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("fromTwoBases.kt") @@ -1039,7 +1040,7 @@ public class IrBlackBoxAgainstJavaCodegenTestGenerated extends AbstractIrBlackBo } public void testAllFilesPresentInThrows() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/throws"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/throws"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("delegationAndThrows.kt") @@ -1057,7 +1058,7 @@ public class IrBlackBoxAgainstJavaCodegenTestGenerated extends AbstractIrBlackBo } public void testAllFilesPresentInTypealias() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/typealias"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/typealias"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("javaStaticMembersViaTypeAlias.kt") @@ -1075,7 +1076,7 @@ public class IrBlackBoxAgainstJavaCodegenTestGenerated extends AbstractIrBlackBo } public void testAllFilesPresentInVarargs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/varargs"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/varargs"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("varargsOverride.kt") @@ -1103,7 +1104,7 @@ public class IrBlackBoxAgainstJavaCodegenTestGenerated extends AbstractIrBlackBo } public void testAllFilesPresentInVisibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/visibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/visibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/codegen/boxAgainstJava/visibility/package") @@ -1115,7 +1116,7 @@ public class IrBlackBoxAgainstJavaCodegenTestGenerated extends AbstractIrBlackBo } public void testAllFilesPresentInPackage() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/visibility/package"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/visibility/package"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt2781.kt") @@ -1148,7 +1149,7 @@ public class IrBlackBoxAgainstJavaCodegenTestGenerated extends AbstractIrBlackBo } public void testAllFilesPresentInProtectedAndPackage() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/visibility/protectedAndPackage"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/visibility/protectedAndPackage"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("overrideProtectedFunInPackage.kt") @@ -1201,7 +1202,7 @@ public class IrBlackBoxAgainstJavaCodegenTestGenerated extends AbstractIrBlackBo } public void testAllFilesPresentInProtectedStatic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/visibility/protectedStatic"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/visibility/protectedStatic"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("funCallInConstructor.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java index ec2168073e4..bf252f8b44a 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.codegen.ir; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInBox() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true, "oldLanguageVersions"); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true, "oldLanguageVersions"); } @TestMetadata("compiler/testData/codegen/box/annotations") @@ -38,7 +39,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("annotatedAnnotationParameter.kt") @@ -235,7 +236,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInAnnotatedLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations/annotatedLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations/annotatedLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("funExpression.kt") @@ -273,7 +274,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInTypeAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations/typeAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations/typeAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("checkingNotincorporatedInputTypes.kt") @@ -317,7 +318,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInArgumentOrder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/argumentOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/argumentOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("argumentOrderInObjectSuperCall.kt") @@ -410,7 +411,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInArrays() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("arrayConstructorWithNonInlineLambda.kt") @@ -747,7 +748,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInArraysOfInlineClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/arraysOfInlineClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/arraysOfInlineClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("arrayOfInlineClassOfArrayOfInlineClass.kt") @@ -765,7 +766,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInForInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/forInReversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/forInReversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("reversedArrayOriginalUpdatedInLoopBody.kt") @@ -798,7 +799,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInMultiDecl() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt15560.kt") @@ -850,7 +851,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInInt() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -883,7 +884,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInLong() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -918,7 +919,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInAssert() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/assert"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/assert"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("alwaysDisable.kt") @@ -940,7 +941,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInJvm() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/assert/jvm"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/assert/jvm"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("assertionsEnabledBeforeClassInitializers.kt") @@ -1064,7 +1065,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInBinaryOp() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/binaryOp"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/binaryOp"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("bitwiseOp.kt") @@ -1207,7 +1208,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInBoxingOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/boxingOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/boxingOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("boxedIntegersCmp.kt") @@ -1380,7 +1381,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInBridges() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/bridges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/bridges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("bridgeInInterface.kt") @@ -1677,7 +1678,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInSubstitutionInSuperClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/bridges/substitutionInSuperClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/bridges/substitutionInSuperClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("boundedTypeArguments.kt") @@ -1741,7 +1742,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInBuilderInference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("callableReferenceAndCoercionToUnit.kt") @@ -1789,7 +1790,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInBuiltinStubMethods() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("Collection.kt") @@ -1926,7 +1927,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInExtendJavaCollections() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/extendJavaCollections"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/extendJavaCollections"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("arrayList.kt") @@ -1959,7 +1960,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInMapGetOrDefault() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/mapGetOrDefault"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/mapGetOrDefault"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("noTypeSafeBridge.kt") @@ -1987,7 +1988,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInMapRemove() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/mapRemove"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/mapRemove"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("noDefaultImpls.kt") @@ -2021,7 +2022,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("builtinFunctionReferenceOwner.kt") @@ -2078,7 +2079,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInAdaptedReferences() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/adaptedReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/adaptedReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("bothWithCoercionToUnit.kt") @@ -2240,7 +2241,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInSuspendConversion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("bound.kt") @@ -2319,7 +2320,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInBound() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("array.kt") @@ -2466,7 +2467,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInEquals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/bound/equals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/bound/equals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("nullableReceiverInEquals.kt") @@ -2500,7 +2501,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInEquality() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/equality"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/equality"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("capturedDefaults.kt") @@ -2578,7 +2579,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/function"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/function"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("argumentTypes.kt") @@ -2860,7 +2861,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInLocal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/function/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/function/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("captureOuter.kt") @@ -2979,7 +2980,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("delegated.kt") @@ -3142,7 +3143,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInSerializability() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/serializability"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/serializability"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("boundWithNotSerializableReceiver.kt") @@ -3181,7 +3182,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInCasts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("as.kt") @@ -3318,7 +3319,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("asFunKBig.kt") @@ -3396,7 +3397,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInJavaInterop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("castWithWrongType.kt") @@ -3479,7 +3480,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInLiteralExpressionAsGenericArgument() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/literalExpressionAsGenericArgument"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/literalExpressionAsGenericArgument"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("binaryExpressionCast.kt") @@ -3527,7 +3528,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInMutableCollections() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/mutableCollections"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/mutableCollections"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("asWithMutable.kt") @@ -3581,7 +3582,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInCheckcastOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/checkcastOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/checkcastOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt19128.kt") @@ -3604,7 +3605,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInClassLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("bareArray.kt") @@ -3626,7 +3627,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInBound() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classLiteral/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classLiteral/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("javaIntrinsicWithSideEffect.kt") @@ -3664,7 +3665,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classLiteral/java"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classLiteral/java"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("java.kt") @@ -3718,7 +3719,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("boxPrimitiveTypeInClinitOfClassObject.kt") @@ -4330,7 +4331,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInInner() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classes/inner"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classes/inner"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("extensionWithOuter.kt") @@ -4379,7 +4380,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInClosures() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("anonymousObjectAsLastExpressionInLambda.kt") @@ -4621,7 +4622,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInCaptureInSuperConstructorCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/captureInSuperConstructorCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/captureInSuperConstructorCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("constructorParameterAndLocalCapturedInLambdaInLocalClass.kt") @@ -4794,7 +4795,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInCaptureOuterProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/captureOuterProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/captureOuterProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("captureFunctionInProperty.kt") @@ -4847,7 +4848,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInCapturedVarsOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/capturedVarsOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/capturedVarsOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("capturedInCrossinline.kt") @@ -4915,7 +4916,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInClosureInsideClosure() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/closureInsideClosure"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/closureInsideClosure"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("localFunInsideLocalFun.kt") @@ -4959,7 +4960,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInCollectionLiterals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/collectionLiterals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/collectionLiterals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("collectionLiteralsInArgumentPosition.kt") @@ -4997,7 +4998,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInCollections() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/collections"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/collections"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("charSequence.kt") @@ -5170,7 +5171,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInCompanion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/companion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/companion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("delegatedPropertyOnCompanion.kt") @@ -5193,7 +5194,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/compatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/compatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("privateCompanionObject.kt") @@ -5211,7 +5212,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInConstants() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/constants"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/constants"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("comparisonFalse.kt") @@ -5274,7 +5275,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInConstructorCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/constructorCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/constructorCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("breakInConstructorArguments.kt") @@ -5372,7 +5373,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInContracts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/contracts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/contracts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("constructorArgument.kt") @@ -5445,7 +5446,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInControlStructures() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("bottles.kt") @@ -5852,7 +5853,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInBreakContinueInExpressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("breakFromOuter.kt") @@ -5955,7 +5956,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInForInArray() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInArray"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInArray"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forInArraySpecializedToUntil.kt") @@ -6018,7 +6019,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInForInArrayWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forInArrayOfObjectArrayWithIndex.kt") @@ -6131,7 +6132,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInForInCharSequenceWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInCharSequenceWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInCharSequenceWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forInCharSeqWithIndexStops.kt") @@ -6214,7 +6215,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInForInIterableWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInIterableWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInIterableWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forInEmptyListWithIndex.kt") @@ -6282,7 +6283,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInForInSequenceWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInSequenceWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInSequenceWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forInEmptySequenceWithIndex.kt") @@ -6350,7 +6351,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInReturnsNothing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/returnsNothing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/returnsNothing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("ifElse.kt") @@ -6388,7 +6389,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInTryCatchInExpressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("catch.kt") @@ -6562,7 +6563,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInCoroutines() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("async.kt") @@ -7144,7 +7145,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInBridges() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/bridges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/bridges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("interfaceSpecialization.kt") @@ -7172,7 +7173,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInControlFlow() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/controlFlow"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/controlFlow"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("breakFinally.kt") @@ -7295,7 +7296,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInDebug() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/debug"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/debug"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("debuggerMetadata.kt") @@ -7348,7 +7349,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInFeatureIntersection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("breakWithNonEmptyStack.kt") @@ -7445,7 +7446,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("bigArity.kt") @@ -7472,7 +7473,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInBound() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("emptyLHS.kt") @@ -7490,7 +7491,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/function"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/function"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("genericCallableReferenceArguments.kt") @@ -7517,7 +7518,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInLocal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/function/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/function/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("equalsHashCode.kt") @@ -7537,7 +7538,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInTailrec() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/tailrec"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/tailrec"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("controlFlowIf.kt") @@ -7616,7 +7617,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("nonLocalReturn.kt") @@ -7633,7 +7634,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInDirect() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses/direct"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses/direct"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("boxReturnValueOfSuspendFunctionReference.kt") @@ -7861,7 +7862,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInResume() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses/resume"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses/resume"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("boxReturnValueOfSuspendFunctionReference.kt") @@ -8089,7 +8090,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInResumeWithException() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("boxReturnValueOfSuspendFunctionReference.kt") @@ -8303,7 +8304,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInIntLikeVarSpilling() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/intLikeVarSpilling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/intLikeVarSpilling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("complicatedMerge.kt") @@ -8371,7 +8372,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInIntrinsicSemantics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/intrinsicSemantics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/intrinsicSemantics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("coroutineContext.kt") @@ -8424,7 +8425,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInJavaInterop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("objectWithSeveralSuspends.kt") @@ -8462,7 +8463,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInLocalFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/localFunctions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/localFunctions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/codegen/box/coroutines/localFunctions/anonymous") @@ -8474,7 +8475,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInAnonymous() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/localFunctions/anonymous"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/localFunctions/anonymous"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("simple.kt") @@ -8492,7 +8493,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInNamed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/localFunctions/named"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/localFunctions/named"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("capturedParameters.kt") @@ -8561,7 +8562,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInMultiModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inlineCrossModule.kt") @@ -8619,7 +8620,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInRedundantLocalsElimination() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/redundantLocalsElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/redundantLocalsElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("ktor_receivedMessage.kt") @@ -8637,7 +8638,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInReflect() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/reflect"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/reflect"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("bigArity.kt") @@ -8665,7 +8666,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInStackUnwinding() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/stackUnwinding"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/stackUnwinding"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("exception.kt") @@ -8708,7 +8709,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInSuspendConversion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/suspendConversion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/suspendConversion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("intersectionTypeToSubtypeConversion.kt") @@ -8741,7 +8742,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInSuspendFunctionAsCoroutine() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("dispatchResume.kt") @@ -8844,7 +8845,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInSuspendFunctionTypeCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/suspendFunctionTypeCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/suspendFunctionTypeCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("localVal.kt") @@ -8882,7 +8883,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInTailCallOptimizations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/tailCallOptimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/tailCallOptimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("also.kt") @@ -8969,7 +8970,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInUnit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/tailCallOptimizations/unit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/tailCallOptimizations/unit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("functionReference.kt") @@ -9038,7 +9039,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInTailOperations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/tailOperations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/tailOperations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("suspendWithIf.kt") @@ -9071,7 +9072,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInUnitTypeReturn() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/unitTypeReturn"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/unitTypeReturn"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("coroutineNonLocalReturn.kt") @@ -9119,7 +9120,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInVarSpilling() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/varSpilling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/varSpilling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("fakeInlinerVariables.kt") @@ -9163,7 +9164,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInDataClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("arrayParams.kt") @@ -9255,7 +9256,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInCopy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/copy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/copy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("constructorWithDefaultParam.kt") @@ -9308,7 +9309,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInEquals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/equals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/equals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("alreadyDeclared.kt") @@ -9356,7 +9357,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInHashCode() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/hashCode"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/hashCode"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("alreadyDeclared.kt") @@ -9434,7 +9435,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInToString() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/toString"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/toString"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("alreadyDeclared.kt") @@ -9483,7 +9484,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInDeadCodeElimination() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/deadCodeElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/deadCodeElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("emptyVariableRange.kt") @@ -9516,7 +9517,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInDefaultArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("callDefaultFromInitializer.kt") @@ -9613,7 +9614,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/constructor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/constructor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("annotation.kt") @@ -9711,7 +9712,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInConvention() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/convention"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/convention"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("incWithDefaultInGetter.kt") @@ -9764,7 +9765,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/function"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/function"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("complexInheritance.kt") @@ -9912,7 +9913,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInPrivate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("memberExtensionFunction.kt") @@ -9945,7 +9946,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/signature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/signature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt2789.kt") @@ -9979,7 +9980,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInDelegatedProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("beforeDeclarationContainerOptimization.kt") @@ -10226,7 +10227,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInLocal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("capturedLocalVal.kt") @@ -10324,7 +10325,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInOptimizedDelegatedProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/optimizedDelegatedProperties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/optimizedDelegatedProperties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("definedInSources.kt") @@ -10387,7 +10388,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInProvideDelegate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/provideDelegate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/provideDelegate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("delegatedPropertyWithIdProvideDelegate.kt") @@ -10511,7 +10512,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInDelegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("byMiddleInterface.kt") @@ -10599,7 +10600,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInDestructuringDeclInLambdaParam() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/destructuringDeclInLambdaParam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/destructuringDeclInLambdaParam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("extensionComponents.kt") @@ -10652,7 +10653,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInDiagnostics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/codegen/box/diagnostics/functions") @@ -10664,7 +10665,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/codegen/box/diagnostics/functions/inference") @@ -10676,7 +10677,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInInference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/inference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/inference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt6176.kt") @@ -10694,7 +10695,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInInvoke() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/invoke"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/invoke"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects") @@ -10706,7 +10707,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInOnObjects() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("invokeOnClassObject1.kt") @@ -10770,7 +10771,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInTailRecursion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/tailRecursion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/tailRecursion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("defaultArgs.kt") @@ -10989,7 +10990,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInVararg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/vararg"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/vararg"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt4172.kt") @@ -11008,7 +11009,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInElvis() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/elvis"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/elvis"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("genericElvisWithMoreSpecificLHS.kt") @@ -11066,7 +11067,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("annotatedParameter.kt") @@ -11383,7 +11384,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInDefaultCtor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/enum/defaultCtor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/enum/defaultCtor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("constructorWithDefaultArguments.kt") @@ -11427,7 +11428,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInEvaluate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/evaluate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/evaluate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("char.kt") @@ -11515,7 +11516,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInExclExcl() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/exclExcl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/exclExcl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("genericNull.kt") @@ -11538,7 +11539,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInExtensionFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/extensionFunctions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/extensionFunctions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("executionOrder.kt") @@ -11676,7 +11677,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInExtensionProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/extensionProperties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/extensionProperties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("genericValForPrimitiveType.kt") @@ -11759,7 +11760,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInExternal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/external"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/external"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("jvmStaticExternal.kt") @@ -11787,7 +11788,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInFakeOverride() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fakeOverride"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fakeOverride"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("diamondFunction.kt") @@ -11830,7 +11831,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInFieldRename() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fieldRename"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fieldRename"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("constructorAndClassObject.kt") @@ -11868,7 +11869,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInFinally() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/finally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/finally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("breakAndOuterFinally.kt") @@ -11991,7 +11992,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInFullJdk() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("charBuffer.kt") @@ -12033,7 +12034,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInNative() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk/native"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk/native"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("nativePropertyAccessors.kt") @@ -12061,7 +12062,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInRegressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk/regressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk/regressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt15112.kt") @@ -12085,7 +12086,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInFunInterface() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("basicFunInterface.kt") @@ -12202,7 +12203,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInEquality() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/funInterface/equality"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/funInterface/equality"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("functionReferencesBound.kt") @@ -12241,7 +12242,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("coerceVoidToArray.kt") @@ -12478,7 +12479,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInBigArity() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/bigArity"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/bigArity"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("callFromJava.kt") @@ -12546,7 +12547,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInFunctionExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/functionExpression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/functionExpression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("functionExpression.kt") @@ -12589,7 +12590,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInInvoke() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/invoke"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/invoke"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("castFunctionToExtension.kt") @@ -12677,7 +12678,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInLocalFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/localFunctions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/localFunctions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("boundTypeParameterInSupertype.kt") @@ -12841,7 +12842,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInHashPMap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/hashPMap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/hashPMap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("empty.kt") @@ -12884,7 +12885,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInIeee754() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ieee754"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ieee754"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("anyToReal.kt") @@ -13142,7 +13143,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInIncrement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/increment"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/increment"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("argumentWithSideEffects.kt") @@ -13285,7 +13286,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInInference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("approximateNonTopLevelCapturedTypes.kt") @@ -13453,7 +13454,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("annotatedMemberExtensionProperty.kt") @@ -14300,7 +14301,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInBoxReturnValueInLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("boxAny.kt") @@ -14373,7 +14374,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInBoxReturnValueOnOverride() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("covariantOverrideChainErasedToAny.kt") @@ -14516,7 +14517,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInCallableReferences() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/callableReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/callableReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("boundInlineClassExtensionFun.kt") @@ -14684,7 +14685,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInContextsAndAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("captureInlineClassInstanceInLambda.kt") @@ -14752,7 +14753,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInDefaultParameterValues() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/defaultParameterValues"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/defaultParameterValues"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("defaultConstructorParameterValuesOfInlineClassType.kt") @@ -14825,7 +14826,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInFunctionNameMangling() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/functionNameMangling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/functionNameMangling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("anonymousObjectInFunctionWithMangledName.kt") @@ -14928,7 +14929,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInHiddenConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/hiddenConstructor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/hiddenConstructor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("constructorReferencedFromOtherFile1.kt") @@ -15006,7 +15007,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInInterfaceDelegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/interfaceDelegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/interfaceDelegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("interfaceImplementationByDelegation.kt") @@ -15059,7 +15060,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInInterfaceMethodCalls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("complexGenericMethodWithInlineClassOverride.kt") @@ -15127,7 +15128,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInJavaInterop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inlineClasInSignature.kt") @@ -15155,7 +15156,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInJvm8DefaultInterfaceMethods() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/jvm8DefaultInterfaceMethods"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/jvm8DefaultInterfaceMethods"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("javaDefaultMethod.kt") @@ -15228,7 +15229,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInPropertyDelegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/propertyDelegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/propertyDelegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("captureLocalVarDelegatedToInlineClass.kt") @@ -15301,7 +15302,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInUnboxGenericParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface") @@ -15313,7 +15314,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInFunInterface() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("any.kt") @@ -15361,7 +15362,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("any.kt") @@ -15409,7 +15410,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInObjectLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("any.kt") @@ -15459,7 +15460,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInInnerNested() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/innerNested"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/innerNested"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("createNestedClass.kt") @@ -15611,7 +15612,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInSuperConstructorCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/innerNested/superConstructorCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/innerNested/superConstructorCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("deepInnerHierarchy.kt") @@ -15730,7 +15731,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInInstructions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/instructions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/instructions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/codegen/box/instructions/swap") @@ -15742,7 +15743,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInSwap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/instructions/swap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/instructions/swap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("swapRefToSharedVarInt.kt") @@ -15766,7 +15767,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInIntrinsics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/intrinsics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/intrinsics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("charToInt.kt") @@ -15914,7 +15915,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInIr() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("anonymousClassLeak.kt") @@ -16021,7 +16022,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInClosureConversion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/closureConversion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/closureConversion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("closureConversion1.kt") @@ -16074,7 +16075,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInPrimitiveNumberComparisons() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/primitiveNumberComparisons"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/primitiveNumberComparisons"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("comparableToDouble.kt") @@ -16107,7 +16108,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInSerializationRegressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/serializationRegressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/serializationRegressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("deepGenericDelegatedProperty.kt") @@ -16161,7 +16162,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInJavaInterop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("genericSamProjectedOut.kt") @@ -16213,7 +16214,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInGenerics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/generics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/generics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("allWildcardsOnClass.kt") @@ -16261,7 +16262,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInNotNullAssertions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("destructuringAssignmentWithNullabilityAssertionOnExtensionReceiver_lv12.kt") @@ -16363,7 +16364,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInEnhancedNullability() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions/enhancedNullability"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions/enhancedNullability"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inFunctionWithExpressionBody.kt") @@ -16416,7 +16417,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInNullCheckOnLambdaReturnValue() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions/nullCheckOnLambdaReturnValue"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions/nullCheckOnLambdaReturnValue"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("nnStringVsT.kt") @@ -16480,7 +16481,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInObjectMethods() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/objectMethods"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/objectMethods"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("cloneCallsConstructor.kt") @@ -16524,7 +16525,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInJdk() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jdk"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jdk"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("arrayList.kt") @@ -16577,7 +16578,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInJvm8() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("bridgeInClass.kt") @@ -16714,7 +16715,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInDefaults() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("bridgeInClass.kt") @@ -16871,7 +16872,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInAllCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("bridge.kt") @@ -17013,7 +17014,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInDelegationBy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("simple.kt") @@ -17037,7 +17038,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/compatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/compatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("bridge.kt") @@ -17130,7 +17131,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInDelegationBy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("simple.kt") @@ -17163,7 +17164,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInNoDefaultImpls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("bridge.kt") @@ -17300,7 +17301,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInDelegationBy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("simple.kt") @@ -17323,7 +17324,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInSpecialization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/specialization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/specialization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("basic.kt") @@ -17342,7 +17343,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInNoDelegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDelegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDelegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("noDelegationToDefaultMethodInClass.kt") @@ -17370,7 +17371,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInReflection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/reflection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/reflection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("propertyAnnotations.kt") @@ -17389,7 +17390,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInInterfaceFlag() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/interfaceFlag"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/interfaceFlag"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("superCall.kt") @@ -17412,7 +17413,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInJavaDefaults() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/javaDefaults"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/javaDefaults"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("capturedSuperCall.kt") @@ -17496,7 +17497,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInJvmField() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmField"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmField"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("annotationCompanion.kt") @@ -17634,7 +17635,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInJvmName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("annotationProperties.kt") @@ -17721,7 +17722,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInFileFacades() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmName/fileFacades"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmName/fileFacades"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("differentFiles.kt") @@ -17750,7 +17751,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInJvmOverloads() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmOverloads"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmOverloads"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("companionObject.kt") @@ -17863,7 +17864,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInJvmPackageName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmPackageName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmPackageName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("metadataField.kt") @@ -17901,7 +17902,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInJvmStatic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmStatic"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmStatic"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("annotations.kt") @@ -18079,7 +18080,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInLabels() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/labels"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/labels"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("controlLabelClashesWithFuncitonName.kt") @@ -18132,7 +18133,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInLazyCodegen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/lazyCodegen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/lazyCodegen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("exceptionInFieldInitializer.kt") @@ -18189,7 +18190,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInOptimizations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/lazyCodegen/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/lazyCodegen/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("negateConstantCompare.kt") @@ -18248,7 +18249,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInLocalClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/localClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/localClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("anonymousObjectInExtension.kt") @@ -18431,7 +18432,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInMangling() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/mangling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/mangling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("field.kt") @@ -18489,7 +18490,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInMixedNamedPosition() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/mixedNamedPosition"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/mixedNamedPosition"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("defaults.kt") @@ -18522,7 +18523,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInMultiDecl() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("ComplexInitializer.kt") @@ -18604,7 +18605,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInForIterator() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forIterator"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forIterator"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("MultiDeclFor.kt") @@ -18641,7 +18642,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInLongIterator() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forIterator/longIterator"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forIterator/longIterator"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -18675,7 +18676,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInForRange() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("MultiDeclFor.kt") @@ -18722,7 +18723,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInExplicitRangeTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("MultiDeclFor.kt") @@ -18759,7 +18760,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInInt() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -18792,7 +18793,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInLong() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -18826,7 +18827,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInExplicitRangeToWithDot() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("MultiDeclFor.kt") @@ -18863,7 +18864,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInInt() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -18896,7 +18897,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInLong() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -18930,7 +18931,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInInt() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -18963,7 +18964,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInLong() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -18998,7 +18999,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInMultifileClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("callMultifileClassMemberFromOtherPackage.kt") @@ -19080,7 +19081,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInOptimized() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multifileClasses/optimized"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multifileClasses/optimized"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("callInInlineLambda.kt") @@ -19149,7 +19150,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInMultiplatform() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("expectClassInJvmMultifileFacade.kt") @@ -19186,7 +19187,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInDefaultArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("annotations.kt") @@ -19314,7 +19315,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInMultiModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("expectActualLink.kt") @@ -19343,7 +19344,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInNonLocalReturns() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nonLocalReturns"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nonLocalReturns"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt6895.kt") @@ -19386,7 +19387,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInNothingValue() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nothingValue"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nothingValue"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inNestedCall.kt") @@ -19409,7 +19410,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInNullCheckOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nullCheckOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nullCheckOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("exclExclThrowsKnpe_1_3.kt") @@ -19482,7 +19483,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInObjectIntrinsics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objectIntrinsics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objectIntrinsics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("objects.kt") @@ -19500,7 +19501,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInObjects() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("anonymousObjectPropertyInitialization.kt") @@ -19872,7 +19873,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInCompanionObjectAccess() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt27117.kt") @@ -19969,7 +19970,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInMultipleCompanionsWithAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("anonymousObjectInPropertyInitializer.kt") @@ -20037,7 +20038,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInPrimitiveCompanion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess/primitiveCompanion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess/primitiveCompanion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("byteCompanionObject.kt") @@ -20087,7 +20088,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInOperatorConventions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/operatorConventions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/operatorConventions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("annotatedAssignment.kt") @@ -20199,7 +20200,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInCompareTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/operatorConventions/compareTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/operatorConventions/compareTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("boolean.kt") @@ -20268,7 +20269,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInOptimizations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("hashCode.kt") @@ -20291,7 +20292,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInPackage() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/package"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/package"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("boxPrimitiveTypeInClinit.kt") @@ -20364,7 +20365,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInParametersMetadata() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/parametersMetadata"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/parametersMetadata"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("defaultImpls.kt") @@ -20427,7 +20428,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInPlatformTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/platformTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/platformTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inferenceFlexibleTToNullable.kt") @@ -20454,7 +20455,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInPrimitives() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/platformTypes/primitives"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/platformTypes/primitives"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("assign.kt") @@ -20573,7 +20574,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInPolymorphicSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/polymorphicSignature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/polymorphicSignature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("anonymousSubclass.kt") @@ -20626,7 +20627,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInPrimitiveTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("comparisonWithNaN.kt") @@ -20933,7 +20934,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInEqualityWithObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes/equalityWithObject"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes/equalityWithObject"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("boxedEqPrimitiveEvaluationOrder.kt") @@ -20990,7 +20991,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInGenerated() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("boxedEqPrimitiveBoolean.kt") @@ -21095,7 +21096,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInPrivate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("arrayConvention.kt") @@ -21118,7 +21119,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInPrivateConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/privateConstructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/privateConstructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("base.kt") @@ -21226,7 +21227,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("augmentedAssignmentsAndIncrements.kt") @@ -21633,7 +21634,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInConst() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/const"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/const"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("anotherFile.kt") @@ -21701,7 +21702,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInLateinit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("exceptionField.kt") @@ -21768,7 +21769,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInIsInitializedAndDeinitialize() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/isInitializedAndDeinitialize"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/isInitializedAndDeinitialize"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("companionObjectField.kt") @@ -21826,7 +21827,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInLocal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("capturedLocalLateinit.kt") @@ -21884,7 +21885,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInTopLevel() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/topLevel"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/topLevel"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("topLevelLateinit.kt") @@ -21914,7 +21915,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInPublishedApi() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/publishedApi"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/publishedApi"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("noMangling.kt") @@ -21942,7 +21943,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInRanges() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forByteProgressionWithIntIncrement.kt") @@ -22039,7 +22040,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInContains() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/contains"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/contains"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("comparisonWithRangeBoundEliminated.kt") @@ -22251,7 +22252,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInGenerated() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/contains/generated"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/contains/generated"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("arrayIndices.kt") @@ -22335,7 +22336,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInEvaluationOrder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forInDownTo.kt") @@ -22392,7 +22393,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInStepped() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo") @@ -22404,7 +22405,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInForInDownTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forInDownToReversedStep.kt") @@ -22457,7 +22458,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInForInRangeLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInRangeLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInRangeLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forInRangeLiteralReversedStep.kt") @@ -22510,7 +22511,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInForInUntil() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInUntil"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInUntil"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forInUntilReversedStep.kt") @@ -22565,7 +22566,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("emptyDownto.kt") @@ -22728,7 +22729,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInForInDownTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInDownTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInDownTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forIntInDownTo.kt") @@ -22766,7 +22767,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInForInIndices() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInIndices"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInIndices"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forInArrayListIndices.kt") @@ -22884,7 +22885,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInForInProgressionWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInProgressionWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInProgressionWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forInDownToWithIndex.kt") @@ -22972,7 +22973,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInForInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInReversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInReversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forInReversedArrayIndices.kt") @@ -23075,7 +23076,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInForInUntil() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInUntil"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInUntil"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forInUntilChar.kt") @@ -23163,7 +23164,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInForWithPossibleOverflow() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forWithPossibleOverflow"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forWithPossibleOverflow"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forInDownToCharMinValue.kt") @@ -23241,7 +23242,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInJavaInterop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("javaArrayOfInheritedNotNull.kt") @@ -23348,7 +23349,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/javaInterop/withIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/javaInterop/withIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("javaArrayOfInheritedNotNullWithIndex.kt") @@ -23427,7 +23428,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("emptyDownto.kt") @@ -23590,7 +23591,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInNullableLoopParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/nullableLoopParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/nullableLoopParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("progressionExpression.kt") @@ -23618,7 +23619,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInStepped() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/codegen/box/ranges/stepped/expression") @@ -23630,7 +23631,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/codegen/box/ranges/stepped/expression/downTo") @@ -23642,7 +23643,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInDownTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/downTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/downTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("emptyProgression.kt") @@ -23734,7 +23735,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/downTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/downTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -23787,7 +23788,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/downTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/downTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("reversedThenStep.kt") @@ -23831,7 +23832,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInRangeTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("emptyProgression.kt") @@ -23923,7 +23924,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -23976,7 +23977,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("reversedThenStep.kt") @@ -24020,7 +24021,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInUntil() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/until"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/until"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("emptyProgression.kt") @@ -24117,7 +24118,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/until/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/until/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -24170,7 +24171,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/until/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/until/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("reversedThenStep.kt") @@ -24215,7 +24216,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/codegen/box/ranges/stepped/literal/downTo") @@ -24227,7 +24228,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInDownTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/downTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/downTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("emptyProgression.kt") @@ -24319,7 +24320,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/downTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/downTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -24372,7 +24373,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/downTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/downTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("reversedThenStep.kt") @@ -24416,7 +24417,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInRangeTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("emptyProgression.kt") @@ -24508,7 +24509,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -24561,7 +24562,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("reversedThenStep.kt") @@ -24605,7 +24606,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInUntil() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/until"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/until"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("emptyProgression.kt") @@ -24702,7 +24703,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/until/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/until/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -24755,7 +24756,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/until/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/until/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("reversedThenStep.kt") @@ -24800,7 +24801,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInUnsigned() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/expression") @@ -24812,7 +24813,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo") @@ -24824,7 +24825,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInDownTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("emptyProgression.kt") @@ -24916,7 +24917,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -24969,7 +24970,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("reversedThenStep.kt") @@ -25013,7 +25014,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInRangeTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("emptyProgression.kt") @@ -25105,7 +25106,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -25158,7 +25159,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("reversedThenStep.kt") @@ -25202,7 +25203,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInUntil() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("emptyProgression.kt") @@ -25299,7 +25300,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -25352,7 +25353,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("reversedThenStep.kt") @@ -25397,7 +25398,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo") @@ -25409,7 +25410,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInDownTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("emptyProgression.kt") @@ -25501,7 +25502,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -25554,7 +25555,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("reversedThenStep.kt") @@ -25598,7 +25599,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInRangeTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("emptyProgression.kt") @@ -25690,7 +25691,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -25743,7 +25744,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("reversedThenStep.kt") @@ -25787,7 +25788,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInUntil() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("emptyProgression.kt") @@ -25884,7 +25885,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -25937,7 +25938,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("reversedThenStep.kt") @@ -25984,7 +25985,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInUnsigned() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inMixedUnsignedRange.kt") @@ -26021,7 +26022,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("emptyDownto.kt") @@ -26184,7 +26185,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("emptyDownto.kt") @@ -26347,7 +26348,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInNullableLoopParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/nullableLoopParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/nullableLoopParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("progressionExpression.kt") @@ -26377,7 +26378,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInReflection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/codegen/box/reflection/annotations") @@ -26389,7 +26390,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/annotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/annotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("annotationRetentionAnnotation.kt") @@ -26496,7 +26497,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInOnTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/annotations/onTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/annotations/onTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("arrayKClass.kt") @@ -26530,7 +26531,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInBuiltins() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/builtins"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/builtins"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("collections.kt") @@ -26558,7 +26559,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("bigArity.kt") @@ -26690,7 +26691,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInBound() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("companionObjectPropertyAccessors.kt") @@ -26768,7 +26769,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("constructorWithInlineClassParameters.kt") @@ -26852,7 +26853,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInCallBy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/callBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/callBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("boundExtensionFunction.kt") @@ -26995,7 +26996,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInClassLiterals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/classLiterals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/classLiterals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("annotationClassLiteral.kt") @@ -27053,7 +27054,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/classes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/classes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("classSimpleName.kt") @@ -27146,7 +27147,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/constructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/constructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("annotationClass.kt") @@ -27189,7 +27190,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInCreateAnnotation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/createAnnotation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/createAnnotation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("annotationType.kt") @@ -27267,7 +27268,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInEnclosing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/enclosing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/enclosing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("anonymousObjectInInlinedLambda.kt") @@ -27405,7 +27406,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("declaredVsInheritedFunctions.kt") @@ -27483,7 +27484,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInGenericSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/genericSignature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/genericSignature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("covariantOverride.kt") @@ -27581,7 +27582,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInIsInstance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/isInstance"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/isInstance"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("isInstanceCastAndSafeCast.kt") @@ -27599,7 +27600,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInKClassInAnnotation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/kClassInAnnotation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/kClassInAnnotation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("array.kt") @@ -27657,7 +27658,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInLambdaClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/lambdaClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/lambdaClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("parameterNamesAndNullability.kt") @@ -27715,7 +27716,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInMapping() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("constructor.kt") @@ -27812,7 +27813,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInFakeOverrides() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/fakeOverrides"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/fakeOverrides"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("javaFieldGetterSetter.kt") @@ -27835,7 +27836,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inlineClassPrimaryVal.kt") @@ -27858,7 +27859,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInJvmStatic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/jvmStatic"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/jvmStatic"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("companionObjectFunction.kt") @@ -27881,7 +27882,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/types"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/types"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("allSupertypes.kt") @@ -28005,7 +28006,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInMethodsFromAny() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/methodsFromAny"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/methodsFromAny"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("builtinFunctionsToString.kt") @@ -28133,7 +28134,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInModifiers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/modifiers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/modifiers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("callableModality.kt") @@ -28191,7 +28192,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInMultifileClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("callFunctionsInMultifileClass.kt") @@ -28219,7 +28220,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInNoReflectAtRuntime() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/noReflectAtRuntime"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/noReflectAtRuntime"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("javaClass.kt") @@ -28266,7 +28267,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInMethodsFromAny() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/noReflectAtRuntime/methodsFromAny"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/noReflectAtRuntime/methodsFromAny"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("callableReferences.kt") @@ -28295,7 +28296,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/parameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/parameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("bigArity.kt") @@ -28383,7 +28384,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("allVsDeclared.kt") @@ -28550,7 +28551,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/accessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/accessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("extensionPropertyAccessors.kt") @@ -28583,7 +28584,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInGetDelegate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/getDelegate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/getDelegate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("booleanPropertyNameStartsWithIs.kt") @@ -28671,7 +28672,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInJvmField() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/jvmField"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/jvmField"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("annotationCompanionWithAnnotation.kt") @@ -28699,7 +28700,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInLocalDelegated() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/localDelegated"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/localDelegated"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("defaultImpls.kt") @@ -28753,7 +28754,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInSupertypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/supertypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/supertypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("builtInClassSupertypes.kt") @@ -28791,7 +28792,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInTypeOf() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("classes.kt") @@ -28828,7 +28829,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInJs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/js"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/js"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } } @@ -28841,7 +28842,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInNoReflect() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/noReflect"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/noReflect"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("classes.kt") @@ -28868,7 +28869,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInNonReifiedTypeParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/noReflect/nonReifiedTypeParameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/noReflect/nonReifiedTypeParameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("defaultUpperBound.kt") @@ -28932,7 +28933,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInNonReifiedTypeParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/nonReifiedTypeParameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/nonReifiedTypeParameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("defaultUpperBound.kt") @@ -29006,7 +29007,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInTypeParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeParameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeParameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("declarationSiteVariance.kt") @@ -29044,7 +29045,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/types"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/types"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("classifierIsClass.kt") @@ -29116,7 +29117,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInCreateType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/types/createType"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/types/createType"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("equality.kt") @@ -29154,7 +29155,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInSubtyping() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/types/subtyping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/types/subtyping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("platformType.kt") @@ -29189,7 +29190,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInRegressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/regressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/regressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("approximateIntersectionType.kt") @@ -29677,7 +29678,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInReified() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reified"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reified"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("anonymousObject.kt") @@ -29864,7 +29865,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInArraysReification() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reified/arraysReification"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reified/arraysReification"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("instanceOf.kt") @@ -29908,7 +29909,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInSafeCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/safeCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/safeCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("genericNull.kt") @@ -29986,7 +29987,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInSam() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("arrayAsVarargAfterSamArgument.kt") @@ -30103,7 +30104,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam/constructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam/constructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("comparator.kt") @@ -30191,7 +30192,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInEquality() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam/equality"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam/equality"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("functionReferencesBound.kt") @@ -30230,7 +30231,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInSealed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sealed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sealed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("multipleFiles_enabled.kt") @@ -30268,7 +30269,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInSecondaryConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/secondaryConstructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/secondaryConstructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("basicNoPrimaryManySinks.kt") @@ -30446,7 +30447,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInSignatureAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/signatureAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/signatureAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("defaultAndNamedCombination.kt") @@ -30524,7 +30525,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInSmap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/smap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/smap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("chainCalls.kt") @@ -30552,7 +30553,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInSmartCasts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/smartCasts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/smartCasts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("falseSmartCast.kt") @@ -30645,7 +30646,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInSpecialBuiltins() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/specialBuiltins"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/specialBuiltins"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("bridgeNotEmptyMap.kt") @@ -30793,7 +30794,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInStatics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/statics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/statics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("anonymousInitializerIObject.kt") @@ -30891,7 +30892,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInStoreStackBeforeInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/storeStackBeforeInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/storeStackBeforeInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("differentTypes.kt") @@ -30929,7 +30930,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInStrings() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/strings"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/strings"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("constInStringTemplate.kt") @@ -31062,7 +31063,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInSuper() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/super"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/super"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("basicmethodSuperClass.kt") @@ -31224,7 +31225,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInSuperConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/super/superConstructor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/super/superConstructor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt13846.kt") @@ -31273,7 +31274,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInSynchronized() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/synchronized"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/synchronized"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("changeMonitor.kt") @@ -31371,7 +31372,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInSyntheticAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/syntheticAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/syntheticAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inline.kt") @@ -31454,7 +31455,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInThrows() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/throws"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/throws"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("delegationAndThrows.kt") @@ -31477,7 +31478,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInToArray() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/toArray"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/toArray"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("incorrectToArrayDetection.kt") @@ -31535,7 +31536,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInTopLevelPrivate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/topLevelPrivate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/topLevelPrivate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("noPrivateNoAccessorsInMultiFileFacade.kt") @@ -31578,7 +31579,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInTrailingComma() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/trailingComma"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/trailingComma"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("noDisambiguation.kt") @@ -31606,7 +31607,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInTraits() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/traits"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/traits"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("defaultImplCall.kt") @@ -31799,7 +31800,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInTypeInfo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typeInfo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typeInfo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("asInLoop.kt") @@ -31847,7 +31848,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInTypeMapping() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typeMapping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typeMapping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("enhancedPrimitiveInReturnType.kt") @@ -31920,7 +31921,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInTypealias() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typealias"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typealias"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("enumEntryQualifier.kt") @@ -32028,7 +32029,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInUnaryOp() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unaryOp"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unaryOp"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("call.kt") @@ -32071,7 +32072,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInUnit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("closureReturnsNullableUnit.kt") @@ -32139,7 +32140,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInUnsignedTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unsignedTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unsignedTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("boxConstValOfUnsignedType.kt") @@ -32356,7 +32357,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInJvm8Intrinsics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unsignedTypes/jvm8Intrinsics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unsignedTypes/jvm8Intrinsics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("unsignedIntCompare_jvm8.kt") @@ -32410,7 +32411,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInValueClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/valueClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/valueClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("jvmInline.kt") @@ -32428,7 +32429,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInVararg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/vararg"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/vararg"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("assigningArrayToVarargInAnnotation.kt") @@ -32526,7 +32527,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInWhen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("callProperty.kt") @@ -32743,7 +32744,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInEnumOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/enumOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/enumOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("bigEnum.kt") @@ -32846,7 +32847,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInStringOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/stringOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/stringOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("duplicatingItems.kt") @@ -32904,7 +32905,7 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes } public void testAllFilesPresentInWhenSubjectVariable() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/whenSubjectVariable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/whenSubjectVariable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("captureSubjectVariable.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrBlackBoxInlineCodegenTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrBlackBoxInlineCodegenTestGenerated.java index 72ae58bb07a..9b79dae0711 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrBlackBoxInlineCodegenTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrBlackBoxInlineCodegenTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.codegen.ir; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInBoxInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/codegen/boxInline/anonymousObject") @@ -38,7 +39,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInAnonymousObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("anonymousObjectInDefault.kt") @@ -340,7 +341,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInEnumWhen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/enumWhen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/enumWhen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("callSite.kt") @@ -373,7 +374,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInProperRecapturing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inlineChain.kt") @@ -416,7 +417,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInProperRecapturingInClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inlineChain.kt") @@ -489,7 +490,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInSam() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("anonymousObjectToSam.kt") @@ -537,7 +538,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInTwoCapturedReceivers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt8668.kt") @@ -576,7 +577,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInArgumentOrder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/argumentOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/argumentOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("boundFunctionReference.kt") @@ -659,7 +660,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInArrayConvention() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/arrayConvention"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/arrayConvention"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("simpleAccess.kt") @@ -702,7 +703,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInAssert() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/assert"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/assert"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("jvmAssertInlineFunctionAssertionsDisabled.kt") @@ -775,7 +776,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInBuilders() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/builders"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/builders"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("builders.kt") @@ -798,7 +799,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInBytecodePreprocessing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/bytecodePreprocessing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/bytecodePreprocessing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("apiVersionAtLeast1.kt") @@ -821,7 +822,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("classLevel.kt") @@ -908,7 +909,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInBound() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("classProperty.kt") @@ -1042,7 +1043,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInCapture() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/capture"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/capture"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("captureInlinable.kt") @@ -1085,7 +1086,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInComplex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/complex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/complex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("closureChain.kt") @@ -1133,7 +1134,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInComplexStack() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/complexStack"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/complexStack"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("asCheck.kt") @@ -1191,7 +1192,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInContracts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/contracts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/contracts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("cfgDependendValInitialization.kt") @@ -1289,7 +1290,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInDefaultValues() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("defaultInExtension.kt") @@ -1391,7 +1392,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInLambdaInlining() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("checkLambdaClassIsPresent.kt") @@ -1563,7 +1564,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInCallableReferences() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("boundFunctionReference.kt") @@ -1697,7 +1698,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInMaskElimination() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/maskElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/maskElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt18792.kt") @@ -1736,7 +1737,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInDelegatedProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/delegatedProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/delegatedProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt16864.kt") @@ -1774,7 +1775,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInEnclosingInfo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/enclosingInfo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/enclosingInfo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("anonymousInLambda.kt") @@ -1822,7 +1823,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt10569.kt") @@ -1900,7 +1901,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInFunctionExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/functionExpression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/functionExpression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("extension.kt") @@ -1918,7 +1919,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inlineClassWithInlineValReturningInlineClass.kt") @@ -1970,7 +1971,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInUnboxGenericParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/funInterface") @@ -1982,7 +1983,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInFunInterface() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("any.kt") @@ -2025,7 +2026,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/lambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/lambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("any.kt") @@ -2068,7 +2069,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInObjectLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/objectLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/objectLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("any.kt") @@ -2113,7 +2114,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInInnerClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/innerClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/innerClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("captureThisAndOuter.kt") @@ -2141,7 +2142,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInJvmPackageName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/jvmPackageName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/jvmPackageName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("simple.kt") @@ -2159,7 +2160,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInLambdaClassClash() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/lambdaClassClash"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/lambdaClassClash"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("lambdaClassClash.kt") @@ -2182,7 +2183,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInLambdaTransformation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/lambdaTransformation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/lambdaTransformation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("lambdaCloning.kt") @@ -2225,7 +2226,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInLocalFunInLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/localFunInLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/localFunInLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("defaultParam.kt") @@ -2258,7 +2259,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInMultiModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("tryCatchWithRecursiveInline.kt") @@ -2276,7 +2277,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInMultifileClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("defaultArguments.kt") @@ -2304,7 +2305,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInMultiplatform() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/codegen/boxInline/multiplatform/defaultArguments") @@ -2316,7 +2317,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInDefaultArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiplatform/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiplatform/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("receiversAndParametersInLambda.kt") @@ -2335,7 +2336,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInNoInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/noInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/noInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("extensionReceiver.kt") @@ -2383,7 +2384,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInNonLocalReturns() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("explicitLocalReturn.kt") @@ -2465,7 +2466,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInDeparenthesize() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/deparenthesize"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/deparenthesize"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("bracket.kt") @@ -2488,7 +2489,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInTryFinally() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt16417.kt") @@ -2565,7 +2566,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInCallSite() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("callSite.kt") @@ -2608,7 +2609,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInChained() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("finallyInFinally.kt") @@ -2661,7 +2662,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInDeclSite() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("complex.kt") @@ -2734,7 +2735,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInExceptionTable() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("break.kt") @@ -2852,7 +2853,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInVariables() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/variables"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/variables"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt7792.kt") @@ -2872,7 +2873,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInOptimizations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt20844.kt") @@ -2905,7 +2906,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInPrivate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("effectivePrivate.kt") @@ -2963,7 +2964,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("augAssignmentAndInc.kt") @@ -3041,7 +3042,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInReified() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("arrayConstructor.kt") @@ -3158,7 +3159,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInCheckCast() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/checkCast"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/checkCast"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("chain.kt") @@ -3221,7 +3222,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInDefaultLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/defaultLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/defaultLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("chain.kt") @@ -3274,7 +3275,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInIsCheck() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/isCheck"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/isCheck"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("chain.kt") @@ -3303,7 +3304,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/signature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/signature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inProjectionSubstitution.kt") @@ -3361,7 +3362,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInSimple() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/simple"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/simple"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("captureAndArgumentIncompatibleTypes.kt") @@ -3494,7 +3495,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInSmap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("assertion.kt") @@ -3596,7 +3597,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInAnonymous() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/anonymous"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/anonymous"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt19175.kt") @@ -3659,7 +3660,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInDefaultLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/defaultLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/defaultLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("defaultLambdaInAnonymous.kt") @@ -3717,7 +3718,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInInlineOnly() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/inlineOnly"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/inlineOnly"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("noSmap.kt") @@ -3760,7 +3761,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInNewsmap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/newsmap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/newsmap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("differentMapping.kt") @@ -3793,7 +3794,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInResolve() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/resolve"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/resolve"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inlineComponent.kt") @@ -3817,7 +3818,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInSpecial() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/special"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/special"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("identityCheck.kt") @@ -3875,7 +3876,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInStackOnReturn() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/stackOnReturn"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/stackOnReturn"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("elvis.kt") @@ -3968,7 +3969,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInSuspend() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("capturedVariables.kt") @@ -4130,7 +4131,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("isAsReified.kt") @@ -4168,7 +4169,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInDefaultParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/defaultParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/defaultParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("defaultValueCrossinline.kt") @@ -4201,7 +4202,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInInlineClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/inlineClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/inlineClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("returnUnboxedDirect.kt") @@ -4224,7 +4225,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInInlineUsedAsNoinline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/inlineUsedAsNoinline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/inlineUsedAsNoinline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inlineOnly.kt") @@ -4257,7 +4258,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInReceiver() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/receiver"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/receiver"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inlineOrdinaryOfCrossinlineSuspend.kt") @@ -4310,7 +4311,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInStateMachine() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/stateMachine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/stateMachine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("crossingCoroutineBoundaries.kt") @@ -4434,7 +4435,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInSyntheticAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/syntheticAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/syntheticAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("constField.kt") @@ -4486,7 +4487,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInWithinInlineLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("directFieldAccess.kt") @@ -4545,7 +4546,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInTrait() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/trait"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/trait"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("trait.kt") @@ -4563,7 +4564,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInTryCatchFinally() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/tryCatchFinally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/tryCatchFinally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt5863.kt") @@ -4596,7 +4597,7 @@ public class IrBlackBoxInlineCodegenTestGenerated extends AbstractIrBlackBoxInli } public void testAllFilesPresentInVarargs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/varargs"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/varargs"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt17653.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrBytecodeListingTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrBytecodeListingTestGenerated.java index 63f4250d5ac..d4881292cd6 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrBytecodeListingTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrBytecodeListingTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.codegen.ir; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -36,7 +37,7 @@ public class IrBytecodeListingTestGenerated extends AbstractIrBytecodeListingTes } public void testAllFilesPresentInBytecodeListing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("anonymousObjectInGenericFun.kt") @@ -238,7 +239,7 @@ public class IrBytecodeListingTestGenerated extends AbstractIrBytecodeListingTes } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/annotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/annotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("annotationsOnDelegatedMembers.kt") @@ -331,7 +332,7 @@ public class IrBytecodeListingTestGenerated extends AbstractIrBytecodeListingTes } public void testAllFilesPresentInCollectionStubs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/collectionStubs"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/collectionStubs"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("collectionByDelegation.kt") @@ -498,7 +499,7 @@ public class IrBytecodeListingTestGenerated extends AbstractIrBytecodeListingTes } public void testAllFilesPresentInAbstractStubSignatures() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/collectionStubs/abstractStubSignatures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("byteShortMap.kt") @@ -646,7 +647,7 @@ public class IrBytecodeListingTestGenerated extends AbstractIrBytecodeListingTes } public void testAllFilesPresentInToArray() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/collectionStubs/toArray"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/collectionStubs/toArray"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("customNonGenericToArray.kt") @@ -675,7 +676,7 @@ public class IrBytecodeListingTestGenerated extends AbstractIrBytecodeListingTes } public void testAllFilesPresentInCoroutines() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("coroutineContextIntrinsic.kt") @@ -727,7 +728,7 @@ public class IrBytecodeListingTestGenerated extends AbstractIrBytecodeListingTes } public void testAllFilesPresentInSpilling() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/coroutines/spilling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/coroutines/spilling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("booleanParameter.kt") @@ -776,7 +777,7 @@ public class IrBytecodeListingTestGenerated extends AbstractIrBytecodeListingTes } public void testAllFilesPresentInDefaultArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("functionInMultifileClass.kt") @@ -804,7 +805,7 @@ public class IrBytecodeListingTestGenerated extends AbstractIrBytecodeListingTes } public void testAllFilesPresentInDeprecated() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/deprecated"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/deprecated"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("deprecatedClass.kt") @@ -862,7 +863,7 @@ public class IrBytecodeListingTestGenerated extends AbstractIrBytecodeListingTes } public void testAllFilesPresentInInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/inline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/inline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inlineOnly.kt") @@ -919,7 +920,7 @@ public class IrBytecodeListingTestGenerated extends AbstractIrBytecodeListingTes } public void testAllFilesPresentInEnclosingInfo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/inline/enclosingInfo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/inline/enclosingInfo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("crossinlineLambdaChain.kt") @@ -963,7 +964,7 @@ public class IrBytecodeListingTestGenerated extends AbstractIrBytecodeListingTes } public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("annotatedPropertyWithInlineClassTypeInSignature.kt") @@ -1105,7 +1106,7 @@ public class IrBytecodeListingTestGenerated extends AbstractIrBytecodeListingTes } public void testAllFilesPresentInDefaultInterfaceMembers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/inlineClasses/defaultInterfaceMembers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/inlineClasses/defaultInterfaceMembers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("javaDefaultInterfaceMember.kt") @@ -1133,7 +1134,7 @@ public class IrBytecodeListingTestGenerated extends AbstractIrBytecodeListingTes } public void testAllFilesPresentInInlineCollection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("collection.kt") @@ -1221,7 +1222,7 @@ public class IrBytecodeListingTestGenerated extends AbstractIrBytecodeListingTes } public void testAllFilesPresentInInlineCollectionOfInlineClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/inlineClasses/inlineCollectionOfInlineClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("collection.kt") @@ -1309,7 +1310,7 @@ public class IrBytecodeListingTestGenerated extends AbstractIrBytecodeListingTes } public void testAllFilesPresentInStdlibManglingIn1430() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/inlineClasses/stdlibManglingIn1430"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/inlineClasses/stdlibManglingIn1430"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("new.kt") @@ -1333,7 +1334,7 @@ public class IrBytecodeListingTestGenerated extends AbstractIrBytecodeListingTes } public void testAllFilesPresentInJvm8() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/jvm8"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/jvm8"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/codegen/bytecodeListing/jvm8/defaults") @@ -1345,7 +1346,7 @@ public class IrBytecodeListingTestGenerated extends AbstractIrBytecodeListingTes } public void testAllFilesPresentInDefaults() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/jvm8/defaults"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/jvm8/defaults"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/codegen/bytecodeListing/jvm8/defaults/allCompatibility") @@ -1357,7 +1358,7 @@ public class IrBytecodeListingTestGenerated extends AbstractIrBytecodeListingTes } public void testAllFilesPresentInAllCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/jvm8/defaults/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/jvm8/defaults/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("deprecation.kt") @@ -1389,7 +1390,7 @@ public class IrBytecodeListingTestGenerated extends AbstractIrBytecodeListingTes } public void testAllFilesPresentInSpecialization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/jvm8/defaults/allCompatibility/specialization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/jvm8/defaults/allCompatibility/specialization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("primitiveAndAny.kt") @@ -1415,7 +1416,7 @@ public class IrBytecodeListingTestGenerated extends AbstractIrBytecodeListingTes } public void testAllFilesPresentInMain() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/main"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/main"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("multifileSuspend.kt") @@ -1453,7 +1454,7 @@ public class IrBytecodeListingTestGenerated extends AbstractIrBytecodeListingTes } public void testAllFilesPresentInMultiplatform() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("optionalExpectation.kt") @@ -1471,7 +1472,7 @@ public class IrBytecodeListingTestGenerated extends AbstractIrBytecodeListingTes } public void testAllFilesPresentInNullabilityAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/nullabilityAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/nullabilityAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("lateInitNotNull.kt") @@ -1509,7 +1510,7 @@ public class IrBytecodeListingTestGenerated extends AbstractIrBytecodeListingTes } public void testAllFilesPresentInSam() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("callableRefGenericFunInterface.kt") @@ -1627,7 +1628,7 @@ public class IrBytecodeListingTestGenerated extends AbstractIrBytecodeListingTes } public void testAllFilesPresentInSpecialBridges() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/specialBridges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/specialBridges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("charSequence.kt") @@ -1694,7 +1695,7 @@ public class IrBytecodeListingTestGenerated extends AbstractIrBytecodeListingTes } public void testAllFilesPresentInSignatures() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/specialBridges/signatures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeListing/specialBridges/signatures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("genericClass.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrBytecodeTextTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrBytecodeTextTestGenerated.java index 15c07b925df..1b1cecdfd78 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrBytecodeTextTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrBytecodeTextTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.codegen.ir; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -41,7 +42,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInBytecodeText() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true, "oldLanguageVersions"); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true, "oldLanguageVersions"); } @TestMetadata("annotationDefaultValue.kt") @@ -448,7 +449,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInArgumentOrder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/argumentOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/argumentOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("sameOrder.kt") @@ -471,7 +472,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInAssert() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/assert"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/assert"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("jvmCrossinline.kt") @@ -509,7 +510,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInBoxing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/boxing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/boxing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("crossinlineSuspend.kt") @@ -537,7 +538,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInBoxingOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/boxingOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/boxingOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("boxingAndEquals.kt") @@ -670,7 +671,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInBuiltinFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/builtinFunctions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/builtinFunctions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("charSequence.kt") @@ -707,7 +708,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInGenericParameterBridge() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/builtinFunctions/genericParameterBridge"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/builtinFunctions/genericParameterBridge"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("IntMC.kt") @@ -751,7 +752,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("boundFieldReferenceInInline.kt") @@ -809,7 +810,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInCapturedVarsOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/capturedVarsOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/capturedVarsOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("capturedInChainOfInlineFuns.kt") @@ -872,7 +873,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInCheckcast() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/checkcast"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/checkcast"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt14811.kt") @@ -905,7 +906,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInCoercionToUnitOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/coercionToUnitOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/coercionToUnitOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inRangeCheckWithConst.kt") @@ -963,7 +964,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInCompanion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/companion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/companion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("directAccessToBackingField.kt") @@ -1046,7 +1047,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInConditions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/conditions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/conditions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("conjunction.kt") @@ -1199,7 +1200,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInConstProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/constProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/constProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("noAccessorsForPrivateConstants.kt") @@ -1237,7 +1238,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInConstantConditions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/constantConditions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/constantConditions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("cmpIntWith0.kt") @@ -1275,7 +1276,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInConstants() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/constants"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/constants"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("byte.kt") @@ -1353,7 +1354,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/constructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/constructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("enumPrimaryDefaults.kt") @@ -1411,7 +1412,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInControlStructures() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/controlStructures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/controlStructures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("ifConsts.kt") @@ -1434,7 +1435,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInCoroutines() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("crossinlineSuspendContinuation_1_3.kt") @@ -1496,7 +1497,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInCleanup() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/coroutines/cleanup"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/coroutines/cleanup"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("backEdge.kt") @@ -1539,7 +1540,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInDebug() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/coroutines/debug"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/coroutines/debug"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("continuationInLvt.kt") @@ -1577,7 +1578,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInDestructuringInLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/coroutines/destructuringInLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/coroutines/destructuringInLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inlineSeparateFiles.kt") @@ -1595,7 +1596,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/coroutines/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/coroutines/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inlineClassBoxingInSuspendFunReturn_Primitive.kt") @@ -1643,7 +1644,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInIntLikeVarSpilling() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/coroutines/intLikeVarSpilling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/coroutines/intLikeVarSpilling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("complicatedMerge.kt") @@ -1706,7 +1707,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInStateMachine() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/coroutines/stateMachine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/coroutines/stateMachine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt25893.kt") @@ -1730,7 +1731,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInDeadCodeElimination() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/deadCodeElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/deadCodeElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("arrayConstructor.kt") @@ -1798,7 +1799,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInDefaultArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inheritedInterfaceFunction.kt") @@ -1861,7 +1862,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInDirectInvoke() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/directInvoke"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/directInvoke"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("callableReference.kt") @@ -1889,7 +1890,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInDisabledOptimizations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/disabledOptimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/disabledOptimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("noJumpInLastBranch.kt") @@ -1932,7 +1933,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("constructorAccessors.kt") @@ -1965,7 +1966,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInExclExcl() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/exclExcl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/exclExcl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("primitive.kt") @@ -1983,7 +1984,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInFieldsForCapturedValues() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/fieldsForCapturedValues"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/fieldsForCapturedValues"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("extensionLambdaExtensionReceiver.kt") @@ -2041,7 +2042,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInForLoop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forInCharSequence.kt") @@ -2178,7 +2179,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInForInArrayWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/forInArrayWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/forInArrayWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forInArrayWithIndexNoElementVar.kt") @@ -2216,7 +2217,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInForInCharSequenceWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/forInCharSequenceWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/forInCharSequenceWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forInCharSequenceWithIndex.kt") @@ -2259,7 +2260,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInForInIndices() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/forInIndices"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/forInIndices"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forInArrayListIndices.kt") @@ -2317,7 +2318,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInForInIterableWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/forInIterableWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/forInIterableWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forInEmptyListWithIndex.kt") @@ -2360,7 +2361,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInForInProgressionWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/forInProgressionWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/forInProgressionWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forInDownToWithIndex.kt") @@ -2433,7 +2434,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInForInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/forInReversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/forInReversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forInReversedArrayIndices.kt") @@ -2511,7 +2512,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInForInSequenceWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/forInSequenceWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/forInSequenceWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forInEmptySequenceWithIndex.kt") @@ -2559,7 +2560,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInForInUntil() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/forInUntil"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/forInUntil"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forInUntilChar.kt") @@ -2617,7 +2618,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInStepped() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/stepped"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/stepped"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("illegalStepConst.kt") @@ -2700,7 +2701,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInUnsigned() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/unsigned"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/forLoop/unsigned"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("forInDownToUIntMinValue.kt") @@ -2789,7 +2790,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInHashCode() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/hashCode"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/hashCode"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("hashCode.kt") @@ -2812,7 +2813,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInIeee754() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/ieee754"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/ieee754"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("nullableDoubleEquals.kt") @@ -2865,7 +2866,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/inline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/inline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("deleteClassOnTransformation.kt") @@ -2972,7 +2973,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/inline/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/inline/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("simple.kt") @@ -2991,7 +2992,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("asCastForInlineClass.kt") @@ -3339,7 +3340,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInInnerClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/innerClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/innerClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("nestedClassInAnnotationArgument.kt") @@ -3362,7 +3363,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInInterfaces() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/interfaces"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/interfaces"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("firstInheritedMethodIsAbstract.kt") @@ -3395,7 +3396,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInIntrinsics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/intrinsics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/intrinsics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("javaObjectType.kt") @@ -3418,7 +3419,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInIntrinsicsCompare() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/intrinsicsCompare"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/intrinsicsCompare"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("byteSmartCast_after.kt") @@ -3481,7 +3482,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInIntrinsicsTrim() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/intrinsicsTrim"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/intrinsicsTrim"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("trimIndentNegative.kt") @@ -3514,7 +3515,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInJvm8() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/jvm8"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/jvm8"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/codegen/bytecodeText/jvm8/hashCode") @@ -3526,7 +3527,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInHashCode() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/jvm8/hashCode"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/jvm8/hashCode"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("dataClass.kt") @@ -3549,7 +3550,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInJvmDefault() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/jvm8/jvmDefault"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/jvm8/jvmDefault"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/codegen/bytecodeText/jvm8/jvmDefault/allCompatibility") @@ -3561,7 +3562,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInAllCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/jvm8/jvmDefault/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/jvm8/jvmDefault/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("defaultArgs.kt") @@ -3599,7 +3600,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/jvm8/jvmDefault/compatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/jvm8/jvmDefault/compatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("defaultArgs.kt") @@ -3639,7 +3640,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInLazyCodegen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/lazyCodegen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/lazyCodegen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inlineConstInsideComparison.kt") @@ -3687,7 +3688,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInLineNumbers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/lineNumbers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/lineNumbers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("ifConsts.kt") @@ -3760,7 +3761,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInLocalInitializationLVT() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/localInitializationLVT"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/localInitializationLVT"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("boxing.kt") @@ -3868,7 +3869,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInMangling() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/mangling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/mangling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("parentheses.kt") @@ -3891,7 +3892,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInMultifileClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("defaultFunctionInMultifileClass.kt") @@ -3919,7 +3920,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInNotNullAssertions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/notNullAssertions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/notNullAssertions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("arrayListGet.kt") @@ -3987,7 +3988,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInNullCheckOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/nullCheckOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/nullCheckOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("alreadyCheckedForIs.kt") @@ -4109,7 +4110,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInLocalLateinit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/nullCheckOptimization/localLateinit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/nullCheckOptimization/localLateinit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("checkedAlways.kt") @@ -4138,7 +4139,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInOptimizedDelegatedProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/optimizedDelegatedProperties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/optimizedDelegatedProperties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("definedInSources.kt") @@ -4171,7 +4172,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInParameterlessMain() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/parameterlessMain"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/parameterlessMain"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("dontGenerateOnExtensionReceiver.kt") @@ -4219,7 +4220,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/properties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/properties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("dataClass.kt") @@ -4241,7 +4242,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInLateinit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/properties/lateinit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/properties/lateinit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("companionObject.kt") @@ -4265,7 +4266,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInRanges() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/ranges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/ranges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("ifNotInRange.kt") @@ -4338,7 +4339,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInSam() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("samWrapperForNullInitialization.kt") @@ -4381,7 +4382,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInStatements() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/statements"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/statements"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("ifSingleBranch.kt") @@ -4434,7 +4435,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInStaticFields() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/staticFields"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/staticFields"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("classObject.kt") @@ -4457,7 +4458,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInStoreStackBeforeInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/storeStackBeforeInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/storeStackBeforeInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("differentTypes.kt") @@ -4495,7 +4496,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInStringOperations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/stringOperations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/stringOperations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("concat.kt") @@ -4668,7 +4669,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInToArray() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/toArray"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/toArray"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("noAccessorForToArray.kt") @@ -4686,7 +4687,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInUnsignedTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/unsignedTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/unsignedTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("unsignedIntCompare_before.kt") @@ -4754,7 +4755,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInVarargs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/varargs"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/varargs"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("doNotCopyImmediatelyCreatedArrays.kt") @@ -4772,7 +4773,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInWhen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/when"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/when"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("edgeCases.kt") @@ -4910,7 +4911,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInWhenEnumOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/whenEnumOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/whenEnumOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("bigEnum.kt") @@ -4998,7 +4999,7 @@ public class IrBytecodeTextTestGenerated extends AbstractIrBytecodeTextTest { } public void testAllFilesPresentInWhenStringOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/whenStringOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/bytecodeText/whenStringOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("denseHashCode.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrCheckLocalVariablesTableTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrCheckLocalVariablesTableTestGenerated.java index fe853f1f52b..f810be392ae 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrCheckLocalVariablesTableTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrCheckLocalVariablesTableTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.codegen.ir; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class IrCheckLocalVariablesTableTestGenerated extends AbstractIrCheckLoca } public void testAllFilesPresentInCheckLocalVariablesTable() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/checkLocalVariablesTable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/checkLocalVariablesTable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("copyFunction.kt") @@ -113,7 +114,7 @@ public class IrCheckLocalVariablesTableTestGenerated extends AbstractIrCheckLoca } public void testAllFilesPresentInCompletionInSuspendFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/checkLocalVariablesTable/completionInSuspendFunction"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/checkLocalVariablesTable/completionInSuspendFunction"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("nonStaticSimple.kt") @@ -156,7 +157,7 @@ public class IrCheckLocalVariablesTableTestGenerated extends AbstractIrCheckLoca } public void testAllFilesPresentInParametersInSuspendLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/checkLocalVariablesTable/parametersInSuspendLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/checkLocalVariablesTable/parametersInSuspendLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("dataClass.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrCompileKotlinAgainstInlineKotlinTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrCompileKotlinAgainstInlineKotlinTestGenerated.java index 0020e5583d8..1f8b967cf1c 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrCompileKotlinAgainstInlineKotlinTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrCompileKotlinAgainstInlineKotlinTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.codegen.ir; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInBoxInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/codegen/boxInline/anonymousObject") @@ -38,7 +39,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInAnonymousObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("anonymousObjectInDefault.kt") @@ -340,7 +341,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInEnumWhen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/enumWhen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/enumWhen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("callSite.kt") @@ -373,7 +374,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInProperRecapturing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inlineChain.kt") @@ -416,7 +417,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInProperRecapturingInClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inlineChain.kt") @@ -489,7 +490,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInSam() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("anonymousObjectToSam.kt") @@ -537,7 +538,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInTwoCapturedReceivers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt8668.kt") @@ -576,7 +577,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInArgumentOrder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/argumentOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/argumentOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("boundFunctionReference.kt") @@ -659,7 +660,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInArrayConvention() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/arrayConvention"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/arrayConvention"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("simpleAccess.kt") @@ -702,7 +703,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInAssert() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/assert"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/assert"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("jvmAssertInlineFunctionAssertionsDisabled.kt") @@ -775,7 +776,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInBuilders() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/builders"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/builders"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("builders.kt") @@ -798,7 +799,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInBytecodePreprocessing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/bytecodePreprocessing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/bytecodePreprocessing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("apiVersionAtLeast1.kt") @@ -821,7 +822,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("classLevel.kt") @@ -908,7 +909,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInBound() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("classProperty.kt") @@ -1042,7 +1043,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInCapture() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/capture"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/capture"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("captureInlinable.kt") @@ -1085,7 +1086,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInComplex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/complex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/complex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("closureChain.kt") @@ -1133,7 +1134,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInComplexStack() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/complexStack"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/complexStack"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("asCheck.kt") @@ -1191,7 +1192,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInContracts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/contracts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/contracts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("cfgDependendValInitialization.kt") @@ -1289,7 +1290,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInDefaultValues() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("defaultInExtension.kt") @@ -1391,7 +1392,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInLambdaInlining() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("checkLambdaClassIsPresent.kt") @@ -1563,7 +1564,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInCallableReferences() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("boundFunctionReference.kt") @@ -1697,7 +1698,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInMaskElimination() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/maskElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/maskElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt18792.kt") @@ -1736,7 +1737,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInDelegatedProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/delegatedProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/delegatedProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt16864.kt") @@ -1774,7 +1775,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInEnclosingInfo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/enclosingInfo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/enclosingInfo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("anonymousInLambda.kt") @@ -1822,7 +1823,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt10569.kt") @@ -1900,7 +1901,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInFunctionExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/functionExpression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/functionExpression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("extension.kt") @@ -1918,7 +1919,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inlineClassWithInlineValReturningInlineClass.kt") @@ -1970,7 +1971,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInUnboxGenericParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/funInterface") @@ -1982,7 +1983,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInFunInterface() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("any.kt") @@ -2025,7 +2026,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/lambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/lambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("any.kt") @@ -2068,7 +2069,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInObjectLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/objectLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/objectLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("any.kt") @@ -2113,7 +2114,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInInnerClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/innerClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/innerClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("captureThisAndOuter.kt") @@ -2141,7 +2142,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInJvmPackageName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/jvmPackageName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/jvmPackageName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("simple.kt") @@ -2159,7 +2160,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInLambdaClassClash() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/lambdaClassClash"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/lambdaClassClash"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("lambdaClassClash.kt") @@ -2182,7 +2183,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInLambdaTransformation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/lambdaTransformation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/lambdaTransformation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("lambdaCloning.kt") @@ -2225,7 +2226,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInLocalFunInLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/localFunInLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/localFunInLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("defaultParam.kt") @@ -2258,7 +2259,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInMultiModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("tryCatchWithRecursiveInline.kt") @@ -2276,7 +2277,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInMultifileClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("defaultArguments.kt") @@ -2304,7 +2305,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInMultiplatform() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/codegen/boxInline/multiplatform/defaultArguments") @@ -2316,7 +2317,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInDefaultArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiplatform/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiplatform/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("receiversAndParametersInLambda.kt") @@ -2335,7 +2336,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInNoInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/noInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/noInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("extensionReceiver.kt") @@ -2383,7 +2384,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInNonLocalReturns() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("explicitLocalReturn.kt") @@ -2465,7 +2466,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInDeparenthesize() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/deparenthesize"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/deparenthesize"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("bracket.kt") @@ -2488,7 +2489,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInTryFinally() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt16417.kt") @@ -2565,7 +2566,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInCallSite() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("callSite.kt") @@ -2608,7 +2609,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInChained() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("finallyInFinally.kt") @@ -2661,7 +2662,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInDeclSite() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("complex.kt") @@ -2734,7 +2735,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInExceptionTable() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("break.kt") @@ -2852,7 +2853,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInVariables() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/variables"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/variables"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt7792.kt") @@ -2872,7 +2873,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInOptimizations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt20844.kt") @@ -2905,7 +2906,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInPrivate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("effectivePrivate.kt") @@ -2963,7 +2964,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("augAssignmentAndInc.kt") @@ -3041,7 +3042,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInReified() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("arrayConstructor.kt") @@ -3158,7 +3159,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInCheckCast() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/checkCast"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/checkCast"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("chain.kt") @@ -3221,7 +3222,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInDefaultLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/defaultLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/defaultLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("chain.kt") @@ -3274,7 +3275,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInIsCheck() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/isCheck"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/isCheck"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("chain.kt") @@ -3303,7 +3304,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/signature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/signature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inProjectionSubstitution.kt") @@ -3361,7 +3362,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInSimple() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/simple"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/simple"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("captureAndArgumentIncompatibleTypes.kt") @@ -3494,7 +3495,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInSmap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("assertion.kt") @@ -3596,7 +3597,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInAnonymous() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/anonymous"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/anonymous"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt19175.kt") @@ -3659,7 +3660,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInDefaultLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/defaultLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/defaultLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("defaultLambdaInAnonymous.kt") @@ -3717,7 +3718,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInInlineOnly() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/inlineOnly"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/inlineOnly"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("noSmap.kt") @@ -3760,7 +3761,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInNewsmap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/newsmap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/newsmap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("differentMapping.kt") @@ -3793,7 +3794,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInResolve() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/resolve"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/resolve"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inlineComponent.kt") @@ -3817,7 +3818,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInSpecial() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/special"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/special"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("identityCheck.kt") @@ -3875,7 +3876,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInStackOnReturn() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/stackOnReturn"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/stackOnReturn"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("elvis.kt") @@ -3968,7 +3969,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInSuspend() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("capturedVariables.kt") @@ -4130,7 +4131,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("isAsReified.kt") @@ -4168,7 +4169,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInDefaultParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/defaultParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/defaultParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("defaultValueCrossinline.kt") @@ -4201,7 +4202,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInInlineClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/inlineClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/inlineClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("returnUnboxedDirect.kt") @@ -4224,7 +4225,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInInlineUsedAsNoinline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/inlineUsedAsNoinline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/inlineUsedAsNoinline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inlineOnly.kt") @@ -4257,7 +4258,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInReceiver() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/receiver"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/receiver"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inlineOrdinaryOfCrossinlineSuspend.kt") @@ -4310,7 +4311,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInStateMachine() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/stateMachine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/stateMachine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("crossingCoroutineBoundaries.kt") @@ -4434,7 +4435,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInSyntheticAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/syntheticAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/syntheticAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("constField.kt") @@ -4486,7 +4487,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInWithinInlineLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("directFieldAccess.kt") @@ -4545,7 +4546,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInTrait() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/trait"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/trait"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("trait.kt") @@ -4563,7 +4564,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInTryCatchFinally() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/tryCatchFinally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/tryCatchFinally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt5863.kt") @@ -4596,7 +4597,7 @@ public class IrCompileKotlinAgainstInlineKotlinTestGenerated extends AbstractIrC } public void testAllFilesPresentInVarargs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/varargs"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/varargs"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kt17653.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrCompileKotlinAgainstKotlinTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrCompileKotlinAgainstKotlinTestGenerated.java index b3b619d0713..3d7413eae47 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrCompileKotlinAgainstKotlinTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrCompileKotlinAgainstKotlinTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.codegen.ir; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class IrCompileKotlinAgainstKotlinTestGenerated extends AbstractIrCompile } public void testAllFilesPresentInCompileKotlinAgainstKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("annotationInInterface.kt") @@ -423,7 +424,7 @@ public class IrCompileKotlinAgainstKotlinTestGenerated extends AbstractIrCompile } public void testAllFilesPresentInFir() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/fir"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/fir"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("AnonymousObjectInProperty.kt") @@ -461,7 +462,7 @@ public class IrCompileKotlinAgainstKotlinTestGenerated extends AbstractIrCompile } public void testAllFilesPresentInJvm8() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults") @@ -473,7 +474,7 @@ public class IrCompileKotlinAgainstKotlinTestGenerated extends AbstractIrCompile } public void testAllFilesPresentInDefaults() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("superCall.kt") @@ -515,7 +516,7 @@ public class IrCompileKotlinAgainstKotlinTestGenerated extends AbstractIrCompile } public void testAllFilesPresentInAllCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("callStackTrace.kt") @@ -562,7 +563,7 @@ public class IrCompileKotlinAgainstKotlinTestGenerated extends AbstractIrCompile } public void testAllFilesPresentInDelegationBy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("simple.kt") @@ -586,7 +587,7 @@ public class IrCompileKotlinAgainstKotlinTestGenerated extends AbstractIrCompile } public void testAllFilesPresentInInterop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/interop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/interop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("likeMemberClash.kt") @@ -635,7 +636,7 @@ public class IrCompileKotlinAgainstKotlinTestGenerated extends AbstractIrCompile } public void testAllFilesPresentInJvm8against6() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/jvm8against6"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/jvm8against6"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("jdk8Against6.kt") @@ -677,7 +678,7 @@ public class IrCompileKotlinAgainstKotlinTestGenerated extends AbstractIrCompile } public void testAllFilesPresentInDelegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/jvm8against6/delegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/jvm8against6/delegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("diamond.kt") @@ -707,7 +708,7 @@ public class IrCompileKotlinAgainstKotlinTestGenerated extends AbstractIrCompile } public void testAllFilesPresentInTypeAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/typeAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/typeAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("implicitReturn.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrScriptCodegenTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrScriptCodegenTestGenerated.java index 005803d5dd9..80ff124624b 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrScriptCodegenTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrScriptCodegenTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.codegen.ir; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -31,7 +32,7 @@ public class IrScriptCodegenTestGenerated extends AbstractIrScriptCodegenTest { } public void testAllFilesPresentInScript() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/script"), Pattern.compile("^(.+)\\.kts$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/script"), Pattern.compile("^(.+)\\.kts$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("classLiteralInsideFunction.kts") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrWriteFlagsTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrWriteFlagsTestGenerated.java index 12f8f98ce30..2b2414195de 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrWriteFlagsTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrWriteFlagsTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.codegen.ir; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class IrWriteFlagsTestGenerated extends AbstractIrWriteFlagsTest { } public void testAllFilesPresentInWriteFlags() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("protectedAccessToBaseMethod.kt") @@ -48,7 +49,7 @@ public class IrWriteFlagsTestGenerated extends AbstractIrWriteFlagsTest { } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/writeFlags/callableReference/flags") @@ -60,7 +61,7 @@ public class IrWriteFlagsTestGenerated extends AbstractIrWriteFlagsTest { } public void testAllFilesPresentInFlags() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/callableReference/flags"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/callableReference/flags"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("functionReference.kt") @@ -94,7 +95,7 @@ public class IrWriteFlagsTestGenerated extends AbstractIrWriteFlagsTest { } public void testAllFilesPresentInClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/class"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/class"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/writeFlags/class/accessFlags") @@ -106,7 +107,7 @@ public class IrWriteFlagsTestGenerated extends AbstractIrWriteFlagsTest { } public void testAllFilesPresentInAccessFlags() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/class/accessFlags"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/class/accessFlags"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("defaultImpls.kt") @@ -169,7 +170,7 @@ public class IrWriteFlagsTestGenerated extends AbstractIrWriteFlagsTest { } public void testAllFilesPresentInDeprecatedFlag() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/class/deprecatedFlag"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/class/deprecatedFlag"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("class.kt") @@ -207,7 +208,7 @@ public class IrWriteFlagsTestGenerated extends AbstractIrWriteFlagsTest { } public void testAllFilesPresentInVisibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/class/visibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/class/visibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/writeFlags/class/visibility/internal") @@ -219,7 +220,7 @@ public class IrWriteFlagsTestGenerated extends AbstractIrWriteFlagsTest { } public void testAllFilesPresentInInternal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/class/visibility/internal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/class/visibility/internal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("class.kt") @@ -272,7 +273,7 @@ public class IrWriteFlagsTestGenerated extends AbstractIrWriteFlagsTest { } public void testAllFilesPresentInPackageprivate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/class/visibility/packageprivate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/class/visibility/packageprivate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("enumEntry.kt") @@ -290,7 +291,7 @@ public class IrWriteFlagsTestGenerated extends AbstractIrWriteFlagsTest { } public void testAllFilesPresentInPrivate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/class/visibility/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/class/visibility/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("class.kt") @@ -343,7 +344,7 @@ public class IrWriteFlagsTestGenerated extends AbstractIrWriteFlagsTest { } public void testAllFilesPresentInPublic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/class/visibility/public"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/class/visibility/public"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("class.kt") @@ -398,7 +399,7 @@ public class IrWriteFlagsTestGenerated extends AbstractIrWriteFlagsTest { } public void testAllFilesPresentInDelegatedProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/delegatedProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/delegatedProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/writeFlags/delegatedProperty/visibility") @@ -410,7 +411,7 @@ public class IrWriteFlagsTestGenerated extends AbstractIrWriteFlagsTest { } public void testAllFilesPresentInVisibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/delegatedProperty/visibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/delegatedProperty/visibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("privateSet.kt") @@ -429,7 +430,7 @@ public class IrWriteFlagsTestGenerated extends AbstractIrWriteFlagsTest { } public void testAllFilesPresentInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/function"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/function"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/writeFlags/function/classObjectPrivate") @@ -441,7 +442,7 @@ public class IrWriteFlagsTestGenerated extends AbstractIrWriteFlagsTest { } public void testAllFilesPresentInClassObjectPrivate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/function/classObjectPrivate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/function/classObjectPrivate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("privateFun.kt") @@ -469,7 +470,7 @@ public class IrWriteFlagsTestGenerated extends AbstractIrWriteFlagsTest { } public void testAllFilesPresentInConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/function/constructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/function/constructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("classObject.kt") @@ -517,7 +518,7 @@ public class IrWriteFlagsTestGenerated extends AbstractIrWriteFlagsTest { } public void testAllFilesPresentInDeprecatedFlag() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/function/deprecatedFlag"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/function/deprecatedFlag"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("deprecatedSinceKotlin.kt") @@ -595,7 +596,7 @@ public class IrWriteFlagsTestGenerated extends AbstractIrWriteFlagsTest { } public void testAllFilesPresentInWithDefaultArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/function/withDefaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/function/withDefaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("funInClass.kt") @@ -634,7 +635,7 @@ public class IrWriteFlagsTestGenerated extends AbstractIrWriteFlagsTest { } public void testAllFilesPresentInHidden() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/hidden"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/hidden"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("function.kt") @@ -662,7 +663,7 @@ public class IrWriteFlagsTestGenerated extends AbstractIrWriteFlagsTest { } public void testAllFilesPresentInInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/inline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/inline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inlineOnly.kt") @@ -695,7 +696,7 @@ public class IrWriteFlagsTestGenerated extends AbstractIrWriteFlagsTest { } public void testAllFilesPresentInInnerClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/innerClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/innerClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/writeFlags/innerClass/visibility") @@ -707,7 +708,7 @@ public class IrWriteFlagsTestGenerated extends AbstractIrWriteFlagsTest { } public void testAllFilesPresentInVisibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/innerClass/visibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/innerClass/visibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("internal.kt") @@ -751,7 +752,7 @@ public class IrWriteFlagsTestGenerated extends AbstractIrWriteFlagsTest { } public void testAllFilesPresentInJvm8() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/jvm8"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/jvm8"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("interfaceMethod.kt") @@ -773,7 +774,7 @@ public class IrWriteFlagsTestGenerated extends AbstractIrWriteFlagsTest { } public void testAllFilesPresentInDefaults() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/jvm8/defaults"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/jvm8/defaults"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("defaultMethod.kt") @@ -810,7 +811,7 @@ public class IrWriteFlagsTestGenerated extends AbstractIrWriteFlagsTest { } public void testAllFilesPresentInCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/jvm8/defaults/compatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/jvm8/defaults/compatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("defaultImplementations.kt") @@ -840,7 +841,7 @@ public class IrWriteFlagsTestGenerated extends AbstractIrWriteFlagsTest { } public void testAllFilesPresentInJvmOverloads() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/jvmOverloads"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/jvmOverloads"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("openFunction.kt") @@ -863,7 +864,7 @@ public class IrWriteFlagsTestGenerated extends AbstractIrWriteFlagsTest { } public void testAllFilesPresentInLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/lambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/lambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("lambdaInInlineFunction.kt") @@ -886,7 +887,7 @@ public class IrWriteFlagsTestGenerated extends AbstractIrWriteFlagsTest { } public void testAllFilesPresentInLateinit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/lateinit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/lateinit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("lateinitGetter.kt") @@ -914,7 +915,7 @@ public class IrWriteFlagsTestGenerated extends AbstractIrWriteFlagsTest { } public void testAllFilesPresentInProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("enumFields.kt") @@ -931,7 +932,7 @@ public class IrWriteFlagsTestGenerated extends AbstractIrWriteFlagsTest { } public void testAllFilesPresentInClassObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/property/classObject"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/property/classObject"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/writeFlags/property/classObject/class") @@ -943,7 +944,7 @@ public class IrWriteFlagsTestGenerated extends AbstractIrWriteFlagsTest { } public void testAllFilesPresentInClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/property/classObject/class"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/property/classObject/class"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("delegatedProtectedVar.kt") @@ -1041,7 +1042,7 @@ public class IrWriteFlagsTestGenerated extends AbstractIrWriteFlagsTest { } public void testAllFilesPresentInRename() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/property/classObject/rename"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/property/classObject/rename"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("constructorAndClassObject.kt") @@ -1074,7 +1075,7 @@ public class IrWriteFlagsTestGenerated extends AbstractIrWriteFlagsTest { } public void testAllFilesPresentInTrait() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/property/classObject/trait"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/property/classObject/trait"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("delegatedProtectedVar.kt") @@ -1193,7 +1194,7 @@ public class IrWriteFlagsTestGenerated extends AbstractIrWriteFlagsTest { } public void testAllFilesPresentInDeprecatedFlag() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/property/deprecatedFlag"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/property/deprecatedFlag"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("propertyInClass.kt") @@ -1216,7 +1217,7 @@ public class IrWriteFlagsTestGenerated extends AbstractIrWriteFlagsTest { } public void testAllFilesPresentInSyntheticAnnotationsMethod() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/property/syntheticAnnotationsMethod"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/property/syntheticAnnotationsMethod"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("doNotUseGetterName.kt") @@ -1254,7 +1255,7 @@ public class IrWriteFlagsTestGenerated extends AbstractIrWriteFlagsTest { } public void testAllFilesPresentInVisibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/property/visibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/property/visibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("internal.kt") @@ -1283,7 +1284,7 @@ public class IrWriteFlagsTestGenerated extends AbstractIrWriteFlagsTest { } public void testAllFilesPresentInTypealias() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/typealias"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/typealias"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/writeFlags/typealias/syntheticAnnotationsMethod") @@ -1295,7 +1296,7 @@ public class IrWriteFlagsTestGenerated extends AbstractIrWriteFlagsTest { } public void testAllFilesPresentInSyntheticAnnotationsMethod() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/typealias/syntheticAnnotationsMethod"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeFlags/typealias/syntheticAnnotationsMethod"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("privateTypealias.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrWriteSignatureTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrWriteSignatureTestGenerated.java index f1b6594828f..e144435e5b0 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrWriteSignatureTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrWriteSignatureTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.codegen.ir; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class IrWriteSignatureTestGenerated extends AbstractIrWriteSignatureTest } public void testAllFilesPresentInWriteSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("ArrayOfCharSequence.kt") @@ -148,7 +149,7 @@ public class IrWriteSignatureTestGenerated extends AbstractIrWriteSignatureTest } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature/annotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature/annotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("kArrayClassOfJClass.kt") @@ -186,7 +187,7 @@ public class IrWriteSignatureTestGenerated extends AbstractIrWriteSignatureTest } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("constructorReferenceInReturnType.kt") @@ -219,7 +220,7 @@ public class IrWriteSignatureTestGenerated extends AbstractIrWriteSignatureTest } public void testAllFilesPresentInConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature/constructor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature/constructor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("Constructor0.kt") @@ -252,7 +253,7 @@ public class IrWriteSignatureTestGenerated extends AbstractIrWriteSignatureTest } public void testAllFilesPresentInDeclarationSiteVariance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature/declarationSiteVariance"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature/declarationSiteVariance"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("FunctionTwoTypeParameters.kt") @@ -399,7 +400,7 @@ public class IrWriteSignatureTestGenerated extends AbstractIrWriteSignatureTest } public void testAllFilesPresentInJvmWildcardAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature/declarationSiteVariance/jvmWildcardAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature/declarationSiteVariance/jvmWildcardAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("onFunction.kt") @@ -427,7 +428,7 @@ public class IrWriteSignatureTestGenerated extends AbstractIrWriteSignatureTest } public void testAllFilesPresentInWildcardOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("argumentOverridability.kt") @@ -496,7 +497,7 @@ public class IrWriteSignatureTestGenerated extends AbstractIrWriteSignatureTest } public void testAllFilesPresentInDefaultImpls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature/defaultImpls"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature/defaultImpls"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("functionTypeParameterClash.kt") @@ -524,7 +525,7 @@ public class IrWriteSignatureTestGenerated extends AbstractIrWriteSignatureTest } public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("basicInlineClassDeclarationCodegen.kt") @@ -587,7 +588,7 @@ public class IrWriteSignatureTestGenerated extends AbstractIrWriteSignatureTest } public void testAllFilesPresentInJava8() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature/java8"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature/java8"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("mutableMapRemove.kt") @@ -605,7 +606,7 @@ public class IrWriteSignatureTestGenerated extends AbstractIrWriteSignatureTest } public void testAllFilesPresentInNothing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature/nothing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature/nothing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("nothing.kt") @@ -628,7 +629,7 @@ public class IrWriteSignatureTestGenerated extends AbstractIrWriteSignatureTest } public void testAllFilesPresentInParameterlessMain() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature/parameterlessMain"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature/parameterlessMain"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("arrayWithContravariantStringIsNotMainMethod.kt") @@ -666,7 +667,7 @@ public class IrWriteSignatureTestGenerated extends AbstractIrWriteSignatureTest } public void testAllFilesPresentInSuspendMain() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature/suspendMain"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature/suspendMain"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("parameterlessSuspendMain.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/JvmIrAgainstOldBoxInlineTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/JvmIrAgainstOldBoxInlineTestGenerated.java index 80f53c21a77..90ff76677be 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/JvmIrAgainstOldBoxInlineTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/JvmIrAgainstOldBoxInlineTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.codegen.ir; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInBoxInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("compiler/testData/codegen/boxInline/anonymousObject") @@ -38,7 +39,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInAnonymousObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("anonymousObjectInDefault.kt") @@ -340,7 +341,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInEnumWhen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/enumWhen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/enumWhen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("callSite.kt") @@ -373,7 +374,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInProperRecapturing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("inlineChain.kt") @@ -416,7 +417,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInProperRecapturingInClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("inlineChain.kt") @@ -489,7 +490,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInSam() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("anonymousObjectToSam.kt") @@ -537,7 +538,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInTwoCapturedReceivers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("kt8668.kt") @@ -576,7 +577,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInArgumentOrder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/argumentOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/argumentOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("boundFunctionReference.kt") @@ -659,7 +660,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInArrayConvention() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/arrayConvention"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/arrayConvention"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("simpleAccess.kt") @@ -702,7 +703,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInAssert() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/assert"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/assert"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("jvmAssertInlineFunctionAssertionsDisabled.kt") @@ -775,7 +776,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInBuilders() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/builders"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/builders"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("builders.kt") @@ -798,7 +799,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInBytecodePreprocessing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/bytecodePreprocessing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/bytecodePreprocessing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("apiVersionAtLeast1.kt") @@ -821,7 +822,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("classLevel.kt") @@ -908,7 +909,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInBound() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("classProperty.kt") @@ -1042,7 +1043,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInCapture() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/capture"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/capture"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("captureInlinable.kt") @@ -1085,7 +1086,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInComplex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/complex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/complex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("closureChain.kt") @@ -1133,7 +1134,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInComplexStack() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/complexStack"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/complexStack"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("asCheck.kt") @@ -1191,7 +1192,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInContracts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/contracts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/contracts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("cfgDependendValInitialization.kt") @@ -1289,7 +1290,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInDefaultValues() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("defaultInExtension.kt") @@ -1391,7 +1392,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInLambdaInlining() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("checkLambdaClassIsPresent.kt") @@ -1563,7 +1564,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInCallableReferences() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("boundFunctionReference.kt") @@ -1697,7 +1698,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInMaskElimination() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/maskElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/maskElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("kt18792.kt") @@ -1736,7 +1737,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInDelegatedProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/delegatedProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/delegatedProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("kt16864.kt") @@ -1774,7 +1775,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInEnclosingInfo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/enclosingInfo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/enclosingInfo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("anonymousInLambda.kt") @@ -1822,7 +1823,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("kt10569.kt") @@ -1900,7 +1901,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInFunctionExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/functionExpression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/functionExpression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("extension.kt") @@ -1918,7 +1919,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("inlineClassWithInlineValReturningInlineClass.kt") @@ -1970,7 +1971,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInUnboxGenericParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/funInterface") @@ -1982,7 +1983,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInFunInterface() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("any.kt") @@ -2025,7 +2026,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/lambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/lambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("any.kt") @@ -2068,7 +2069,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInObjectLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/objectLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/objectLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("any.kt") @@ -2113,7 +2114,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInInnerClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/innerClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/innerClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("captureThisAndOuter.kt") @@ -2141,7 +2142,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInJvmPackageName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/jvmPackageName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/jvmPackageName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("simple.kt") @@ -2159,7 +2160,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInLambdaClassClash() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/lambdaClassClash"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/lambdaClassClash"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("lambdaClassClash.kt") @@ -2182,7 +2183,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInLambdaTransformation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/lambdaTransformation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/lambdaTransformation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("lambdaCloning.kt") @@ -2225,7 +2226,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInLocalFunInLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/localFunInLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/localFunInLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("defaultParam.kt") @@ -2258,7 +2259,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInMultiModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("tryCatchWithRecursiveInline.kt") @@ -2276,7 +2277,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInMultifileClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("defaultArguments.kt") @@ -2304,7 +2305,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInMultiplatform() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("compiler/testData/codegen/boxInline/multiplatform/defaultArguments") @@ -2316,7 +2317,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInDefaultArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiplatform/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiplatform/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("receiversAndParametersInLambda.kt") @@ -2335,7 +2336,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInNoInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/noInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/noInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("extensionReceiver.kt") @@ -2383,7 +2384,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInNonLocalReturns() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("explicitLocalReturn.kt") @@ -2465,7 +2466,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInDeparenthesize() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/deparenthesize"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/deparenthesize"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("bracket.kt") @@ -2488,7 +2489,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInTryFinally() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("kt16417.kt") @@ -2565,7 +2566,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInCallSite() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("callSite.kt") @@ -2608,7 +2609,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInChained() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("finallyInFinally.kt") @@ -2661,7 +2662,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInDeclSite() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("complex.kt") @@ -2734,7 +2735,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInExceptionTable() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("break.kt") @@ -2852,7 +2853,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInVariables() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/variables"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/variables"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("kt7792.kt") @@ -2872,7 +2873,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInOptimizations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("kt20844.kt") @@ -2905,7 +2906,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInPrivate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("effectivePrivate.kt") @@ -2963,7 +2964,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("augAssignmentAndInc.kt") @@ -3041,7 +3042,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInReified() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("arrayConstructor.kt") @@ -3158,7 +3159,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInCheckCast() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/checkCast"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/checkCast"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("chain.kt") @@ -3221,7 +3222,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInDefaultLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/defaultLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/defaultLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("chain.kt") @@ -3274,7 +3275,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInIsCheck() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/isCheck"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/isCheck"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("chain.kt") @@ -3303,7 +3304,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/signature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/signature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("inProjectionSubstitution.kt") @@ -3361,7 +3362,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInSimple() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/simple"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/simple"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("captureAndArgumentIncompatibleTypes.kt") @@ -3494,7 +3495,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInSmap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("assertion.kt") @@ -3596,7 +3597,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInAnonymous() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/anonymous"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/anonymous"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("kt19175.kt") @@ -3659,7 +3660,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInDefaultLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/defaultLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/defaultLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("defaultLambdaInAnonymous.kt") @@ -3717,7 +3718,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInInlineOnly() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/inlineOnly"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/inlineOnly"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("noSmap.kt") @@ -3760,7 +3761,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInNewsmap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/newsmap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/newsmap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("differentMapping.kt") @@ -3793,7 +3794,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInResolve() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/resolve"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/resolve"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("inlineComponent.kt") @@ -3817,7 +3818,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInSpecial() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/special"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/special"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("identityCheck.kt") @@ -3875,7 +3876,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInStackOnReturn() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/stackOnReturn"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/stackOnReturn"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("elvis.kt") @@ -3968,7 +3969,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInSuspend() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("capturedVariables.kt") @@ -4130,7 +4131,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("isAsReified.kt") @@ -4168,7 +4169,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInDefaultParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/defaultParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/defaultParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("defaultValueCrossinline.kt") @@ -4201,7 +4202,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInInlineClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/inlineClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/inlineClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("returnUnboxedDirect.kt") @@ -4224,7 +4225,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInInlineUsedAsNoinline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/inlineUsedAsNoinline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/inlineUsedAsNoinline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("inlineOnly.kt") @@ -4257,7 +4258,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInReceiver() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/receiver"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/receiver"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("inlineOrdinaryOfCrossinlineSuspend.kt") @@ -4310,7 +4311,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInStateMachine() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/stateMachine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/stateMachine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("crossingCoroutineBoundaries.kt") @@ -4434,7 +4435,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInSyntheticAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/syntheticAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/syntheticAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("constField.kt") @@ -4486,7 +4487,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInWithinInlineLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("directFieldAccess.kt") @@ -4545,7 +4546,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInTrait() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/trait"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/trait"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("trait.kt") @@ -4563,7 +4564,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInTryCatchFinally() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/tryCatchFinally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/tryCatchFinally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("kt5863.kt") @@ -4596,7 +4597,7 @@ public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstO } public void testAllFilesPresentInVarargs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/varargs"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/varargs"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("kt17653.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/JvmIrAgainstOldBoxTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/JvmIrAgainstOldBoxTestGenerated.java index 5005fea3504..882afcb2b15 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/JvmIrAgainstOldBoxTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/JvmIrAgainstOldBoxTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.codegen.ir; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class JvmIrAgainstOldBoxTestGenerated extends AbstractJvmIrAgainstOldBoxT } public void testAllFilesPresentInCompileKotlinAgainstKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("annotationInInterface.kt") @@ -423,7 +424,7 @@ public class JvmIrAgainstOldBoxTestGenerated extends AbstractJvmIrAgainstOldBoxT } public void testAllFilesPresentInFir() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/fir"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/fir"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("AnonymousObjectInProperty.kt") @@ -461,7 +462,7 @@ public class JvmIrAgainstOldBoxTestGenerated extends AbstractJvmIrAgainstOldBoxT } public void testAllFilesPresentInJvm8() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults") @@ -473,7 +474,7 @@ public class JvmIrAgainstOldBoxTestGenerated extends AbstractJvmIrAgainstOldBoxT } public void testAllFilesPresentInDefaults() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("superCall.kt") @@ -515,7 +516,7 @@ public class JvmIrAgainstOldBoxTestGenerated extends AbstractJvmIrAgainstOldBoxT } public void testAllFilesPresentInAllCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("callStackTrace.kt") @@ -562,7 +563,7 @@ public class JvmIrAgainstOldBoxTestGenerated extends AbstractJvmIrAgainstOldBoxT } public void testAllFilesPresentInDelegationBy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("simple.kt") @@ -586,7 +587,7 @@ public class JvmIrAgainstOldBoxTestGenerated extends AbstractJvmIrAgainstOldBoxT } public void testAllFilesPresentInInterop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/interop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/interop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("likeMemberClash.kt") @@ -635,7 +636,7 @@ public class JvmIrAgainstOldBoxTestGenerated extends AbstractJvmIrAgainstOldBoxT } public void testAllFilesPresentInJvm8against6() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/jvm8against6"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/jvm8against6"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("jdk8Against6.kt") @@ -677,7 +678,7 @@ public class JvmIrAgainstOldBoxTestGenerated extends AbstractJvmIrAgainstOldBoxT } public void testAllFilesPresentInDelegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/jvm8against6/delegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/jvm8against6/delegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("diamond.kt") @@ -707,7 +708,7 @@ public class JvmIrAgainstOldBoxTestGenerated extends AbstractJvmIrAgainstOldBoxT } public void testAllFilesPresentInTypeAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/typeAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/typeAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); } @TestMetadata("implicitReturn.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/JvmOldAgainstIrBoxInlineTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/JvmOldAgainstIrBoxInlineTestGenerated.java index 6adf46a8b9e..6eeb161ffee 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/JvmOldAgainstIrBoxInlineTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/JvmOldAgainstIrBoxInlineTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.codegen.ir; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInBoxInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("compiler/testData/codegen/boxInline/anonymousObject") @@ -38,7 +39,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInAnonymousObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("anonymousObjectInDefault.kt") @@ -340,7 +341,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInEnumWhen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/enumWhen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/enumWhen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("callSite.kt") @@ -373,7 +374,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInProperRecapturing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("inlineChain.kt") @@ -416,7 +417,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInProperRecapturingInClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("inlineChain.kt") @@ -489,7 +490,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInSam() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("anonymousObjectToSam.kt") @@ -537,7 +538,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInTwoCapturedReceivers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("kt8668.kt") @@ -576,7 +577,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInArgumentOrder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/argumentOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/argumentOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("boundFunctionReference.kt") @@ -659,7 +660,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInArrayConvention() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/arrayConvention"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/arrayConvention"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("simpleAccess.kt") @@ -702,7 +703,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInAssert() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/assert"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/assert"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("jvmAssertInlineFunctionAssertionsDisabled.kt") @@ -775,7 +776,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInBuilders() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/builders"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/builders"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("builders.kt") @@ -798,7 +799,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInBytecodePreprocessing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/bytecodePreprocessing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/bytecodePreprocessing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("apiVersionAtLeast1.kt") @@ -821,7 +822,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("classLevel.kt") @@ -908,7 +909,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInBound() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("classProperty.kt") @@ -1042,7 +1043,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInCapture() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/capture"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/capture"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("captureInlinable.kt") @@ -1085,7 +1086,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInComplex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/complex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/complex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("closureChain.kt") @@ -1133,7 +1134,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInComplexStack() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/complexStack"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/complexStack"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("asCheck.kt") @@ -1191,7 +1192,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInContracts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/contracts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/contracts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("cfgDependendValInitialization.kt") @@ -1289,7 +1290,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInDefaultValues() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("defaultInExtension.kt") @@ -1391,7 +1392,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInLambdaInlining() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("checkLambdaClassIsPresent.kt") @@ -1563,7 +1564,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInCallableReferences() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("boundFunctionReference.kt") @@ -1697,7 +1698,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInMaskElimination() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/maskElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/maskElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("kt18792.kt") @@ -1736,7 +1737,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInDelegatedProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/delegatedProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/delegatedProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("kt16864.kt") @@ -1774,7 +1775,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInEnclosingInfo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/enclosingInfo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/enclosingInfo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("anonymousInLambda.kt") @@ -1822,7 +1823,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("kt10569.kt") @@ -1900,7 +1901,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInFunctionExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/functionExpression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/functionExpression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("extension.kt") @@ -1918,7 +1919,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("inlineClassWithInlineValReturningInlineClass.kt") @@ -1970,7 +1971,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInUnboxGenericParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/funInterface") @@ -1982,7 +1983,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInFunInterface() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("any.kt") @@ -2025,7 +2026,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/lambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/lambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("any.kt") @@ -2068,7 +2069,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInObjectLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/objectLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/objectLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("any.kt") @@ -2113,7 +2114,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInInnerClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/innerClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/innerClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("captureThisAndOuter.kt") @@ -2141,7 +2142,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInJvmPackageName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/jvmPackageName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/jvmPackageName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("simple.kt") @@ -2159,7 +2160,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInLambdaClassClash() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/lambdaClassClash"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/lambdaClassClash"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("lambdaClassClash.kt") @@ -2182,7 +2183,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInLambdaTransformation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/lambdaTransformation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/lambdaTransformation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("lambdaCloning.kt") @@ -2225,7 +2226,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInLocalFunInLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/localFunInLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/localFunInLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("defaultParam.kt") @@ -2258,7 +2259,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInMultiModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("tryCatchWithRecursiveInline.kt") @@ -2276,7 +2277,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInMultifileClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("defaultArguments.kt") @@ -2304,7 +2305,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInMultiplatform() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("compiler/testData/codegen/boxInline/multiplatform/defaultArguments") @@ -2316,7 +2317,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInDefaultArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiplatform/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiplatform/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("receiversAndParametersInLambda.kt") @@ -2335,7 +2336,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInNoInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/noInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/noInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("extensionReceiver.kt") @@ -2383,7 +2384,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInNonLocalReturns() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("explicitLocalReturn.kt") @@ -2465,7 +2466,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInDeparenthesize() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/deparenthesize"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/deparenthesize"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("bracket.kt") @@ -2488,7 +2489,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInTryFinally() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("kt16417.kt") @@ -2565,7 +2566,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInCallSite() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("callSite.kt") @@ -2608,7 +2609,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInChained() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("finallyInFinally.kt") @@ -2661,7 +2662,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInDeclSite() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("complex.kt") @@ -2734,7 +2735,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInExceptionTable() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("break.kt") @@ -2852,7 +2853,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInVariables() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/variables"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/variables"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("kt7792.kt") @@ -2872,7 +2873,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInOptimizations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("kt20844.kt") @@ -2905,7 +2906,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInPrivate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("effectivePrivate.kt") @@ -2963,7 +2964,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("augAssignmentAndInc.kt") @@ -3041,7 +3042,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInReified() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("arrayConstructor.kt") @@ -3158,7 +3159,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInCheckCast() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/checkCast"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/checkCast"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("chain.kt") @@ -3221,7 +3222,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInDefaultLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/defaultLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/defaultLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("chain.kt") @@ -3274,7 +3275,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInIsCheck() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/isCheck"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/isCheck"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("chain.kt") @@ -3303,7 +3304,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/signature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/signature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("inProjectionSubstitution.kt") @@ -3361,7 +3362,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInSimple() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/simple"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/simple"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("captureAndArgumentIncompatibleTypes.kt") @@ -3494,7 +3495,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInSmap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("assertion.kt") @@ -3596,7 +3597,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInAnonymous() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/anonymous"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/anonymous"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("kt19175.kt") @@ -3659,7 +3660,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInDefaultLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/defaultLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/defaultLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("defaultLambdaInAnonymous.kt") @@ -3717,7 +3718,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInInlineOnly() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/inlineOnly"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/inlineOnly"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("noSmap.kt") @@ -3760,7 +3761,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInNewsmap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/newsmap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/newsmap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("differentMapping.kt") @@ -3793,7 +3794,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInResolve() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/resolve"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/resolve"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("inlineComponent.kt") @@ -3817,7 +3818,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInSpecial() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/special"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/special"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("identityCheck.kt") @@ -3875,7 +3876,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInStackOnReturn() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/stackOnReturn"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/stackOnReturn"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("elvis.kt") @@ -3968,7 +3969,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInSuspend() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("capturedVariables.kt") @@ -4130,7 +4131,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("isAsReified.kt") @@ -4168,7 +4169,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInDefaultParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/defaultParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/defaultParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("defaultValueCrossinline.kt") @@ -4201,7 +4202,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInInlineClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/inlineClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/inlineClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("returnUnboxedDirect.kt") @@ -4224,7 +4225,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInInlineUsedAsNoinline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/inlineUsedAsNoinline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/inlineUsedAsNoinline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("inlineOnly.kt") @@ -4257,7 +4258,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInReceiver() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/receiver"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/receiver"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("inlineOrdinaryOfCrossinlineSuspend.kt") @@ -4310,7 +4311,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInStateMachine() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/stateMachine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/stateMachine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("crossingCoroutineBoundaries.kt") @@ -4434,7 +4435,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInSyntheticAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/syntheticAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/syntheticAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("constField.kt") @@ -4486,7 +4487,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInWithinInlineLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("directFieldAccess.kt") @@ -4545,7 +4546,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInTrait() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/trait"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/trait"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("trait.kt") @@ -4563,7 +4564,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInTryCatchFinally() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/tryCatchFinally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/tryCatchFinally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("kt5863.kt") @@ -4596,7 +4597,7 @@ public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainst } public void testAllFilesPresentInVarargs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/varargs"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/varargs"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("kt17653.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/JvmOldAgainstIrBoxTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/JvmOldAgainstIrBoxTestGenerated.java index 4d326471d3c..2397bb77079 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/JvmOldAgainstIrBoxTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/JvmOldAgainstIrBoxTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.codegen.ir; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class JvmOldAgainstIrBoxTestGenerated extends AbstractJvmOldAgainstIrBoxT } public void testAllFilesPresentInCompileKotlinAgainstKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("annotationInInterface.kt") @@ -423,7 +424,7 @@ public class JvmOldAgainstIrBoxTestGenerated extends AbstractJvmOldAgainstIrBoxT } public void testAllFilesPresentInFir() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/fir"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/fir"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("AnonymousObjectInProperty.kt") @@ -461,7 +462,7 @@ public class JvmOldAgainstIrBoxTestGenerated extends AbstractJvmOldAgainstIrBoxT } public void testAllFilesPresentInJvm8() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults") @@ -473,7 +474,7 @@ public class JvmOldAgainstIrBoxTestGenerated extends AbstractJvmOldAgainstIrBoxT } public void testAllFilesPresentInDefaults() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("superCall.kt") @@ -515,7 +516,7 @@ public class JvmOldAgainstIrBoxTestGenerated extends AbstractJvmOldAgainstIrBoxT } public void testAllFilesPresentInAllCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("callStackTrace.kt") @@ -562,7 +563,7 @@ public class JvmOldAgainstIrBoxTestGenerated extends AbstractJvmOldAgainstIrBoxT } public void testAllFilesPresentInDelegationBy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("simple.kt") @@ -586,7 +587,7 @@ public class JvmOldAgainstIrBoxTestGenerated extends AbstractJvmOldAgainstIrBoxT } public void testAllFilesPresentInInterop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/interop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/interop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("likeMemberClash.kt") @@ -635,7 +636,7 @@ public class JvmOldAgainstIrBoxTestGenerated extends AbstractJvmOldAgainstIrBoxT } public void testAllFilesPresentInJvm8against6() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/jvm8against6"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/jvm8against6"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("jdk8Against6.kt") @@ -677,7 +678,7 @@ public class JvmOldAgainstIrBoxTestGenerated extends AbstractJvmOldAgainstIrBoxT } public void testAllFilesPresentInDelegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/jvm8against6/delegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/jvm8against6/delegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("diamond.kt") @@ -707,7 +708,7 @@ public class JvmOldAgainstIrBoxTestGenerated extends AbstractJvmOldAgainstIrBoxT } public void testAllFilesPresentInTypeAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/typeAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/typeAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); } @TestMetadata("implicitReturn.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/integration/AntTaskTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/integration/AntTaskTestGenerated.java index 4ba52f91cff..269fc75f165 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/integration/AntTaskTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/integration/AntTaskTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.integration; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -30,7 +31,7 @@ public class AntTaskTestGenerated extends AbstractAntTaskTest { } public void testAllFilesPresentInJvm() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/integration/ant/jvm"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/integration/ant/jvm"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("doNotFailOnError") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/ir/IrCfgTestCaseGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/ir/IrCfgTestCaseGenerated.java index 64a8b6d5081..8294fbd927a 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/ir/IrCfgTestCaseGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/ir/IrCfgTestCaseGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.ir; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class IrCfgTestCaseGenerated extends AbstractIrCfgTestCase { } public void testAllFilesPresentInIrCfg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irCfg"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irCfg"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("expressionFun.kt") @@ -67,7 +68,7 @@ public class IrCfgTestCaseGenerated extends AbstractIrCfgTestCase { } public void testAllFilesPresentInLoop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irCfg/loop"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irCfg/loop"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("digitCount.kt") @@ -95,7 +96,7 @@ public class IrCfgTestCaseGenerated extends AbstractIrCfgTestCase { } public void testAllFilesPresentInWhen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irCfg/when"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irCfg/when"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("cascadeIf.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/ir/IrJsTextTestCaseGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/ir/IrJsTextTestCaseGenerated.java index 8d640c5a783..bfab8052f2e 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/ir/IrJsTextTestCaseGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/ir/IrJsTextTestCaseGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.ir; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class IrJsTextTestCaseGenerated extends AbstractIrJsTextTestCase { } public void testAllFilesPresentInIrJsText() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irJsText"), Pattern.compile("^(.+)\\.kt(s)?$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irJsText"), Pattern.compile("^(.+)\\.kt(s)?$"), null, true); } @TestMetadata("compiler/testData/ir/irJsText/dynamic") @@ -37,7 +38,7 @@ public class IrJsTextTestCaseGenerated extends AbstractIrJsTextTestCase { } public void testAllFilesPresentInDynamic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irJsText/dynamic"), Pattern.compile("^(.+)\\.kt(s)?$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irJsText/dynamic"), Pattern.compile("^(.+)\\.kt(s)?$"), null, true); } @TestMetadata("dynamicAndMembersOfAny.kt") @@ -160,7 +161,7 @@ public class IrJsTextTestCaseGenerated extends AbstractIrJsTextTestCase { } public void testAllFilesPresentInExternal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irJsText/external"), Pattern.compile("^(.+)\\.kt(s)?$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irJsText/external"), Pattern.compile("^(.+)\\.kt(s)?$"), null, true); } @TestMetadata("kt38765.kt") @@ -178,7 +179,7 @@ public class IrJsTextTestCaseGenerated extends AbstractIrJsTextTestCase { } public void testAllFilesPresentInNative() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irJsText/native"), Pattern.compile("^(.+)\\.kt(s)?$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irJsText/native"), Pattern.compile("^(.+)\\.kt(s)?$"), null, true); } @TestMetadata("nativeNativeKotlin.kt") @@ -196,7 +197,7 @@ public class IrJsTextTestCaseGenerated extends AbstractIrJsTextTestCase { } public void testAllFilesPresentInScripting() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irJsText/scripting"), Pattern.compile("^(.+)\\.kt(s)?$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irJsText/scripting"), Pattern.compile("^(.+)\\.kt(s)?$"), null, true); } @TestMetadata("arrayAssignment.kts") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/ir/IrSourceRangesTestCaseGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/ir/IrSourceRangesTestCaseGenerated.java index d06b938895d..0aa0e7fed4d 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/ir/IrSourceRangesTestCaseGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/ir/IrSourceRangesTestCaseGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.ir; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class IrSourceRangesTestCaseGenerated extends AbstractIrSourceRangesTestC } public void testAllFilesPresentInSourceRanges() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/sourceRanges"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/sourceRanges"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("augmentedAssignmentWithExpression.kt") @@ -52,7 +53,7 @@ public class IrSourceRangesTestCaseGenerated extends AbstractIrSourceRangesTestC } public void testAllFilesPresentInDeclarations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/sourceRanges/declarations"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/sourceRanges/declarations"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("classFuns.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/ir/IrTextTestCaseGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/ir/IrTextTestCaseGenerated.java index f90fb2e507a..c9d9cac3e7f 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/ir/IrTextTestCaseGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/ir/IrTextTestCaseGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.ir; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class IrTextTestCaseGenerated extends AbstractIrTextTestCase { } public void testAllFilesPresentInIrText() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/testData/ir/irText/classes") @@ -42,7 +43,7 @@ public class IrTextTestCaseGenerated extends AbstractIrTextTestCase { } public void testAllFilesPresentInClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/classes"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/classes"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("annotationClasses.kt") @@ -285,7 +286,7 @@ public class IrTextTestCaseGenerated extends AbstractIrTextTestCase { } public void testAllFilesPresentInDeclarations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/declarations"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/declarations"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("catchParameterInTopLevelProperty.kt") @@ -412,7 +413,7 @@ public class IrTextTestCaseGenerated extends AbstractIrTextTestCase { } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/declarations/annotations"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/declarations/annotations"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("annotationsInAnnotationArguments.kt") @@ -585,7 +586,7 @@ public class IrTextTestCaseGenerated extends AbstractIrTextTestCase { } public void testAllFilesPresentInMultiplatform() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/declarations/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/declarations/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("expectClassInherited.kt") @@ -613,7 +614,7 @@ public class IrTextTestCaseGenerated extends AbstractIrTextTestCase { } public void testAllFilesPresentInParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/declarations/parameters"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/declarations/parameters"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("class.kt") @@ -691,7 +692,7 @@ public class IrTextTestCaseGenerated extends AbstractIrTextTestCase { } public void testAllFilesPresentInProvideDelegate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/declarations/provideDelegate"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/declarations/provideDelegate"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("differentReceivers.kt") @@ -735,7 +736,7 @@ public class IrTextTestCaseGenerated extends AbstractIrTextTestCase { } public void testAllFilesPresentInErrors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/errors"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/errors"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("suppressedNonPublicCall.kt") @@ -758,7 +759,7 @@ public class IrTextTestCaseGenerated extends AbstractIrTextTestCase { } public void testAllFilesPresentInExpressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/expressions"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/expressions"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("argumentMappedWithError.kt") @@ -1480,7 +1481,7 @@ public class IrTextTestCaseGenerated extends AbstractIrTextTestCase { } public void testAllFilesPresentInCallableReferences() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/expressions/callableReferences"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/expressions/callableReferences"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("boundInlineAdaptedReference.kt") @@ -1573,7 +1574,7 @@ public class IrTextTestCaseGenerated extends AbstractIrTextTestCase { } public void testAllFilesPresentInFloatingPointComparisons() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/expressions/floatingPointComparisons"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/expressions/floatingPointComparisons"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("comparableWithDoubleOrFloat.kt") @@ -1641,7 +1642,7 @@ public class IrTextTestCaseGenerated extends AbstractIrTextTestCase { } public void testAllFilesPresentInFunInterface() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/expressions/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/expressions/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("arrayAsVarargAfterSamArgument_fi.kt") @@ -1694,7 +1695,7 @@ public class IrTextTestCaseGenerated extends AbstractIrTextTestCase { } public void testAllFilesPresentInSam() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/expressions/sam"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/expressions/sam"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("arrayAsVarargAfterSamArgument.kt") @@ -1773,7 +1774,7 @@ public class IrTextTestCaseGenerated extends AbstractIrTextTestCase { } public void testAllFilesPresentInFirProblems() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/firProblems"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/firProblems"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("AnnotationInAnnotation.kt") @@ -1891,7 +1892,7 @@ public class IrTextTestCaseGenerated extends AbstractIrTextTestCase { } public void testAllFilesPresentInLambdas() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/lambdas"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/lambdas"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("anonymousFunction.kt") @@ -1944,7 +1945,7 @@ public class IrTextTestCaseGenerated extends AbstractIrTextTestCase { } public void testAllFilesPresentInRegressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/regressions"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/regressions"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("coercionInLoop.kt") @@ -1981,7 +1982,7 @@ public class IrTextTestCaseGenerated extends AbstractIrTextTestCase { } public void testAllFilesPresentInNewInference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/regressions/newInference"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/regressions/newInference"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("fixationOrder1.kt") @@ -2000,7 +2001,7 @@ public class IrTextTestCaseGenerated extends AbstractIrTextTestCase { } public void testAllFilesPresentInSingletons() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/singletons"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/singletons"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("companion.kt") @@ -2028,7 +2029,7 @@ public class IrTextTestCaseGenerated extends AbstractIrTextTestCase { } public void testAllFilesPresentInStubs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/stubs"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/stubs"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("builtinMap.kt") @@ -2111,7 +2112,7 @@ public class IrTextTestCaseGenerated extends AbstractIrTextTestCase { } public void testAllFilesPresentInTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/types"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/types"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("asOnPlatformType.kt") @@ -2233,7 +2234,7 @@ public class IrTextTestCaseGenerated extends AbstractIrTextTestCase { } public void testAllFilesPresentInNullChecks() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/types/nullChecks"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/types/nullChecks"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("enhancedNullability.kt") @@ -2280,7 +2281,7 @@ public class IrTextTestCaseGenerated extends AbstractIrTextTestCase { } public void testAllFilesPresentInNullCheckOnLambdaResult() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/types/nullChecks/nullCheckOnLambdaResult"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/ir/irText/types/nullChecks/nullCheckOnLambdaResult"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("nnStringVsT.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/jvm/compiler/CompileJavaAgainstKotlinTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/jvm/compiler/CompileJavaAgainstKotlinTestGenerated.java index 5f0395cbc8a..9bd19e82015 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/jvm/compiler/CompileJavaAgainstKotlinTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/jvm/compiler/CompileJavaAgainstKotlinTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.jvm.compiler; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -28,7 +29,7 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg } public void testAllFilesPresentInWithoutJavac() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/compileJavaAgainstKotlin/annotation") @@ -40,7 +41,7 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg } public void testAllFilesPresentInAnnotation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/annotation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/annotation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("retention.kt") @@ -58,7 +59,7 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("GenericSignature.kt") @@ -76,7 +77,7 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg } public void testAllFilesPresentInClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/class"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/class"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("ClassObject.kt") @@ -159,7 +160,7 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg } public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("DefaultArgumentInEnumConstructor.kt") @@ -177,7 +178,7 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg } public void testAllFilesPresentInJvmStatic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/jvmStatic"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/jvmStatic"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("simpleCompanionObject.kt") @@ -215,7 +216,7 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg } public void testAllFilesPresentInMethod() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("Any.kt") @@ -347,7 +348,7 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg } public void testAllFilesPresentInPlatformName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/platformName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/platformName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("PlatformName.kt") @@ -365,7 +366,7 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg } public void testAllFilesPresentInPrimitiveOverride() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("ByteOverridesObject.kt") @@ -433,7 +434,7 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg } public void testAllFilesPresentInPrimitiveOverrideWithInlineClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/primitiveOverrideWithInlineClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/primitiveOverrideWithInlineClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("InlineIntOverridesObject.kt") @@ -451,7 +452,7 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg } public void testAllFilesPresentInThrows() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/throws"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/throws"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("ClassMembers.kt") @@ -505,7 +506,7 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg } public void testAllFilesPresentInProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("ConstVal.kt") @@ -532,7 +533,7 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg } public void testAllFilesPresentInPlatformName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/property/platformName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/property/platformName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("PlatformName.kt") @@ -551,7 +552,7 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg } public void testAllFilesPresentInSealed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/sealed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/sealed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("Derived.kt") @@ -574,7 +575,7 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg } public void testAllFilesPresentInStaticFields() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/staticFields"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/staticFields"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("AnnotationClass.kt") @@ -612,7 +613,7 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg } public void testAllFilesPresentInTargets() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/targets"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/targets"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("annotation.kt") @@ -691,7 +692,7 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg } public void testAllFilesPresentInWithJavac() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("compiler/testData/compileJavaAgainstKotlin/annotation") @@ -703,7 +704,7 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg } public void testAllFilesPresentInAnnotation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/annotation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/annotation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("retention.kt") @@ -721,7 +722,7 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("GenericSignature.kt") @@ -739,7 +740,7 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg } public void testAllFilesPresentInClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/class"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/class"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("ClassObject.kt") @@ -822,7 +823,7 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg } public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("DefaultArgumentInEnumConstructor.kt") @@ -840,7 +841,7 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg } public void testAllFilesPresentInJvmStatic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/jvmStatic"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/jvmStatic"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("simpleCompanionObject.kt") @@ -878,7 +879,7 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg } public void testAllFilesPresentInMethod() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("Any.kt") @@ -1010,7 +1011,7 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg } public void testAllFilesPresentInPlatformName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/platformName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/platformName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("PlatformName.kt") @@ -1028,7 +1029,7 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg } public void testAllFilesPresentInPrimitiveOverride() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("ByteOverridesObject.kt") @@ -1096,7 +1097,7 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg } public void testAllFilesPresentInPrimitiveOverrideWithInlineClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/primitiveOverrideWithInlineClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/primitiveOverrideWithInlineClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("InlineIntOverridesObject.kt") @@ -1114,7 +1115,7 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg } public void testAllFilesPresentInThrows() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/throws"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/throws"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("ClassMembers.kt") @@ -1168,7 +1169,7 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg } public void testAllFilesPresentInProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("ConstVal.kt") @@ -1195,7 +1196,7 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg } public void testAllFilesPresentInPlatformName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/property/platformName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/property/platformName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("PlatformName.kt") @@ -1214,7 +1215,7 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg } public void testAllFilesPresentInSealed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/sealed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/sealed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("Derived.kt") @@ -1237,7 +1238,7 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg } public void testAllFilesPresentInStaticFields() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/staticFields"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/staticFields"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("AnnotationClass.kt") @@ -1275,7 +1276,7 @@ public class CompileJavaAgainstKotlinTestGenerated extends AbstractCompileJavaAg } public void testAllFilesPresentInTargets() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/targets"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/targets"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("annotation.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/jvm/compiler/CompileKotlinAgainstJavaTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/jvm/compiler/CompileKotlinAgainstJavaTestGenerated.java index b443cd8ab9b..a2707eaaa53 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/jvm/compiler/CompileKotlinAgainstJavaTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/jvm/compiler/CompileKotlinAgainstJavaTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.jvm.compiler; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -38,7 +39,7 @@ public class CompileKotlinAgainstJavaTestGenerated extends AbstractCompileKotlin } public void testAllFilesPresentInWithAPT() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstJava"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstJava"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("AnnotationWithArguments.kt") @@ -326,7 +327,7 @@ public class CompileKotlinAgainstJavaTestGenerated extends AbstractCompileKotlin } public void testAllFilesPresentInWithoutAPT() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstJava"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstJava"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("AnnotationWithArguments.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/jvm/compiler/LoadJava15TestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/jvm/compiler/LoadJava15TestGenerated.java index a306af5eb18..cb98fc4f0ff 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/jvm/compiler/LoadJava15TestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/jvm/compiler/LoadJava15TestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.jvm.compiler; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -27,7 +28,7 @@ public class LoadJava15TestGenerated extends AbstractLoadJava15Test { } public void testAllFilesPresentInCompiledJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava15"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava15"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("GenericRecord.java") @@ -50,7 +51,7 @@ public class LoadJava15TestGenerated extends AbstractLoadJava15Test { } public void testAllFilesPresentInSourceJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava15"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava15"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("GenericRecord.java") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/jvm/compiler/LoadJava15WithPsiClassReadingTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/jvm/compiler/LoadJava15WithPsiClassReadingTestGenerated.java index aad9d58fcd9..cc11b4ff551 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/jvm/compiler/LoadJava15WithPsiClassReadingTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/jvm/compiler/LoadJava15WithPsiClassReadingTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.jvm.compiler; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class LoadJava15WithPsiClassReadingTestGenerated extends AbstractLoadJava } public void testAllFilesPresentInLoadJava15() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava15"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava15"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("GenericRecord.java") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/jvm/compiler/LoadJavaTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/jvm/compiler/LoadJavaTestGenerated.java index 3c16526e600..6d564a0c46e 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/jvm/compiler/LoadJavaTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/jvm/compiler/LoadJavaTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.jvm.compiler; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -27,7 +28,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInCompiledJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("ArrayInGenericArguments.java") @@ -269,7 +270,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/annotations"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/annotations"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("AnnotatedAnnotation.java") @@ -472,7 +473,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/constructor"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/constructor"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("ConstructorGenericDeep.java") @@ -500,7 +501,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/enum"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/enum"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("EnumMembers.java") @@ -528,7 +529,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInJavaBean() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/javaBean"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/javaBean"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("DifferentGetterAndSetter.java") @@ -576,7 +577,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInKotlinSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("ArrayType.java") @@ -663,7 +664,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInError() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/error"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/error"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("WrongProjectionKind.java") @@ -696,7 +697,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInPropagation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("PropagateTypeArgumentNullable.java") @@ -713,7 +714,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("ChangeProjectionKind1.java") @@ -866,7 +867,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInReturn() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("CantMakeImmutableInSubclass.java") @@ -1019,7 +1020,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInTypeParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/typeParameter"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/typeParameter"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("InheritNullability.java") @@ -1069,7 +1070,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInLibrary() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/library"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/library"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("LoadIterable.java") @@ -1097,7 +1098,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInModality() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/modality"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/modality"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("ModalityOfFakeOverrides.java") @@ -1115,7 +1116,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInMutability() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/mutability"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/mutability"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("LoadIterable.java") @@ -1153,7 +1154,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInNotNull() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/notNull"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/notNull"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("NotNullField.java") @@ -1191,7 +1192,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInProtectedPackage() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/protectedPackage"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/protectedPackage"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("ProtectedPackageConstructor.java") @@ -1219,7 +1220,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInProtectedStatic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/protectedStatic"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/protectedStatic"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("ConstructorInProtectedStaticNestedClass.java") @@ -1237,7 +1238,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInRendering() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/rendering"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/rendering"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("Rendering.java") @@ -1255,7 +1256,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInSam() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/sam"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/sam"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("Comparator.java") @@ -1347,7 +1348,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInAdapters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/sam/adapters"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/sam/adapters"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("AmbiguousAdapters.java") @@ -1434,7 +1435,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInInheritance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/sam/adapters/inheritance"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/sam/adapters/inheritance"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("InheritedAdapterAndDeclaration.java") @@ -1494,7 +1495,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInSignatureAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/signatureAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/signatureAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("StableName.java") @@ -1512,7 +1513,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInSignaturePropagation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/signaturePropagation"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/signaturePropagation"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("ArraysInSubtypes.java") @@ -1570,7 +1571,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInStatic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/static"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/static"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("DeeplyInnerClass.java") @@ -1638,7 +1639,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInVararg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/vararg"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/vararg"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("VarargInt.java") @@ -1662,7 +1663,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInCompiledJavaAndKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJavaAndKotlin"), Pattern.compile("^(.+)\\.txt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJavaAndKotlin"), Pattern.compile("^(.+)\\.txt$"), null, true); } @TestMetadata("MixedPackage.txt") @@ -1679,7 +1680,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInMixedPackage() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJavaAndKotlin/MixedPackage"), Pattern.compile("^(.+)\\.txt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJavaAndKotlin/MixedPackage"), Pattern.compile("^(.+)\\.txt$"), null, true); } } } @@ -1693,7 +1694,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInCompiledJavaIncludeObjectMethods() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJavaIncludeObjectMethods"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJavaIncludeObjectMethods"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("ClassWithObjectMethod.java") @@ -1721,7 +1722,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInCompiledKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/testData/loadJava/compiledKotlin/annotations") @@ -1733,7 +1734,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("AnnotatedAnnotation.kt") @@ -1790,7 +1791,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInClassMembers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/classMembers"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/classMembers"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassObjectPropertyField.kt") @@ -1858,7 +1859,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/classes"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/classes"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("AnnotationInClassObject.kt") @@ -1946,7 +1947,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInPackageMembers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/packageMembers"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/packageMembers"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("DelegatedProperty.kt") @@ -1999,7 +2000,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/parameters"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/parameters"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Constructor.kt") @@ -2072,7 +2073,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInPropertiesWithoutBackingFields() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Class.kt") @@ -2125,7 +2126,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/types"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/types"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassLiteralArgument.kt") @@ -2183,7 +2184,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInWithUseSiteTarget() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/withUseSiteTarget"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/withUseSiteTarget"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("DelegateTarget.kt") @@ -2217,7 +2218,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/class"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/class"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Class.kt") @@ -2414,7 +2415,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInJavaBean() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/class/javaBean"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/class/javaBean"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("DifferentGetterAndSetter.kt") @@ -2458,7 +2459,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInClassFun() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/classFun"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/classFun"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassInParamUsedInFun.kt") @@ -2496,7 +2497,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInClassObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/classObject"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/classObject"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassObjectDeclaresVal.kt") @@ -2574,7 +2575,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/constructor"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/constructor"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Constructor0.kt") @@ -2666,7 +2667,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInVararg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/constructor/vararg"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/constructor/vararg"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ConstructorNonLastVararg.kt") @@ -2690,7 +2691,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInCoroutines() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Basic.kt") @@ -2708,7 +2709,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInDataClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/dataClass"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/dataClass"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("MixedComponents.kt") @@ -2741,7 +2742,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/enum"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/enum"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("enumVisibility.kt") @@ -2784,7 +2785,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInFromLoadJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ArrayTypeVariance.kt") @@ -2971,7 +2972,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInKotlinSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ArrayType.kt") @@ -3063,7 +3064,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInError() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ConflictingProjectionKind.kt") @@ -3206,7 +3207,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInPropagation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("PropagateTypeArgumentNullable.kt") @@ -3223,7 +3224,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ChangeProjectionKind1.kt") @@ -3396,7 +3397,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInReturn() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("CantMakeImmutableInSubclass.kt") @@ -3549,7 +3550,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInTypeParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/typeParameter"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/typeParameter"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("InheritMutability.kt") @@ -3609,7 +3610,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInLibrary() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/library"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/library"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("LoadIterable.kt") @@ -3637,7 +3638,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInModality() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/modality"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/modality"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ModalityOfFakeOverrides.kt") @@ -3655,7 +3656,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInNotNull() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/notNull"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/notNull"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("NotNullField.kt") @@ -3694,7 +3695,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInFun() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Assert.kt") @@ -3761,7 +3762,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInGenericWithTypeVariables() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/genericWithTypeVariables"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/genericWithTypeVariables"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("FunGenericParam.kt") @@ -3824,7 +3825,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInGenericWithoutTypeVariables() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/genericWithoutTypeVariables"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/genericWithoutTypeVariables"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("FunClassParamNotNull.kt") @@ -3862,7 +3863,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInNonGeneric() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassFun.kt") @@ -3955,7 +3956,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInVararg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/vararg"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/vararg"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("nonLastVararg.kt") @@ -3984,7 +3985,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/inline"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/inline"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("inlineFunction.kt") @@ -4002,7 +4003,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInMemberOrder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/memberOrder"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/memberOrder"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("callablesNameClash.kt") @@ -4045,7 +4046,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInNested() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/nested"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/nested"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("deepInnerGeneric.kt") @@ -4073,7 +4074,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInPlatformTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/platformTypes"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/platformTypes"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("notnullTypeArgument.kt") @@ -4096,7 +4097,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInProp() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/prop"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/prop"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassVal.kt") @@ -4278,7 +4279,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInDefaultAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/prop/defaultAccessors"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/prop/defaultAccessors"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassVal.kt") @@ -4342,7 +4343,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/type"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/type"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Any.kt") @@ -4510,7 +4511,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInTypealias() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/typealias"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/typealias"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Annotations.kt") @@ -4543,7 +4544,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInVisibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/visibility"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/visibility"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("InternalClass.kt") @@ -4612,7 +4613,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInCompiledKotlinWithStdlib() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlinWithStdlib"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlinWithStdlib"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/testData/loadJava/compiledKotlinWithStdlib/annotations") @@ -4624,7 +4625,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlinWithStdlib/annotations"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlinWithStdlib/annotations"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ConstValInMultifileClass.kt") @@ -4652,7 +4653,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInContracts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlinWithStdlib/contracts"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlinWithStdlib/contracts"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("callsEffect.kt") @@ -4725,7 +4726,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInCoroutines() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlinWithStdlib/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlinWithStdlib/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("annotatedSuspendFun.kt") @@ -4743,7 +4744,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInMutability() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlinWithStdlib/mutability"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlinWithStdlib/mutability"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("LoadIterable.kt") @@ -4776,7 +4777,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInPlatformNames() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlinWithStdlib/platformNames"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlinWithStdlib/platformNames"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("functionName.kt") @@ -4795,7 +4796,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInJavaAgainstKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin"), Pattern.compile("^(.+)\\.txt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin"), Pattern.compile("^(.+)\\.txt$"), null, true); } @TestMetadata("compiler/testData/loadJava/javaAgainstKotlin/samAdapters") @@ -4807,7 +4808,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInSamAdapters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/samAdapters"), Pattern.compile("^(.+)\\.txt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/samAdapters"), Pattern.compile("^(.+)\\.txt$"), null, true); } @TestMetadata("InheritAmbguousSamAdaptersInKotlin.txt") @@ -4844,7 +4845,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInInheritAmbguousSamAdaptersInKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/samAdapters/InheritAmbguousSamAdaptersInKotlin"), Pattern.compile("^(.+)\\.txt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/samAdapters/InheritAmbguousSamAdaptersInKotlin"), Pattern.compile("^(.+)\\.txt$"), null, true); } } @@ -4857,7 +4858,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInInheritSamAdapterInKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/samAdapters/InheritSamAdapterInKotlin"), Pattern.compile("^(.+)\\.txt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/samAdapters/InheritSamAdapterInKotlin"), Pattern.compile("^(.+)\\.txt$"), null, true); } } @@ -4870,7 +4871,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInOverrideSamAdapterInKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/samAdapters/OverrideSamAdapterInKotlin"), Pattern.compile("^(.+)\\.txt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/samAdapters/OverrideSamAdapterInKotlin"), Pattern.compile("^(.+)\\.txt$"), null, true); } } @@ -4883,7 +4884,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInSamAdapterForInheritedFromKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/samAdapters/SamAdapterForInheritedFromKotlin"), Pattern.compile("^(.+)\\.txt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/samAdapters/SamAdapterForInheritedFromKotlin"), Pattern.compile("^(.+)\\.txt$"), null, true); } } @@ -4896,7 +4897,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInSamAdapterForOverriddenFromKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/samAdapters/SamAdapterForOverriddenFromKotlin"), Pattern.compile("^(.+)\\.txt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/samAdapters/SamAdapterForOverriddenFromKotlin"), Pattern.compile("^(.+)\\.txt$"), null, true); } } } @@ -4910,7 +4911,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInSignaturePropagation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation"), Pattern.compile("^(.+)\\.txt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation"), Pattern.compile("^(.+)\\.txt$"), null, true); } @TestMetadata("DeepSubclassingKotlinInJava.txt") @@ -4947,7 +4948,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInDeepSubclassingKotlinInJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/DeepSubclassingKotlinInJava"), Pattern.compile("^(.+)\\.txt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/DeepSubclassingKotlinInJava"), Pattern.compile("^(.+)\\.txt$"), null, true); } } @@ -4960,7 +4961,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInInheritExtensionAndNot() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/InheritExtensionAndNot"), Pattern.compile("^(.+)\\.txt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/InheritExtensionAndNot"), Pattern.compile("^(.+)\\.txt$"), null, true); } } @@ -4973,7 +4974,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInInheritExtensionFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/InheritExtensionFunction"), Pattern.compile("^(.+)\\.txt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/InheritExtensionFunction"), Pattern.compile("^(.+)\\.txt$"), null, true); } } @@ -4986,7 +4987,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInSubclassFromTraitImplementation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/SubclassFromTraitImplementation"), Pattern.compile("^(.+)\\.txt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/SubclassFromTraitImplementation"), Pattern.compile("^(.+)\\.txt$"), null, true); } } @@ -4999,7 +5000,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInSubclassingKotlinInJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/SubclassingKotlinInJava"), Pattern.compile("^(.+)\\.txt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/SubclassingKotlinInJava"), Pattern.compile("^(.+)\\.txt$"), null, true); } } } @@ -5013,7 +5014,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInVisibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/visibility"), Pattern.compile("^(.+)\\.txt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/visibility"), Pattern.compile("^(.+)\\.txt$"), null, true); } @TestMetadata("PackageLocal.txt") @@ -5035,7 +5036,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInPackageLocal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/visibility/PackageLocal"), Pattern.compile("^(.+)\\.txt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/visibility/PackageLocal"), Pattern.compile("^(.+)\\.txt$"), null, true); } } @@ -5048,7 +5049,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInProtectedPackage() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/visibility/ProtectedPackage"), Pattern.compile("^(.+)\\.txt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/visibility/ProtectedPackage"), Pattern.compile("^(.+)\\.txt$"), null, true); } } } @@ -5063,7 +5064,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInKotlinAgainstCompiledJavaWithKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/kotlinAgainstCompiledJavaWithKotlin"), Pattern.compile("^(.+)\\.kt$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/kotlinAgainstCompiledJavaWithKotlin"), Pattern.compile("^(.+)\\.kt$"), null, false); } @TestMetadata("InheritJavaField.kt") @@ -5101,7 +5102,7 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { } public void testAllFilesPresentInSourceJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/sourceJava"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/sourceJava"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("ClassExtendsTypeParameter.java") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/jvm/compiler/LoadJavaWithPsiClassReadingTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/jvm/compiler/LoadJavaWithPsiClassReadingTestGenerated.java index 8c2f71c4771..6811a7510d2 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/jvm/compiler/LoadJavaWithPsiClassReadingTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/jvm/compiler/LoadJavaWithPsiClassReadingTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.jvm.compiler; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class LoadJavaWithPsiClassReadingTestGenerated extends AbstractLoadJavaWi } public void testAllFilesPresentInCompiledJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("ArrayInGenericArguments.java") @@ -267,7 +268,7 @@ public class LoadJavaWithPsiClassReadingTestGenerated extends AbstractLoadJavaWi } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/annotations"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/annotations"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("AnnotatedAnnotation.java") @@ -470,7 +471,7 @@ public class LoadJavaWithPsiClassReadingTestGenerated extends AbstractLoadJavaWi } public void testAllFilesPresentInConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/constructor"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/constructor"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("ConstructorGenericDeep.java") @@ -498,7 +499,7 @@ public class LoadJavaWithPsiClassReadingTestGenerated extends AbstractLoadJavaWi } public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/enum"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/enum"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("EnumMembers.java") @@ -526,7 +527,7 @@ public class LoadJavaWithPsiClassReadingTestGenerated extends AbstractLoadJavaWi } public void testAllFilesPresentInJavaBean() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/javaBean"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/javaBean"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("DifferentGetterAndSetter.java") @@ -574,7 +575,7 @@ public class LoadJavaWithPsiClassReadingTestGenerated extends AbstractLoadJavaWi } public void testAllFilesPresentInKotlinSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("ArrayType.java") @@ -661,7 +662,7 @@ public class LoadJavaWithPsiClassReadingTestGenerated extends AbstractLoadJavaWi } public void testAllFilesPresentInError() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/error"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/error"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("WrongProjectionKind.java") @@ -694,7 +695,7 @@ public class LoadJavaWithPsiClassReadingTestGenerated extends AbstractLoadJavaWi } public void testAllFilesPresentInPropagation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("PropagateTypeArgumentNullable.java") @@ -711,7 +712,7 @@ public class LoadJavaWithPsiClassReadingTestGenerated extends AbstractLoadJavaWi } public void testAllFilesPresentInParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("ChangeProjectionKind1.java") @@ -864,7 +865,7 @@ public class LoadJavaWithPsiClassReadingTestGenerated extends AbstractLoadJavaWi } public void testAllFilesPresentInReturn() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("CantMakeImmutableInSubclass.java") @@ -1017,7 +1018,7 @@ public class LoadJavaWithPsiClassReadingTestGenerated extends AbstractLoadJavaWi } public void testAllFilesPresentInTypeParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/typeParameter"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/typeParameter"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("InheritNullability.java") @@ -1067,7 +1068,7 @@ public class LoadJavaWithPsiClassReadingTestGenerated extends AbstractLoadJavaWi } public void testAllFilesPresentInLibrary() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/library"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/library"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("LoadIterable.java") @@ -1095,7 +1096,7 @@ public class LoadJavaWithPsiClassReadingTestGenerated extends AbstractLoadJavaWi } public void testAllFilesPresentInModality() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/modality"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/modality"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("ModalityOfFakeOverrides.java") @@ -1113,7 +1114,7 @@ public class LoadJavaWithPsiClassReadingTestGenerated extends AbstractLoadJavaWi } public void testAllFilesPresentInMutability() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/mutability"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/mutability"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("LoadIterable.java") @@ -1151,7 +1152,7 @@ public class LoadJavaWithPsiClassReadingTestGenerated extends AbstractLoadJavaWi } public void testAllFilesPresentInNotNull() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/notNull"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/notNull"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("NotNullField.java") @@ -1189,7 +1190,7 @@ public class LoadJavaWithPsiClassReadingTestGenerated extends AbstractLoadJavaWi } public void testAllFilesPresentInProtectedPackage() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/protectedPackage"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/protectedPackage"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("ProtectedPackageConstructor.java") @@ -1217,7 +1218,7 @@ public class LoadJavaWithPsiClassReadingTestGenerated extends AbstractLoadJavaWi } public void testAllFilesPresentInProtectedStatic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/protectedStatic"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/protectedStatic"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("ConstructorInProtectedStaticNestedClass.java") @@ -1235,7 +1236,7 @@ public class LoadJavaWithPsiClassReadingTestGenerated extends AbstractLoadJavaWi } public void testAllFilesPresentInRendering() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/rendering"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/rendering"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("Rendering.java") @@ -1253,7 +1254,7 @@ public class LoadJavaWithPsiClassReadingTestGenerated extends AbstractLoadJavaWi } public void testAllFilesPresentInSam() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/sam"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/sam"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("Comparator.java") @@ -1345,7 +1346,7 @@ public class LoadJavaWithPsiClassReadingTestGenerated extends AbstractLoadJavaWi } public void testAllFilesPresentInAdapters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/sam/adapters"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/sam/adapters"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("AmbiguousAdapters.java") @@ -1432,7 +1433,7 @@ public class LoadJavaWithPsiClassReadingTestGenerated extends AbstractLoadJavaWi } public void testAllFilesPresentInInheritance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/sam/adapters/inheritance"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/sam/adapters/inheritance"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("InheritedAdapterAndDeclaration.java") @@ -1492,7 +1493,7 @@ public class LoadJavaWithPsiClassReadingTestGenerated extends AbstractLoadJavaWi } public void testAllFilesPresentInSignatureAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/signatureAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/signatureAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("StableName.java") @@ -1510,7 +1511,7 @@ public class LoadJavaWithPsiClassReadingTestGenerated extends AbstractLoadJavaWi } public void testAllFilesPresentInSignaturePropagation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/signaturePropagation"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/signaturePropagation"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("ArraysInSubtypes.java") @@ -1568,7 +1569,7 @@ public class LoadJavaWithPsiClassReadingTestGenerated extends AbstractLoadJavaWi } public void testAllFilesPresentInStatic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/static"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/static"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("DeeplyInnerClass.java") @@ -1636,7 +1637,7 @@ public class LoadJavaWithPsiClassReadingTestGenerated extends AbstractLoadJavaWi } public void testAllFilesPresentInVararg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/vararg"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/vararg"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("VarargInt.java") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/jvm/compiler/LoadKotlinWithTypeTableTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/jvm/compiler/LoadKotlinWithTypeTableTestGenerated.java index 04bc17a7b63..f8329ac6c9a 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/jvm/compiler/LoadKotlinWithTypeTableTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/jvm/compiler/LoadKotlinWithTypeTableTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.jvm.compiler; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class LoadKotlinWithTypeTableTestGenerated extends AbstractLoadKotlinWith } public void testAllFilesPresentInCompiledKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/testData/loadJava/compiledKotlin/annotations") @@ -37,7 +38,7 @@ public class LoadKotlinWithTypeTableTestGenerated extends AbstractLoadKotlinWith } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("AnnotatedAnnotation.kt") @@ -94,7 +95,7 @@ public class LoadKotlinWithTypeTableTestGenerated extends AbstractLoadKotlinWith } public void testAllFilesPresentInClassMembers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/classMembers"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/classMembers"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassObjectPropertyField.kt") @@ -162,7 +163,7 @@ public class LoadKotlinWithTypeTableTestGenerated extends AbstractLoadKotlinWith } public void testAllFilesPresentInClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/classes"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/classes"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("AnnotationInClassObject.kt") @@ -250,7 +251,7 @@ public class LoadKotlinWithTypeTableTestGenerated extends AbstractLoadKotlinWith } public void testAllFilesPresentInPackageMembers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/packageMembers"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/packageMembers"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("DelegatedProperty.kt") @@ -303,7 +304,7 @@ public class LoadKotlinWithTypeTableTestGenerated extends AbstractLoadKotlinWith } public void testAllFilesPresentInParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/parameters"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/parameters"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Constructor.kt") @@ -376,7 +377,7 @@ public class LoadKotlinWithTypeTableTestGenerated extends AbstractLoadKotlinWith } public void testAllFilesPresentInPropertiesWithoutBackingFields() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Class.kt") @@ -429,7 +430,7 @@ public class LoadKotlinWithTypeTableTestGenerated extends AbstractLoadKotlinWith } public void testAllFilesPresentInTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/types"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/types"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassLiteralArgument.kt") @@ -487,7 +488,7 @@ public class LoadKotlinWithTypeTableTestGenerated extends AbstractLoadKotlinWith } public void testAllFilesPresentInWithUseSiteTarget() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/withUseSiteTarget"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/withUseSiteTarget"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("DelegateTarget.kt") @@ -521,7 +522,7 @@ public class LoadKotlinWithTypeTableTestGenerated extends AbstractLoadKotlinWith } public void testAllFilesPresentInClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/class"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/class"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Class.kt") @@ -718,7 +719,7 @@ public class LoadKotlinWithTypeTableTestGenerated extends AbstractLoadKotlinWith } public void testAllFilesPresentInJavaBean() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/class/javaBean"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/class/javaBean"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("DifferentGetterAndSetter.kt") @@ -762,7 +763,7 @@ public class LoadKotlinWithTypeTableTestGenerated extends AbstractLoadKotlinWith } public void testAllFilesPresentInClassFun() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/classFun"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/classFun"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassInParamUsedInFun.kt") @@ -800,7 +801,7 @@ public class LoadKotlinWithTypeTableTestGenerated extends AbstractLoadKotlinWith } public void testAllFilesPresentInClassObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/classObject"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/classObject"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassObjectDeclaresVal.kt") @@ -878,7 +879,7 @@ public class LoadKotlinWithTypeTableTestGenerated extends AbstractLoadKotlinWith } public void testAllFilesPresentInConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/constructor"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/constructor"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Constructor0.kt") @@ -970,7 +971,7 @@ public class LoadKotlinWithTypeTableTestGenerated extends AbstractLoadKotlinWith } public void testAllFilesPresentInVararg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/constructor/vararg"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/constructor/vararg"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ConstructorNonLastVararg.kt") @@ -994,7 +995,7 @@ public class LoadKotlinWithTypeTableTestGenerated extends AbstractLoadKotlinWith } public void testAllFilesPresentInCoroutines() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Basic.kt") @@ -1012,7 +1013,7 @@ public class LoadKotlinWithTypeTableTestGenerated extends AbstractLoadKotlinWith } public void testAllFilesPresentInDataClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/dataClass"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/dataClass"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("MixedComponents.kt") @@ -1045,7 +1046,7 @@ public class LoadKotlinWithTypeTableTestGenerated extends AbstractLoadKotlinWith } public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/enum"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/enum"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("enumVisibility.kt") @@ -1088,7 +1089,7 @@ public class LoadKotlinWithTypeTableTestGenerated extends AbstractLoadKotlinWith } public void testAllFilesPresentInFromLoadJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ArrayTypeVariance.kt") @@ -1275,7 +1276,7 @@ public class LoadKotlinWithTypeTableTestGenerated extends AbstractLoadKotlinWith } public void testAllFilesPresentInKotlinSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ArrayType.kt") @@ -1367,7 +1368,7 @@ public class LoadKotlinWithTypeTableTestGenerated extends AbstractLoadKotlinWith } public void testAllFilesPresentInError() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ConflictingProjectionKind.kt") @@ -1510,7 +1511,7 @@ public class LoadKotlinWithTypeTableTestGenerated extends AbstractLoadKotlinWith } public void testAllFilesPresentInPropagation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("PropagateTypeArgumentNullable.kt") @@ -1527,7 +1528,7 @@ public class LoadKotlinWithTypeTableTestGenerated extends AbstractLoadKotlinWith } public void testAllFilesPresentInParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ChangeProjectionKind1.kt") @@ -1700,7 +1701,7 @@ public class LoadKotlinWithTypeTableTestGenerated extends AbstractLoadKotlinWith } public void testAllFilesPresentInReturn() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("CantMakeImmutableInSubclass.kt") @@ -1853,7 +1854,7 @@ public class LoadKotlinWithTypeTableTestGenerated extends AbstractLoadKotlinWith } public void testAllFilesPresentInTypeParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/typeParameter"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/typeParameter"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("InheritMutability.kt") @@ -1913,7 +1914,7 @@ public class LoadKotlinWithTypeTableTestGenerated extends AbstractLoadKotlinWith } public void testAllFilesPresentInLibrary() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/library"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/library"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("LoadIterable.kt") @@ -1941,7 +1942,7 @@ public class LoadKotlinWithTypeTableTestGenerated extends AbstractLoadKotlinWith } public void testAllFilesPresentInModality() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/modality"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/modality"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ModalityOfFakeOverrides.kt") @@ -1959,7 +1960,7 @@ public class LoadKotlinWithTypeTableTestGenerated extends AbstractLoadKotlinWith } public void testAllFilesPresentInNotNull() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/notNull"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/notNull"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("NotNullField.kt") @@ -1998,7 +1999,7 @@ public class LoadKotlinWithTypeTableTestGenerated extends AbstractLoadKotlinWith } public void testAllFilesPresentInFun() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Assert.kt") @@ -2065,7 +2066,7 @@ public class LoadKotlinWithTypeTableTestGenerated extends AbstractLoadKotlinWith } public void testAllFilesPresentInGenericWithTypeVariables() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/genericWithTypeVariables"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/genericWithTypeVariables"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("FunGenericParam.kt") @@ -2128,7 +2129,7 @@ public class LoadKotlinWithTypeTableTestGenerated extends AbstractLoadKotlinWith } public void testAllFilesPresentInGenericWithoutTypeVariables() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/genericWithoutTypeVariables"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/genericWithoutTypeVariables"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("FunClassParamNotNull.kt") @@ -2166,7 +2167,7 @@ public class LoadKotlinWithTypeTableTestGenerated extends AbstractLoadKotlinWith } public void testAllFilesPresentInNonGeneric() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassFun.kt") @@ -2259,7 +2260,7 @@ public class LoadKotlinWithTypeTableTestGenerated extends AbstractLoadKotlinWith } public void testAllFilesPresentInVararg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/vararg"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/vararg"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("nonLastVararg.kt") @@ -2288,7 +2289,7 @@ public class LoadKotlinWithTypeTableTestGenerated extends AbstractLoadKotlinWith } public void testAllFilesPresentInInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/inline"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/inline"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("inlineFunction.kt") @@ -2306,7 +2307,7 @@ public class LoadKotlinWithTypeTableTestGenerated extends AbstractLoadKotlinWith } public void testAllFilesPresentInMemberOrder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/memberOrder"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/memberOrder"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("callablesNameClash.kt") @@ -2349,7 +2350,7 @@ public class LoadKotlinWithTypeTableTestGenerated extends AbstractLoadKotlinWith } public void testAllFilesPresentInNested() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/nested"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/nested"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("deepInnerGeneric.kt") @@ -2377,7 +2378,7 @@ public class LoadKotlinWithTypeTableTestGenerated extends AbstractLoadKotlinWith } public void testAllFilesPresentInPlatformTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/platformTypes"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/platformTypes"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("notnullTypeArgument.kt") @@ -2400,7 +2401,7 @@ public class LoadKotlinWithTypeTableTestGenerated extends AbstractLoadKotlinWith } public void testAllFilesPresentInProp() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/prop"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/prop"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassVal.kt") @@ -2582,7 +2583,7 @@ public class LoadKotlinWithTypeTableTestGenerated extends AbstractLoadKotlinWith } public void testAllFilesPresentInDefaultAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/prop/defaultAccessors"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/prop/defaultAccessors"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassVal.kt") @@ -2646,7 +2647,7 @@ public class LoadKotlinWithTypeTableTestGenerated extends AbstractLoadKotlinWith } public void testAllFilesPresentInType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/type"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/type"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Any.kt") @@ -2814,7 +2815,7 @@ public class LoadKotlinWithTypeTableTestGenerated extends AbstractLoadKotlinWith } public void testAllFilesPresentInTypealias() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/typealias"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/typealias"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Annotations.kt") @@ -2847,7 +2848,7 @@ public class LoadKotlinWithTypeTableTestGenerated extends AbstractLoadKotlinWith } public void testAllFilesPresentInVisibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/visibility"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/visibility"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("InternalClass.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/jvm/compiler/WriteSignatureTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/jvm/compiler/WriteSignatureTestGenerated.java index f4c54571bc2..7d582c2f443 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/jvm/compiler/WriteSignatureTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/jvm/compiler/WriteSignatureTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.jvm.compiler; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class WriteSignatureTestGenerated extends AbstractWriteSignatureTest { } public void testAllFilesPresentInWriteSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ArrayOfCharSequence.kt") @@ -147,7 +148,7 @@ public class WriteSignatureTestGenerated extends AbstractWriteSignatureTest { } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature/annotations"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature/annotations"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("kArrayClassOfJClass.kt") @@ -185,7 +186,7 @@ public class WriteSignatureTestGenerated extends AbstractWriteSignatureTest { } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("constructorReferenceInReturnType.kt") @@ -218,7 +219,7 @@ public class WriteSignatureTestGenerated extends AbstractWriteSignatureTest { } public void testAllFilesPresentInConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature/constructor"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature/constructor"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Constructor0.kt") @@ -251,7 +252,7 @@ public class WriteSignatureTestGenerated extends AbstractWriteSignatureTest { } public void testAllFilesPresentInDeclarationSiteVariance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature/declarationSiteVariance"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature/declarationSiteVariance"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("FunctionTwoTypeParameters.kt") @@ -398,7 +399,7 @@ public class WriteSignatureTestGenerated extends AbstractWriteSignatureTest { } public void testAllFilesPresentInJvmWildcardAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature/declarationSiteVariance/jvmWildcardAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature/declarationSiteVariance/jvmWildcardAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("onFunction.kt") @@ -426,7 +427,7 @@ public class WriteSignatureTestGenerated extends AbstractWriteSignatureTest { } public void testAllFilesPresentInWildcardOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature/declarationSiteVariance/wildcardOptimization"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("argumentOverridability.kt") @@ -495,7 +496,7 @@ public class WriteSignatureTestGenerated extends AbstractWriteSignatureTest { } public void testAllFilesPresentInDefaultImpls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature/defaultImpls"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature/defaultImpls"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("functionTypeParameterClash.kt") @@ -523,7 +524,7 @@ public class WriteSignatureTestGenerated extends AbstractWriteSignatureTest { } public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("basicInlineClassDeclarationCodegen.kt") @@ -586,7 +587,7 @@ public class WriteSignatureTestGenerated extends AbstractWriteSignatureTest { } public void testAllFilesPresentInJava8() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature/java8"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature/java8"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("mutableMapRemove.kt") @@ -604,7 +605,7 @@ public class WriteSignatureTestGenerated extends AbstractWriteSignatureTest { } public void testAllFilesPresentInNothing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature/nothing"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature/nothing"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("nothing.kt") @@ -627,7 +628,7 @@ public class WriteSignatureTestGenerated extends AbstractWriteSignatureTest { } public void testAllFilesPresentInParameterlessMain() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature/parameterlessMain"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature/parameterlessMain"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("arrayWithContravariantStringIsNotMainMethod.kt") @@ -665,7 +666,7 @@ public class WriteSignatureTestGenerated extends AbstractWriteSignatureTest { } public void testAllFilesPresentInSuspendMain() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature/suspendMain"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/writeSignature/suspendMain"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("parameterlessSuspendMain.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/jvm/compiler/ir/IrCompileJavaAgainstKotlinTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/jvm/compiler/ir/IrCompileJavaAgainstKotlinTestGenerated.java index bae13882d2b..50fbe8c4418 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/jvm/compiler/ir/IrCompileJavaAgainstKotlinTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/jvm/compiler/ir/IrCompileJavaAgainstKotlinTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.jvm.compiler.ir; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -28,7 +29,7 @@ public class IrCompileJavaAgainstKotlinTestGenerated extends AbstractIrCompileJa } public void testAllFilesPresentInWithoutJavac() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/compileJavaAgainstKotlin/annotation") @@ -40,7 +41,7 @@ public class IrCompileJavaAgainstKotlinTestGenerated extends AbstractIrCompileJa } public void testAllFilesPresentInAnnotation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/annotation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/annotation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("retention.kt") @@ -58,7 +59,7 @@ public class IrCompileJavaAgainstKotlinTestGenerated extends AbstractIrCompileJa } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("GenericSignature.kt") @@ -76,7 +77,7 @@ public class IrCompileJavaAgainstKotlinTestGenerated extends AbstractIrCompileJa } public void testAllFilesPresentInClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/class"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/class"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("ClassObject.kt") @@ -159,7 +160,7 @@ public class IrCompileJavaAgainstKotlinTestGenerated extends AbstractIrCompileJa } public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("DefaultArgumentInEnumConstructor.kt") @@ -177,7 +178,7 @@ public class IrCompileJavaAgainstKotlinTestGenerated extends AbstractIrCompileJa } public void testAllFilesPresentInJvmStatic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/jvmStatic"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/jvmStatic"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("simpleCompanionObject.kt") @@ -215,7 +216,7 @@ public class IrCompileJavaAgainstKotlinTestGenerated extends AbstractIrCompileJa } public void testAllFilesPresentInMethod() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("Any.kt") @@ -347,7 +348,7 @@ public class IrCompileJavaAgainstKotlinTestGenerated extends AbstractIrCompileJa } public void testAllFilesPresentInPlatformName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/platformName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/platformName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("PlatformName.kt") @@ -365,7 +366,7 @@ public class IrCompileJavaAgainstKotlinTestGenerated extends AbstractIrCompileJa } public void testAllFilesPresentInPrimitiveOverride() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("ByteOverridesObject.kt") @@ -433,7 +434,7 @@ public class IrCompileJavaAgainstKotlinTestGenerated extends AbstractIrCompileJa } public void testAllFilesPresentInPrimitiveOverrideWithInlineClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/primitiveOverrideWithInlineClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/primitiveOverrideWithInlineClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("InlineIntOverridesObject.kt") @@ -451,7 +452,7 @@ public class IrCompileJavaAgainstKotlinTestGenerated extends AbstractIrCompileJa } public void testAllFilesPresentInThrows() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/throws"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/throws"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("ClassMembers.kt") @@ -505,7 +506,7 @@ public class IrCompileJavaAgainstKotlinTestGenerated extends AbstractIrCompileJa } public void testAllFilesPresentInProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("ConstVal.kt") @@ -532,7 +533,7 @@ public class IrCompileJavaAgainstKotlinTestGenerated extends AbstractIrCompileJa } public void testAllFilesPresentInPlatformName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/property/platformName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/property/platformName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("PlatformName.kt") @@ -551,7 +552,7 @@ public class IrCompileJavaAgainstKotlinTestGenerated extends AbstractIrCompileJa } public void testAllFilesPresentInSealed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/sealed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/sealed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("Derived.kt") @@ -574,7 +575,7 @@ public class IrCompileJavaAgainstKotlinTestGenerated extends AbstractIrCompileJa } public void testAllFilesPresentInStaticFields() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/staticFields"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/staticFields"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("AnnotationClass.kt") @@ -612,7 +613,7 @@ public class IrCompileJavaAgainstKotlinTestGenerated extends AbstractIrCompileJa } public void testAllFilesPresentInTargets() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/targets"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/targets"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("annotation.kt") @@ -691,7 +692,7 @@ public class IrCompileJavaAgainstKotlinTestGenerated extends AbstractIrCompileJa } public void testAllFilesPresentInWithJavac() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/compileJavaAgainstKotlin/annotation") @@ -703,7 +704,7 @@ public class IrCompileJavaAgainstKotlinTestGenerated extends AbstractIrCompileJa } public void testAllFilesPresentInAnnotation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/annotation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/annotation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("retention.kt") @@ -721,7 +722,7 @@ public class IrCompileJavaAgainstKotlinTestGenerated extends AbstractIrCompileJa } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("GenericSignature.kt") @@ -739,7 +740,7 @@ public class IrCompileJavaAgainstKotlinTestGenerated extends AbstractIrCompileJa } public void testAllFilesPresentInClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/class"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/class"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("ClassObject.kt") @@ -822,7 +823,7 @@ public class IrCompileJavaAgainstKotlinTestGenerated extends AbstractIrCompileJa } public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("DefaultArgumentInEnumConstructor.kt") @@ -840,7 +841,7 @@ public class IrCompileJavaAgainstKotlinTestGenerated extends AbstractIrCompileJa } public void testAllFilesPresentInJvmStatic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/jvmStatic"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/jvmStatic"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("simpleCompanionObject.kt") @@ -878,7 +879,7 @@ public class IrCompileJavaAgainstKotlinTestGenerated extends AbstractIrCompileJa } public void testAllFilesPresentInMethod() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("Any.kt") @@ -1010,7 +1011,7 @@ public class IrCompileJavaAgainstKotlinTestGenerated extends AbstractIrCompileJa } public void testAllFilesPresentInPlatformName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/platformName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/platformName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("PlatformName.kt") @@ -1028,7 +1029,7 @@ public class IrCompileJavaAgainstKotlinTestGenerated extends AbstractIrCompileJa } public void testAllFilesPresentInPrimitiveOverride() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/primitiveOverride"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("ByteOverridesObject.kt") @@ -1096,7 +1097,7 @@ public class IrCompileJavaAgainstKotlinTestGenerated extends AbstractIrCompileJa } public void testAllFilesPresentInPrimitiveOverrideWithInlineClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/primitiveOverrideWithInlineClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/primitiveOverrideWithInlineClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("InlineIntOverridesObject.kt") @@ -1114,7 +1115,7 @@ public class IrCompileJavaAgainstKotlinTestGenerated extends AbstractIrCompileJa } public void testAllFilesPresentInThrows() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/throws"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/method/throws"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("ClassMembers.kt") @@ -1168,7 +1169,7 @@ public class IrCompileJavaAgainstKotlinTestGenerated extends AbstractIrCompileJa } public void testAllFilesPresentInProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("ConstVal.kt") @@ -1195,7 +1196,7 @@ public class IrCompileJavaAgainstKotlinTestGenerated extends AbstractIrCompileJa } public void testAllFilesPresentInPlatformName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/property/platformName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/property/platformName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("PlatformName.kt") @@ -1214,7 +1215,7 @@ public class IrCompileJavaAgainstKotlinTestGenerated extends AbstractIrCompileJa } public void testAllFilesPresentInSealed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/sealed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/sealed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("Derived.kt") @@ -1237,7 +1238,7 @@ public class IrCompileJavaAgainstKotlinTestGenerated extends AbstractIrCompileJa } public void testAllFilesPresentInStaticFields() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/staticFields"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/staticFields"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("AnnotationClass.kt") @@ -1275,7 +1276,7 @@ public class IrCompileJavaAgainstKotlinTestGenerated extends AbstractIrCompileJa } public void testAllFilesPresentInTargets() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/targets"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileJavaAgainstKotlin/targets"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("annotation.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/jvm/compiler/ir/IrCompileKotlinAgainstJavaTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/jvm/compiler/ir/IrCompileKotlinAgainstJavaTestGenerated.java index 247a25adf23..0964cf52ad4 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/jvm/compiler/ir/IrCompileKotlinAgainstJavaTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/jvm/compiler/ir/IrCompileKotlinAgainstJavaTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.jvm.compiler.ir; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -38,7 +39,7 @@ public class IrCompileKotlinAgainstJavaTestGenerated extends AbstractIrCompileKo } public void testAllFilesPresentInWithAPT() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstJava"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstJava"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("AnnotationWithArguments.kt") @@ -326,7 +327,7 @@ public class IrCompileKotlinAgainstJavaTestGenerated extends AbstractIrCompileKo } public void testAllFilesPresentInWithoutAPT() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstJava"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstJava"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("AnnotationWithArguments.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/jvm/compiler/ir/IrLoadJavaTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/jvm/compiler/ir/IrLoadJavaTestGenerated.java index 51cbaf37ad2..ca07b164d85 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/jvm/compiler/ir/IrLoadJavaTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/jvm/compiler/ir/IrLoadJavaTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.jvm.compiler.ir; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -28,7 +29,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInCompiledJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("ArrayInGenericArguments.java") @@ -270,7 +271,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/annotations"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/annotations"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("AnnotatedAnnotation.java") @@ -473,7 +474,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/constructor"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/constructor"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("ConstructorGenericDeep.java") @@ -501,7 +502,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/enum"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/enum"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("EnumMembers.java") @@ -529,7 +530,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInJavaBean() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/javaBean"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/javaBean"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("DifferentGetterAndSetter.java") @@ -577,7 +578,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInKotlinSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("ArrayType.java") @@ -664,7 +665,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInError() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/error"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/error"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("WrongProjectionKind.java") @@ -697,7 +698,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInPropagation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("PropagateTypeArgumentNullable.java") @@ -714,7 +715,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("ChangeProjectionKind1.java") @@ -867,7 +868,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInReturn() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("CantMakeImmutableInSubclass.java") @@ -1020,7 +1021,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInTypeParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/typeParameter"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/typeParameter"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("InheritNullability.java") @@ -1070,7 +1071,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInLibrary() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/library"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/library"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("LoadIterable.java") @@ -1098,7 +1099,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInModality() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/modality"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/modality"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("ModalityOfFakeOverrides.java") @@ -1116,7 +1117,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInMutability() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/mutability"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/mutability"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("LoadIterable.java") @@ -1154,7 +1155,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInNotNull() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/notNull"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/notNull"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("NotNullField.java") @@ -1192,7 +1193,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInProtectedPackage() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/protectedPackage"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/protectedPackage"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("ProtectedPackageConstructor.java") @@ -1220,7 +1221,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInProtectedStatic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/protectedStatic"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/protectedStatic"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("ConstructorInProtectedStaticNestedClass.java") @@ -1238,7 +1239,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInRendering() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/rendering"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/rendering"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("Rendering.java") @@ -1256,7 +1257,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInSam() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/sam"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/sam"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("Comparator.java") @@ -1348,7 +1349,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInAdapters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/sam/adapters"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/sam/adapters"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("AmbiguousAdapters.java") @@ -1435,7 +1436,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInInheritance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/sam/adapters/inheritance"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/sam/adapters/inheritance"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("InheritedAdapterAndDeclaration.java") @@ -1495,7 +1496,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInSignatureAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/signatureAnnotations"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/signatureAnnotations"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("StableName.java") @@ -1513,7 +1514,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInSignaturePropagation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/signaturePropagation"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/signaturePropagation"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("ArraysInSubtypes.java") @@ -1571,7 +1572,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInStatic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/static"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/static"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("DeeplyInnerClass.java") @@ -1639,7 +1640,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInVararg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/vararg"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/vararg"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("VarargInt.java") @@ -1663,7 +1664,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInCompiledJavaAndKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJavaAndKotlin"), Pattern.compile("^(.+)\\.txt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJavaAndKotlin"), Pattern.compile("^(.+)\\.txt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("MixedPackage.txt") @@ -1680,7 +1681,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInMixedPackage() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJavaAndKotlin/MixedPackage"), Pattern.compile("^(.+)\\.txt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJavaAndKotlin/MixedPackage"), Pattern.compile("^(.+)\\.txt$"), null, TargetBackend.JVM_IR, true); } } } @@ -1694,7 +1695,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInCompiledJavaIncludeObjectMethods() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJavaIncludeObjectMethods"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJavaIncludeObjectMethods"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("ClassWithObjectMethod.java") @@ -1722,7 +1723,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInCompiledKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/loadJava/compiledKotlin/annotations") @@ -1734,7 +1735,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("AnnotatedAnnotation.kt") @@ -1791,7 +1792,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInClassMembers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/classMembers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/classMembers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("ClassObjectPropertyField.kt") @@ -1859,7 +1860,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/classes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/classes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("AnnotationInClassObject.kt") @@ -1947,7 +1948,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInPackageMembers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/packageMembers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/packageMembers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("DelegatedProperty.kt") @@ -2000,7 +2001,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/parameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/parameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("Constructor.kt") @@ -2073,7 +2074,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInPropertiesWithoutBackingFields() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("Class.kt") @@ -2126,7 +2127,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/types"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/types"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("ClassLiteralArgument.kt") @@ -2184,7 +2185,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInWithUseSiteTarget() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/withUseSiteTarget"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/withUseSiteTarget"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("DelegateTarget.kt") @@ -2218,7 +2219,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/class"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/class"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("Class.kt") @@ -2415,7 +2416,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInJavaBean() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/class/javaBean"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/class/javaBean"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("DifferentGetterAndSetter.kt") @@ -2459,7 +2460,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInClassFun() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/classFun"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/classFun"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("ClassInParamUsedInFun.kt") @@ -2497,7 +2498,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInClassObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/classObject"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/classObject"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("ClassObjectDeclaresVal.kt") @@ -2575,7 +2576,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/constructor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/constructor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("Constructor0.kt") @@ -2667,7 +2668,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInVararg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/constructor/vararg"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/constructor/vararg"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("ConstructorNonLastVararg.kt") @@ -2691,7 +2692,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInCoroutines() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("Basic.kt") @@ -2709,7 +2710,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInDataClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/dataClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/dataClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("MixedComponents.kt") @@ -2742,7 +2743,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("enumVisibility.kt") @@ -2785,7 +2786,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInFromLoadJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("ArrayTypeVariance.kt") @@ -2972,7 +2973,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInKotlinSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("ArrayType.kt") @@ -3064,7 +3065,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInError() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("ConflictingProjectionKind.kt") @@ -3207,7 +3208,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInPropagation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("PropagateTypeArgumentNullable.kt") @@ -3224,7 +3225,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("ChangeProjectionKind1.kt") @@ -3397,7 +3398,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInReturn() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("CantMakeImmutableInSubclass.kt") @@ -3550,7 +3551,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInTypeParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/typeParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/typeParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("InheritMutability.kt") @@ -3610,7 +3611,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInLibrary() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/library"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/library"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("LoadIterable.kt") @@ -3638,7 +3639,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInModality() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/modality"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/modality"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("ModalityOfFakeOverrides.kt") @@ -3656,7 +3657,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInNotNull() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/notNull"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/notNull"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("NotNullField.kt") @@ -3695,7 +3696,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInFun() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("Assert.kt") @@ -3762,7 +3763,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInGenericWithTypeVariables() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/genericWithTypeVariables"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/genericWithTypeVariables"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("FunGenericParam.kt") @@ -3825,7 +3826,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInGenericWithoutTypeVariables() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/genericWithoutTypeVariables"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/genericWithoutTypeVariables"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("FunClassParamNotNull.kt") @@ -3863,7 +3864,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInNonGeneric() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("ClassFun.kt") @@ -3956,7 +3957,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInVararg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/vararg"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/vararg"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("nonLastVararg.kt") @@ -3985,7 +3986,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/inline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/inline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("inlineFunction.kt") @@ -4003,7 +4004,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInMemberOrder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/memberOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/memberOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("callablesNameClash.kt") @@ -4046,7 +4047,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInNested() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/nested"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/nested"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("deepInnerGeneric.kt") @@ -4074,7 +4075,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInPlatformTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/platformTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/platformTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("notnullTypeArgument.kt") @@ -4097,7 +4098,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInProp() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/prop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/prop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("ClassVal.kt") @@ -4279,7 +4280,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInDefaultAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/prop/defaultAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/prop/defaultAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("ClassVal.kt") @@ -4343,7 +4344,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/type"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/type"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("Any.kt") @@ -4511,7 +4512,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInTypealias() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/typealias"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/typealias"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("Annotations.kt") @@ -4544,7 +4545,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInVisibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/visibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/visibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("InternalClass.kt") @@ -4613,7 +4614,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInCompiledKotlinWithStdlib() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlinWithStdlib"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlinWithStdlib"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/loadJava/compiledKotlinWithStdlib/annotations") @@ -4625,7 +4626,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlinWithStdlib/annotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlinWithStdlib/annotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("ConstValInMultifileClass.kt") @@ -4653,7 +4654,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInContracts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlinWithStdlib/contracts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlinWithStdlib/contracts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("callsEffect.kt") @@ -4726,7 +4727,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInCoroutines() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlinWithStdlib/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlinWithStdlib/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("annotatedSuspendFun.kt") @@ -4744,7 +4745,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInMutability() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlinWithStdlib/mutability"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlinWithStdlib/mutability"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("LoadIterable.kt") @@ -4777,7 +4778,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInPlatformNames() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlinWithStdlib/platformNames"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlinWithStdlib/platformNames"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("functionName.kt") @@ -4796,7 +4797,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInJavaAgainstKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin"), Pattern.compile("^(.+)\\.txt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin"), Pattern.compile("^(.+)\\.txt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("compiler/testData/loadJava/javaAgainstKotlin/samAdapters") @@ -4808,7 +4809,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInSamAdapters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/samAdapters"), Pattern.compile("^(.+)\\.txt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/samAdapters"), Pattern.compile("^(.+)\\.txt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("InheritAmbguousSamAdaptersInKotlin.txt") @@ -4845,7 +4846,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInInheritAmbguousSamAdaptersInKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/samAdapters/InheritAmbguousSamAdaptersInKotlin"), Pattern.compile("^(.+)\\.txt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/samAdapters/InheritAmbguousSamAdaptersInKotlin"), Pattern.compile("^(.+)\\.txt$"), null, TargetBackend.JVM_IR, true); } } @@ -4858,7 +4859,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInInheritSamAdapterInKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/samAdapters/InheritSamAdapterInKotlin"), Pattern.compile("^(.+)\\.txt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/samAdapters/InheritSamAdapterInKotlin"), Pattern.compile("^(.+)\\.txt$"), null, TargetBackend.JVM_IR, true); } } @@ -4871,7 +4872,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInOverrideSamAdapterInKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/samAdapters/OverrideSamAdapterInKotlin"), Pattern.compile("^(.+)\\.txt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/samAdapters/OverrideSamAdapterInKotlin"), Pattern.compile("^(.+)\\.txt$"), null, TargetBackend.JVM_IR, true); } } @@ -4884,7 +4885,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInSamAdapterForInheritedFromKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/samAdapters/SamAdapterForInheritedFromKotlin"), Pattern.compile("^(.+)\\.txt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/samAdapters/SamAdapterForInheritedFromKotlin"), Pattern.compile("^(.+)\\.txt$"), null, TargetBackend.JVM_IR, true); } } @@ -4897,7 +4898,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInSamAdapterForOverriddenFromKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/samAdapters/SamAdapterForOverriddenFromKotlin"), Pattern.compile("^(.+)\\.txt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/samAdapters/SamAdapterForOverriddenFromKotlin"), Pattern.compile("^(.+)\\.txt$"), null, TargetBackend.JVM_IR, true); } } } @@ -4911,7 +4912,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInSignaturePropagation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation"), Pattern.compile("^(.+)\\.txt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation"), Pattern.compile("^(.+)\\.txt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("DeepSubclassingKotlinInJava.txt") @@ -4948,7 +4949,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInDeepSubclassingKotlinInJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/DeepSubclassingKotlinInJava"), Pattern.compile("^(.+)\\.txt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/DeepSubclassingKotlinInJava"), Pattern.compile("^(.+)\\.txt$"), null, TargetBackend.JVM_IR, true); } } @@ -4961,7 +4962,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInInheritExtensionAndNot() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/InheritExtensionAndNot"), Pattern.compile("^(.+)\\.txt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/InheritExtensionAndNot"), Pattern.compile("^(.+)\\.txt$"), null, TargetBackend.JVM_IR, true); } } @@ -4974,7 +4975,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInInheritExtensionFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/InheritExtensionFunction"), Pattern.compile("^(.+)\\.txt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/InheritExtensionFunction"), Pattern.compile("^(.+)\\.txt$"), null, TargetBackend.JVM_IR, true); } } @@ -4987,7 +4988,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInSubclassFromTraitImplementation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/SubclassFromTraitImplementation"), Pattern.compile("^(.+)\\.txt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/SubclassFromTraitImplementation"), Pattern.compile("^(.+)\\.txt$"), null, TargetBackend.JVM_IR, true); } } @@ -5000,7 +5001,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInSubclassingKotlinInJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/SubclassingKotlinInJava"), Pattern.compile("^(.+)\\.txt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/SubclassingKotlinInJava"), Pattern.compile("^(.+)\\.txt$"), null, TargetBackend.JVM_IR, true); } } } @@ -5014,7 +5015,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInVisibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/visibility"), Pattern.compile("^(.+)\\.txt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/visibility"), Pattern.compile("^(.+)\\.txt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("PackageLocal.txt") @@ -5036,7 +5037,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInPackageLocal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/visibility/PackageLocal"), Pattern.compile("^(.+)\\.txt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/visibility/PackageLocal"), Pattern.compile("^(.+)\\.txt$"), null, TargetBackend.JVM_IR, true); } } @@ -5049,7 +5050,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInProtectedPackage() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/visibility/ProtectedPackage"), Pattern.compile("^(.+)\\.txt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/visibility/ProtectedPackage"), Pattern.compile("^(.+)\\.txt$"), null, TargetBackend.JVM_IR, true); } } } @@ -5064,7 +5065,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInKotlinAgainstCompiledJavaWithKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/kotlinAgainstCompiledJavaWithKotlin"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/kotlinAgainstCompiledJavaWithKotlin"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, false); } @TestMetadata("InheritJavaField.kt") @@ -5102,7 +5103,7 @@ public class IrLoadJavaTestGenerated extends AbstractIrLoadJavaTest { } public void testAllFilesPresentInSourceJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/sourceJava"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/sourceJava"), Pattern.compile("^(.+)\\.java$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("ClassExtendsTypeParameter.java") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/jvm/compiler/javac/LoadJavaUsingJavacTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/jvm/compiler/javac/LoadJavaUsingJavacTestGenerated.java index 96712104654..1fdecca8494 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/jvm/compiler/javac/LoadJavaUsingJavacTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/jvm/compiler/javac/LoadJavaUsingJavacTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.jvm.compiler.javac; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -27,7 +28,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInCompiledJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("ArrayInGenericArguments.java") @@ -269,7 +270,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/annotations"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/annotations"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("AnnotatedAnnotation.java") @@ -472,7 +473,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/constructor"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/constructor"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("ConstructorGenericDeep.java") @@ -500,7 +501,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/enum"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/enum"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("EnumMembers.java") @@ -528,7 +529,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInJavaBean() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/javaBean"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/javaBean"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("DifferentGetterAndSetter.java") @@ -576,7 +577,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInKotlinSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("ArrayType.java") @@ -663,7 +664,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInError() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/error"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/error"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("WrongProjectionKind.java") @@ -696,7 +697,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInPropagation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("PropagateTypeArgumentNullable.java") @@ -713,7 +714,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/parameter"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("ChangeProjectionKind1.java") @@ -866,7 +867,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInReturn() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/return"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("CantMakeImmutableInSubclass.java") @@ -1019,7 +1020,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInTypeParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/typeParameter"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/propagation/typeParameter"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("InheritNullability.java") @@ -1069,7 +1070,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInLibrary() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/library"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/library"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("LoadIterable.java") @@ -1097,7 +1098,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInModality() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/modality"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/modality"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("ModalityOfFakeOverrides.java") @@ -1115,7 +1116,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInMutability() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/mutability"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/mutability"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("LoadIterable.java") @@ -1153,7 +1154,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInNotNull() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/notNull"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/notNull"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("NotNullField.java") @@ -1191,7 +1192,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInProtectedPackage() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/protectedPackage"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/protectedPackage"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("ProtectedPackageConstructor.java") @@ -1219,7 +1220,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInProtectedStatic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/protectedStatic"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/protectedStatic"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("ConstructorInProtectedStaticNestedClass.java") @@ -1237,7 +1238,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInRendering() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/rendering"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/rendering"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("Rendering.java") @@ -1255,7 +1256,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInSam() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/sam"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/sam"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("Comparator.java") @@ -1347,7 +1348,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInAdapters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/sam/adapters"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/sam/adapters"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("AmbiguousAdapters.java") @@ -1434,7 +1435,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInInheritance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/sam/adapters/inheritance"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/sam/adapters/inheritance"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("InheritedAdapterAndDeclaration.java") @@ -1494,7 +1495,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInSignatureAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/signatureAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/signatureAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("StableName.java") @@ -1512,7 +1513,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInSignaturePropagation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/signaturePropagation"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/signaturePropagation"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("ArraysInSubtypes.java") @@ -1570,7 +1571,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInStatic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/static"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/static"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("DeeplyInnerClass.java") @@ -1638,7 +1639,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInVararg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/vararg"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/vararg"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("VarargInt.java") @@ -1662,7 +1663,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInCompiledJavaAndKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJavaAndKotlin"), Pattern.compile("^(.+)\\.txt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJavaAndKotlin"), Pattern.compile("^(.+)\\.txt$"), null, true); } @TestMetadata("MixedPackage.txt") @@ -1679,7 +1680,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInMixedPackage() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJavaAndKotlin/MixedPackage"), Pattern.compile("^(.+)\\.txt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJavaAndKotlin/MixedPackage"), Pattern.compile("^(.+)\\.txt$"), null, true); } } } @@ -1693,7 +1694,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInCompiledJavaIncludeObjectMethods() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJavaIncludeObjectMethods"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJavaIncludeObjectMethods"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("ClassWithObjectMethod.java") @@ -1721,7 +1722,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInCompiledKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/testData/loadJava/compiledKotlin/annotations") @@ -1733,7 +1734,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("AnnotatedAnnotation.kt") @@ -1790,7 +1791,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInClassMembers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/classMembers"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/classMembers"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassObjectPropertyField.kt") @@ -1858,7 +1859,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/classes"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/classes"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("AnnotationInClassObject.kt") @@ -1946,7 +1947,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInPackageMembers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/packageMembers"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/packageMembers"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("DelegatedProperty.kt") @@ -1999,7 +2000,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/parameters"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/parameters"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Constructor.kt") @@ -2072,7 +2073,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInPropertiesWithoutBackingFields() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Class.kt") @@ -2125,7 +2126,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/types"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/types"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassLiteralArgument.kt") @@ -2183,7 +2184,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInWithUseSiteTarget() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/withUseSiteTarget"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/withUseSiteTarget"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("DelegateTarget.kt") @@ -2217,7 +2218,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/class"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/class"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Class.kt") @@ -2414,7 +2415,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInJavaBean() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/class/javaBean"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/class/javaBean"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("DifferentGetterAndSetter.kt") @@ -2458,7 +2459,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInClassFun() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/classFun"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/classFun"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassInParamUsedInFun.kt") @@ -2496,7 +2497,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInClassObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/classObject"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/classObject"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassObjectDeclaresVal.kt") @@ -2574,7 +2575,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/constructor"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/constructor"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Constructor0.kt") @@ -2666,7 +2667,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInVararg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/constructor/vararg"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/constructor/vararg"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ConstructorNonLastVararg.kt") @@ -2690,7 +2691,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInCoroutines() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Basic.kt") @@ -2708,7 +2709,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInDataClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/dataClass"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/dataClass"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("MixedComponents.kt") @@ -2741,7 +2742,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/enum"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/enum"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("enumVisibility.kt") @@ -2784,7 +2785,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInFromLoadJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ArrayTypeVariance.kt") @@ -2971,7 +2972,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInKotlinSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ArrayType.kt") @@ -3063,7 +3064,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInError() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ConflictingProjectionKind.kt") @@ -3206,7 +3207,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInPropagation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("PropagateTypeArgumentNullable.kt") @@ -3223,7 +3224,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ChangeProjectionKind1.kt") @@ -3396,7 +3397,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInReturn() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("CantMakeImmutableInSubclass.kt") @@ -3549,7 +3550,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInTypeParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/typeParameter"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/typeParameter"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("InheritMutability.kt") @@ -3609,7 +3610,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInLibrary() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/library"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/library"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("LoadIterable.kt") @@ -3637,7 +3638,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInModality() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/modality"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/modality"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ModalityOfFakeOverrides.kt") @@ -3655,7 +3656,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInNotNull() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/notNull"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/notNull"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("NotNullField.kt") @@ -3694,7 +3695,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInFun() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Assert.kt") @@ -3761,7 +3762,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInGenericWithTypeVariables() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/genericWithTypeVariables"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/genericWithTypeVariables"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("FunGenericParam.kt") @@ -3824,7 +3825,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInGenericWithoutTypeVariables() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/genericWithoutTypeVariables"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/genericWithoutTypeVariables"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("FunClassParamNotNull.kt") @@ -3862,7 +3863,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInNonGeneric() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassFun.kt") @@ -3955,7 +3956,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInVararg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/vararg"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/vararg"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("nonLastVararg.kt") @@ -3984,7 +3985,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/inline"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/inline"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("inlineFunction.kt") @@ -4002,7 +4003,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInMemberOrder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/memberOrder"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/memberOrder"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("callablesNameClash.kt") @@ -4045,7 +4046,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInNested() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/nested"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/nested"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("deepInnerGeneric.kt") @@ -4073,7 +4074,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInPlatformTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/platformTypes"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/platformTypes"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("notnullTypeArgument.kt") @@ -4096,7 +4097,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInProp() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/prop"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/prop"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassVal.kt") @@ -4278,7 +4279,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInDefaultAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/prop/defaultAccessors"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/prop/defaultAccessors"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassVal.kt") @@ -4342,7 +4343,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/type"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/type"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Any.kt") @@ -4510,7 +4511,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInTypealias() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/typealias"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/typealias"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Annotations.kt") @@ -4543,7 +4544,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInVisibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/visibility"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/visibility"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("InternalClass.kt") @@ -4612,7 +4613,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInCompiledKotlinWithStdlib() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlinWithStdlib"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlinWithStdlib"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/testData/loadJava/compiledKotlinWithStdlib/annotations") @@ -4624,7 +4625,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlinWithStdlib/annotations"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlinWithStdlib/annotations"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ConstValInMultifileClass.kt") @@ -4652,7 +4653,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInContracts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlinWithStdlib/contracts"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlinWithStdlib/contracts"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("callsEffect.kt") @@ -4725,7 +4726,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInCoroutines() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlinWithStdlib/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlinWithStdlib/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("annotatedSuspendFun.kt") @@ -4743,7 +4744,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInMutability() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlinWithStdlib/mutability"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlinWithStdlib/mutability"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("LoadIterable.kt") @@ -4776,7 +4777,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInPlatformNames() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlinWithStdlib/platformNames"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlinWithStdlib/platformNames"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("functionName.kt") @@ -4795,7 +4796,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInJavaAgainstKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin"), Pattern.compile("^(.+)\\.txt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin"), Pattern.compile("^(.+)\\.txt$"), null, true); } @TestMetadata("compiler/testData/loadJava/javaAgainstKotlin/samAdapters") @@ -4807,7 +4808,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInSamAdapters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/samAdapters"), Pattern.compile("^(.+)\\.txt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/samAdapters"), Pattern.compile("^(.+)\\.txt$"), null, true); } @TestMetadata("InheritAmbguousSamAdaptersInKotlin.txt") @@ -4844,7 +4845,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInInheritAmbguousSamAdaptersInKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/samAdapters/InheritAmbguousSamAdaptersInKotlin"), Pattern.compile("^(.+)\\.txt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/samAdapters/InheritAmbguousSamAdaptersInKotlin"), Pattern.compile("^(.+)\\.txt$"), null, true); } } @@ -4857,7 +4858,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInInheritSamAdapterInKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/samAdapters/InheritSamAdapterInKotlin"), Pattern.compile("^(.+)\\.txt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/samAdapters/InheritSamAdapterInKotlin"), Pattern.compile("^(.+)\\.txt$"), null, true); } } @@ -4870,7 +4871,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInOverrideSamAdapterInKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/samAdapters/OverrideSamAdapterInKotlin"), Pattern.compile("^(.+)\\.txt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/samAdapters/OverrideSamAdapterInKotlin"), Pattern.compile("^(.+)\\.txt$"), null, true); } } @@ -4883,7 +4884,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInSamAdapterForInheritedFromKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/samAdapters/SamAdapterForInheritedFromKotlin"), Pattern.compile("^(.+)\\.txt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/samAdapters/SamAdapterForInheritedFromKotlin"), Pattern.compile("^(.+)\\.txt$"), null, true); } } @@ -4896,7 +4897,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInSamAdapterForOverriddenFromKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/samAdapters/SamAdapterForOverriddenFromKotlin"), Pattern.compile("^(.+)\\.txt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/samAdapters/SamAdapterForOverriddenFromKotlin"), Pattern.compile("^(.+)\\.txt$"), null, true); } } } @@ -4910,7 +4911,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInSignaturePropagation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation"), Pattern.compile("^(.+)\\.txt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation"), Pattern.compile("^(.+)\\.txt$"), null, true); } @TestMetadata("DeepSubclassingKotlinInJava.txt") @@ -4947,7 +4948,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInDeepSubclassingKotlinInJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/DeepSubclassingKotlinInJava"), Pattern.compile("^(.+)\\.txt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/DeepSubclassingKotlinInJava"), Pattern.compile("^(.+)\\.txt$"), null, true); } } @@ -4960,7 +4961,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInInheritExtensionAndNot() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/InheritExtensionAndNot"), Pattern.compile("^(.+)\\.txt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/InheritExtensionAndNot"), Pattern.compile("^(.+)\\.txt$"), null, true); } } @@ -4973,7 +4974,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInInheritExtensionFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/InheritExtensionFunction"), Pattern.compile("^(.+)\\.txt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/InheritExtensionFunction"), Pattern.compile("^(.+)\\.txt$"), null, true); } } @@ -4986,7 +4987,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInSubclassFromTraitImplementation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/SubclassFromTraitImplementation"), Pattern.compile("^(.+)\\.txt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/SubclassFromTraitImplementation"), Pattern.compile("^(.+)\\.txt$"), null, true); } } @@ -4999,7 +5000,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInSubclassingKotlinInJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/SubclassingKotlinInJava"), Pattern.compile("^(.+)\\.txt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/signaturePropagation/SubclassingKotlinInJava"), Pattern.compile("^(.+)\\.txt$"), null, true); } } } @@ -5013,7 +5014,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInVisibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/visibility"), Pattern.compile("^(.+)\\.txt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/visibility"), Pattern.compile("^(.+)\\.txt$"), null, true); } @TestMetadata("PackageLocal.txt") @@ -5035,7 +5036,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInPackageLocal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/visibility/PackageLocal"), Pattern.compile("^(.+)\\.txt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/visibility/PackageLocal"), Pattern.compile("^(.+)\\.txt$"), null, true); } } @@ -5048,7 +5049,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInProtectedPackage() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/visibility/ProtectedPackage"), Pattern.compile("^(.+)\\.txt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/javaAgainstKotlin/visibility/ProtectedPackage"), Pattern.compile("^(.+)\\.txt$"), null, true); } } } @@ -5063,7 +5064,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInKotlinAgainstCompiledJavaWithKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/kotlinAgainstCompiledJavaWithKotlin"), Pattern.compile("^(.+)\\.kt$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/kotlinAgainstCompiledJavaWithKotlin"), Pattern.compile("^(.+)\\.kt$"), null, false); } @TestMetadata("InheritJavaField.kt") @@ -5101,7 +5102,7 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT } public void testAllFilesPresentInSourceJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/sourceJava"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/sourceJava"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("ClassExtendsTypeParameter.java") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/lexer/kdoc/KDocLexerTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/lexer/kdoc/KDocLexerTestGenerated.java index b4f6409368a..92ae10fd299 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/lexer/kdoc/KDocLexerTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/lexer/kdoc/KDocLexerTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.lexer.kdoc; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class KDocLexerTestGenerated extends AbstractKDocLexerTest { } public void testAllFilesPresentInKdoc() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/lexer/kdoc"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/lexer/kdoc"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("codeBlocks.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/lexer/kotlin/KotlinLexerTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/lexer/kotlin/KotlinLexerTestGenerated.java index 196423aec5b..8e8cb972073 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/lexer/kotlin/KotlinLexerTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/lexer/kotlin/KotlinLexerTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.lexer.kotlin; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class KotlinLexerTestGenerated extends AbstractKotlinLexerTest { } public void testAllFilesPresentInKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/lexer/kotlin"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/lexer/kotlin"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/testData/lexer/kotlin/whitespaceCharacters") @@ -37,7 +38,7 @@ public class KotlinLexerTestGenerated extends AbstractKotlinLexerTest { } public void testAllFilesPresentInWhitespaceCharacters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/lexer/kotlin/whitespaceCharacters"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/lexer/kotlin/whitespaceCharacters"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/testData/lexer/kotlin/whitespaceCharacters/carriageReturn") @@ -49,7 +50,7 @@ public class KotlinLexerTestGenerated extends AbstractKotlinLexerTest { } public void testAllFilesPresentInCarriageReturn() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/lexer/kotlin/whitespaceCharacters/carriageReturn"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/lexer/kotlin/whitespaceCharacters/carriageReturn"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("carriageReturn.kt") @@ -77,7 +78,7 @@ public class KotlinLexerTestGenerated extends AbstractKotlinLexerTest { } public void testAllFilesPresentInLineSeparator() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/lexer/kotlin/whitespaceCharacters/lineSeparator"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/lexer/kotlin/whitespaceCharacters/lineSeparator"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("lineSeparator.kt") @@ -105,7 +106,7 @@ public class KotlinLexerTestGenerated extends AbstractKotlinLexerTest { } public void testAllFilesPresentInNextLine() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/lexer/kotlin/whitespaceCharacters/nextLine"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/lexer/kotlin/whitespaceCharacters/nextLine"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("nextLine.kt") @@ -133,7 +134,7 @@ public class KotlinLexerTestGenerated extends AbstractKotlinLexerTest { } public void testAllFilesPresentInPageBreak() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/lexer/kotlin/whitespaceCharacters/pageBreak"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/lexer/kotlin/whitespaceCharacters/pageBreak"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("pageBreak.kt") @@ -161,7 +162,7 @@ public class KotlinLexerTestGenerated extends AbstractKotlinLexerTest { } public void testAllFilesPresentInParagraphSeparator() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/lexer/kotlin/whitespaceCharacters/paragraphSeparator"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/lexer/kotlin/whitespaceCharacters/paragraphSeparator"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("paragraphSeparator.kt") @@ -189,7 +190,7 @@ public class KotlinLexerTestGenerated extends AbstractKotlinLexerTest { } public void testAllFilesPresentInVerticalTab() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/lexer/kotlin/whitespaceCharacters/verticalTab"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/lexer/kotlin/whitespaceCharacters/verticalTab"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("verticalTab.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/modules/xml/ModuleXmlParserTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/modules/xml/ModuleXmlParserTestGenerated.java index af3169ced9e..25e0ac6760e 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/modules/xml/ModuleXmlParserTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/modules/xml/ModuleXmlParserTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.modules.xml; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class ModuleXmlParserTestGenerated extends AbstractModuleXmlParserTest { } public void testAllFilesPresentInModules_xml() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/modules.xml"), Pattern.compile("^(.+)\\.xml$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/modules.xml"), Pattern.compile("^(.+)\\.xml$"), null, true); } @TestMetadata("allOnce.xml") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/multiplatform/MultiPlatformIntegrationTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/multiplatform/MultiPlatformIntegrationTestGenerated.java index 13389bede3b..247210a1663 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/multiplatform/MultiPlatformIntegrationTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/multiplatform/MultiPlatformIntegrationTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.multiplatform; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class MultiPlatformIntegrationTestGenerated extends AbstractMultiPlatform } public void testAllFilesPresentInMultiplatform() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("compatibleProperties") @@ -152,7 +153,7 @@ public class MultiPlatformIntegrationTestGenerated extends AbstractMultiPlatform } public void testAllFilesPresentInClassScopes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/classScopes"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/classScopes"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("constructorIncorrectSignature") @@ -209,7 +210,7 @@ public class MultiPlatformIntegrationTestGenerated extends AbstractMultiPlatform } public void testAllFilesPresentInConstructorIncorrectSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/classScopes/constructorIncorrectSignature"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/classScopes/constructorIncorrectSignature"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -222,7 +223,7 @@ public class MultiPlatformIntegrationTestGenerated extends AbstractMultiPlatform } public void testAllFilesPresentInEnumsWithDifferentEntries() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/classScopes/enumsWithDifferentEntries"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/classScopes/enumsWithDifferentEntries"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -235,7 +236,7 @@ public class MultiPlatformIntegrationTestGenerated extends AbstractMultiPlatform } public void testAllFilesPresentInFakeOverrides() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/classScopes/fakeOverrides"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/classScopes/fakeOverrides"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -248,7 +249,7 @@ public class MultiPlatformIntegrationTestGenerated extends AbstractMultiPlatform } public void testAllFilesPresentInFunctionAndPropertyWithSameName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/classScopes/functionAndPropertyWithSameName"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/classScopes/functionAndPropertyWithSameName"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -261,7 +262,7 @@ public class MultiPlatformIntegrationTestGenerated extends AbstractMultiPlatform } public void testAllFilesPresentInFunctionIncorrectSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/classScopes/functionIncorrectSignature"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/classScopes/functionIncorrectSignature"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -274,7 +275,7 @@ public class MultiPlatformIntegrationTestGenerated extends AbstractMultiPlatform } public void testAllFilesPresentInFunctionIncorrectSignatureFromSuperclass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/classScopes/functionIncorrectSignatureFromSuperclass"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/classScopes/functionIncorrectSignatureFromSuperclass"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -287,7 +288,7 @@ public class MultiPlatformIntegrationTestGenerated extends AbstractMultiPlatform } public void testAllFilesPresentInMissingConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/classScopes/missingConstructor"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/classScopes/missingConstructor"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -300,7 +301,7 @@ public class MultiPlatformIntegrationTestGenerated extends AbstractMultiPlatform } public void testAllFilesPresentInMissingFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/classScopes/missingFunction"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/classScopes/missingFunction"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -313,7 +314,7 @@ public class MultiPlatformIntegrationTestGenerated extends AbstractMultiPlatform } public void testAllFilesPresentInSimple() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/classScopes/simple"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/classScopes/simple"), Pattern.compile("^([^\\.]+)$"), null, true); } } } @@ -327,7 +328,7 @@ public class MultiPlatformIntegrationTestGenerated extends AbstractMultiPlatform } public void testAllFilesPresentInCompatibleProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/compatibleProperties"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/compatibleProperties"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -340,7 +341,7 @@ public class MultiPlatformIntegrationTestGenerated extends AbstractMultiPlatform } public void testAllFilesPresentInCompilerArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/compilerArguments"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/compilerArguments"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -353,7 +354,7 @@ public class MultiPlatformIntegrationTestGenerated extends AbstractMultiPlatform } public void testAllFilesPresentInContracts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/contracts"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/contracts"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -366,7 +367,7 @@ public class MultiPlatformIntegrationTestGenerated extends AbstractMultiPlatform } public void testAllFilesPresentInCreateImplClassInPlatformModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/createImplClassInPlatformModule"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/createImplClassInPlatformModule"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -379,7 +380,7 @@ public class MultiPlatformIntegrationTestGenerated extends AbstractMultiPlatform } public void testAllFilesPresentInDefaultArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/defaultArguments"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/defaultArguments"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("useDefaultArgumentsInDependency") @@ -396,7 +397,7 @@ public class MultiPlatformIntegrationTestGenerated extends AbstractMultiPlatform } public void testAllFilesPresentInUseDefaultArgumentsInDependency() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/defaultArguments/useDefaultArgumentsInDependency"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/defaultArguments/useDefaultArgumentsInDependency"), Pattern.compile("^([^\\.]+)$"), null, true); } } } @@ -410,7 +411,7 @@ public class MultiPlatformIntegrationTestGenerated extends AbstractMultiPlatform } public void testAllFilesPresentInExplicitActualOnOverrideOfAbstractMethod() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/explicitActualOnOverrideOfAbstractMethod"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/explicitActualOnOverrideOfAbstractMethod"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -423,7 +424,7 @@ public class MultiPlatformIntegrationTestGenerated extends AbstractMultiPlatform } public void testAllFilesPresentInFunInterfaces() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/funInterfaces"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/funInterfaces"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -436,7 +437,7 @@ public class MultiPlatformIntegrationTestGenerated extends AbstractMultiPlatform } public void testAllFilesPresentInGenericDeclarations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/genericDeclarations"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/genericDeclarations"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -449,7 +450,7 @@ public class MultiPlatformIntegrationTestGenerated extends AbstractMultiPlatform } public void testAllFilesPresentInImplTypeAlias() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/implTypeAlias"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/implTypeAlias"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("discriminateHeaderClassInFavorOfTypeAlias") @@ -476,7 +477,7 @@ public class MultiPlatformIntegrationTestGenerated extends AbstractMultiPlatform } public void testAllFilesPresentInDiscriminateHeaderClassInFavorOfTypeAlias() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/implTypeAlias/discriminateHeaderClassInFavorOfTypeAlias"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/implTypeAlias/discriminateHeaderClassInFavorOfTypeAlias"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -489,7 +490,7 @@ public class MultiPlatformIntegrationTestGenerated extends AbstractMultiPlatform } public void testAllFilesPresentInGeneric() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/implTypeAlias/generic"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/implTypeAlias/generic"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -502,7 +503,7 @@ public class MultiPlatformIntegrationTestGenerated extends AbstractMultiPlatform } public void testAllFilesPresentInNestedClassesViaTypeAlias() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/implTypeAlias/nestedClassesViaTypeAlias"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/implTypeAlias/nestedClassesViaTypeAlias"), Pattern.compile("^([^\\.]+)$"), null, true); } } } @@ -516,7 +517,7 @@ public class MultiPlatformIntegrationTestGenerated extends AbstractMultiPlatform } public void testAllFilesPresentInIncompatibleCallables() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/incompatibleCallables"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/incompatibleCallables"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -529,7 +530,7 @@ public class MultiPlatformIntegrationTestGenerated extends AbstractMultiPlatform } public void testAllFilesPresentInIncompatibleClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/incompatibleClasses"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/incompatibleClasses"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -542,7 +543,7 @@ public class MultiPlatformIntegrationTestGenerated extends AbstractMultiPlatform } public void testAllFilesPresentInIncompatibleFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/incompatibleFunctions"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/incompatibleFunctions"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -555,7 +556,7 @@ public class MultiPlatformIntegrationTestGenerated extends AbstractMultiPlatform } public void testAllFilesPresentInIncompatibleNestedClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/incompatibleNestedClasses"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/incompatibleNestedClasses"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -568,7 +569,7 @@ public class MultiPlatformIntegrationTestGenerated extends AbstractMultiPlatform } public void testAllFilesPresentInIncompatibleProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/incompatibleProperties"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/incompatibleProperties"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -581,7 +582,7 @@ public class MultiPlatformIntegrationTestGenerated extends AbstractMultiPlatform } public void testAllFilesPresentInIncorrectImplInClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/incorrectImplInClass"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/incorrectImplInClass"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -594,7 +595,7 @@ public class MultiPlatformIntegrationTestGenerated extends AbstractMultiPlatform } public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/inlineClasses"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/inlineClasses"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -607,7 +608,7 @@ public class MultiPlatformIntegrationTestGenerated extends AbstractMultiPlatform } public void testAllFilesPresentInInnerGenericClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/innerGenericClass"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/innerGenericClass"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -620,7 +621,7 @@ public class MultiPlatformIntegrationTestGenerated extends AbstractMultiPlatform } public void testAllFilesPresentInJsNameClash() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/jsNameClash"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/jsNameClash"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -633,7 +634,7 @@ public class MultiPlatformIntegrationTestGenerated extends AbstractMultiPlatform } public void testAllFilesPresentInJvmMultifileClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/jvmMultifileClass"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/jvmMultifileClass"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -646,7 +647,7 @@ public class MultiPlatformIntegrationTestGenerated extends AbstractMultiPlatform } public void testAllFilesPresentInMissingOverload() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/missingOverload"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/missingOverload"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -659,7 +660,7 @@ public class MultiPlatformIntegrationTestGenerated extends AbstractMultiPlatform } public void testAllFilesPresentInOptionalExpectation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/optionalExpectation"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/optionalExpectation"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -672,7 +673,7 @@ public class MultiPlatformIntegrationTestGenerated extends AbstractMultiPlatform } public void testAllFilesPresentInOptionalExpectationIncorrectUse() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/optionalExpectationIncorrectUse"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/optionalExpectationIncorrectUse"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -685,7 +686,7 @@ public class MultiPlatformIntegrationTestGenerated extends AbstractMultiPlatform } public void testAllFilesPresentInRegressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/regressions"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/regressions"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("incompatibleClassScopesWithImplTypeAlias") @@ -712,7 +713,7 @@ public class MultiPlatformIntegrationTestGenerated extends AbstractMultiPlatform } public void testAllFilesPresentInIncompatibleClassScopesWithImplTypeAlias() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/regressions/incompatibleClassScopesWithImplTypeAlias"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/regressions/incompatibleClassScopesWithImplTypeAlias"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -725,7 +726,7 @@ public class MultiPlatformIntegrationTestGenerated extends AbstractMultiPlatform } public void testAllFilesPresentInKt17001() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/regressions/kt17001"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/regressions/kt17001"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -738,7 +739,7 @@ public class MultiPlatformIntegrationTestGenerated extends AbstractMultiPlatform } public void testAllFilesPresentInKt28385() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/regressions/kt28385"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/regressions/kt28385"), Pattern.compile("^([^\\.]+)$"), null, true); } } } @@ -752,7 +753,7 @@ public class MultiPlatformIntegrationTestGenerated extends AbstractMultiPlatform } public void testAllFilesPresentInSimple() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/simple"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/simple"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -765,7 +766,7 @@ public class MultiPlatformIntegrationTestGenerated extends AbstractMultiPlatform } public void testAllFilesPresentInSimpleNoImplKeywordOnTopLevelFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/simpleNoImplKeywordOnTopLevelFunction"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/simpleNoImplKeywordOnTopLevelFunction"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -778,7 +779,7 @@ public class MultiPlatformIntegrationTestGenerated extends AbstractMultiPlatform } public void testAllFilesPresentInWeakIncompatibilityWithoutActualModifier() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/weakIncompatibilityWithoutActualModifier"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/multiplatform/weakIncompatibilityWithoutActualModifier"), Pattern.compile("^([^\\.]+)$"), null, true); } } } diff --git a/compiler/tests-gen/org/jetbrains/kotlin/parsing/ParsingTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/parsing/ParsingTestGenerated.java index fa2e42f6ba6..e1581e98ba7 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/parsing/ParsingTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/parsing/ParsingTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.parsing; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -32,7 +33,7 @@ public class ParsingTestGenerated extends AbstractParsingTest { } public void testAllFilesPresentInPsi() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi"), Pattern.compile("^(.*)\\.kts?$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi"), Pattern.compile("^(.*)\\.kts?$"), null, true); } @TestMetadata("AnonymousInitializer.kt") @@ -764,7 +765,7 @@ public class ParsingTestGenerated extends AbstractParsingTest { } public void testAllFilesPresentInAnnotation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/annotation"), Pattern.compile("^(.*)\\.kts?$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/annotation"), Pattern.compile("^(.*)\\.kts?$"), null, true); } @TestMetadata("AnnotatedExpressions.kt") @@ -841,7 +842,7 @@ public class ParsingTestGenerated extends AbstractParsingTest { } public void testAllFilesPresentInAt() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/annotation/at"), Pattern.compile("^(.*)\\.kts?$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/annotation/at"), Pattern.compile("^(.*)\\.kts?$"), null, true); } @TestMetadata("annotationAtFileStart.kt") @@ -929,7 +930,7 @@ public class ParsingTestGenerated extends AbstractParsingTest { } public void testAllFilesPresentInFunctionalTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/annotation/functionalTypes"), Pattern.compile("^(.*)\\.kts?$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/annotation/functionalTypes"), Pattern.compile("^(.*)\\.kts?$"), null, true); } @TestMetadata("compiler/testData/psi/annotation/functionalTypes/regressionForSimilarSyntax") @@ -941,7 +942,7 @@ public class ParsingTestGenerated extends AbstractParsingTest { } public void testAllFilesPresentInRegressionForSimilarSyntax() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/annotation/functionalTypes/regressionForSimilarSyntax"), Pattern.compile("^(.*)\\.kts?$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/annotation/functionalTypes/regressionForSimilarSyntax"), Pattern.compile("^(.*)\\.kts?$"), null, true); } @TestMetadata("forDestructuring.kt") @@ -969,7 +970,7 @@ public class ParsingTestGenerated extends AbstractParsingTest { } public void testAllFilesPresentInWithParentheses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/annotation/functionalTypes/withParentheses"), Pattern.compile("^(.*)\\.kts?$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/annotation/functionalTypes/withParentheses"), Pattern.compile("^(.*)\\.kts?$"), null, true); } @TestMetadata("withParameter.kt") @@ -992,7 +993,7 @@ public class ParsingTestGenerated extends AbstractParsingTest { } public void testAllFilesPresentInWithoutParentheses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/annotation/functionalTypes/withoutParentheses"), Pattern.compile("^(.*)\\.kts?$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/annotation/functionalTypes/withoutParentheses"), Pattern.compile("^(.*)\\.kts?$"), null, true); } @TestMetadata("annotationList.kt") @@ -1031,7 +1032,7 @@ public class ParsingTestGenerated extends AbstractParsingTest { } public void testAllFilesPresentInList() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/annotation/list"), Pattern.compile("^(.*)\\.kts?$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/annotation/list"), Pattern.compile("^(.*)\\.kts?$"), null, true); } @TestMetadata("basic.kt") @@ -1054,7 +1055,7 @@ public class ParsingTestGenerated extends AbstractParsingTest { } public void testAllFilesPresentInModifiersMigration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/annotation/modifiersMigration"), Pattern.compile("^(.*)\\.kts?$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/annotation/modifiersMigration"), Pattern.compile("^(.*)\\.kts?$"), null, true); } @TestMetadata("newModifiers.kt") @@ -1077,7 +1078,7 @@ public class ParsingTestGenerated extends AbstractParsingTest { } public void testAllFilesPresentInOptions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/annotation/options"), Pattern.compile("^(.*)\\.kts?$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/annotation/options"), Pattern.compile("^(.*)\\.kts?$"), null, true); } @TestMetadata("annotationAsArg.kt") @@ -1110,7 +1111,7 @@ public class ParsingTestGenerated extends AbstractParsingTest { } public void testAllFilesPresentInTargeted() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/annotation/targeted"), Pattern.compile("^(.*)\\.kts?$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/annotation/targeted"), Pattern.compile("^(.*)\\.kts?$"), null, true); } @TestMetadata("compiler/testData/psi/annotation/targeted/onField") @@ -1122,7 +1123,7 @@ public class ParsingTestGenerated extends AbstractParsingTest { } public void testAllFilesPresentInOnField() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/annotation/targeted/onField"), Pattern.compile("^(.*)\\.kts?$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/annotation/targeted/onField"), Pattern.compile("^(.*)\\.kts?$"), null, true); } @TestMetadata("delegate.kt") @@ -1160,7 +1161,7 @@ public class ParsingTestGenerated extends AbstractParsingTest { } public void testAllFilesPresentInOnFile() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/annotation/targeted/onFile"), Pattern.compile("^(.*)\\.kts?$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/annotation/targeted/onFile"), Pattern.compile("^(.*)\\.kts?$"), null, true); } @TestMetadata("fileAnnotationInWrongPlace.kt") @@ -1213,7 +1214,7 @@ public class ParsingTestGenerated extends AbstractParsingTest { } public void testAllFilesPresentInOnGetSetSparam() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/annotation/targeted/onGetSetSparam"), Pattern.compile("^(.*)\\.kts?$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/annotation/targeted/onGetSetSparam"), Pattern.compile("^(.*)\\.kts?$"), null, true); } @TestMetadata("inWrongPlace.kt") @@ -1241,7 +1242,7 @@ public class ParsingTestGenerated extends AbstractParsingTest { } public void testAllFilesPresentInOnParam() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/annotation/targeted/onParam"), Pattern.compile("^(.*)\\.kts?$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/annotation/targeted/onParam"), Pattern.compile("^(.*)\\.kts?$"), null, true); } @TestMetadata("modifiers.kt") @@ -1276,7 +1277,7 @@ public class ParsingTestGenerated extends AbstractParsingTest { } public void testAllFilesPresentInContracts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/contracts"), Pattern.compile("^(.*)\\.kts?$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/contracts"), Pattern.compile("^(.*)\\.kts?$"), null, true); } @TestMetadata("FunctionWithMultilineContract.kt") @@ -1309,7 +1310,7 @@ public class ParsingTestGenerated extends AbstractParsingTest { } public void testAllFilesPresentInExamples() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/examples"), Pattern.compile("^(.*)\\.kts?$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/examples"), Pattern.compile("^(.*)\\.kts?$"), null, true); } @TestMetadata("AnonymousObjects.kt") @@ -1391,7 +1392,7 @@ public class ParsingTestGenerated extends AbstractParsingTest { } public void testAllFilesPresentInArray() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/examples/array"), Pattern.compile("^(.*)\\.kts?$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/examples/array"), Pattern.compile("^(.*)\\.kts?$"), null, true); } @TestMetadata("MutableArray.kt") @@ -1409,7 +1410,7 @@ public class ParsingTestGenerated extends AbstractParsingTest { } public void testAllFilesPresentInCollections() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/examples/collections"), Pattern.compile("^(.*)\\.kts?$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/examples/collections"), Pattern.compile("^(.*)\\.kts?$"), null, true); } @TestMetadata("ArrayList.kt") @@ -1482,7 +1483,7 @@ public class ParsingTestGenerated extends AbstractParsingTest { } public void testAllFilesPresentInIo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/examples/io"), Pattern.compile("^(.*)\\.kts?$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/examples/io"), Pattern.compile("^(.*)\\.kts?$"), null, true); } @TestMetadata("IOSamples.kt") @@ -1500,7 +1501,7 @@ public class ParsingTestGenerated extends AbstractParsingTest { } public void testAllFilesPresentInMap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/examples/map"), Pattern.compile("^(.*)\\.kts?$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/examples/map"), Pattern.compile("^(.*)\\.kts?$"), null, true); } @TestMetadata("IMap.kt") @@ -1518,7 +1519,7 @@ public class ParsingTestGenerated extends AbstractParsingTest { } public void testAllFilesPresentInPriorityqueues() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/examples/priorityqueues"), Pattern.compile("^(.*)\\.kts?$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/examples/priorityqueues"), Pattern.compile("^(.*)\\.kts?$"), null, true); } @TestMetadata("BinaryHeap.kt") @@ -1546,7 +1547,7 @@ public class ParsingTestGenerated extends AbstractParsingTest { } public void testAllFilesPresentInUtil() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/examples/util"), Pattern.compile("^(.*)\\.kts?$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/examples/util"), Pattern.compile("^(.*)\\.kts?$"), null, true); } @TestMetadata("Comparison.kt") @@ -1570,7 +1571,7 @@ public class ParsingTestGenerated extends AbstractParsingTest { } public void testAllFilesPresentInFunctionReceivers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/functionReceivers"), Pattern.compile("^(.*)\\.kts?$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/functionReceivers"), Pattern.compile("^(.*)\\.kts?$"), null, true); } @TestMetadata("FunctionTypesWithFunctionReceivers.kt") @@ -1618,7 +1619,7 @@ public class ParsingTestGenerated extends AbstractParsingTest { } public void testAllFilesPresentInGreatSyntacticShift() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/greatSyntacticShift"), Pattern.compile("^(.*)\\.kts?$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/greatSyntacticShift"), Pattern.compile("^(.*)\\.kts?$"), null, true); } @TestMetadata("functionLiterals.kt") @@ -1651,7 +1652,7 @@ public class ParsingTestGenerated extends AbstractParsingTest { } public void testAllFilesPresentInKdoc() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/kdoc"), Pattern.compile("^(.*)\\.kts?$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/kdoc"), Pattern.compile("^(.*)\\.kts?$"), null, true); } @TestMetadata("AtTags.kt") @@ -1774,7 +1775,7 @@ public class ParsingTestGenerated extends AbstractParsingTest { } public void testAllFilesPresentInNewLabels() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/newLabels"), Pattern.compile("^(.*)\\.kts?$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/newLabels"), Pattern.compile("^(.*)\\.kts?$"), null, true); } @TestMetadata("basic.kt") @@ -1807,7 +1808,7 @@ public class ParsingTestGenerated extends AbstractParsingTest { } public void testAllFilesPresentInPackages() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/packages"), Pattern.compile("^(.*)\\.kts?$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/packages"), Pattern.compile("^(.*)\\.kts?$"), null, true); } @TestMetadata("PackageBlockFirst.kt") @@ -1875,7 +1876,7 @@ public class ParsingTestGenerated extends AbstractParsingTest { } public void testAllFilesPresentInPlatformTypesRecovery() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/platformTypesRecovery"), Pattern.compile("^(.*)\\.kts?$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/platformTypesRecovery"), Pattern.compile("^(.*)\\.kts?$"), null, true); } @TestMetadata("Array.kt") @@ -1938,7 +1939,7 @@ public class ParsingTestGenerated extends AbstractParsingTest { } public void testAllFilesPresentInPrimaryConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/primaryConstructor"), Pattern.compile("^(.*)\\.kts?$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/primaryConstructor"), Pattern.compile("^(.*)\\.kts?$"), null, true); } @TestMetadata("local.kt") @@ -1976,7 +1977,7 @@ public class ParsingTestGenerated extends AbstractParsingTest { } public void testAllFilesPresentInPropertyDelegate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/propertyDelegate"), Pattern.compile("^(.*)\\.kts?$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/propertyDelegate"), Pattern.compile("^(.*)\\.kts?$"), null, true); } @TestMetadata("BracketsInDelegate.kt") @@ -2049,7 +2050,7 @@ public class ParsingTestGenerated extends AbstractParsingTest { } public void testAllFilesPresentInRecovery() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/recovery"), Pattern.compile("^(.*)\\.kts?$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/recovery"), Pattern.compile("^(.*)\\.kts?$"), null, true); } @TestMetadata("BareVal.kt") @@ -2396,7 +2397,7 @@ public class ParsingTestGenerated extends AbstractParsingTest { } public void testAllFilesPresentInObjects() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/recovery/objects"), Pattern.compile("^(.*)\\.kts?$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/recovery/objects"), Pattern.compile("^(.*)\\.kts?$"), null, true); } @TestMetadata("compiler/testData/psi/recovery/objects/declarations") @@ -2408,7 +2409,7 @@ public class ParsingTestGenerated extends AbstractParsingTest { } public void testAllFilesPresentInDeclarations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/recovery/objects/declarations"), Pattern.compile("^(.*)\\.kts?$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/recovery/objects/declarations"), Pattern.compile("^(.*)\\.kts?$"), null, true); } @TestMetadata("ConstructorModifiers.kt") @@ -2461,7 +2462,7 @@ public class ParsingTestGenerated extends AbstractParsingTest { } public void testAllFilesPresentInExpressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/recovery/objects/expressions"), Pattern.compile("^(.*)\\.kts?$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/recovery/objects/expressions"), Pattern.compile("^(.*)\\.kts?$"), null, true); } @TestMetadata("ConstructorModifiers.kt") @@ -2520,7 +2521,7 @@ public class ParsingTestGenerated extends AbstractParsingTest { } public void testAllFilesPresentInQualifiedExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/recovery/qualifiedExpression"), Pattern.compile("^(.*)\\.kts?$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/recovery/qualifiedExpression"), Pattern.compile("^(.*)\\.kts?$"), null, true); } @TestMetadata("noQualifiedExpression.kt") @@ -2563,7 +2564,7 @@ public class ParsingTestGenerated extends AbstractParsingTest { } public void testAllFilesPresentInUnnamedParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/recovery/unnamedParameter"), Pattern.compile("^(.*)\\.kts?$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/recovery/unnamedParameter"), Pattern.compile("^(.*)\\.kts?$"), null, true); } @TestMetadata("firstInFunction.kt") @@ -2632,7 +2633,7 @@ public class ParsingTestGenerated extends AbstractParsingTest { } public void testAllFilesPresentInScript() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/script"), Pattern.compile("^(.*)\\.kts?$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/script"), Pattern.compile("^(.*)\\.kts?$"), null, true); } @TestMetadata("ComplexScript.kts") @@ -2705,7 +2706,7 @@ public class ParsingTestGenerated extends AbstractParsingTest { } public void testAllFilesPresentInSecondaryConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/secondaryConstructors"), Pattern.compile("^(.*)\\.kts?$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/secondaryConstructors"), Pattern.compile("^(.*)\\.kts?$"), null, true); } @TestMetadata("anonymousInitializer.kt") @@ -2773,7 +2774,7 @@ public class ParsingTestGenerated extends AbstractParsingTest { } public void testAllFilesPresentInStringTemplates() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/stringTemplates"), Pattern.compile("^(.*)\\.kts?$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/stringTemplates"), Pattern.compile("^(.*)\\.kts?$"), null, true); } @TestMetadata("RawStringsWithManyQuotes.kt") @@ -2802,7 +2803,7 @@ public class ParsingTestGenerated extends AbstractParsingTest { } public void testAllFilesPresentInExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/parseCodeFragment/expression"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/parseCodeFragment/expression"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("error.kt") @@ -2825,7 +2826,7 @@ public class ParsingTestGenerated extends AbstractParsingTest { } public void testAllFilesPresentInBlock() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/parseCodeFragment/block"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/parseCodeFragment/block"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("expressionOnTopLevel.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/renderer/DescriptorRendererTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/renderer/DescriptorRendererTestGenerated.java index 9e15cf03aef..d5d1a9e0927 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/renderer/DescriptorRendererTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/renderer/DescriptorRendererTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.renderer; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class DescriptorRendererTestGenerated extends AbstractDescriptorRendererT } public void testAllFilesPresentInRenderer() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/renderer"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/renderer"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Classes.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/renderer/FunctionDescriptorInExpressionRendererTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/renderer/FunctionDescriptorInExpressionRendererTestGenerated.java index 59839923cc7..95e240e3cc6 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/renderer/FunctionDescriptorInExpressionRendererTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/renderer/FunctionDescriptorInExpressionRendererTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.renderer; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class FunctionDescriptorInExpressionRendererTestGenerated extends Abstrac } public void testAllFilesPresentInRenderFunctionDescriptorInExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/renderFunctionDescriptorInExpression"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/renderFunctionDescriptorInExpression"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("basicFunExpr.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/repl/ReplInterpreterTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/repl/ReplInterpreterTestGenerated.java index 988adebb373..13086e76aa1 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/repl/ReplInterpreterTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/repl/ReplInterpreterTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.repl; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class ReplInterpreterTestGenerated extends AbstractReplInterpreterTest { } public void testAllFilesPresentInRepl() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/repl"), Pattern.compile("^(.+)\\.repl$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/repl"), Pattern.compile("^(.+)\\.repl$"), null, true); } @TestMetadata("analyzeErrors.repl") @@ -137,7 +138,7 @@ public class ReplInterpreterTestGenerated extends AbstractReplInterpreterTest { } public void testAllFilesPresentInClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/repl/classes"), Pattern.compile("^(.+)\\.repl$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/repl/classes"), Pattern.compile("^(.+)\\.repl$"), null, true); } @TestMetadata("classInheritance.repl") @@ -200,7 +201,7 @@ public class ReplInterpreterTestGenerated extends AbstractReplInterpreterTest { } public void testAllFilesPresentInControlFlow() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/repl/controlFlow"), Pattern.compile("^(.+)\\.repl$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/repl/controlFlow"), Pattern.compile("^(.+)\\.repl$"), null, true); } @TestMetadata("functionWithoutReturn.repl") @@ -248,7 +249,7 @@ public class ReplInterpreterTestGenerated extends AbstractReplInterpreterTest { } public void testAllFilesPresentInModules() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/repl/modules"), Pattern.compile("^(.+)\\.repl$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/repl/modules"), Pattern.compile("^(.+)\\.repl$"), null, true); } @TestMetadata("kt10001.repl") @@ -266,7 +267,7 @@ public class ReplInterpreterTestGenerated extends AbstractReplInterpreterTest { } public void testAllFilesPresentInMultiline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/repl/multiline"), Pattern.compile("^(.+)\\.repl$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/repl/multiline"), Pattern.compile("^(.+)\\.repl$"), null, true); } @TestMetadata("blankLinesAndComments.repl") @@ -304,7 +305,7 @@ public class ReplInterpreterTestGenerated extends AbstractReplInterpreterTest { } public void testAllFilesPresentInObjects() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/repl/objects"), Pattern.compile("^(.+)\\.repl$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/repl/objects"), Pattern.compile("^(.+)\\.repl$"), null, true); } @TestMetadata("emptyObject.repl") @@ -332,7 +333,7 @@ public class ReplInterpreterTestGenerated extends AbstractReplInterpreterTest { } public void testAllFilesPresentInPrimitiveTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/repl/primitiveTypes"), Pattern.compile("^(.+)\\.repl$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/repl/primitiveTypes"), Pattern.compile("^(.+)\\.repl$"), null, true); } @TestMetadata("arrayOfBoxed.repl") @@ -355,7 +356,7 @@ public class ReplInterpreterTestGenerated extends AbstractReplInterpreterTest { } public void testAllFilesPresentInRegressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/repl/regressions"), Pattern.compile("^(.+)\\.repl$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/repl/regressions"), Pattern.compile("^(.+)\\.repl$"), null, true); } @TestMetadata("kt6843.repl") @@ -373,7 +374,7 @@ public class ReplInterpreterTestGenerated extends AbstractReplInterpreterTest { } public void testAllFilesPresentInUseJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/repl/useJava"), Pattern.compile("^(.+)\\.repl$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/repl/useJava"), Pattern.compile("^(.+)\\.repl$"), null, true); } @TestMetadata("syntheticProperty.repl") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/resolve/ResolveTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/resolve/ResolveTestGenerated.java index 3faa35b222d..8720d2e598e 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/resolve/ResolveTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/resolve/ResolveTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.resolve; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class ResolveTestGenerated extends AbstractResolveTest { } public void testAllFilesPresentInResolve() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolve"), Pattern.compile("^(.+)\\.resolve$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolve"), Pattern.compile("^(.+)\\.resolve$"), null, true); } @TestMetadata("Basic.resolve") @@ -177,7 +178,7 @@ public class ResolveTestGenerated extends AbstractResolveTest { } public void testAllFilesPresentInCandidatesPriority() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolve/candidatesPriority"), Pattern.compile("^(.+)\\.resolve$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolve/candidatesPriority"), Pattern.compile("^(.+)\\.resolve$"), null, true); } @TestMetadata("classObjectOuterResolve.resolve") @@ -275,7 +276,7 @@ public class ResolveTestGenerated extends AbstractResolveTest { } public void testAllFilesPresentInDelegatedProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolve/delegatedProperty"), Pattern.compile("^(.+)\\.resolve$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolve/delegatedProperty"), Pattern.compile("^(.+)\\.resolve$"), null, true); } @TestMetadata("delegationByCall.resolve") @@ -323,7 +324,7 @@ public class ResolveTestGenerated extends AbstractResolveTest { } public void testAllFilesPresentInImports() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolve/imports"), Pattern.compile("^(.+)\\.resolve$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolve/imports"), Pattern.compile("^(.+)\\.resolve$"), null, true); } @TestMetadata("ImportConflictAllPackage.resolve") @@ -396,7 +397,7 @@ public class ResolveTestGenerated extends AbstractResolveTest { } public void testAllFilesPresentInLabels() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolve/labels"), Pattern.compile("^(.+)\\.resolve$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolve/labels"), Pattern.compile("^(.+)\\.resolve$"), null, true); } @TestMetadata("labelForPropertyInGetter.resolve") @@ -419,7 +420,7 @@ public class ResolveTestGenerated extends AbstractResolveTest { } public void testAllFilesPresentInRegressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolve/regressions"), Pattern.compile("^(.+)\\.resolve$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolve/regressions"), Pattern.compile("^(.+)\\.resolve$"), null, true); } @TestMetadata("kt300.resolve") @@ -442,7 +443,7 @@ public class ResolveTestGenerated extends AbstractResolveTest { } public void testAllFilesPresentInVarargs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolve/varargs"), Pattern.compile("^(.+)\\.resolve$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolve/varargs"), Pattern.compile("^(.+)\\.resolve$"), null, true); } @TestMetadata("MoreSpecificVarargsOfEqualLength.resolve") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/resolve/annotation/AnnotationParameterTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/resolve/annotation/AnnotationParameterTestGenerated.java index d8922765694..e6afe5734e9 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/resolve/annotation/AnnotationParameterTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/resolve/annotation/AnnotationParameterTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.resolve.annotation; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class AnnotationParameterTestGenerated extends AbstractAnnotationParamete } public void testAllFilesPresentInParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolveAnnotations/parameters"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolveAnnotations/parameters"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("byte.kt") @@ -72,7 +73,7 @@ public class AnnotationParameterTestGenerated extends AbstractAnnotationParamete } public void testAllFilesPresentInExpressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolveAnnotations/parameters/expressions"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolveAnnotations/parameters/expressions"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("andAnd.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/resolve/calls/ResolvedCallsTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/resolve/calls/ResolvedCallsTestGenerated.java index 83d53f8d1c7..8c5004f3821 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/resolve/calls/ResolvedCallsTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/resolve/calls/ResolvedCallsTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.resolve.calls; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class ResolvedCallsTestGenerated extends AbstractResolvedCallsTest { } public void testAllFilesPresentInResolvedCalls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolvedCalls"), Pattern.compile("^(.+)\\.kt$"), null, true, "enhancedSignatures"); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolvedCalls"), Pattern.compile("^(.+)\\.kt$"), null, true, "enhancedSignatures"); } @TestMetadata("explicitReceiverIsDispatchReceiver.kt") @@ -77,7 +78,7 @@ public class ResolvedCallsTestGenerated extends AbstractResolvedCallsTest { } public void testAllFilesPresentInArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolvedCalls/arguments"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolvedCalls/arguments"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/testData/resolvedCalls/arguments/functionLiterals") @@ -89,7 +90,7 @@ public class ResolvedCallsTestGenerated extends AbstractResolvedCallsTest { } public void testAllFilesPresentInFunctionLiterals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolvedCalls/arguments/functionLiterals"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolvedCalls/arguments/functionLiterals"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("chainedLambdas.kt") @@ -132,7 +133,7 @@ public class ResolvedCallsTestGenerated extends AbstractResolvedCallsTest { } public void testAllFilesPresentInGenericCalls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolvedCalls/arguments/genericCalls"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolvedCalls/arguments/genericCalls"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("inferredParameter.kt") @@ -165,7 +166,7 @@ public class ResolvedCallsTestGenerated extends AbstractResolvedCallsTest { } public void testAllFilesPresentInNamedArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolvedCalls/arguments/namedArguments"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolvedCalls/arguments/namedArguments"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("positionedAfterNamed.kt") @@ -188,7 +189,7 @@ public class ResolvedCallsTestGenerated extends AbstractResolvedCallsTest { } public void testAllFilesPresentInOneArgument() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolvedCalls/arguments/oneArgument"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolvedCalls/arguments/oneArgument"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("argumentHasNoType.kt") @@ -221,7 +222,7 @@ public class ResolvedCallsTestGenerated extends AbstractResolvedCallsTest { } public void testAllFilesPresentInRealExamples() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolvedCalls/arguments/realExamples"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolvedCalls/arguments/realExamples"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("emptyList.kt") @@ -244,7 +245,7 @@ public class ResolvedCallsTestGenerated extends AbstractResolvedCallsTest { } public void testAllFilesPresentInSeveralCandidates() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolvedCalls/arguments/severalCandidates"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolvedCalls/arguments/severalCandidates"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("mostSpecific.kt") @@ -263,7 +264,7 @@ public class ResolvedCallsTestGenerated extends AbstractResolvedCallsTest { } public void testAllFilesPresentInDifferentCallElements() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolvedCalls/differentCallElements"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolvedCalls/differentCallElements"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("annotationCall.kt") @@ -291,7 +292,7 @@ public class ResolvedCallsTestGenerated extends AbstractResolvedCallsTest { } public void testAllFilesPresentInDynamic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolvedCalls/dynamic"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolvedCalls/dynamic"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("explicitReceiverIsDispatchReceiver.kt") @@ -334,7 +335,7 @@ public class ResolvedCallsTestGenerated extends AbstractResolvedCallsTest { } public void testAllFilesPresentInFunctionTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolvedCalls/functionTypes"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolvedCalls/functionTypes"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("invokeForExtensionFunctionType.kt") @@ -377,7 +378,7 @@ public class ResolvedCallsTestGenerated extends AbstractResolvedCallsTest { } public void testAllFilesPresentInInvoke() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolvedCalls/invoke"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolvedCalls/invoke"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("bothReceivers.kt") @@ -440,7 +441,7 @@ public class ResolvedCallsTestGenerated extends AbstractResolvedCallsTest { } public void testAllFilesPresentInObjectsAndClassObjects() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolvedCalls/objectsAndClassObjects"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolvedCalls/objectsAndClassObjects"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("classObject.kt") @@ -468,7 +469,7 @@ public class ResolvedCallsTestGenerated extends AbstractResolvedCallsTest { } public void testAllFilesPresentInRealExamples() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolvedCalls/realExamples"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolvedCalls/realExamples"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("stringPlusInBuilders.kt") @@ -486,7 +487,7 @@ public class ResolvedCallsTestGenerated extends AbstractResolvedCallsTest { } public void testAllFilesPresentInResolve() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolvedCalls/resolve"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolvedCalls/resolve"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("mostSpecificUninferredParam.kt") @@ -509,7 +510,7 @@ public class ResolvedCallsTestGenerated extends AbstractResolvedCallsTest { } public void testAllFilesPresentInSecondaryConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolvedCalls/secondaryConstructors"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolvedCalls/secondaryConstructors"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("classWithGenerics.kt") @@ -592,7 +593,7 @@ public class ResolvedCallsTestGenerated extends AbstractResolvedCallsTest { } public void testAllFilesPresentInThisOrSuper() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolvedCalls/thisOrSuper"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolvedCalls/thisOrSuper"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("labeledSuper.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/resolve/calls/ResolvedConstructorDelegationCallsTestsGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/resolve/calls/ResolvedConstructorDelegationCallsTestsGenerated.java index c31e9b75bb4..afe01b2a605 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/resolve/calls/ResolvedConstructorDelegationCallsTestsGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/resolve/calls/ResolvedConstructorDelegationCallsTestsGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.resolve.calls; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class ResolvedConstructorDelegationCallsTestsGenerated extends AbstractRe } public void testAllFilesPresentInResolveConstructorDelegationCalls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolveConstructorDelegationCalls"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolveConstructorDelegationCalls"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("classWithGenerics.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/resolve/constants/evaluate/CompileTimeConstantEvaluatorTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/resolve/constants/evaluate/CompileTimeConstantEvaluatorTestGenerated.java index 01810df1908..a6006552f6b 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/resolve/constants/evaluate/CompileTimeConstantEvaluatorTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/resolve/constants/evaluate/CompileTimeConstantEvaluatorTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.resolve.constants.evaluate; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -27,7 +28,7 @@ public class CompileTimeConstantEvaluatorTestGenerated extends AbstractCompileTi } public void testAllFilesPresentInConstant() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/evaluate/constant"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/evaluate/constant"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("classObjectProperty.kt") @@ -145,7 +146,7 @@ public class CompileTimeConstantEvaluatorTestGenerated extends AbstractCompileTi } public void testAllFilesPresentInIsPure() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/evaluate/isPure"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/evaluate/isPure"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("innerToType.kt") @@ -183,7 +184,7 @@ public class CompileTimeConstantEvaluatorTestGenerated extends AbstractCompileTi } public void testAllFilesPresentInUsesVariableAsConstant() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/evaluate/usesVariableAsConstant"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/evaluate/usesVariableAsConstant"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("binaryTypes.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/resolve/constraintSystem/ConstraintSystemTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/resolve/constraintSystem/ConstraintSystemTestGenerated.java index b6879a6ba50..47975ab5d91 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/resolve/constraintSystem/ConstraintSystemTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/resolve/constraintSystem/ConstraintSystemTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.resolve.constraintSystem; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class ConstraintSystemTestGenerated extends AbstractConstraintSystemTest } public void testAllFilesPresentInConstraintSystem() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/constraintSystem"), Pattern.compile("^(.+)\\.constraints$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/constraintSystem"), Pattern.compile("^(.+)\\.constraints$"), null, true); } @TestMetadata("compiler/testData/constraintSystem/checkStatus") @@ -37,7 +38,7 @@ public class ConstraintSystemTestGenerated extends AbstractConstraintSystemTest } public void testAllFilesPresentInCheckStatus() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/constraintSystem/checkStatus"), Pattern.compile("^(.+)\\.constraints$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/constraintSystem/checkStatus"), Pattern.compile("^(.+)\\.constraints$"), null, true); } @TestMetadata("conflictingConstraints.constraints") @@ -70,7 +71,7 @@ public class ConstraintSystemTestGenerated extends AbstractConstraintSystemTest } public void testAllFilesPresentInComputeValues() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/constraintSystem/computeValues"), Pattern.compile("^(.+)\\.constraints$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/constraintSystem/computeValues"), Pattern.compile("^(.+)\\.constraints$"), null, true); } @TestMetadata("contradiction.constraints") @@ -103,7 +104,7 @@ public class ConstraintSystemTestGenerated extends AbstractConstraintSystemTest } public void testAllFilesPresentInIntegerValueTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/constraintSystem/integerValueTypes"), Pattern.compile("^(.+)\\.constraints$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/constraintSystem/integerValueTypes"), Pattern.compile("^(.+)\\.constraints$"), null, true); } @TestMetadata("byteOverflow.constraints") @@ -156,7 +157,7 @@ public class ConstraintSystemTestGenerated extends AbstractConstraintSystemTest } public void testAllFilesPresentInSeveralVariables() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/constraintSystem/severalVariables"), Pattern.compile("^(.+)\\.constraints$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/constraintSystem/severalVariables"), Pattern.compile("^(.+)\\.constraints$"), null, true); } @TestMetadata("simpleDependency.constraints") @@ -198,7 +199,7 @@ public class ConstraintSystemTestGenerated extends AbstractConstraintSystemTest } public void testAllFilesPresentInDirect() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/constraintSystem/severalVariables/direct"), Pattern.compile("^(.+)\\.constraints$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/constraintSystem/severalVariables/direct"), Pattern.compile("^(.+)\\.constraints$"), null, true); } @TestMetadata("compiler/testData/constraintSystem/severalVariables/direct/contravariant") @@ -210,7 +211,7 @@ public class ConstraintSystemTestGenerated extends AbstractConstraintSystemTest } public void testAllFilesPresentInContravariant() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/constraintSystem/severalVariables/direct/contravariant"), Pattern.compile("^(.+)\\.constraints$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/constraintSystem/severalVariables/direct/contravariant"), Pattern.compile("^(.+)\\.constraints$"), null, true); } @TestMetadata("varEqDepEq.constraints") @@ -268,7 +269,7 @@ public class ConstraintSystemTestGenerated extends AbstractConstraintSystemTest } public void testAllFilesPresentInCovariant() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/constraintSystem/severalVariables/direct/covariant"), Pattern.compile("^(.+)\\.constraints$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/constraintSystem/severalVariables/direct/covariant"), Pattern.compile("^(.+)\\.constraints$"), null, true); } @TestMetadata("varEqDepEq.constraints") @@ -326,7 +327,7 @@ public class ConstraintSystemTestGenerated extends AbstractConstraintSystemTest } public void testAllFilesPresentInInvariant() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/constraintSystem/severalVariables/direct/invariant"), Pattern.compile("^(.+)\\.constraints$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/constraintSystem/severalVariables/direct/invariant"), Pattern.compile("^(.+)\\.constraints$"), null, true); } @TestMetadata("varEqDepEq.constraints") @@ -385,7 +386,7 @@ public class ConstraintSystemTestGenerated extends AbstractConstraintSystemTest } public void testAllFilesPresentInInterdependency() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/constraintSystem/severalVariables/interdependency"), Pattern.compile("^(.+)\\.constraints$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/constraintSystem/severalVariables/interdependency"), Pattern.compile("^(.+)\\.constraints$"), null, true); } @TestMetadata("interdependency1.constraints") @@ -413,7 +414,7 @@ public class ConstraintSystemTestGenerated extends AbstractConstraintSystemTest } public void testAllFilesPresentInNullable() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/constraintSystem/severalVariables/nullable"), Pattern.compile("^(.+)\\.constraints$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/constraintSystem/severalVariables/nullable"), Pattern.compile("^(.+)\\.constraints$"), null, true); } @TestMetadata("compiler/testData/constraintSystem/severalVariables/nullable/contravariant") @@ -425,7 +426,7 @@ public class ConstraintSystemTestGenerated extends AbstractConstraintSystemTest } public void testAllFilesPresentInContravariant() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/constraintSystem/severalVariables/nullable/contravariant"), Pattern.compile("^(.+)\\.constraints$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/constraintSystem/severalVariables/nullable/contravariant"), Pattern.compile("^(.+)\\.constraints$"), null, true); } @TestMetadata("varEqDepEq.constraints") @@ -483,7 +484,7 @@ public class ConstraintSystemTestGenerated extends AbstractConstraintSystemTest } public void testAllFilesPresentInCovariant() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/constraintSystem/severalVariables/nullable/covariant"), Pattern.compile("^(.+)\\.constraints$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/constraintSystem/severalVariables/nullable/covariant"), Pattern.compile("^(.+)\\.constraints$"), null, true); } @TestMetadata("varEqDepEq.constraints") @@ -541,7 +542,7 @@ public class ConstraintSystemTestGenerated extends AbstractConstraintSystemTest } public void testAllFilesPresentInInvariant() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/constraintSystem/severalVariables/nullable/invariant"), Pattern.compile("^(.+)\\.constraints$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/constraintSystem/severalVariables/nullable/invariant"), Pattern.compile("^(.+)\\.constraints$"), null, true); } @TestMetadata("varEqDepEq.constraints") @@ -600,7 +601,7 @@ public class ConstraintSystemTestGenerated extends AbstractConstraintSystemTest } public void testAllFilesPresentInOther() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/constraintSystem/severalVariables/other"), Pattern.compile("^(.+)\\.constraints$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/constraintSystem/severalVariables/other"), Pattern.compile("^(.+)\\.constraints$"), null, true); } @TestMetadata("constraintForNullables.constraints") @@ -673,7 +674,7 @@ public class ConstraintSystemTestGenerated extends AbstractConstraintSystemTest } public void testAllFilesPresentInRecursive() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/constraintSystem/severalVariables/recursive"), Pattern.compile("^(.+)\\.constraints$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/constraintSystem/severalVariables/recursive"), Pattern.compile("^(.+)\\.constraints$"), null, true); } @TestMetadata("implicitlyRecursive.constraints") @@ -706,7 +707,7 @@ public class ConstraintSystemTestGenerated extends AbstractConstraintSystemTest } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/constraintSystem/severalVariables/reversed"), Pattern.compile("^(.+)\\.constraints$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/constraintSystem/severalVariables/reversed"), Pattern.compile("^(.+)\\.constraints$"), null, true); } @TestMetadata("compiler/testData/constraintSystem/severalVariables/reversed/contravariant") @@ -718,7 +719,7 @@ public class ConstraintSystemTestGenerated extends AbstractConstraintSystemTest } public void testAllFilesPresentInContravariant() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/constraintSystem/severalVariables/reversed/contravariant"), Pattern.compile("^(.+)\\.constraints$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/constraintSystem/severalVariables/reversed/contravariant"), Pattern.compile("^(.+)\\.constraints$"), null, true); } @TestMetadata("varEqDepEq.constraints") @@ -776,7 +777,7 @@ public class ConstraintSystemTestGenerated extends AbstractConstraintSystemTest } public void testAllFilesPresentInCovariant() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/constraintSystem/severalVariables/reversed/covariant"), Pattern.compile("^(.+)\\.constraints$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/constraintSystem/severalVariables/reversed/covariant"), Pattern.compile("^(.+)\\.constraints$"), null, true); } @TestMetadata("varEqDepEq.constraints") @@ -834,7 +835,7 @@ public class ConstraintSystemTestGenerated extends AbstractConstraintSystemTest } public void testAllFilesPresentInInvariant() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/constraintSystem/severalVariables/reversed/invariant"), Pattern.compile("^(.+)\\.constraints$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/constraintSystem/severalVariables/reversed/invariant"), Pattern.compile("^(.+)\\.constraints$"), null, true); } @TestMetadata("varEqDepEq.constraints") @@ -894,7 +895,7 @@ public class ConstraintSystemTestGenerated extends AbstractConstraintSystemTest } public void testAllFilesPresentInVariance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/constraintSystem/variance"), Pattern.compile("^(.+)\\.constraints$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/constraintSystem/variance"), Pattern.compile("^(.+)\\.constraints$"), null, true); } @TestMetadata("consumer.constraints") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/serialization/LocalClassProtoTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/serialization/LocalClassProtoTestGenerated.java index 9c7a369b859..d3eb379cfaa 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/serialization/LocalClassProtoTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/serialization/LocalClassProtoTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.serialization; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class LocalClassProtoTestGenerated extends AbstractLocalClassProtoTest { } public void testAllFilesPresentInLocal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/serialization/local"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/serialization/local"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("annotationsInLocalClass.kt") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/types/TypeBindingTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/types/TypeBindingTestGenerated.java index a6896b9d70b..1d662bbd86c 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/types/TypeBindingTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/types/TypeBindingTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.types; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class TypeBindingTestGenerated extends AbstractTypeBindingTest { } public void testAllFilesPresentInBinding() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/type/binding"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/type/binding"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/testData/type/binding/explicit") @@ -37,7 +38,7 @@ public class TypeBindingTestGenerated extends AbstractTypeBindingTest { } public void testAllFilesPresentInExplicit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/type/binding/explicit"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/type/binding/explicit"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("conflictingProjection.kt") @@ -140,7 +141,7 @@ public class TypeBindingTestGenerated extends AbstractTypeBindingTest { } public void testAllFilesPresentInImplicit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/type/binding/implicit"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/type/binding/implicit"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("conflictingProjection.kt") diff --git a/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsNoAnnotationInClasspathTestGenerated.java b/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsNoAnnotationInClasspathTestGenerated.java index 0dee259c9ad..ad6569ce9f8 100644 --- a/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsNoAnnotationInClasspathTestGenerated.java +++ b/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsNoAnnotationInClasspathTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.checkers; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class ForeignJava8AnnotationsNoAnnotationInClasspathTestGenerated extends } public void testAllFilesPresentInTests() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests"), Pattern.compile("^(.+)\\.kt$"), null, true, "jspecify"); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests"), Pattern.compile("^(.+)\\.kt$"), null, true, "jspecify"); } @TestMetadata("checkerFramework.kt") @@ -52,7 +53,7 @@ public class ForeignJava8AnnotationsNoAnnotationInClasspathTestGenerated extends } public void testAllFilesPresentInJsr305() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests/jsr305"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests/jsr305"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("defaultAnnotationAppliedToType.kt") @@ -90,7 +91,7 @@ public class ForeignJava8AnnotationsNoAnnotationInClasspathTestGenerated extends } public void testAllFilesPresentInTypeEnhancement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("annotatedTypeArguments.kt") diff --git a/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsNoAnnotationInClasspathWithPsiClassReadingTestGenerated.java b/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsNoAnnotationInClasspathWithPsiClassReadingTestGenerated.java index d37c99f58f0..e30b43baf87 100644 --- a/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsNoAnnotationInClasspathWithPsiClassReadingTestGenerated.java +++ b/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsNoAnnotationInClasspathWithPsiClassReadingTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.checkers; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class ForeignJava8AnnotationsNoAnnotationInClasspathWithPsiClassReadingTe } public void testAllFilesPresentInTests() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests"), Pattern.compile("^(.+)\\.kt$"), null, true, "jspecify"); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests"), Pattern.compile("^(.+)\\.kt$"), null, true, "jspecify"); } @TestMetadata("checkerFramework.kt") @@ -52,7 +53,7 @@ public class ForeignJava8AnnotationsNoAnnotationInClasspathWithPsiClassReadingTe } public void testAllFilesPresentInJsr305() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests/jsr305"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests/jsr305"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("defaultAnnotationAppliedToType.kt") @@ -90,7 +91,7 @@ public class ForeignJava8AnnotationsNoAnnotationInClasspathWithPsiClassReadingTe } public void testAllFilesPresentInTypeEnhancement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("annotatedTypeArguments.kt") diff --git a/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsTestGenerated.java b/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsTestGenerated.java index e0cffd0f119..bdfef3aeeac 100644 --- a/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsTestGenerated.java +++ b/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.checkers; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class ForeignJava8AnnotationsTestGenerated extends AbstractForeignJava8An } public void testAllFilesPresentInTests() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests"), Pattern.compile("^(.+)\\.kt$"), null, true, "jspecify"); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests"), Pattern.compile("^(.+)\\.kt$"), null, true, "jspecify"); } @TestMetadata("checkerFramework.kt") @@ -52,7 +53,7 @@ public class ForeignJava8AnnotationsTestGenerated extends AbstractForeignJava8An } public void testAllFilesPresentInJsr305() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests/jsr305"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests/jsr305"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("defaultAnnotationAppliedToType.kt") @@ -90,7 +91,7 @@ public class ForeignJava8AnnotationsTestGenerated extends AbstractForeignJava8An } public void testAllFilesPresentInTypeEnhancement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("annotatedTypeArguments.kt") diff --git a/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/JspecifyAnnotationsTestGenerated.java b/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/JspecifyAnnotationsTestGenerated.java index b4ae1d84b0d..dc862175c93 100644 --- a/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/JspecifyAnnotationsTestGenerated.java +++ b/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/JspecifyAnnotationsTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.checkers; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class JspecifyAnnotationsTestGenerated extends AbstractJspecifyAnnotation } public void testAllFilesPresentInKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode") @@ -37,7 +38,7 @@ public class JspecifyAnnotationsTestGenerated extends AbstractJspecifyAnnotation } public void testAllFilesPresentInStrictMode() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/strictMode"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("AnnotatedBoundsOfWildcard.kt") @@ -100,7 +101,7 @@ public class JspecifyAnnotationsTestGenerated extends AbstractJspecifyAnnotation } public void testAllFilesPresentInWarnMode() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests/jspecify/kotlin/warnMode"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("AnnotatedBoundsOfWildcard.kt") diff --git a/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/javac/JavacForeignJava8AnnotationsTestGenerated.java b/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/javac/JavacForeignJava8AnnotationsTestGenerated.java index 87a12494209..18ec7c9c912 100644 --- a/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/javac/JavacForeignJava8AnnotationsTestGenerated.java +++ b/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/javac/JavacForeignJava8AnnotationsTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.checkers.javac; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class JavacForeignJava8AnnotationsTestGenerated extends AbstractJavacFore } public void testAllFilesPresentInTests() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests"), Pattern.compile("^(.+)\\.kt$"), null, true, "jspecify"); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests"), Pattern.compile("^(.+)\\.kt$"), null, true, "jspecify"); } @TestMetadata("checkerFramework.kt") @@ -52,7 +53,7 @@ public class JavacForeignJava8AnnotationsTestGenerated extends AbstractJavacFore } public void testAllFilesPresentInJsr305() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests/jsr305"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests/jsr305"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("defaultAnnotationAppliedToType.kt") @@ -90,7 +91,7 @@ public class JavacForeignJava8AnnotationsTestGenerated extends AbstractJavacFore } public void testAllFilesPresentInTypeEnhancement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("annotatedTypeArguments.kt") diff --git a/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/LoadJava8TestGenerated.java b/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/LoadJava8TestGenerated.java index 2a94ab35ab4..2262382181b 100644 --- a/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/LoadJava8TestGenerated.java +++ b/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/LoadJava8TestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.jvm.compiler; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -27,7 +28,7 @@ public class LoadJava8TestGenerated extends AbstractLoadJava8Test { } public void testAllFilesPresentInCompiledJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/compiledJava"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/compiledJava"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("InnerClassTypeAnnotation.java") @@ -65,7 +66,7 @@ public class LoadJava8TestGenerated extends AbstractLoadJava8Test { } public void testAllFilesPresentInSourceJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/sourceJava"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/sourceJava"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("MapRemove.java") diff --git a/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/LoadJava8WithPsiClassReadingTestGenerated.java b/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/LoadJava8WithPsiClassReadingTestGenerated.java index 7803a82f8be..b1d1f14a44e 100644 --- a/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/LoadJava8WithPsiClassReadingTestGenerated.java +++ b/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/LoadJava8WithPsiClassReadingTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.jvm.compiler; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class LoadJava8WithPsiClassReadingTestGenerated extends AbstractLoadJava8 } public void testAllFilesPresentInCompiledJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/compiledJava"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/compiledJava"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("InnerClassTypeAnnotation.java") diff --git a/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/javac/LoadJava8UsingJavacTestGenerated.java b/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/javac/LoadJava8UsingJavacTestGenerated.java index a7c248546f6..248e50883db 100644 --- a/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/javac/LoadJava8UsingJavacTestGenerated.java +++ b/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/javac/LoadJava8UsingJavacTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.jvm.compiler.javac; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -27,7 +28,7 @@ public class LoadJava8UsingJavacTestGenerated extends AbstractLoadJava8UsingJava } public void testAllFilesPresentInCompiledJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/compiledJava"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/compiledJava"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("InnerClassTypeAnnotation.java") @@ -65,7 +66,7 @@ public class LoadJava8UsingJavacTestGenerated extends AbstractLoadJava8UsingJava } public void testAllFilesPresentInSourceJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/sourceJava"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/sourceJava"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("MapRemove.java") diff --git a/compiler/tests-java8/tests/org/jetbrains/kotlin/resolve/calls/EnhancedSignaturesResolvedCallsTestGenerated.java b/compiler/tests-java8/tests/org/jetbrains/kotlin/resolve/calls/EnhancedSignaturesResolvedCallsTestGenerated.java index 7b663fc9e62..545a461742a 100644 --- a/compiler/tests-java8/tests/org/jetbrains/kotlin/resolve/calls/EnhancedSignaturesResolvedCallsTestGenerated.java +++ b/compiler/tests-java8/tests/org/jetbrains/kotlin/resolve/calls/EnhancedSignaturesResolvedCallsTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.resolve.calls; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class EnhancedSignaturesResolvedCallsTestGenerated extends AbstractEnhanc } public void testAllFilesPresentInEnhancedSignatures() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolvedCalls/enhancedSignatures"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolvedCalls/enhancedSignatures"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/testData/resolvedCalls/enhancedSignatures/collection") @@ -37,7 +38,7 @@ public class EnhancedSignaturesResolvedCallsTestGenerated extends AbstractEnhanc } public void testAllFilesPresentInCollection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolvedCalls/enhancedSignatures/collection"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolvedCalls/enhancedSignatures/collection"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("collectionRemoveIf.kt") @@ -65,7 +66,7 @@ public class EnhancedSignaturesResolvedCallsTestGenerated extends AbstractEnhanc } public void testAllFilesPresentInIterable() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolvedCalls/enhancedSignatures/iterable"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolvedCalls/enhancedSignatures/iterable"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("iterableSpliterator.kt") @@ -83,7 +84,7 @@ public class EnhancedSignaturesResolvedCallsTestGenerated extends AbstractEnhanc } public void testAllFilesPresentInIterator() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolvedCalls/enhancedSignatures/iterator"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolvedCalls/enhancedSignatures/iterator"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("iteratorForEachRemaining.kt") @@ -101,7 +102,7 @@ public class EnhancedSignaturesResolvedCallsTestGenerated extends AbstractEnhanc } public void testAllFilesPresentInList() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolvedCalls/enhancedSignatures/list"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolvedCalls/enhancedSignatures/list"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("listReplaceAll.kt") @@ -124,7 +125,7 @@ public class EnhancedSignaturesResolvedCallsTestGenerated extends AbstractEnhanc } public void testAllFilesPresentInMap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolvedCalls/enhancedSignatures/map"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolvedCalls/enhancedSignatures/map"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("mapCompute.kt") @@ -172,7 +173,7 @@ public class EnhancedSignaturesResolvedCallsTestGenerated extends AbstractEnhanc } public void testAllFilesPresentInOptional() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolvedCalls/enhancedSignatures/optional"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolvedCalls/enhancedSignatures/optional"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("optionalEmpty.kt") @@ -205,7 +206,7 @@ public class EnhancedSignaturesResolvedCallsTestGenerated extends AbstractEnhanc } public void testAllFilesPresentInReferences() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolvedCalls/enhancedSignatures/references"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/resolvedCalls/enhancedSignatures/references"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("softReference.kt") diff --git a/compiler/tests-spec/tests/org/jetbrains/kotlin/spec/checkers/DiagnosticsTestSpecGenerated.java b/compiler/tests-spec/tests/org/jetbrains/kotlin/spec/checkers/DiagnosticsTestSpecGenerated.java index e7bd2bdf4c2..1808f929fa9 100644 --- a/compiler/tests-spec/tests/org/jetbrains/kotlin/spec/checkers/DiagnosticsTestSpecGenerated.java +++ b/compiler/tests-spec/tests/org/jetbrains/kotlin/spec/checkers/DiagnosticsTestSpecGenerated.java @@ -25,7 +25,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInDiagnostics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "helpers", "linked/annotations", "linked/built-in-types-and-their-semantics", "linked/control--and-data-flow-analysis.control-flow-graph.expressions-1.conditional-expressions", "linked/control--and-data-flow-analysis/performing-analysis-on-the-control-flow-graph", "linked/declarations/classifier-declaration/class-declaration/nested-and-inner-classifiers", "linked/declarations/classifier-declaration/classifier-initialization", "linked/declarations/classifier-declaration/data-class-declaration", "linked/declarations/function-declaration", "linked/declarations/property-declaration/property-initialization", "linked/declarations/type-alias", "linked/expressions/call-and-property-access-expressions", "linked/expressions/function-literals", "linked/inheritance", "linked/overload-resolution/c-level-partition", "linked/overload-resolution/determining-function-applicability-for-a-specific-call/rationale", "linked/overloadable-operators", "linked/statements/assignments/simple-assignments", "linked/type-inference/local-type-inference", "linked/type-inference/smart-casts/smart-cast-types", "linked/type-system/subtyping/subtyping-for-nullable-types", "linked/type-system/type-kinds/type-parameters"); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "helpers", "linked/annotations", "linked/built-in-types-and-their-semantics", "linked/control--and-data-flow-analysis.control-flow-graph.expressions-1.conditional-expressions", "linked/control--and-data-flow-analysis/performing-analysis-on-the-control-flow-graph", "linked/declarations/classifier-declaration/class-declaration/nested-and-inner-classifiers", "linked/declarations/classifier-declaration/classifier-initialization", "linked/declarations/classifier-declaration/data-class-declaration", "linked/declarations/function-declaration", "linked/declarations/property-declaration/property-initialization", "linked/declarations/type-alias", "linked/expressions/call-and-property-access-expressions", "linked/expressions/function-literals", "linked/inheritance", "linked/overload-resolution/c-level-partition", "linked/overload-resolution/determining-function-applicability-for-a-specific-call/rationale", "linked/overloadable-operators", "linked/statements/assignments/simple-assignments", "linked/type-inference/local-type-inference", "linked/type-inference/smart-casts/smart-cast-types", "linked/type-system/subtyping/subtyping-for-nullable-types", "linked/type-system/type-kinds/type-parameters"); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked") @@ -37,7 +37,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInLinked() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "annotations", "built-in-types-and-their-semantics", "control--and-data-flow-analysis.control-flow-graph.expressions-1.conditional-expressions", "control--and-data-flow-analysis/performing-analysis-on-the-control-flow-graph", "declarations/classifier-declaration/class-declaration/nested-and-inner-classifiers", "declarations/classifier-declaration/classifier-initialization", "declarations/classifier-declaration/data-class-declaration", "declarations/function-declaration", "declarations/property-declaration/property-initialization", "declarations/type-alias", "expressions/call-and-property-access-expressions", "expressions/function-literals", "inheritance", "overload-resolution/c-level-partition", "overload-resolution/determining-function-applicability-for-a-specific-call/rationale", "overloadable-operators", "statements/assignments/simple-assignments", "type-inference/local-type-inference", "type-inference/smart-casts/smart-cast-types", "type-system/subtyping/subtyping-for-nullable-types", "type-system/type-kinds/type-parameters"); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "annotations", "built-in-types-and-their-semantics", "control--and-data-flow-analysis.control-flow-graph.expressions-1.conditional-expressions", "control--and-data-flow-analysis/performing-analysis-on-the-control-flow-graph", "declarations/classifier-declaration/class-declaration/nested-and-inner-classifiers", "declarations/classifier-declaration/classifier-initialization", "declarations/classifier-declaration/data-class-declaration", "declarations/function-declaration", "declarations/property-declaration/property-initialization", "declarations/type-alias", "expressions/call-and-property-access-expressions", "expressions/function-literals", "inheritance", "overload-resolution/c-level-partition", "overload-resolution/determining-function-applicability-for-a-specific-call/rationale", "overloadable-operators", "statements/assignments/simple-assignments", "type-inference/local-type-inference", "type-inference/smart-casts/smart-cast-types", "type-system/subtyping/subtyping-for-nullable-types", "type-system/type-kinds/type-parameters"); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis") @@ -49,7 +49,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInControl__and_data_flow_analysis() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "performing-analysis-on-the-control-flow-graph"); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "performing-analysis-on-the-control-flow-graph"); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph") @@ -61,7 +61,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInControl_flow_graph() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph/expressions-1") @@ -73,7 +73,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInExpressions_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph/expressions-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph/expressions-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph/expressions-1/conditional-expressions") @@ -85,7 +85,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInConditional_expressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph/expressions-1/conditional-expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph/expressions-1/conditional-expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph/expressions-1/conditional-expressions/p-1") @@ -97,7 +97,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph/expressions-1/conditional-expressions/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph/expressions-1/conditional-expressions/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph/expressions-1/conditional-expressions/p-1/neg") @@ -134,7 +134,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph/expressions-1/conditional-expressions/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph/expressions-1/conditional-expressions/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -162,7 +162,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph/expressions-1/conditional-expressions/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph/expressions-1/conditional-expressions/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -180,7 +180,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInDeclarations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "classifier-declaration/class-declaration/nested-and-inner-classifiers", "classifier-declaration/classifier-initialization", "classifier-declaration/data-class-declaration", "function-declaration", "property-declaration/property-initialization", "type-alias"); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "classifier-declaration/class-declaration/nested-and-inner-classifiers", "classifier-declaration/classifier-initialization", "classifier-declaration/data-class-declaration", "function-declaration", "property-declaration/property-initialization", "type-alias"); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration") @@ -192,7 +192,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInClassifier_declaration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "class-declaration/nested-and-inner-classifiers", "classifier-initialization", "data-class-declaration"); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "class-declaration/nested-and-inner-classifiers", "classifier-initialization", "data-class-declaration"); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration") @@ -204,7 +204,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInClass_declaration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "nested-and-inner-classifiers"); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "nested-and-inner-classifiers"); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes") @@ -216,7 +216,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInAbstract_classes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-1") @@ -228,7 +228,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-1/neg") @@ -250,7 +250,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -268,7 +268,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -282,7 +282,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg") @@ -344,7 +344,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -377,7 +377,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -392,7 +392,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInConstructor_declaration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-4") @@ -404,7 +404,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_4() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-4/pos") @@ -421,7 +421,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -435,7 +435,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_5() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/neg") @@ -467,7 +467,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -545,7 +545,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -562,7 +562,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInProperty_declaration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/property-declaration"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "property-initialization"); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/property-declaration"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "property-initialization"); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/declarations/property-declaration/local-property-declaration") @@ -574,7 +574,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInLocal_property_declaration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/property-declaration/local-property-declaration"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/property-declaration/local-property-declaration"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/declarations/property-declaration/local-property-declaration/p-1") @@ -586,7 +586,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/property-declaration/local-property-declaration/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/property-declaration/local-property-declaration/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/declarations/property-declaration/local-property-declaration/p-1/neg") @@ -603,7 +603,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/property-declaration/local-property-declaration/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/property-declaration/local-property-declaration/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -620,7 +620,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInExpressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "call-and-property-access-expressions", "function-literals"); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "call-and-property-access-expressions", "function-literals"); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/additive-expression") @@ -632,7 +632,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInAdditive_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/additive-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/additive-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/additive-expression/p-4") @@ -644,7 +644,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_4() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/additive-expression/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/additive-expression/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/additive-expression/p-4/pos") @@ -661,7 +661,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/additive-expression/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/additive-expression/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -676,7 +676,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInBuilt_in_types_and_their_semantics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1") @@ -688,7 +688,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInKotlin_nothing_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1") @@ -700,7 +700,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1/pos") @@ -717,7 +717,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -732,7 +732,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInKotlin_unit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.unit"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.unit"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.unit/p-1") @@ -744,7 +744,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.unit/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.unit/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.unit/p-1/pos") @@ -761,7 +761,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.unit/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.unit/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -777,7 +777,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInComparison_expressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-1") @@ -789,7 +789,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-1/neg") @@ -806,7 +806,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -820,7 +820,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_4() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-4/neg") @@ -837,7 +837,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-4/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-4/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -851,7 +851,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_5() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-5/pos") @@ -868,7 +868,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -883,7 +883,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInConditional_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/conditional-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/conditional-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/conditional-expression/p-6") @@ -895,7 +895,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_6() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/conditional-expression/p-6"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/conditional-expression/p-6"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/conditional-expression/p-6/neg") @@ -912,7 +912,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/conditional-expression/p-6/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/conditional-expression/p-6/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -930,7 +930,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/conditional-expression/p-6/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/conditional-expression/p-6/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -945,7 +945,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInConstant_literals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/boolean-literals") @@ -957,7 +957,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInBoolean_literals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/boolean-literals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/boolean-literals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/boolean-literals/p-1") @@ -969,7 +969,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/boolean-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/boolean-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/boolean-literals/p-1/neg") @@ -991,7 +991,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/boolean-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/boolean-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -1019,7 +1019,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/boolean-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/boolean-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -1034,7 +1034,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInCharacter_literals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals/p-1") @@ -1046,7 +1046,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals/p-1/neg") @@ -1063,7 +1063,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -1081,7 +1081,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -1095,7 +1095,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_4() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals/p-4/neg") @@ -1112,7 +1112,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals/p-4/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals/p-4/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -1135,7 +1135,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -1150,7 +1150,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInInteger_literals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/binary-integer-literals") @@ -1162,7 +1162,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInBinary_integer_literals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/binary-integer-literals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/binary-integer-literals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/binary-integer-literals/p-1") @@ -1174,7 +1174,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/binary-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/binary-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/binary-integer-literals/p-1/neg") @@ -1206,7 +1206,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/binary-integer-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/binary-integer-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -1221,7 +1221,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInDecimal_integer_literals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/decimal-integer-literals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/decimal-integer-literals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-1") @@ -1233,7 +1233,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-1/neg") @@ -1260,7 +1260,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -1275,7 +1275,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInHexadecimal_integer_literals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1") @@ -1287,7 +1287,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1/neg") @@ -1324,7 +1324,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -1340,7 +1340,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInReal_literals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-1") @@ -1352,7 +1352,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-1/neg") @@ -1374,7 +1374,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -1407,7 +1407,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -1421,7 +1421,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-2/neg") @@ -1453,7 +1453,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -1476,7 +1476,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -1490,7 +1490,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_3() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-3/neg") @@ -1517,7 +1517,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-3/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-3/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -1570,7 +1570,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -1584,7 +1584,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_4() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-4/neg") @@ -1621,7 +1621,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-4/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-4/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -1659,7 +1659,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -1673,7 +1673,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_5() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-5/pos") @@ -1710,7 +1710,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -1725,7 +1725,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInThe_types_for_integer_literals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1") @@ -1737,7 +1737,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/neg") @@ -1789,7 +1789,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -1827,7 +1827,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -1843,7 +1843,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInElvis_operator_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/elvis-operator-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/elvis-operator-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/elvis-operator-expression/p-3") @@ -1855,7 +1855,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_3() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/elvis-operator-expression/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/elvis-operator-expression/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/elvis-operator-expression/p-3/pos") @@ -1872,7 +1872,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/elvis-operator-expression/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/elvis-operator-expression/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -1887,7 +1887,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInEquality_expressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/equality-expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/equality-expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/equality-expressions/value-equality-expressions") @@ -1899,7 +1899,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInValue_equality_expressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/equality-expressions/value-equality-expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/equality-expressions/value-equality-expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/equality-expressions/value-equality-expressions/p-3") @@ -1911,7 +1911,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_3() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/equality-expressions/value-equality-expressions/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/equality-expressions/value-equality-expressions/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/equality-expressions/value-equality-expressions/p-3/pos") @@ -1928,7 +1928,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/equality-expressions/value-equality-expressions/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/equality-expressions/value-equality-expressions/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -1944,7 +1944,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInJump_expressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/break-expression") @@ -1956,7 +1956,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInBreak_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/break-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/break-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/break-expression/p-1") @@ -1968,7 +1968,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/break-expression/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/break-expression/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/break-expression/p-1/neg") @@ -1985,7 +1985,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/break-expression/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/break-expression/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -2000,7 +2000,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInContinue_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/continue-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/continue-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/continue-expression/p-1") @@ -2012,7 +2012,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/continue-expression/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/continue-expression/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/continue-expression/p-1/neg") @@ -2029,7 +2029,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/continue-expression/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/continue-expression/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -2044,7 +2044,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/p-2/pos") @@ -2061,7 +2061,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -2075,7 +2075,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInReturn_expressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/return-expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/return-expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/return-expressions/p-1") @@ -2087,7 +2087,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/return-expressions/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/return-expressions/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/return-expressions/p-1/pos") @@ -2104,7 +2104,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/return-expressions/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/return-expressions/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -2118,7 +2118,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_4() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/return-expressions/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/return-expressions/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/return-expressions/p-4/neg") @@ -2135,7 +2135,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/return-expressions/p-4/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/return-expressions/p-4/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -2151,7 +2151,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInLogical_conjunction_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-conjunction-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-conjunction-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-conjunction-expression/p-2") @@ -2163,7 +2163,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-conjunction-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-conjunction-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-conjunction-expression/p-2/neg") @@ -2180,7 +2180,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-conjunction-expression/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-conjunction-expression/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -2198,7 +2198,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-conjunction-expression/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-conjunction-expression/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -2213,7 +2213,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInLogical_disjunction_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-disjunction-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-disjunction-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-disjunction-expression/p-2") @@ -2225,7 +2225,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-disjunction-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-disjunction-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-disjunction-expression/p-2/neg") @@ -2242,7 +2242,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-disjunction-expression/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-disjunction-expression/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -2260,7 +2260,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-disjunction-expression/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-disjunction-expression/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -2275,7 +2275,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInMultiplicative_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/multiplicative-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/multiplicative-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/multiplicative-expression/p-5") @@ -2287,7 +2287,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_5() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/multiplicative-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/multiplicative-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/multiplicative-expression/p-5/pos") @@ -2304,7 +2304,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/multiplicative-expression/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/multiplicative-expression/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -2319,7 +2319,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNot_null_assertion_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/not-null-assertion-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/not-null-assertion-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/not-null-assertion-expression/p-2") @@ -2331,7 +2331,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/not-null-assertion-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/not-null-assertion-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/not-null-assertion-expression/p-2/pos") @@ -2348,7 +2348,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/not-null-assertion-expression/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/not-null-assertion-expression/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -2362,7 +2362,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_3() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/not-null-assertion-expression/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/not-null-assertion-expression/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/not-null-assertion-expression/p-3/pos") @@ -2379,7 +2379,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/not-null-assertion-expression/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/not-null-assertion-expression/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -2394,7 +2394,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPrefix_expressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/logical-not-expression") @@ -2406,7 +2406,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInLogical_not_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/logical-not-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/logical-not-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/logical-not-expression/p-3") @@ -2418,7 +2418,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_3() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/logical-not-expression/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/logical-not-expression/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/logical-not-expression/p-3/pos") @@ -2435,7 +2435,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/logical-not-expression/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/logical-not-expression/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -2450,7 +2450,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPrefix_decrement_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-decrement-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-decrement-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-decrement-expression/p-4") @@ -2462,7 +2462,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_4() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-decrement-expression/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-decrement-expression/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-decrement-expression/p-4/neg") @@ -2479,7 +2479,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-decrement-expression/p-4/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-decrement-expression/p-4/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -2493,7 +2493,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_5() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-decrement-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-decrement-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-decrement-expression/p-5/neg") @@ -2510,7 +2510,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-decrement-expression/p-5/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-decrement-expression/p-5/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -2525,7 +2525,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPrefix_increment_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-4") @@ -2537,7 +2537,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_4() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-4/neg") @@ -2554,7 +2554,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-4/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-4/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -2568,7 +2568,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_5() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-5/neg") @@ -2585,7 +2585,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-5/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-5/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -2600,7 +2600,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInUnary_minus_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/unary-minus-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/unary-minus-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/unary-minus-expression/p-3") @@ -2612,7 +2612,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_3() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/unary-minus-expression/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/unary-minus-expression/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/unary-minus-expression/p-3/pos") @@ -2629,7 +2629,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/unary-minus-expression/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/unary-minus-expression/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -2644,7 +2644,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInUnary_plus_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/unary-plus-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/unary-plus-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/unary-plus-expression/p-3") @@ -2656,7 +2656,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_3() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/unary-plus-expression/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/unary-plus-expression/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/unary-plus-expression/p-3/pos") @@ -2673,7 +2673,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/unary-plus-expression/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/unary-plus-expression/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -2689,7 +2689,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInRange_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/range-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/range-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/range-expression/p-4") @@ -2701,7 +2701,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_4() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/range-expression/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/range-expression/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/range-expression/p-4/pos") @@ -2718,7 +2718,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/range-expression/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/range-expression/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -2733,7 +2733,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInTry_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-1") @@ -2745,7 +2745,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-1/neg") @@ -2777,7 +2777,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -2815,7 +2815,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -2829,7 +2829,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-2/pos") @@ -2846,7 +2846,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -2860,7 +2860,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_5() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-5/pos") @@ -2882,7 +2882,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -2896,7 +2896,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_8() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-8"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-8"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-8/neg") @@ -2913,7 +2913,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-8/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-8/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -2931,7 +2931,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-8/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-8/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -2946,7 +2946,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInType_checking_and_containment_checking_expressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions/containment-checking-expression") @@ -2958,7 +2958,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInContainment_checking_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions/containment-checking-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions/containment-checking-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions/containment-checking-expression/p-5") @@ -2970,7 +2970,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_5() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions/containment-checking-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions/containment-checking-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions/containment-checking-expression/p-5/pos") @@ -2987,7 +2987,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions/containment-checking-expression/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions/containment-checking-expression/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -3002,7 +3002,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInType_checking_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression/p-4") @@ -3014,7 +3014,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_4() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression/p-4/pos") @@ -3031,7 +3031,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -3047,7 +3047,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInWhen_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/exhaustive-when-expressions") @@ -3059,7 +3059,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInExhaustive_when_expressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/exhaustive-when-expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/exhaustive-when-expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/exhaustive-when-expressions/p-2") @@ -3071,7 +3071,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/exhaustive-when-expressions/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/exhaustive-when-expressions/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/exhaustive-when-expressions/p-2/neg") @@ -3118,7 +3118,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/exhaustive-when-expressions/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/exhaustive-when-expressions/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -3176,7 +3176,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/exhaustive-when-expressions/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/exhaustive-when-expressions/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -3191,7 +3191,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-1/pos") @@ -3213,7 +3213,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -3227,7 +3227,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-2/neg") @@ -3249,7 +3249,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -3287,7 +3287,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -3301,7 +3301,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_3() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-3/neg") @@ -3318,7 +3318,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-3/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-3/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -3332,7 +3332,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_4() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-4/neg") @@ -3349,7 +3349,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-4/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-4/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -3367,7 +3367,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -3381,7 +3381,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_5() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-5/pos") @@ -3403,7 +3403,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -3417,7 +3417,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_6() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-6"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-6"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-6/neg") @@ -3459,7 +3459,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-6/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-6/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -3527,7 +3527,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-6/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-6/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -3543,7 +3543,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInOverload_resolution() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "c-level-partition", "determining-function-applicability-for-a-specific-call/rationale"); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "c-level-partition", "determining-function-applicability-for-a-specific-call/rationale"); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs") @@ -3555,7 +3555,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInBuilding_the_overload_candidate_set_ocs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver") @@ -3567,7 +3567,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInCall_with_an_explicit_receiver() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/call-with-an-explicit-type-receiver") @@ -3579,7 +3579,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInCall_with_an_explicit_type_receiver() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/call-with-an-explicit-type-receiver"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/call-with-an-explicit-type-receiver"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/call-with-an-explicit-type-receiver/p-3") @@ -3591,7 +3591,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_3() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/call-with-an-explicit-type-receiver/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/call-with-an-explicit-type-receiver/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/call-with-an-explicit-type-receiver/p-3/pos") @@ -3608,7 +3608,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/call-with-an-explicit-type-receiver/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/call-with-an-explicit-type-receiver/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -3623,7 +3623,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_6() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/p-6"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/p-6"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/p-6/pos") @@ -3715,7 +3715,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/p-6/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/p-6/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -3730,7 +3730,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInCall_with_named_parameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/p-1") @@ -3742,7 +3742,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/p-1/pos") @@ -3834,7 +3834,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -3848,7 +3848,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_5() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/p-5/pos") @@ -3860,7 +3860,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -3875,7 +3875,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInCall_with_specified_type_parameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-specified-type-parameters"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-specified-type-parameters"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-specified-type-parameters/p-2") @@ -3887,7 +3887,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-specified-type-parameters/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-specified-type-parameters/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-specified-type-parameters/p-2/pos") @@ -3904,7 +3904,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-specified-type-parameters/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-specified-type-parameters/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -3919,7 +3919,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInCall_with_trailing_lambda_expressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1") @@ -3931,7 +3931,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos") @@ -4048,7 +4048,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -4063,7 +4063,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInCall_without_an_explicit_receiver() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver/p-5") @@ -4075,7 +4075,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_5() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver/p-5/neg") @@ -4122,7 +4122,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver/p-5/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver/p-5/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -4215,7 +4215,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -4230,7 +4230,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInInfix_function_call() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/p-2") @@ -4242,7 +4242,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/p-2/neg") @@ -4279,7 +4279,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -4317,7 +4317,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -4332,7 +4332,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInOperator_call() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1") @@ -4344,7 +4344,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg") @@ -4396,7 +4396,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -4419,7 +4419,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -4433,7 +4433,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-2/pos") @@ -4475,7 +4475,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -4489,7 +4489,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_4() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-4/neg") @@ -4506,7 +4506,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-4/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-4/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -4524,7 +4524,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -4540,7 +4540,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInCallables_and_invoke_convention() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/callables-and-invoke-convention"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/callables-and-invoke-convention"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/callables-and-invoke-convention/p-2") @@ -4552,7 +4552,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/callables-and-invoke-convention/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/callables-and-invoke-convention/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/callables-and-invoke-convention/p-2/pos") @@ -4579,7 +4579,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/callables-and-invoke-convention/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/callables-and-invoke-convention/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -4594,7 +4594,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInChoosing_the_most_specific_candidate_from_the_overload_candidate_set() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection") @@ -4606,7 +4606,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInAlgorithm_of_msc_selection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-11") @@ -4618,7 +4618,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_11() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-11"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-11"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-11/pos") @@ -4670,7 +4670,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-11/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-11/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -4684,7 +4684,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_12() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-12"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-12"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-12/pos") @@ -4731,7 +4731,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-12/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-12/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -4745,7 +4745,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_14() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-14"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-14"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-14/neg") @@ -4792,7 +4792,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-14/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-14/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -4806,7 +4806,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_17() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-17"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-17"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-17/neg") @@ -4828,7 +4828,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-17/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-17/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -4842,7 +4842,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_3() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-3/pos") @@ -4874,7 +4874,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -4888,7 +4888,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_9() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-9"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-9"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-9/neg") @@ -4915,7 +4915,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-9/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-9/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -4933,7 +4933,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-9/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-9/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -4948,7 +4948,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInRationale_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/rationale-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/rationale-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/rationale-1/p-2") @@ -4960,7 +4960,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/rationale-1/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/rationale-1/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/rationale-1/p-2/pos") @@ -4977,7 +4977,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/rationale-1/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/rationale-1/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -4991,7 +4991,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_3() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/rationale-1/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/rationale-1/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/rationale-1/p-3/neg") @@ -5008,7 +5008,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/rationale-1/p-3/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/rationale-1/p-3/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -5024,7 +5024,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInDetermining_function_applicability_for_a_specific_call() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/determining-function-applicability-for-a-specific-call"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "rationale"); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/determining-function-applicability-for-a-specific-call"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "rationale"); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/determining-function-applicability-for-a-specific-call/description") @@ -5036,7 +5036,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInDescription() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/determining-function-applicability-for-a-specific-call/description"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/determining-function-applicability-for-a-specific-call/description"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/determining-function-applicability-for-a-specific-call/description/p-2") @@ -5048,7 +5048,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/determining-function-applicability-for-a-specific-call/description/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/determining-function-applicability-for-a-specific-call/description/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/determining-function-applicability-for-a-specific-call/description/p-2/neg") @@ -5065,7 +5065,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/determining-function-applicability-for-a-specific-call/description/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/determining-function-applicability-for-a-specific-call/description/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -5081,7 +5081,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInReceivers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/receivers"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/receivers"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/receivers/p-5") @@ -5093,7 +5093,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_5() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/receivers/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/receivers/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/receivers/p-5/pos") @@ -5120,7 +5120,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/receivers/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/receivers/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -5135,7 +5135,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInResolving_callable_references() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/bidirectional-resolution-for-callable-calls") @@ -5147,7 +5147,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInBidirectional_resolution_for_callable_calls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/bidirectional-resolution-for-callable-calls"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/bidirectional-resolution-for-callable-calls"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/bidirectional-resolution-for-callable-calls/p-1") @@ -5159,7 +5159,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/bidirectional-resolution-for-callable-calls/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/bidirectional-resolution-for-callable-calls/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/bidirectional-resolution-for-callable-calls/p-1/pos") @@ -5176,7 +5176,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/bidirectional-resolution-for-callable-calls/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/bidirectional-resolution-for-callable-calls/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -5190,7 +5190,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_3() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/bidirectional-resolution-for-callable-calls/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/bidirectional-resolution-for-callable-calls/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/bidirectional-resolution-for-callable-calls/p-3/neg") @@ -5207,7 +5207,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/bidirectional-resolution-for-callable-calls/p-3/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/bidirectional-resolution-for-callable-calls/p-3/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -5240,7 +5240,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/bidirectional-resolution-for-callable-calls/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/bidirectional-resolution-for-callable-calls/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -5255,7 +5255,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/p-2/pos") @@ -5272,7 +5272,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -5286,7 +5286,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInResolving_callable_references_not_used_as_arguments_to_a_call() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/resolving-callable-references-not-used-as-arguments-to-a-call"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/resolving-callable-references-not-used-as-arguments-to-a-call"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/resolving-callable-references-not-used-as-arguments-to-a-call/p-1") @@ -5298,7 +5298,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/resolving-callable-references-not-used-as-arguments-to-a-call/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/resolving-callable-references-not-used-as-arguments-to-a-call/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/resolving-callable-references-not-used-as-arguments-to-a-call/p-1/neg") @@ -5335,7 +5335,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/resolving-callable-references-not-used-as-arguments-to-a-call/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/resolving-callable-references-not-used-as-arguments-to-a-call/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -5363,7 +5363,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/resolving-callable-references-not-used-as-arguments-to-a-call/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/resolving-callable-references-not-used-as-arguments-to-a-call/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -5380,7 +5380,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInStatements() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "assignments/simple-assignments"); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "assignments/simple-assignments"); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/statements/assignments") @@ -5392,7 +5392,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInAssignments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/assignments"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "simple-assignments"); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/assignments"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "simple-assignments"); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/operator-assignments") @@ -5404,7 +5404,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInOperator_assignments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/operator-assignments"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/operator-assignments"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/operator-assignments/p-2") @@ -5416,7 +5416,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/operator-assignments/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/operator-assignments/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/operator-assignments/p-2/neg") @@ -5433,7 +5433,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/operator-assignments/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/operator-assignments/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -5451,7 +5451,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/operator-assignments/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/operator-assignments/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -5466,7 +5466,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/p-1/neg") @@ -5483,7 +5483,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -5497,7 +5497,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/p-2/neg") @@ -5519,7 +5519,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -5534,7 +5534,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInLoop_statements() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/do-while-loop-statement") @@ -5546,7 +5546,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInDo_while_loop_statement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/do-while-loop-statement"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/do-while-loop-statement"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/do-while-loop-statement/p-1") @@ -5558,7 +5558,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/do-while-loop-statement/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/do-while-loop-statement/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/do-while-loop-statement/p-1/pos") @@ -5575,7 +5575,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/do-while-loop-statement/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/do-while-loop-statement/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -5589,7 +5589,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_3() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/do-while-loop-statement/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/do-while-loop-statement/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/do-while-loop-statement/p-3/neg") @@ -5606,7 +5606,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/do-while-loop-statement/p-3/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/do-while-loop-statement/p-3/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -5621,7 +5621,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInWhile_loop_statement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/while-loop-statement"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/while-loop-statement"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/while-loop-statement/p-1") @@ -5633,7 +5633,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/while-loop-statement/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/while-loop-statement/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/while-loop-statement/p-1/pos") @@ -5650,7 +5650,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/while-loop-statement/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/while-loop-statement/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -5664,7 +5664,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_3() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/while-loop-statement/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/while-loop-statement/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/while-loop-statement/p-3/neg") @@ -5681,7 +5681,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/while-loop-statement/p-3/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/while-loop-statement/p-3/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -5698,7 +5698,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInType_inference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-inference"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "local-type-inference", "smart-casts/smart-cast-types"); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-inference"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "local-type-inference", "smart-casts/smart-cast-types"); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-inference/smart-casts") @@ -5710,7 +5710,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInSmart_casts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-inference/smart-casts"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "smart-cast-types"); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-inference/smart-casts"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "smart-cast-types"); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-inference/smart-casts/smart-cast-sink-stability") @@ -5722,7 +5722,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInSmart_cast_sink_stability() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-inference/smart-casts/smart-cast-sink-stability"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-inference/smart-casts/smart-cast-sink-stability"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-inference/smart-casts/smart-cast-sink-stability/p-5") @@ -5734,7 +5734,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_5() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-inference/smart-casts/smart-cast-sink-stability/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-inference/smart-casts/smart-cast-sink-stability/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-inference/smart-casts/smart-cast-sink-stability/p-5/neg") @@ -5751,7 +5751,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-inference/smart-casts/smart-cast-sink-stability/p-5/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-inference/smart-casts/smart-cast-sink-stability/p-5/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -5769,7 +5769,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-inference/smart-casts/smart-cast-sink-stability/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-inference/smart-casts/smart-cast-sink-stability/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -5786,7 +5786,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInType_system() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "subtyping/subtyping-for-nullable-types", "type-kinds/type-parameters"); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "subtyping/subtyping-for-nullable-types", "type-kinds/type-parameters"); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/introduction-1") @@ -5798,7 +5798,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInIntroduction_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/introduction-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/introduction-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/introduction-1/p-6") @@ -5810,7 +5810,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_6() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/introduction-1/p-6"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/introduction-1/p-6"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/introduction-1/p-6/neg") @@ -5837,7 +5837,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/introduction-1/p-6/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/introduction-1/p-6/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -5851,7 +5851,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_8() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/introduction-1/p-8"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/introduction-1/p-8"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/introduction-1/p-8/pos") @@ -5873,7 +5873,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/introduction-1/p-8/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/introduction-1/p-8/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -5888,7 +5888,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInSubtyping() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "subtyping-for-nullable-types"); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "subtyping-for-nullable-types"); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping/subtyping-for-intersection-types") @@ -5900,7 +5900,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInSubtyping_for_intersection_types() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping/subtyping-for-intersection-types"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping/subtyping-for-intersection-types"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping/subtyping-for-intersection-types/p-1") @@ -5912,7 +5912,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping/subtyping-for-intersection-types/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping/subtyping-for-intersection-types/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping/subtyping-for-intersection-types/p-1/pos") @@ -5939,7 +5939,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping/subtyping-for-intersection-types/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping/subtyping-for-intersection-types/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -5954,7 +5954,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInSubtyping_rules() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping/subtyping-rules"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping/subtyping-rules"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping/subtyping-rules/p-2") @@ -5966,7 +5966,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping/subtyping-rules/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping/subtyping-rules/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping/subtyping-rules/p-2/pos") @@ -5983,7 +5983,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping/subtyping-rules/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping/subtyping-rules/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -5999,7 +5999,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInType_contexts_and_scopes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-contexts-and-scopes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-contexts-and-scopes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/type-contexts-and-scopes/inner-and-nested-type-contexts") @@ -6011,7 +6011,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInInner_and_nested_type_contexts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-contexts-and-scopes/inner-and-nested-type-contexts"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-contexts-and-scopes/inner-and-nested-type-contexts"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/type-contexts-and-scopes/inner-and-nested-type-contexts/p-1") @@ -6023,7 +6023,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-contexts-and-scopes/inner-and-nested-type-contexts/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-contexts-and-scopes/inner-and-nested-type-contexts/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/type-contexts-and-scopes/inner-and-nested-type-contexts/p-1/neg") @@ -6050,7 +6050,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-contexts-and-scopes/inner-and-nested-type-contexts/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-contexts-and-scopes/inner-and-nested-type-contexts/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -6073,7 +6073,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-contexts-and-scopes/inner-and-nested-type-contexts/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-contexts-and-scopes/inner-and-nested-type-contexts/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -6089,7 +6089,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInType_kinds() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "type-parameters"); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "type-parameters"); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types") @@ -6101,7 +6101,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInBuilt_in_types() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.any") @@ -6113,7 +6113,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInKotlin_any() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.any"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.any"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.any/p-1") @@ -6125,7 +6125,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.any/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.any/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.any/p-1/pos") @@ -6147,7 +6147,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.any/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.any/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -6162,7 +6162,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInKotlin_nothing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.nothing"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.nothing"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.nothing/p-1") @@ -6174,7 +6174,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.nothing/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.nothing/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.nothing/p-1/neg") @@ -6191,7 +6191,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.nothing/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.nothing/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -6214,7 +6214,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.nothing/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.nothing/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -6233,7 +6233,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNotLinked() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/annotations") @@ -6245,7 +6245,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/annotations"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/annotations"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/annotations/annotation-classes") @@ -6257,7 +6257,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInAnnotation_classes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/annotations/annotation-classes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/annotations/annotation-classes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/annotations/annotation-classes/neg") @@ -6274,7 +6274,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/annotations/annotation-classes/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/annotations/annotation-classes/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -6288,7 +6288,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInType_annotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/annotations/type-annotations"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/annotations/type-annotations"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/annotations/type-annotations/neg") @@ -6355,7 +6355,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/annotations/type-annotations/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/annotations/type-annotations/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -6370,7 +6370,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInCoercion_to_unit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/coercion-to-unit"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/coercion-to-unit"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/coercion-to-unit/neg") @@ -6387,7 +6387,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/coercion-to-unit/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/coercion-to-unit/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -6401,7 +6401,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInContracts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis") @@ -6413,7 +6413,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInAnalysis() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/common") @@ -6425,7 +6425,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInCommon() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/common"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/common"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/common/neg") @@ -6442,7 +6442,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/common/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/common/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -6465,7 +6465,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/common/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/common/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -6479,7 +6479,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInControlFlow() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/initialization") @@ -6491,7 +6491,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInInitialization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/initialization"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/initialization"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/initialization/neg") @@ -6528,7 +6528,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/initialization/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/initialization/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -6576,7 +6576,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/initialization/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/initialization/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -6590,7 +6590,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInUnreachableCode() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/unreachableCode"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/unreachableCode"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/unreachableCode/neg") @@ -6607,7 +6607,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/unreachableCode/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/unreachableCode/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -6655,7 +6655,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/unreachableCode/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/unreachableCode/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -6670,7 +6670,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInSmartcasts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/neg") @@ -6757,7 +6757,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -6840,7 +6840,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -6855,7 +6855,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInDeclarations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder") @@ -6867,7 +6867,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInContractBuilder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common") @@ -6879,7 +6879,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInCommon() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/neg") @@ -6981,7 +6981,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -7004,7 +7004,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -7018,7 +7018,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInEffects() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/callsInPlace") @@ -7030,7 +7030,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInCallsInPlace() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/callsInPlace"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/callsInPlace"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/callsInPlace/neg") @@ -7052,7 +7052,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/callsInPlace/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/callsInPlace/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -7080,7 +7080,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/callsInPlace/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/callsInPlace/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -7094,7 +7094,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInCommon() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/common"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/common"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/common/neg") @@ -7111,7 +7111,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/common/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/common/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -7125,7 +7125,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInReturns() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/returns"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/returns"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/returns/neg") @@ -7172,7 +7172,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/returns/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/returns/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -7205,7 +7205,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/returns/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/returns/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -7221,7 +7221,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInContractFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractFunction"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractFunction"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractFunction/neg") @@ -7253,7 +7253,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractFunction/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractFunction/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -7276,7 +7276,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractFunction/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractFunction/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -7292,7 +7292,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInDfa() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/dfa"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/dfa"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg") @@ -7529,7 +7529,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -7907,7 +7907,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -7921,7 +7921,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInLocal_variables() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/local-variables"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/local-variables"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/local-variables/type-parameters") @@ -7933,7 +7933,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInType_parameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/local-variables/type-parameters"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/local-variables/type-parameters"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/local-variables/type-parameters/neg") @@ -7950,7 +7950,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/local-variables/type-parameters/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/local-variables/type-parameters/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -7965,7 +7965,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInOverload_resolution() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/overload-resolution"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/overload-resolution"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/overload-resolution/building-the-overload-candidate-set-ocs") @@ -7977,7 +7977,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInBuilding_the_overload_candidate_set_ocs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/overload-resolution/building-the-overload-candidate-set-ocs"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/overload-resolution/building-the-overload-candidate-set-ocs"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call") @@ -7989,7 +7989,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInInfix_function_call() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/pos") @@ -8021,7 +8021,7 @@ public class DiagnosticsTestSpecGenerated extends AbstractDiagnosticsTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } diff --git a/compiler/tests-spec/tests/org/jetbrains/kotlin/spec/checkers/FirDiagnosticsTestSpecGenerated.java b/compiler/tests-spec/tests/org/jetbrains/kotlin/spec/checkers/FirDiagnosticsTestSpecGenerated.java index 47b5b6cb458..ce8c4a9319d 100644 --- a/compiler/tests-spec/tests/org/jetbrains/kotlin/spec/checkers/FirDiagnosticsTestSpecGenerated.java +++ b/compiler/tests-spec/tests/org/jetbrains/kotlin/spec/checkers/FirDiagnosticsTestSpecGenerated.java @@ -25,7 +25,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInDiagnostics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "helpers", "linked/annotations", "linked/built-in-types-and-their-semantics", "linked/control--and-data-flow-analysis.control-flow-graph.expressions-1.conditional-expressions", "linked/control--and-data-flow-analysis/performing-analysis-on-the-control-flow-graph", "linked/declarations/classifier-declaration/class-declaration/nested-and-inner-classifiers", "linked/declarations/classifier-declaration/classifier-initialization", "linked/declarations/classifier-declaration/data-class-declaration", "linked/declarations/function-declaration", "linked/declarations/property-declaration/property-initialization", "linked/declarations/type-alias", "linked/expressions/call-and-property-access-expressions", "linked/expressions/function-literals", "linked/inheritance", "linked/overload-resolution/c-level-partition", "linked/overload-resolution/determining-function-applicability-for-a-specific-call/rationale", "linked/overloadable-operators", "linked/statements/assignments/simple-assignments", "linked/type-inference/local-type-inference", "linked/type-inference/smart-casts/smart-cast-types", "linked/type-system/subtyping/subtyping-for-nullable-types", "linked/type-system/type-kinds/type-parameters"); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "helpers", "linked/annotations", "linked/built-in-types-and-their-semantics", "linked/control--and-data-flow-analysis.control-flow-graph.expressions-1.conditional-expressions", "linked/control--and-data-flow-analysis/performing-analysis-on-the-control-flow-graph", "linked/declarations/classifier-declaration/class-declaration/nested-and-inner-classifiers", "linked/declarations/classifier-declaration/classifier-initialization", "linked/declarations/classifier-declaration/data-class-declaration", "linked/declarations/function-declaration", "linked/declarations/property-declaration/property-initialization", "linked/declarations/type-alias", "linked/expressions/call-and-property-access-expressions", "linked/expressions/function-literals", "linked/inheritance", "linked/overload-resolution/c-level-partition", "linked/overload-resolution/determining-function-applicability-for-a-specific-call/rationale", "linked/overloadable-operators", "linked/statements/assignments/simple-assignments", "linked/type-inference/local-type-inference", "linked/type-inference/smart-casts/smart-cast-types", "linked/type-system/subtyping/subtyping-for-nullable-types", "linked/type-system/type-kinds/type-parameters"); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked") @@ -37,7 +37,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInLinked() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "annotations", "built-in-types-and-their-semantics", "control--and-data-flow-analysis.control-flow-graph.expressions-1.conditional-expressions", "control--and-data-flow-analysis/performing-analysis-on-the-control-flow-graph", "declarations/classifier-declaration/class-declaration/nested-and-inner-classifiers", "declarations/classifier-declaration/classifier-initialization", "declarations/classifier-declaration/data-class-declaration", "declarations/function-declaration", "declarations/property-declaration/property-initialization", "declarations/type-alias", "expressions/call-and-property-access-expressions", "expressions/function-literals", "inheritance", "overload-resolution/c-level-partition", "overload-resolution/determining-function-applicability-for-a-specific-call/rationale", "overloadable-operators", "statements/assignments/simple-assignments", "type-inference/local-type-inference", "type-inference/smart-casts/smart-cast-types", "type-system/subtyping/subtyping-for-nullable-types", "type-system/type-kinds/type-parameters"); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "annotations", "built-in-types-and-their-semantics", "control--and-data-flow-analysis.control-flow-graph.expressions-1.conditional-expressions", "control--and-data-flow-analysis/performing-analysis-on-the-control-flow-graph", "declarations/classifier-declaration/class-declaration/nested-and-inner-classifiers", "declarations/classifier-declaration/classifier-initialization", "declarations/classifier-declaration/data-class-declaration", "declarations/function-declaration", "declarations/property-declaration/property-initialization", "declarations/type-alias", "expressions/call-and-property-access-expressions", "expressions/function-literals", "inheritance", "overload-resolution/c-level-partition", "overload-resolution/determining-function-applicability-for-a-specific-call/rationale", "overloadable-operators", "statements/assignments/simple-assignments", "type-inference/local-type-inference", "type-inference/smart-casts/smart-cast-types", "type-system/subtyping/subtyping-for-nullable-types", "type-system/type-kinds/type-parameters"); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis") @@ -49,7 +49,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInControl__and_data_flow_analysis() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "performing-analysis-on-the-control-flow-graph"); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "performing-analysis-on-the-control-flow-graph"); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph") @@ -61,7 +61,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInControl_flow_graph() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph/expressions-1") @@ -73,7 +73,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInExpressions_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph/expressions-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph/expressions-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph/expressions-1/conditional-expressions") @@ -85,7 +85,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInConditional_expressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph/expressions-1/conditional-expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph/expressions-1/conditional-expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph/expressions-1/conditional-expressions/p-1") @@ -97,7 +97,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph/expressions-1/conditional-expressions/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph/expressions-1/conditional-expressions/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph/expressions-1/conditional-expressions/p-1/neg") @@ -134,7 +134,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph/expressions-1/conditional-expressions/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph/expressions-1/conditional-expressions/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -162,7 +162,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph/expressions-1/conditional-expressions/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/control--and-data-flow-analysis/control-flow-graph/expressions-1/conditional-expressions/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -180,7 +180,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInDeclarations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "classifier-declaration/class-declaration/nested-and-inner-classifiers", "classifier-declaration/classifier-initialization", "classifier-declaration/data-class-declaration", "function-declaration", "property-declaration/property-initialization", "type-alias"); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "classifier-declaration/class-declaration/nested-and-inner-classifiers", "classifier-declaration/classifier-initialization", "classifier-declaration/data-class-declaration", "function-declaration", "property-declaration/property-initialization", "type-alias"); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration") @@ -192,7 +192,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInClassifier_declaration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "class-declaration/nested-and-inner-classifiers", "classifier-initialization", "data-class-declaration"); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "class-declaration/nested-and-inner-classifiers", "classifier-initialization", "data-class-declaration"); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration") @@ -204,7 +204,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInClass_declaration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "nested-and-inner-classifiers"); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "nested-and-inner-classifiers"); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes") @@ -216,7 +216,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInAbstract_classes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-1") @@ -228,7 +228,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-1/neg") @@ -250,7 +250,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -268,7 +268,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -282,7 +282,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg") @@ -344,7 +344,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -377,7 +377,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -392,7 +392,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInConstructor_declaration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-4") @@ -404,7 +404,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_4() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-4/pos") @@ -421,7 +421,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -435,7 +435,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_5() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/neg") @@ -467,7 +467,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -545,7 +545,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/constructor-declaration/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -562,7 +562,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInProperty_declaration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/property-declaration"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "property-initialization"); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/property-declaration"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "property-initialization"); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/declarations/property-declaration/local-property-declaration") @@ -574,7 +574,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInLocal_property_declaration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/property-declaration/local-property-declaration"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/property-declaration/local-property-declaration"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/declarations/property-declaration/local-property-declaration/p-1") @@ -586,7 +586,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/property-declaration/local-property-declaration/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/property-declaration/local-property-declaration/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/declarations/property-declaration/local-property-declaration/p-1/neg") @@ -603,7 +603,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/property-declaration/local-property-declaration/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/declarations/property-declaration/local-property-declaration/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -620,7 +620,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInExpressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "call-and-property-access-expressions", "function-literals"); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "call-and-property-access-expressions", "function-literals"); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/additive-expression") @@ -632,7 +632,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInAdditive_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/additive-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/additive-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/additive-expression/p-4") @@ -644,7 +644,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_4() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/additive-expression/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/additive-expression/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/additive-expression/p-4/pos") @@ -661,7 +661,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/additive-expression/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/additive-expression/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -676,7 +676,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInBuilt_in_types_and_their_semantics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1") @@ -688,7 +688,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInKotlin_nothing_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1") @@ -700,7 +700,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1/pos") @@ -717,7 +717,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -732,7 +732,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInKotlin_unit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.unit"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.unit"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.unit/p-1") @@ -744,7 +744,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.unit/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.unit/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.unit/p-1/pos") @@ -761,7 +761,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.unit/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/built-in-types-and-their-semantics/kotlin.unit/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -777,7 +777,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInComparison_expressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-1") @@ -789,7 +789,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-1/neg") @@ -806,7 +806,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -820,7 +820,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_4() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-4/neg") @@ -837,7 +837,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-4/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-4/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -851,7 +851,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_5() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-5/pos") @@ -868,7 +868,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/comparison-expressions/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -883,7 +883,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInConditional_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/conditional-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/conditional-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/conditional-expression/p-6") @@ -895,7 +895,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_6() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/conditional-expression/p-6"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/conditional-expression/p-6"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/conditional-expression/p-6/neg") @@ -912,7 +912,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/conditional-expression/p-6/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/conditional-expression/p-6/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -930,7 +930,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/conditional-expression/p-6/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/conditional-expression/p-6/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -945,7 +945,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInConstant_literals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/boolean-literals") @@ -957,7 +957,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInBoolean_literals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/boolean-literals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/boolean-literals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/boolean-literals/p-1") @@ -969,7 +969,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/boolean-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/boolean-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/boolean-literals/p-1/neg") @@ -991,7 +991,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/boolean-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/boolean-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -1019,7 +1019,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/boolean-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/boolean-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -1034,7 +1034,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInCharacter_literals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals/p-1") @@ -1046,7 +1046,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals/p-1/neg") @@ -1063,7 +1063,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -1081,7 +1081,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -1095,7 +1095,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_4() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals/p-4/neg") @@ -1112,7 +1112,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals/p-4/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals/p-4/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -1135,7 +1135,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/character-literals/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -1150,7 +1150,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInInteger_literals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/binary-integer-literals") @@ -1162,7 +1162,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInBinary_integer_literals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/binary-integer-literals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/binary-integer-literals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/binary-integer-literals/p-1") @@ -1174,7 +1174,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/binary-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/binary-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/binary-integer-literals/p-1/neg") @@ -1206,7 +1206,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/binary-integer-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/binary-integer-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -1221,7 +1221,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInDecimal_integer_literals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/decimal-integer-literals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/decimal-integer-literals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-1") @@ -1233,7 +1233,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-1/neg") @@ -1260,7 +1260,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -1275,7 +1275,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInHexadecimal_integer_literals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1") @@ -1287,7 +1287,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1/neg") @@ -1324,7 +1324,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -1340,7 +1340,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInReal_literals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-1") @@ -1352,7 +1352,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-1/neg") @@ -1374,7 +1374,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -1407,7 +1407,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -1421,7 +1421,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-2/neg") @@ -1453,7 +1453,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -1476,7 +1476,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -1490,7 +1490,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_3() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-3/neg") @@ -1517,7 +1517,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-3/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-3/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -1570,7 +1570,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -1584,7 +1584,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_4() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-4/neg") @@ -1621,7 +1621,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-4/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-4/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -1659,7 +1659,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -1673,7 +1673,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_5() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-5/pos") @@ -1710,7 +1710,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/real-literals/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -1725,7 +1725,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInThe_types_for_integer_literals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1") @@ -1737,7 +1737,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/neg") @@ -1789,7 +1789,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -1827,7 +1827,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -1843,7 +1843,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInElvis_operator_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/elvis-operator-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/elvis-operator-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/elvis-operator-expression/p-3") @@ -1855,7 +1855,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_3() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/elvis-operator-expression/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/elvis-operator-expression/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/elvis-operator-expression/p-3/pos") @@ -1872,7 +1872,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/elvis-operator-expression/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/elvis-operator-expression/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -1887,7 +1887,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInEquality_expressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/equality-expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/equality-expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/equality-expressions/value-equality-expressions") @@ -1899,7 +1899,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInValue_equality_expressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/equality-expressions/value-equality-expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/equality-expressions/value-equality-expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/equality-expressions/value-equality-expressions/p-3") @@ -1911,7 +1911,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_3() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/equality-expressions/value-equality-expressions/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/equality-expressions/value-equality-expressions/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/equality-expressions/value-equality-expressions/p-3/pos") @@ -1928,7 +1928,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/equality-expressions/value-equality-expressions/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/equality-expressions/value-equality-expressions/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -1944,7 +1944,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInJump_expressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/break-expression") @@ -1956,7 +1956,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInBreak_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/break-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/break-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/break-expression/p-1") @@ -1968,7 +1968,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/break-expression/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/break-expression/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/break-expression/p-1/neg") @@ -1985,7 +1985,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/break-expression/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/break-expression/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -2000,7 +2000,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInContinue_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/continue-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/continue-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/continue-expression/p-1") @@ -2012,7 +2012,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/continue-expression/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/continue-expression/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/continue-expression/p-1/neg") @@ -2029,7 +2029,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/continue-expression/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/continue-expression/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -2044,7 +2044,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/p-2/pos") @@ -2061,7 +2061,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -2075,7 +2075,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInReturn_expressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/return-expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/return-expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/return-expressions/p-1") @@ -2087,7 +2087,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/return-expressions/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/return-expressions/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/return-expressions/p-1/pos") @@ -2104,7 +2104,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/return-expressions/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/return-expressions/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -2118,7 +2118,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_4() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/return-expressions/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/return-expressions/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/return-expressions/p-4/neg") @@ -2135,7 +2135,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/return-expressions/p-4/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/jump-expressions/return-expressions/p-4/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -2151,7 +2151,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInLogical_conjunction_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-conjunction-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-conjunction-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-conjunction-expression/p-2") @@ -2163,7 +2163,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-conjunction-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-conjunction-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-conjunction-expression/p-2/neg") @@ -2180,7 +2180,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-conjunction-expression/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-conjunction-expression/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -2198,7 +2198,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-conjunction-expression/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-conjunction-expression/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -2213,7 +2213,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInLogical_disjunction_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-disjunction-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-disjunction-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-disjunction-expression/p-2") @@ -2225,7 +2225,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-disjunction-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-disjunction-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-disjunction-expression/p-2/neg") @@ -2242,7 +2242,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-disjunction-expression/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-disjunction-expression/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -2260,7 +2260,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-disjunction-expression/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/logical-disjunction-expression/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -2275,7 +2275,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInMultiplicative_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/multiplicative-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/multiplicative-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/multiplicative-expression/p-5") @@ -2287,7 +2287,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_5() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/multiplicative-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/multiplicative-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/multiplicative-expression/p-5/pos") @@ -2304,7 +2304,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/multiplicative-expression/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/multiplicative-expression/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -2319,7 +2319,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNot_null_assertion_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/not-null-assertion-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/not-null-assertion-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/not-null-assertion-expression/p-2") @@ -2331,7 +2331,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/not-null-assertion-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/not-null-assertion-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/not-null-assertion-expression/p-2/pos") @@ -2348,7 +2348,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/not-null-assertion-expression/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/not-null-assertion-expression/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -2362,7 +2362,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_3() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/not-null-assertion-expression/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/not-null-assertion-expression/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/not-null-assertion-expression/p-3/pos") @@ -2379,7 +2379,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/not-null-assertion-expression/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/not-null-assertion-expression/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -2394,7 +2394,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPrefix_expressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/logical-not-expression") @@ -2406,7 +2406,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInLogical_not_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/logical-not-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/logical-not-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/logical-not-expression/p-3") @@ -2418,7 +2418,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_3() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/logical-not-expression/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/logical-not-expression/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/logical-not-expression/p-3/pos") @@ -2435,7 +2435,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/logical-not-expression/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/logical-not-expression/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -2450,7 +2450,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPrefix_decrement_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-decrement-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-decrement-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-decrement-expression/p-4") @@ -2462,7 +2462,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_4() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-decrement-expression/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-decrement-expression/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-decrement-expression/p-4/neg") @@ -2479,7 +2479,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-decrement-expression/p-4/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-decrement-expression/p-4/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -2493,7 +2493,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_5() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-decrement-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-decrement-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-decrement-expression/p-5/neg") @@ -2510,7 +2510,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-decrement-expression/p-5/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-decrement-expression/p-5/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -2525,7 +2525,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPrefix_increment_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-4") @@ -2537,7 +2537,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_4() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-4/neg") @@ -2554,7 +2554,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-4/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-4/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -2568,7 +2568,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_5() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-5/neg") @@ -2585,7 +2585,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-5/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/prefix-increment-expression/p-5/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -2600,7 +2600,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInUnary_minus_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/unary-minus-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/unary-minus-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/unary-minus-expression/p-3") @@ -2612,7 +2612,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_3() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/unary-minus-expression/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/unary-minus-expression/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/unary-minus-expression/p-3/pos") @@ -2629,7 +2629,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/unary-minus-expression/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/unary-minus-expression/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -2644,7 +2644,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInUnary_plus_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/unary-plus-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/unary-plus-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/unary-plus-expression/p-3") @@ -2656,7 +2656,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_3() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/unary-plus-expression/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/unary-plus-expression/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/unary-plus-expression/p-3/pos") @@ -2673,7 +2673,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/unary-plus-expression/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/prefix-expressions/unary-plus-expression/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -2689,7 +2689,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInRange_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/range-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/range-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/range-expression/p-4") @@ -2701,7 +2701,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_4() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/range-expression/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/range-expression/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/range-expression/p-4/pos") @@ -2718,7 +2718,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/range-expression/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/range-expression/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -2733,7 +2733,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInTry_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-1") @@ -2745,7 +2745,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-1/neg") @@ -2777,7 +2777,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -2815,7 +2815,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -2829,7 +2829,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-2/pos") @@ -2846,7 +2846,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -2860,7 +2860,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_5() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-5/pos") @@ -2882,7 +2882,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -2896,7 +2896,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_8() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-8"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-8"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-8/neg") @@ -2913,7 +2913,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-8/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-8/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -2931,7 +2931,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-8/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/try-expression/p-8/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -2946,7 +2946,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInType_checking_and_containment_checking_expressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions/containment-checking-expression") @@ -2958,7 +2958,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInContainment_checking_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions/containment-checking-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions/containment-checking-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions/containment-checking-expression/p-5") @@ -2970,7 +2970,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_5() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions/containment-checking-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions/containment-checking-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions/containment-checking-expression/p-5/pos") @@ -2987,7 +2987,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions/containment-checking-expression/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions/containment-checking-expression/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -3002,7 +3002,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInType_checking_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression/p-4") @@ -3014,7 +3014,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_4() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression/p-4/pos") @@ -3031,7 +3031,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -3047,7 +3047,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInWhen_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/exhaustive-when-expressions") @@ -3059,7 +3059,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInExhaustive_when_expressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/exhaustive-when-expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/exhaustive-when-expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/exhaustive-when-expressions/p-2") @@ -3071,7 +3071,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/exhaustive-when-expressions/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/exhaustive-when-expressions/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/exhaustive-when-expressions/p-2/neg") @@ -3118,7 +3118,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/exhaustive-when-expressions/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/exhaustive-when-expressions/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -3176,7 +3176,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/exhaustive-when-expressions/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/exhaustive-when-expressions/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -3191,7 +3191,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-1/pos") @@ -3213,7 +3213,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -3227,7 +3227,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-2/neg") @@ -3249,7 +3249,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -3287,7 +3287,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -3301,7 +3301,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_3() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-3/neg") @@ -3318,7 +3318,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-3/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-3/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -3332,7 +3332,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_4() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-4/neg") @@ -3349,7 +3349,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-4/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-4/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -3367,7 +3367,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -3381,7 +3381,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_5() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-5/pos") @@ -3403,7 +3403,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -3417,7 +3417,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_6() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-6"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-6"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-6/neg") @@ -3459,7 +3459,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-6/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-6/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -3527,7 +3527,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-6/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/expressions/when-expression/p-6/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -3543,7 +3543,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInOverload_resolution() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "c-level-partition", "determining-function-applicability-for-a-specific-call/rationale"); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "c-level-partition", "determining-function-applicability-for-a-specific-call/rationale"); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs") @@ -3555,7 +3555,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInBuilding_the_overload_candidate_set_ocs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver") @@ -3567,7 +3567,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInCall_with_an_explicit_receiver() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/call-with-an-explicit-type-receiver") @@ -3579,7 +3579,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInCall_with_an_explicit_type_receiver() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/call-with-an-explicit-type-receiver"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/call-with-an-explicit-type-receiver"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/call-with-an-explicit-type-receiver/p-3") @@ -3591,7 +3591,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_3() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/call-with-an-explicit-type-receiver/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/call-with-an-explicit-type-receiver/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/call-with-an-explicit-type-receiver/p-3/pos") @@ -3608,7 +3608,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/call-with-an-explicit-type-receiver/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/call-with-an-explicit-type-receiver/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -3623,7 +3623,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_6() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/p-6"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/p-6"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/p-6/pos") @@ -3715,7 +3715,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/p-6/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver/p-6/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -3730,7 +3730,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInCall_with_named_parameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/p-1") @@ -3742,7 +3742,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/p-1/pos") @@ -3834,7 +3834,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -3848,7 +3848,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_5() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/p-5/pos") @@ -3860,7 +3860,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-named-parameters/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -3875,7 +3875,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInCall_with_specified_type_parameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-specified-type-parameters"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-specified-type-parameters"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-specified-type-parameters/p-2") @@ -3887,7 +3887,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-specified-type-parameters/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-specified-type-parameters/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-specified-type-parameters/p-2/pos") @@ -3904,7 +3904,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-specified-type-parameters/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-specified-type-parameters/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -3919,7 +3919,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInCall_with_trailing_lambda_expressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1") @@ -3931,7 +3931,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos") @@ -4048,7 +4048,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-trailing-lambda-expressions/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -4063,7 +4063,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInCall_without_an_explicit_receiver() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver/p-5") @@ -4075,7 +4075,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_5() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver/p-5/neg") @@ -4122,7 +4122,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver/p-5/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver/p-5/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -4215,7 +4215,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/call-without-an-explicit-receiver/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -4230,7 +4230,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInInfix_function_call() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/p-2") @@ -4242,7 +4242,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/p-2/neg") @@ -4279,7 +4279,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -4317,7 +4317,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -4332,7 +4332,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInOperator_call() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1") @@ -4344,7 +4344,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg") @@ -4396,7 +4396,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -4419,7 +4419,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -4433,7 +4433,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-2/pos") @@ -4475,7 +4475,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -4489,7 +4489,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_4() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-4"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-4/neg") @@ -4506,7 +4506,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-4/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-4/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -4524,7 +4524,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -4540,7 +4540,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInCallables_and_invoke_convention() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/callables-and-invoke-convention"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/callables-and-invoke-convention"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/callables-and-invoke-convention/p-2") @@ -4552,7 +4552,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/callables-and-invoke-convention/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/callables-and-invoke-convention/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/callables-and-invoke-convention/p-2/pos") @@ -4579,7 +4579,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/callables-and-invoke-convention/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/callables-and-invoke-convention/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -4594,7 +4594,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInChoosing_the_most_specific_candidate_from_the_overload_candidate_set() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection") @@ -4606,7 +4606,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInAlgorithm_of_msc_selection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-11") @@ -4618,7 +4618,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_11() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-11"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-11"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-11/pos") @@ -4670,7 +4670,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-11/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-11/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -4684,7 +4684,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_12() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-12"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-12"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-12/pos") @@ -4731,7 +4731,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-12/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-12/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -4745,7 +4745,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_14() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-14"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-14"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-14/neg") @@ -4792,7 +4792,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-14/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-14/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -4806,7 +4806,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_17() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-17"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-17"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-17/neg") @@ -4828,7 +4828,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-17/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-17/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -4842,7 +4842,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_3() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-3/pos") @@ -4874,7 +4874,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -4888,7 +4888,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_9() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-9"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-9"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-9/neg") @@ -4915,7 +4915,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-9/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-9/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -4933,7 +4933,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-9/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-9/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -4948,7 +4948,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInRationale_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/rationale-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/rationale-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/rationale-1/p-2") @@ -4960,7 +4960,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/rationale-1/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/rationale-1/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/rationale-1/p-2/pos") @@ -4977,7 +4977,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/rationale-1/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/rationale-1/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -4991,7 +4991,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_3() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/rationale-1/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/rationale-1/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/rationale-1/p-3/neg") @@ -5008,7 +5008,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/rationale-1/p-3/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/rationale-1/p-3/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -5024,7 +5024,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInDetermining_function_applicability_for_a_specific_call() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/determining-function-applicability-for-a-specific-call"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "rationale"); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/determining-function-applicability-for-a-specific-call"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "rationale"); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/determining-function-applicability-for-a-specific-call/description") @@ -5036,7 +5036,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInDescription() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/determining-function-applicability-for-a-specific-call/description"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/determining-function-applicability-for-a-specific-call/description"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/determining-function-applicability-for-a-specific-call/description/p-2") @@ -5048,7 +5048,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/determining-function-applicability-for-a-specific-call/description/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/determining-function-applicability-for-a-specific-call/description/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/determining-function-applicability-for-a-specific-call/description/p-2/neg") @@ -5065,7 +5065,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/determining-function-applicability-for-a-specific-call/description/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/determining-function-applicability-for-a-specific-call/description/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -5081,7 +5081,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInReceivers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/receivers"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/receivers"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/receivers/p-5") @@ -5093,7 +5093,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_5() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/receivers/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/receivers/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/receivers/p-5/pos") @@ -5120,7 +5120,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/receivers/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/receivers/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -5135,7 +5135,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInResolving_callable_references() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/bidirectional-resolution-for-callable-calls") @@ -5147,7 +5147,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInBidirectional_resolution_for_callable_calls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/bidirectional-resolution-for-callable-calls"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/bidirectional-resolution-for-callable-calls"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/bidirectional-resolution-for-callable-calls/p-1") @@ -5159,7 +5159,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/bidirectional-resolution-for-callable-calls/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/bidirectional-resolution-for-callable-calls/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/bidirectional-resolution-for-callable-calls/p-1/pos") @@ -5176,7 +5176,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/bidirectional-resolution-for-callable-calls/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/bidirectional-resolution-for-callable-calls/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -5190,7 +5190,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_3() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/bidirectional-resolution-for-callable-calls/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/bidirectional-resolution-for-callable-calls/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/bidirectional-resolution-for-callable-calls/p-3/neg") @@ -5207,7 +5207,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/bidirectional-resolution-for-callable-calls/p-3/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/bidirectional-resolution-for-callable-calls/p-3/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -5240,7 +5240,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/bidirectional-resolution-for-callable-calls/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/bidirectional-resolution-for-callable-calls/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -5255,7 +5255,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/p-2/pos") @@ -5272,7 +5272,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -5286,7 +5286,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInResolving_callable_references_not_used_as_arguments_to_a_call() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/resolving-callable-references-not-used-as-arguments-to-a-call"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/resolving-callable-references-not-used-as-arguments-to-a-call"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/resolving-callable-references-not-used-as-arguments-to-a-call/p-1") @@ -5298,7 +5298,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/resolving-callable-references-not-used-as-arguments-to-a-call/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/resolving-callable-references-not-used-as-arguments-to-a-call/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/resolving-callable-references-not-used-as-arguments-to-a-call/p-1/neg") @@ -5335,7 +5335,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/resolving-callable-references-not-used-as-arguments-to-a-call/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/resolving-callable-references-not-used-as-arguments-to-a-call/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -5363,7 +5363,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/resolving-callable-references-not-used-as-arguments-to-a-call/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/overload-resolution/resolving-callable-references/resolving-callable-references-not-used-as-arguments-to-a-call/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -5380,7 +5380,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInStatements() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "assignments/simple-assignments"); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "assignments/simple-assignments"); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/statements/assignments") @@ -5392,7 +5392,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInAssignments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/assignments"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "simple-assignments"); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/assignments"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "simple-assignments"); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/operator-assignments") @@ -5404,7 +5404,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInOperator_assignments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/operator-assignments"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/operator-assignments"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/operator-assignments/p-2") @@ -5416,7 +5416,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/operator-assignments/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/operator-assignments/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/operator-assignments/p-2/neg") @@ -5433,7 +5433,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/operator-assignments/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/operator-assignments/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -5451,7 +5451,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/operator-assignments/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/operator-assignments/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -5466,7 +5466,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/p-1/neg") @@ -5483,7 +5483,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -5497,7 +5497,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/p-2/neg") @@ -5519,7 +5519,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/assignments/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -5534,7 +5534,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInLoop_statements() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/do-while-loop-statement") @@ -5546,7 +5546,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInDo_while_loop_statement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/do-while-loop-statement"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/do-while-loop-statement"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/do-while-loop-statement/p-1") @@ -5558,7 +5558,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/do-while-loop-statement/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/do-while-loop-statement/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/do-while-loop-statement/p-1/pos") @@ -5575,7 +5575,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/do-while-loop-statement/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/do-while-loop-statement/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -5589,7 +5589,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_3() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/do-while-loop-statement/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/do-while-loop-statement/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/do-while-loop-statement/p-3/neg") @@ -5606,7 +5606,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/do-while-loop-statement/p-3/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/do-while-loop-statement/p-3/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -5621,7 +5621,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInWhile_loop_statement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/while-loop-statement"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/while-loop-statement"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/while-loop-statement/p-1") @@ -5633,7 +5633,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/while-loop-statement/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/while-loop-statement/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/while-loop-statement/p-1/pos") @@ -5650,7 +5650,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/while-loop-statement/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/while-loop-statement/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -5664,7 +5664,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_3() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/while-loop-statement/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/while-loop-statement/p-3"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/while-loop-statement/p-3/neg") @@ -5681,7 +5681,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/while-loop-statement/p-3/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/statements/loop-statements/while-loop-statement/p-3/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -5698,7 +5698,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInType_inference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-inference"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "local-type-inference", "smart-casts/smart-cast-types"); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-inference"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "local-type-inference", "smart-casts/smart-cast-types"); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-inference/smart-casts") @@ -5710,7 +5710,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInSmart_casts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-inference/smart-casts"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "smart-cast-types"); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-inference/smart-casts"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "smart-cast-types"); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-inference/smart-casts/smart-cast-sink-stability") @@ -5722,7 +5722,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInSmart_cast_sink_stability() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-inference/smart-casts/smart-cast-sink-stability"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-inference/smart-casts/smart-cast-sink-stability"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-inference/smart-casts/smart-cast-sink-stability/p-5") @@ -5734,7 +5734,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_5() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-inference/smart-casts/smart-cast-sink-stability/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-inference/smart-casts/smart-cast-sink-stability/p-5"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-inference/smart-casts/smart-cast-sink-stability/p-5/neg") @@ -5751,7 +5751,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-inference/smart-casts/smart-cast-sink-stability/p-5/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-inference/smart-casts/smart-cast-sink-stability/p-5/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -5769,7 +5769,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-inference/smart-casts/smart-cast-sink-stability/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-inference/smart-casts/smart-cast-sink-stability/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -5786,7 +5786,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInType_system() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "subtyping/subtyping-for-nullable-types", "type-kinds/type-parameters"); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "subtyping/subtyping-for-nullable-types", "type-kinds/type-parameters"); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/introduction-1") @@ -5798,7 +5798,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInIntroduction_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/introduction-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/introduction-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/introduction-1/p-6") @@ -5810,7 +5810,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_6() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/introduction-1/p-6"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/introduction-1/p-6"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/introduction-1/p-6/neg") @@ -5837,7 +5837,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/introduction-1/p-6/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/introduction-1/p-6/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -5851,7 +5851,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_8() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/introduction-1/p-8"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/introduction-1/p-8"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/introduction-1/p-8/pos") @@ -5873,7 +5873,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/introduction-1/p-8/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/introduction-1/p-8/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -5888,7 +5888,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInSubtyping() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "subtyping-for-nullable-types"); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "subtyping-for-nullable-types"); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping/subtyping-for-intersection-types") @@ -5900,7 +5900,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInSubtyping_for_intersection_types() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping/subtyping-for-intersection-types"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping/subtyping-for-intersection-types"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping/subtyping-for-intersection-types/p-1") @@ -5912,7 +5912,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping/subtyping-for-intersection-types/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping/subtyping-for-intersection-types/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping/subtyping-for-intersection-types/p-1/pos") @@ -5939,7 +5939,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping/subtyping-for-intersection-types/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping/subtyping-for-intersection-types/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -5954,7 +5954,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInSubtyping_rules() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping/subtyping-rules"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping/subtyping-rules"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping/subtyping-rules/p-2") @@ -5966,7 +5966,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping/subtyping-rules/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping/subtyping-rules/p-2"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping/subtyping-rules/p-2/pos") @@ -5983,7 +5983,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping/subtyping-rules/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/subtyping/subtyping-rules/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -5999,7 +5999,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInType_contexts_and_scopes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-contexts-and-scopes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-contexts-and-scopes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/type-contexts-and-scopes/inner-and-nested-type-contexts") @@ -6011,7 +6011,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInInner_and_nested_type_contexts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-contexts-and-scopes/inner-and-nested-type-contexts"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-contexts-and-scopes/inner-and-nested-type-contexts"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/type-contexts-and-scopes/inner-and-nested-type-contexts/p-1") @@ -6023,7 +6023,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-contexts-and-scopes/inner-and-nested-type-contexts/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-contexts-and-scopes/inner-and-nested-type-contexts/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/type-contexts-and-scopes/inner-and-nested-type-contexts/p-1/neg") @@ -6050,7 +6050,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-contexts-and-scopes/inner-and-nested-type-contexts/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-contexts-and-scopes/inner-and-nested-type-contexts/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -6073,7 +6073,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-contexts-and-scopes/inner-and-nested-type-contexts/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-contexts-and-scopes/inner-and-nested-type-contexts/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -6089,7 +6089,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInType_kinds() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "type-parameters"); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true, "type-parameters"); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types") @@ -6101,7 +6101,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInBuilt_in_types() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.any") @@ -6113,7 +6113,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInKotlin_any() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.any"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.any"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.any/p-1") @@ -6125,7 +6125,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.any/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.any/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.any/p-1/pos") @@ -6147,7 +6147,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.any/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.any/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -6162,7 +6162,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInKotlin_nothing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.nothing"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.nothing"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.nothing/p-1") @@ -6174,7 +6174,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.nothing/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.nothing/p-1"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.nothing/p-1/neg") @@ -6191,7 +6191,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.nothing/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.nothing/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -6214,7 +6214,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.nothing/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/linked/type-system/type-kinds/built-in-types/kotlin.nothing/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -6233,7 +6233,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNotLinked() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/annotations") @@ -6245,7 +6245,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/annotations"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/annotations"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/annotations/annotation-classes") @@ -6257,7 +6257,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInAnnotation_classes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/annotations/annotation-classes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/annotations/annotation-classes"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/annotations/annotation-classes/neg") @@ -6274,7 +6274,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/annotations/annotation-classes/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/annotations/annotation-classes/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -6288,7 +6288,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInType_annotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/annotations/type-annotations"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/annotations/type-annotations"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/annotations/type-annotations/neg") @@ -6355,7 +6355,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/annotations/type-annotations/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/annotations/type-annotations/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -6370,7 +6370,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInCoercion_to_unit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/coercion-to-unit"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/coercion-to-unit"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/coercion-to-unit/neg") @@ -6387,7 +6387,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/coercion-to-unit/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/coercion-to-unit/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -6401,7 +6401,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInContracts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis") @@ -6413,7 +6413,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInAnalysis() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/common") @@ -6425,7 +6425,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInCommon() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/common"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/common"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/common/neg") @@ -6442,7 +6442,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/common/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/common/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -6465,7 +6465,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/common/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/common/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -6479,7 +6479,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInControlFlow() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/initialization") @@ -6491,7 +6491,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInInitialization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/initialization"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/initialization"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/initialization/neg") @@ -6528,7 +6528,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/initialization/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/initialization/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -6576,7 +6576,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/initialization/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/initialization/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -6590,7 +6590,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInUnreachableCode() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/unreachableCode"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/unreachableCode"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/unreachableCode/neg") @@ -6607,7 +6607,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/unreachableCode/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/unreachableCode/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -6655,7 +6655,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/unreachableCode/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/controlFlow/unreachableCode/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -6670,7 +6670,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInSmartcasts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/neg") @@ -6757,7 +6757,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -6840,7 +6840,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/analysis/smartcasts/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -6855,7 +6855,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInDeclarations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder") @@ -6867,7 +6867,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInContractBuilder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common") @@ -6879,7 +6879,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInCommon() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/neg") @@ -6981,7 +6981,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -7004,7 +7004,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -7018,7 +7018,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInEffects() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/callsInPlace") @@ -7030,7 +7030,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInCallsInPlace() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/callsInPlace"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/callsInPlace"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/callsInPlace/neg") @@ -7052,7 +7052,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/callsInPlace/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/callsInPlace/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -7080,7 +7080,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/callsInPlace/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/callsInPlace/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -7094,7 +7094,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInCommon() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/common"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/common"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/common/neg") @@ -7111,7 +7111,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/common/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/common/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -7125,7 +7125,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInReturns() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/returns"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/returns"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/returns/neg") @@ -7172,7 +7172,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/returns/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/returns/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -7205,7 +7205,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/returns/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/effects/returns/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -7221,7 +7221,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInContractFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractFunction"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractFunction"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractFunction/neg") @@ -7253,7 +7253,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractFunction/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractFunction/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -7276,7 +7276,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractFunction/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractFunction/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -7292,7 +7292,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInDfa() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/dfa"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/dfa"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg") @@ -7529,7 +7529,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/dfa/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } @@ -7907,7 +7907,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -7921,7 +7921,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInLocal_variables() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/local-variables"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/local-variables"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/local-variables/type-parameters") @@ -7933,7 +7933,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInType_parameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/local-variables/type-parameters"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/local-variables/type-parameters"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/local-variables/type-parameters/neg") @@ -7950,7 +7950,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/local-variables/type-parameters/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/local-variables/type-parameters/neg"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } @@ -7965,7 +7965,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInOverload_resolution() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/overload-resolution"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/overload-resolution"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/overload-resolution/building-the-overload-candidate-set-ocs") @@ -7977,7 +7977,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInBuilding_the_overload_candidate_set_ocs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/overload-resolution/building-the-overload-candidate-set-ocs"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/overload-resolution/building-the-overload-candidate-set-ocs"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call") @@ -7989,7 +7989,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInInfix_function_call() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } @TestMetadata("compiler/tests-spec/testData/diagnostics/notLinked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/pos") @@ -8021,7 +8021,7 @@ public class FirDiagnosticsTestSpecGenerated extends AbstractFirDiagnosticsTestS } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/diagnostics/notLinked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/pos"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } } } diff --git a/compiler/tests-spec/tests/org/jetbrains/kotlin/spec/codegen/BlackBoxCodegenTestSpecGenerated.java b/compiler/tests-spec/tests/org/jetbrains/kotlin/spec/codegen/BlackBoxCodegenTestSpecGenerated.java index 696b7770691..41482ef7def 100644 --- a/compiler/tests-spec/tests/org/jetbrains/kotlin/spec/codegen/BlackBoxCodegenTestSpecGenerated.java +++ b/compiler/tests-spec/tests/org/jetbrains/kotlin/spec/codegen/BlackBoxCodegenTestSpecGenerated.java @@ -25,7 +25,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInBox() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box"), Pattern.compile("^(.+)\\.kt$"), null, true, "helpers", "templates", "linked/exceptions", "linked/operator-call", "linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver", "linked/overloadable-operators"); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box"), Pattern.compile("^(.+)\\.kt$"), null, true, "helpers", "templates", "linked/exceptions", "linked/operator-call", "linked/overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver", "linked/overloadable-operators"); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked") @@ -37,7 +37,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInLinked() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked"), Pattern.compile("^(.+)\\.kt$"), null, true, "exceptions", "operator-call", "overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver", "overloadable-operators"); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked"), Pattern.compile("^(.+)\\.kt$"), null, true, "exceptions", "operator-call", "overload-resolution/building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver", "overloadable-operators"); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions") @@ -49,7 +49,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInExpressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/additive-expression") @@ -61,7 +61,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInAdditive_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/additive-expression"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/additive-expression"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/additive-expression/p-2") @@ -73,7 +73,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/additive-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/additive-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/additive-expression/p-2/pos") @@ -95,7 +95,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/additive-expression/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/additive-expression/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -110,7 +110,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInBuilt_in_types_and_their_semantics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1") @@ -122,7 +122,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInKotlin_nothing_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1") @@ -134,7 +134,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1/pos") @@ -196,7 +196,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.nothing-1/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -211,7 +211,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInKotlin_unit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.unit"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.unit"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.unit/p-1") @@ -223,7 +223,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.unit/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.unit/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.unit/p-1/pos") @@ -240,7 +240,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.unit/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/built-in-types-and-their-semantics/kotlin.unit/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -256,7 +256,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInCast_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/cast-expression"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/cast-expression"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/cast-expression/p-1") @@ -268,7 +268,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/cast-expression/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/cast-expression/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/cast-expression/p-1/pos") @@ -285,7 +285,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/cast-expression/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/cast-expression/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -300,7 +300,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInComparison_expressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/comparison-expressions"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/comparison-expressions"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/comparison-expressions/p-1") @@ -312,7 +312,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/comparison-expressions/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/comparison-expressions/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/comparison-expressions/p-1/pos") @@ -344,7 +344,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/comparison-expressions/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/comparison-expressions/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -359,7 +359,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInConditional_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/conditional-expression"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/conditional-expression"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/conditional-expression/p-1") @@ -371,7 +371,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/conditional-expression/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/conditional-expression/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/conditional-expression/p-1/pos") @@ -423,7 +423,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/conditional-expression/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/conditional-expression/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -437,7 +437,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/conditional-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/conditional-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/conditional-expression/p-2/pos") @@ -454,7 +454,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/conditional-expression/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/conditional-expression/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -468,7 +468,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_6() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/conditional-expression/p-6"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/conditional-expression/p-6"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/conditional-expression/p-6/pos") @@ -485,7 +485,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/conditional-expression/p-6/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/conditional-expression/p-6/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -500,7 +500,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInConstant_literals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/boolean-literals") @@ -512,7 +512,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInBoolean_literals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/boolean-literals"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/boolean-literals"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/boolean-literals/p-1") @@ -524,7 +524,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/boolean-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/boolean-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/boolean-literals/p-1/pos") @@ -666,7 +666,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/boolean-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/boolean-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -681,7 +681,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInCharacter_literals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/character-literals"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/character-literals"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/character-literals/p-4") @@ -693,7 +693,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_4() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/character-literals/p-4"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/character-literals/p-4"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/character-literals/p-4/pos") @@ -710,7 +710,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/character-literals/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/character-literals/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -725,7 +725,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInInteger_literals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals/binary-integer-literals") @@ -737,7 +737,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInBinary_integer_literals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals/binary-integer-literals"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals/binary-integer-literals"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals/binary-integer-literals/p-1") @@ -749,7 +749,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals/binary-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals/binary-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals/binary-integer-literals/p-1/pos") @@ -771,7 +771,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals/binary-integer-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals/binary-integer-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -786,7 +786,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInDecimal_integer_literals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals/decimal-integer-literals"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals/decimal-integer-literals"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-1") @@ -798,7 +798,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-1/pos") @@ -820,7 +820,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -835,7 +835,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInHexadecimal_integer_literals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1") @@ -847,7 +847,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1/pos") @@ -869,7 +869,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -885,7 +885,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInReal_literals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/real-literals"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/real-literals"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/real-literals/p-1") @@ -897,7 +897,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/real-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/real-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/real-literals/p-1/pos") @@ -919,7 +919,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/real-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/real-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -933,7 +933,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/real-literals/p-2"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/real-literals/p-2"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/real-literals/p-2/pos") @@ -955,7 +955,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/real-literals/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/real-literals/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -969,7 +969,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_3() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/real-literals/p-3"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/real-literals/p-3"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/real-literals/p-3/pos") @@ -1016,7 +1016,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/real-literals/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/real-literals/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -1030,7 +1030,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_4() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/real-literals/p-4"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/real-literals/p-4"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/real-literals/p-4/pos") @@ -1067,7 +1067,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/real-literals/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/real-literals/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -1082,7 +1082,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInThe_types_for_integer_literals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/the-types-for-integer-literals"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/the-types-for-integer-literals"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/the-types-for-integer-literals/p-1") @@ -1094,7 +1094,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/the-types-for-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/the-types-for-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/pos") @@ -1121,7 +1121,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -1137,7 +1137,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInElvis_operator_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/elvis-operator-expression"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/elvis-operator-expression"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/elvis-operator-expression/p-1") @@ -1149,7 +1149,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/elvis-operator-expression/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/elvis-operator-expression/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/elvis-operator-expression/p-1/pos") @@ -1166,7 +1166,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/elvis-operator-expression/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/elvis-operator-expression/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -1181,7 +1181,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInEquality_expressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions/reference-equality-expressions") @@ -1193,7 +1193,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInReference_equality_expressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions/reference-equality-expressions"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions/reference-equality-expressions"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions/reference-equality-expressions/p-1") @@ -1205,7 +1205,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions/reference-equality-expressions/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions/reference-equality-expressions/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions/reference-equality-expressions/p-1/pos") @@ -1247,7 +1247,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions/reference-equality-expressions/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions/reference-equality-expressions/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -1261,7 +1261,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_3() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions/reference-equality-expressions/p-3"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions/reference-equality-expressions/p-3"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions/reference-equality-expressions/p-3/pos") @@ -1288,7 +1288,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions/reference-equality-expressions/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions/reference-equality-expressions/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -1303,7 +1303,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInValue_equality_expressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions/value-equality-expressions"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions/value-equality-expressions"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions/value-equality-expressions/p-2") @@ -1315,7 +1315,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions/value-equality-expressions/p-2"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions/value-equality-expressions/p-2"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions/value-equality-expressions/p-2/pos") @@ -1377,7 +1377,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions/value-equality-expressions/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/equality-expressions/value-equality-expressions/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -1393,7 +1393,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInIndexing_expressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/indexing-expressions"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/indexing-expressions"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/indexing-expressions/p-3") @@ -1405,7 +1405,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_3() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/indexing-expressions/p-3"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/indexing-expressions/p-3"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/indexing-expressions/p-3/pos") @@ -1442,7 +1442,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/indexing-expressions/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/indexing-expressions/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -1457,7 +1457,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInJump_expressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/jump-expressions"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/jump-expressions"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/jump-expressions/break-expression") @@ -1469,7 +1469,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInBreak_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/jump-expressions/break-expression"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/jump-expressions/break-expression"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/jump-expressions/break-expression/p-3") @@ -1481,7 +1481,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_3() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/jump-expressions/break-expression/p-3"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/jump-expressions/break-expression/p-3"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/jump-expressions/break-expression/p-3/pos") @@ -1513,7 +1513,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/jump-expressions/break-expression/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/jump-expressions/break-expression/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -1528,7 +1528,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInContinue_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/jump-expressions/continue-expression"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/jump-expressions/continue-expression"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/jump-expressions/continue-expression/p-3") @@ -1540,7 +1540,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_3() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/jump-expressions/continue-expression/p-3"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/jump-expressions/continue-expression/p-3"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/jump-expressions/continue-expression/p-3/pos") @@ -1572,7 +1572,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/jump-expressions/continue-expression/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/jump-expressions/continue-expression/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -1587,7 +1587,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInReturn_expressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/jump-expressions/return-expressions"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/jump-expressions/return-expressions"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/jump-expressions/return-expressions/p-1") @@ -1599,7 +1599,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/jump-expressions/return-expressions/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/jump-expressions/return-expressions/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/jump-expressions/return-expressions/p-1/pos") @@ -1626,7 +1626,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/jump-expressions/return-expressions/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/jump-expressions/return-expressions/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -1640,7 +1640,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_3() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/jump-expressions/return-expressions/p-3"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/jump-expressions/return-expressions/p-3"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/jump-expressions/return-expressions/p-3/pos") @@ -1662,7 +1662,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/jump-expressions/return-expressions/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/jump-expressions/return-expressions/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -1678,7 +1678,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInLogical_conjunction_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/logical-conjunction-expression"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/logical-conjunction-expression"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/logical-conjunction-expression/p-1") @@ -1690,7 +1690,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/logical-conjunction-expression/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/logical-conjunction-expression/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/logical-conjunction-expression/p-1/pos") @@ -1717,7 +1717,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/logical-conjunction-expression/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/logical-conjunction-expression/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -1732,7 +1732,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInLogical_disjunction_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/logical-disjunction-expression"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/logical-disjunction-expression"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/logical-disjunction-expression/p-1") @@ -1744,7 +1744,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/logical-disjunction-expression/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/logical-disjunction-expression/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/logical-disjunction-expression/p-1/pos") @@ -1771,7 +1771,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/logical-disjunction-expression/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/logical-disjunction-expression/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -1786,7 +1786,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInMultiplicative_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/multiplicative-expression"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/multiplicative-expression"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/multiplicative-expression/p-2") @@ -1798,7 +1798,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/multiplicative-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/multiplicative-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/multiplicative-expression/p-2/pos") @@ -1825,7 +1825,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/multiplicative-expression/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/multiplicative-expression/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -1840,7 +1840,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInNot_null_assertion_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/not-null-assertion-expression"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/not-null-assertion-expression"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/not-null-assertion-expression/p-2") @@ -1852,7 +1852,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/not-null-assertion-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/not-null-assertion-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/not-null-assertion-expression/p-2/pos") @@ -1879,7 +1879,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/not-null-assertion-expression/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/not-null-assertion-expression/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -1894,7 +1894,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPostfix_operator_expressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/postfix-operator-expressions"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/postfix-operator-expressions"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/postfix-operator-expressions/postfix-decrement-expression") @@ -1906,7 +1906,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPostfix_decrement_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/postfix-operator-expressions/postfix-decrement-expression"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/postfix-operator-expressions/postfix-decrement-expression"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/postfix-operator-expressions/postfix-decrement-expression/p-1") @@ -1918,7 +1918,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/postfix-operator-expressions/postfix-decrement-expression/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/postfix-operator-expressions/postfix-decrement-expression/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/postfix-operator-expressions/postfix-decrement-expression/p-1/pos") @@ -1940,7 +1940,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/postfix-operator-expressions/postfix-decrement-expression/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/postfix-operator-expressions/postfix-decrement-expression/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -1954,7 +1954,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_4() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/postfix-operator-expressions/postfix-decrement-expression/p-4"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/postfix-operator-expressions/postfix-decrement-expression/p-4"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/postfix-operator-expressions/postfix-decrement-expression/p-4/pos") @@ -1976,7 +1976,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/postfix-operator-expressions/postfix-decrement-expression/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/postfix-operator-expressions/postfix-decrement-expression/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -1990,7 +1990,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_5() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/postfix-operator-expressions/postfix-decrement-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/postfix-operator-expressions/postfix-decrement-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/postfix-operator-expressions/postfix-decrement-expression/p-5/pos") @@ -2007,7 +2007,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/postfix-operator-expressions/postfix-decrement-expression/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/postfix-operator-expressions/postfix-decrement-expression/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -2021,7 +2021,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_6() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/postfix-operator-expressions/postfix-decrement-expression/p-6"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/postfix-operator-expressions/postfix-decrement-expression/p-6"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/postfix-operator-expressions/postfix-decrement-expression/p-6/pos") @@ -2043,7 +2043,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/postfix-operator-expressions/postfix-decrement-expression/p-6/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/postfix-operator-expressions/postfix-decrement-expression/p-6/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -2058,7 +2058,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPostfix_increment_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/postfix-operator-expressions/postfix-increment-expression"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/postfix-operator-expressions/postfix-increment-expression"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/postfix-operator-expressions/postfix-increment-expression/p-1") @@ -2070,7 +2070,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/postfix-operator-expressions/postfix-increment-expression/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/postfix-operator-expressions/postfix-increment-expression/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/postfix-operator-expressions/postfix-increment-expression/p-1/pos") @@ -2092,7 +2092,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/postfix-operator-expressions/postfix-increment-expression/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/postfix-operator-expressions/postfix-increment-expression/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -2106,7 +2106,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_4() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/postfix-operator-expressions/postfix-increment-expression/p-4"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/postfix-operator-expressions/postfix-increment-expression/p-4"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/postfix-operator-expressions/postfix-increment-expression/p-4/pos") @@ -2128,7 +2128,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/postfix-operator-expressions/postfix-increment-expression/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/postfix-operator-expressions/postfix-increment-expression/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -2142,7 +2142,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_5() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/postfix-operator-expressions/postfix-increment-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/postfix-operator-expressions/postfix-increment-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/postfix-operator-expressions/postfix-increment-expression/p-5/pos") @@ -2159,7 +2159,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/postfix-operator-expressions/postfix-increment-expression/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/postfix-operator-expressions/postfix-increment-expression/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -2173,7 +2173,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_6() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/postfix-operator-expressions/postfix-increment-expression/p-6"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/postfix-operator-expressions/postfix-increment-expression/p-6"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/postfix-operator-expressions/postfix-increment-expression/p-6/pos") @@ -2195,7 +2195,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/postfix-operator-expressions/postfix-increment-expression/p-6/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/postfix-operator-expressions/postfix-increment-expression/p-6/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -2211,7 +2211,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPrefix_expressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/logical-not-expression") @@ -2223,7 +2223,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInLogical_not_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/logical-not-expression"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/logical-not-expression"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/logical-not-expression/p-2") @@ -2235,7 +2235,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/logical-not-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/logical-not-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/logical-not-expression/p-2/pos") @@ -2252,7 +2252,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/logical-not-expression/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/logical-not-expression/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -2267,7 +2267,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPrefix_decrement_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-decrement-expression"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-decrement-expression"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-decrement-expression/p-1") @@ -2279,7 +2279,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-decrement-expression/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-decrement-expression/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-decrement-expression/p-1/pos") @@ -2301,7 +2301,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-decrement-expression/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-decrement-expression/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -2315,7 +2315,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_4() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-decrement-expression/p-4"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-decrement-expression/p-4"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-decrement-expression/p-4/pos") @@ -2337,7 +2337,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-decrement-expression/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-decrement-expression/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -2351,7 +2351,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_5() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-decrement-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-decrement-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-decrement-expression/p-5/pos") @@ -2368,7 +2368,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-decrement-expression/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-decrement-expression/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -2382,7 +2382,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_6() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-decrement-expression/p-6"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-decrement-expression/p-6"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-decrement-expression/p-6/pos") @@ -2404,7 +2404,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-decrement-expression/p-6/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-decrement-expression/p-6/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -2419,7 +2419,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPrefix_increment_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-1") @@ -2431,7 +2431,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-1/pos") @@ -2453,7 +2453,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -2467,7 +2467,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_4() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-4"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-4"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-4/pos") @@ -2489,7 +2489,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -2503,7 +2503,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_5() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-5/pos") @@ -2520,7 +2520,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -2534,7 +2534,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_6() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-6"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-6"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-6/pos") @@ -2556,7 +2556,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-6/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/prefix-increment-expression/p-6/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -2571,7 +2571,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInUnary_minus_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/unary-minus-expression"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/unary-minus-expression"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/unary-minus-expression/p-2") @@ -2583,7 +2583,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/unary-minus-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/unary-minus-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/unary-minus-expression/p-2/pos") @@ -2600,7 +2600,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/unary-minus-expression/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/unary-minus-expression/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -2615,7 +2615,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInUnary_plus_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/unary-plus-expression"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/unary-plus-expression"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/unary-plus-expression/p-2") @@ -2627,7 +2627,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/unary-plus-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/unary-plus-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/unary-plus-expression/p-2/pos") @@ -2644,7 +2644,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/unary-plus-expression/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/prefix-expressions/unary-plus-expression/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -2660,7 +2660,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInRange_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/range-expression"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/range-expression"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/range-expression/p-2") @@ -2672,7 +2672,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/range-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/range-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/range-expression/p-2/pos") @@ -2689,7 +2689,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/range-expression/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/range-expression/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -2704,7 +2704,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInTry_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/try-expression"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/try-expression"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/try-expression/p-2") @@ -2716,7 +2716,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/try-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/try-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/try-expression/p-2/neg") @@ -2733,7 +2733,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/try-expression/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/try-expression/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); } } @@ -2771,7 +2771,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/try-expression/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/try-expression/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -2785,7 +2785,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_5() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/try-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/try-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/try-expression/p-5/neg") @@ -2802,7 +2802,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/try-expression/p-5/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/try-expression/p-5/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); } } @@ -2830,7 +2830,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/try-expression/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/try-expression/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -2844,7 +2844,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_6() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/try-expression/p-6"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/try-expression/p-6"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/try-expression/p-6/pos") @@ -2861,7 +2861,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/try-expression/p-6/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/try-expression/p-6/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -2875,7 +2875,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_7() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/try-expression/p-7"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/try-expression/p-7"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/try-expression/p-7/pos") @@ -2892,7 +2892,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/try-expression/p-7/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/try-expression/p-7/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -2907,7 +2907,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInType_checking_and_containment_checking_expressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions/containment-checking-expression") @@ -2919,7 +2919,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInContainment_checking_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions/containment-checking-expression"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions/containment-checking-expression"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions/containment-checking-expression/p-2") @@ -2931,7 +2931,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions/containment-checking-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions/containment-checking-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions/containment-checking-expression/p-2/pos") @@ -2953,7 +2953,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions/containment-checking-expression/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions/containment-checking-expression/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -2967,7 +2967,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_4() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions/containment-checking-expression/p-4"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions/containment-checking-expression/p-4"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions/containment-checking-expression/p-4/pos") @@ -2989,7 +2989,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions/containment-checking-expression/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions/containment-checking-expression/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -3003,7 +3003,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_5() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions/containment-checking-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions/containment-checking-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions/containment-checking-expression/p-5/neg") @@ -3020,7 +3020,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions/containment-checking-expression/p-5/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions/containment-checking-expression/p-5/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -3035,7 +3035,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInType_checking_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression/p-1") @@ -3047,7 +3047,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression/p-1/neg") @@ -3059,7 +3059,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); } } @@ -3082,7 +3082,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -3096,7 +3096,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression/p-2/neg") @@ -3113,7 +3113,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -3127,7 +3127,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_5() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression/p-5/pos") @@ -3144,7 +3144,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/type-checking-and-containment-checking-expressions/type-checking-expression/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -3160,7 +3160,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInWhen_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/when-expression"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/when-expression"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/when-expression/p-4") @@ -3172,7 +3172,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_4() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/when-expression/p-4"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/when-expression/p-4"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/when-expression/p-4/neg") @@ -3204,7 +3204,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/when-expression/p-4/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/when-expression/p-4/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); } } @@ -3237,7 +3237,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/when-expression/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/when-expression/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -3251,7 +3251,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_5() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/when-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/when-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/expressions/when-expression/p-5/neg") @@ -3268,7 +3268,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/when-expression/p-5/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/when-expression/p-5/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); } } @@ -3286,7 +3286,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/when-expression/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/expressions/when-expression/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -3302,7 +3302,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInOverload_resolution() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/overload-resolution"), Pattern.compile("^(.+)\\.kt$"), null, true, "building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver"); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/overload-resolution"), Pattern.compile("^(.+)\\.kt$"), null, true, "building-the-overload-candidate-set-ocs/call-with-an-explicit-receiver"); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs") @@ -3314,7 +3314,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInBuilding_the_overload_candidate_set_ocs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs"), Pattern.compile("^(.+)\\.kt$"), null, true, "call-with-an-explicit-receiver"); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs"), Pattern.compile("^(.+)\\.kt$"), null, true, "call-with-an-explicit-receiver"); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call") @@ -3326,7 +3326,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInInfix_function_call() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/p-2") @@ -3338,7 +3338,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/p-2"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/p-2"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/p-2/pos") @@ -3355,7 +3355,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/infix-function-call/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -3370,7 +3370,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInOperator_call() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1") @@ -3382,7 +3382,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg") @@ -3424,7 +3424,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); } } @@ -3487,7 +3487,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -3501,7 +3501,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-2"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-2"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-2/pos") @@ -3563,7 +3563,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -3579,7 +3579,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInCallables_and_invoke_convention() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/callables-and-invoke-convention"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/callables-and-invoke-convention"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/callables-and-invoke-convention/p-5") @@ -3591,7 +3591,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_5() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/callables-and-invoke-convention/p-5"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/callables-and-invoke-convention/p-5"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/callables-and-invoke-convention/p-5/pos") @@ -3648,7 +3648,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/callables-and-invoke-convention/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/callables-and-invoke-convention/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -3663,7 +3663,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInChoosing_the_most_specific_candidate_from_the_overload_candidate_set() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection") @@ -3675,7 +3675,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInAlgorithm_of_msc_selection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-3") @@ -3687,7 +3687,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_3() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-3"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-3"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-3/pos") @@ -3709,7 +3709,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/choosing-the-most-specific-candidate-from-the-overload-candidate-set/algorithm-of-msc-selection/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -3725,7 +3725,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInReceivers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/receivers"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/receivers"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/receivers/p-6") @@ -3737,7 +3737,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_6() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/receivers/p-6"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/receivers/p-6"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/receivers/p-6/pos") @@ -3774,7 +3774,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/receivers/p-6/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/overload-resolution/receivers/p-6/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -3790,7 +3790,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInStatements() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/statements"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/statements"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/statements/assignments") @@ -3802,7 +3802,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInAssignments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/statements/assignments"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/statements/assignments"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/statements/assignments/operator-assignments") @@ -3814,7 +3814,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInOperator_assignments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/statements/assignments/operator-assignments"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/statements/assignments/operator-assignments"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/statements/assignments/operator-assignments/p-2") @@ -3826,7 +3826,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/statements/assignments/operator-assignments/p-2"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/statements/assignments/operator-assignments/p-2"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/statements/assignments/operator-assignments/p-2/neg") @@ -3888,7 +3888,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/statements/assignments/operator-assignments/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/statements/assignments/operator-assignments/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); } } @@ -3951,7 +3951,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/statements/assignments/operator-assignments/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/statements/assignments/operator-assignments/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -3966,7 +3966,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInSimple_assignments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/statements/assignments/simple-assignments"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/statements/assignments/simple-assignments"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/statements/assignments/simple-assignments/p-2") @@ -3978,7 +3978,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/statements/assignments/simple-assignments/p-2"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/statements/assignments/simple-assignments/p-2"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/statements/assignments/simple-assignments/p-2/pos") @@ -4045,7 +4045,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/statements/assignments/simple-assignments/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/statements/assignments/simple-assignments/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -4059,7 +4059,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_6() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/statements/assignments/simple-assignments/p-6"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/statements/assignments/simple-assignments/p-6"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/statements/assignments/simple-assignments/p-6/pos") @@ -4076,7 +4076,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/statements/assignments/simple-assignments/p-6/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/statements/assignments/simple-assignments/p-6/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -4092,7 +4092,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInLoop_statements() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/statements/loop-statements"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/statements/loop-statements"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/statements/loop-statements/do-while-loop-statement") @@ -4104,7 +4104,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInDo_while_loop_statement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/statements/loop-statements/do-while-loop-statement"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/statements/loop-statements/do-while-loop-statement"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/statements/loop-statements/do-while-loop-statement/p-1") @@ -4116,7 +4116,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/statements/loop-statements/do-while-loop-statement/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/statements/loop-statements/do-while-loop-statement/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/statements/loop-statements/do-while-loop-statement/p-1/pos") @@ -4138,7 +4138,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/statements/loop-statements/do-while-loop-statement/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/statements/loop-statements/do-while-loop-statement/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -4153,7 +4153,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInWhile_loop_statement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/statements/loop-statements/while-loop-statement"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/statements/loop-statements/while-loop-statement"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/statements/loop-statements/while-loop-statement/p-1") @@ -4165,7 +4165,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/statements/loop-statements/while-loop-statement/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/statements/loop-statements/while-loop-statement/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/statements/loop-statements/while-loop-statement/p-1/pos") @@ -4187,7 +4187,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/statements/loop-statements/while-loop-statement/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/statements/loop-statements/while-loop-statement/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -4204,7 +4204,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInType_system() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/type-system"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/type-system"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/type-system/introduction-1") @@ -4216,7 +4216,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInIntroduction_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/type-system/introduction-1"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/type-system/introduction-1"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/type-system/introduction-1/p-5") @@ -4228,7 +4228,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_5() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/type-system/introduction-1/p-5"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/type-system/introduction-1/p-5"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/type-system/introduction-1/p-5/pos") @@ -4245,7 +4245,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/type-system/introduction-1/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/type-system/introduction-1/p-5/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -4260,7 +4260,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInType_kinds() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/type-system/type-kinds"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/type-system/type-kinds"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/type-system/type-kinds/built-in-types") @@ -4272,7 +4272,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInBuilt_in_types() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/type-system/type-kinds/built-in-types"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/type-system/type-kinds/built-in-types"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/type-system/type-kinds/built-in-types/kotlin.nothing") @@ -4284,7 +4284,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInKotlin_nothing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/type-system/type-kinds/built-in-types/kotlin.nothing"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/type-system/type-kinds/built-in-types/kotlin.nothing"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/type-system/type-kinds/built-in-types/kotlin.nothing/p-1") @@ -4296,7 +4296,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/type-system/type-kinds/built-in-types/kotlin.nothing/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/type-system/type-kinds/built-in-types/kotlin.nothing/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/linked/type-system/type-kinds/built-in-types/kotlin.nothing/p-1/pos") @@ -4318,7 +4318,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/type-system/type-kinds/built-in-types/kotlin.nothing/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/linked/type-system/type-kinds/built-in-types/kotlin.nothing/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -4337,7 +4337,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInNotLinked() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/notLinked"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/notLinked"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/notLinked/annotations") @@ -4349,7 +4349,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/notLinked/annotations"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/notLinked/annotations"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/notLinked/annotations/type-annotations") @@ -4361,7 +4361,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInType_annotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/notLinked/annotations/type-annotations"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/notLinked/annotations/type-annotations"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/notLinked/annotations/type-annotations/neg") @@ -4428,7 +4428,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/notLinked/annotations/type-annotations/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/notLinked/annotations/type-annotations/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -4443,7 +4443,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInFlexibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/notLinked/flexibility"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/notLinked/flexibility"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/notLinked/flexibility/neg") @@ -4465,7 +4465,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/notLinked/flexibility/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/notLinked/flexibility/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -4479,7 +4479,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInObjects() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/notLinked/objects"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/notLinked/objects"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/notLinked/objects/inheritance") @@ -4491,7 +4491,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInInheritance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/notLinked/objects/inheritance"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/notLinked/objects/inheritance"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/codegen/box/notLinked/objects/inheritance/neg") @@ -4598,7 +4598,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/notLinked/objects/inheritance/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/notLinked/objects/inheritance/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); } } @@ -4621,7 +4621,7 @@ public class BlackBoxCodegenTestSpecGenerated extends AbstractBlackBoxCodegenTes } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/notLinked/objects/inheritance/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/codegen/box/notLinked/objects/inheritance/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } diff --git a/compiler/tests-spec/tests/org/jetbrains/kotlin/spec/parsing/ParsingTestSpecGenerated.java b/compiler/tests-spec/tests/org/jetbrains/kotlin/spec/parsing/ParsingTestSpecGenerated.java index cb634e57781..c318eeaa3ba 100644 --- a/compiler/tests-spec/tests/org/jetbrains/kotlin/spec/parsing/ParsingTestSpecGenerated.java +++ b/compiler/tests-spec/tests/org/jetbrains/kotlin/spec/parsing/ParsingTestSpecGenerated.java @@ -25,7 +25,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec { } public void testAllFilesPresentInPsi() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi"), Pattern.compile("^(.+)\\.kt$"), null, true, "helpers", "templates"); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi"), Pattern.compile("^(.+)\\.kt$"), null, true, "helpers", "templates"); } @TestMetadata("compiler/tests-spec/testData/psi/linked") @@ -37,7 +37,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec { } public void testAllFilesPresentInLinked() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/psi/linked/expressions") @@ -49,7 +49,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec { } public void testAllFilesPresentInExpressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/psi/linked/expressions/constant-literals") @@ -61,7 +61,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec { } public void testAllFilesPresentInConstant_literals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals") @@ -73,7 +73,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec { } public void testAllFilesPresentInInteger_literals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/binary-integer-literals") @@ -85,7 +85,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec { } public void testAllFilesPresentInBinary_integer_literals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/binary-integer-literals"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/binary-integer-literals"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/binary-integer-literals/p-1") @@ -97,7 +97,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec { } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/binary-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/binary-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/binary-integer-literals/p-1/neg") @@ -124,7 +124,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/binary-integer-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/binary-integer-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); } } @@ -172,7 +172,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/binary-integer-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/binary-integer-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -187,7 +187,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec { } public void testAllFilesPresentInDecimal_integer_literals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/decimal-integer-literals"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/decimal-integer-literals"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-1") @@ -199,7 +199,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec { } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-1/neg") @@ -216,7 +216,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); } } @@ -249,7 +249,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -263,7 +263,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec { } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-2"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-2"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-2/neg") @@ -275,7 +275,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/decimal-integer-literals/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -290,7 +290,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec { } public void testAllFilesPresentInHexadecimal_integer_literals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1") @@ -302,7 +302,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec { } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1/neg") @@ -329,7 +329,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); } } @@ -372,7 +372,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -388,7 +388,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec { } public void testAllFilesPresentInReal_literals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-1") @@ -400,7 +400,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec { } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-1/neg") @@ -457,7 +457,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); } } @@ -490,7 +490,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -504,7 +504,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec { } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-2"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-2"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-2/neg") @@ -536,7 +536,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); } } @@ -579,7 +579,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-2/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -593,7 +593,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec { } public void testAllFilesPresentInP_3() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-3"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-3"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-3/neg") @@ -640,7 +640,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-3/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-3/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); } } @@ -703,7 +703,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-3/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -717,7 +717,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec { } public void testAllFilesPresentInP_4() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-4"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-4"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-4/neg") @@ -749,7 +749,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-4/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-4/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); } } @@ -812,7 +812,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-4/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -826,7 +826,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec { } public void testAllFilesPresentInP_6() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-6"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-6"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-6/neg") @@ -843,7 +843,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-6/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/real-literals/p-6/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -858,7 +858,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec { } public void testAllFilesPresentInThe_types_for_integer_literals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/the-types-for-integer-literals"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/the-types-for-integer-literals"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/the-types-for-integer-literals/p-1") @@ -870,7 +870,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec { } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/the-types-for-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/the-types-for-integer-literals/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/neg") @@ -902,7 +902,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); } } @@ -965,7 +965,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -981,7 +981,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec { } public void testAllFilesPresentInWhen_expression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/when-expression"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/when-expression"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/psi/linked/expressions/when-expression/p-1") @@ -993,7 +993,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec { } public void testAllFilesPresentInP_1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/when-expression/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/when-expression/p-1"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/psi/linked/expressions/when-expression/p-1/neg") @@ -1015,7 +1015,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/when-expression/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/when-expression/p-1/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); } } @@ -1038,7 +1038,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec { } public void testAllFilesPresentInPos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/when-expression/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/when-expression/p-1/pos"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -1052,7 +1052,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec { } public void testAllFilesPresentInP_2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/when-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/when-expression/p-2"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/psi/linked/expressions/when-expression/p-2/neg") @@ -1084,7 +1084,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/when-expression/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/when-expression/p-2/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -1098,7 +1098,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec { } public void testAllFilesPresentInP_5() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/when-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/when-expression/p-5"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/psi/linked/expressions/when-expression/p-5/neg") @@ -1125,7 +1125,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/when-expression/p-5/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/when-expression/p-5/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } @@ -1139,7 +1139,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec { } public void testAllFilesPresentInP_6() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/when-expression/p-6"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/when-expression/p-6"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/tests-spec/testData/psi/linked/expressions/when-expression/p-6/neg") @@ -1176,7 +1176,7 @@ public class ParsingTestSpecGenerated extends AbstractParsingTestSpec { } public void testAllFilesPresentInNeg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/when-expression/p-6/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/tests-spec/testData/psi/linked/expressions/when-expression/p-6/neg"), Pattern.compile("^(.+)\\.kt$"), null, true); } } } diff --git a/compiler/visualizer/tests-gen/org/jetbrains/kotlin/visualizer/fir/FirVisualizerForRawFirDataGenerated.java b/compiler/visualizer/tests-gen/org/jetbrains/kotlin/visualizer/fir/FirVisualizerForRawFirDataGenerated.java index 27b54d72a6b..711b43b4625 100644 --- a/compiler/visualizer/tests-gen/org/jetbrains/kotlin/visualizer/fir/FirVisualizerForRawFirDataGenerated.java +++ b/compiler/visualizer/tests-gen/org/jetbrains/kotlin/visualizer/fir/FirVisualizerForRawFirDataGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.visualizer.fir; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class FirVisualizerForRawFirDataGenerated extends AbstractFirVisualizer { } public void testAllFilesPresentInRawBuilder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations") @@ -37,7 +38,7 @@ public class FirVisualizerForRawFirDataGenerated extends AbstractFirVisualizer { } public void testAllFilesPresentInDeclarations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("annotation.kt") @@ -174,7 +175,7 @@ public class FirVisualizerForRawFirDataGenerated extends AbstractFirVisualizer { } public void testAllFilesPresentInContracts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations/contracts"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations/contracts"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations/contracts/newSyntax") @@ -186,7 +187,7 @@ public class FirVisualizerForRawFirDataGenerated extends AbstractFirVisualizer { } public void testAllFilesPresentInNewSyntax() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations/contracts/newSyntax"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations/contracts/newSyntax"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("functionWithBothOldAndNewSyntaxContractDescription.kt") @@ -214,7 +215,7 @@ public class FirVisualizerForRawFirDataGenerated extends AbstractFirVisualizer { } public void testAllFilesPresentInOldSyntax() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations/contracts/oldSyntax"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations/contracts/oldSyntax"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("contractDescription.kt") @@ -234,7 +235,7 @@ public class FirVisualizerForRawFirDataGenerated extends AbstractFirVisualizer { } public void testAllFilesPresentInExpressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/expressions"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/expressions"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("annotated.kt") diff --git a/compiler/visualizer/tests-gen/org/jetbrains/kotlin/visualizer/fir/FirVisualizerForUncommonCasesGenerated.java b/compiler/visualizer/tests-gen/org/jetbrains/kotlin/visualizer/fir/FirVisualizerForUncommonCasesGenerated.java index 6ea2963ed28..f01efcd97a8 100644 --- a/compiler/visualizer/tests-gen/org/jetbrains/kotlin/visualizer/fir/FirVisualizerForUncommonCasesGenerated.java +++ b/compiler/visualizer/tests-gen/org/jetbrains/kotlin/visualizer/fir/FirVisualizerForUncommonCasesGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.visualizer.fir; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class FirVisualizerForUncommonCasesGenerated extends AbstractFirVisualize } public void testAllFilesPresentInTestFiles() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/visualizer/testData/uncommonCases/testFiles"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/visualizer/testData/uncommonCases/testFiles"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("dataClass.kt") diff --git a/compiler/visualizer/tests-gen/org/jetbrains/kotlin/visualizer/psi/PsiVisualizerForRawFirDataGenerated.java b/compiler/visualizer/tests-gen/org/jetbrains/kotlin/visualizer/psi/PsiVisualizerForRawFirDataGenerated.java index 9662afd3d49..2f0e0a83072 100644 --- a/compiler/visualizer/tests-gen/org/jetbrains/kotlin/visualizer/psi/PsiVisualizerForRawFirDataGenerated.java +++ b/compiler/visualizer/tests-gen/org/jetbrains/kotlin/visualizer/psi/PsiVisualizerForRawFirDataGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.visualizer.psi; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class PsiVisualizerForRawFirDataGenerated extends AbstractPsiVisualizer { } public void testAllFilesPresentInRawBuilder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations") @@ -37,7 +38,7 @@ public class PsiVisualizerForRawFirDataGenerated extends AbstractPsiVisualizer { } public void testAllFilesPresentInDeclarations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("annotation.kt") @@ -174,7 +175,7 @@ public class PsiVisualizerForRawFirDataGenerated extends AbstractPsiVisualizer { } public void testAllFilesPresentInContracts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations/contracts"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations/contracts"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations/contracts/newSyntax") @@ -186,7 +187,7 @@ public class PsiVisualizerForRawFirDataGenerated extends AbstractPsiVisualizer { } public void testAllFilesPresentInNewSyntax() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations/contracts/newSyntax"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations/contracts/newSyntax"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("functionWithBothOldAndNewSyntaxContractDescription.kt") @@ -214,7 +215,7 @@ public class PsiVisualizerForRawFirDataGenerated extends AbstractPsiVisualizer { } public void testAllFilesPresentInOldSyntax() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations/contracts/oldSyntax"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/declarations/contracts/oldSyntax"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("contractDescription.kt") @@ -234,7 +235,7 @@ public class PsiVisualizerForRawFirDataGenerated extends AbstractPsiVisualizer { } public void testAllFilesPresentInExpressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/expressions"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/raw-fir/psi2fir/testData/rawBuilder/expressions"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("annotated.kt") diff --git a/compiler/visualizer/tests-gen/org/jetbrains/kotlin/visualizer/psi/PsiVisualizerForUncommonCasesGenerated.java b/compiler/visualizer/tests-gen/org/jetbrains/kotlin/visualizer/psi/PsiVisualizerForUncommonCasesGenerated.java index 472c59599f6..155a131a4f7 100644 --- a/compiler/visualizer/tests-gen/org/jetbrains/kotlin/visualizer/psi/PsiVisualizerForUncommonCasesGenerated.java +++ b/compiler/visualizer/tests-gen/org/jetbrains/kotlin/visualizer/psi/PsiVisualizerForUncommonCasesGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.visualizer.psi; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class PsiVisualizerForUncommonCasesGenerated extends AbstractPsiVisualize } public void testAllFilesPresentInTestFiles() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/visualizer/testData/uncommonCases/testFiles"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/visualizer/testData/uncommonCases/testFiles"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("dataClass.kt") diff --git a/core/descriptors.runtime/tests/org/jetbrains/kotlin/jvm/runtime/Jvm8RuntimeDescriptorLoaderTestGenerated.java b/core/descriptors.runtime/tests/org/jetbrains/kotlin/jvm/runtime/Jvm8RuntimeDescriptorLoaderTestGenerated.java index 893482c74ef..f28d46f1df2 100644 --- a/core/descriptors.runtime/tests/org/jetbrains/kotlin/jvm/runtime/Jvm8RuntimeDescriptorLoaderTestGenerated.java +++ b/core/descriptors.runtime/tests/org/jetbrains/kotlin/jvm/runtime/Jvm8RuntimeDescriptorLoaderTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.jvm.runtime; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class Jvm8RuntimeDescriptorLoaderTestGenerated extends AbstractJvm8Runtim } public void testAllFilesPresentInCompiledJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/compiledJava"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/compiledJava"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("InnerClassTypeAnnotation.java") diff --git a/core/descriptors.runtime/tests/org/jetbrains/kotlin/jvm/runtime/JvmRuntimeDescriptorLoaderTestGenerated.java b/core/descriptors.runtime/tests/org/jetbrains/kotlin/jvm/runtime/JvmRuntimeDescriptorLoaderTestGenerated.java index a5b832699b4..eda776b13a8 100644 --- a/core/descriptors.runtime/tests/org/jetbrains/kotlin/jvm/runtime/JvmRuntimeDescriptorLoaderTestGenerated.java +++ b/core/descriptors.runtime/tests/org/jetbrains/kotlin/jvm/runtime/JvmRuntimeDescriptorLoaderTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.jvm.runtime; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -27,7 +28,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInCompiledKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/testData/loadJava/compiledKotlin/annotations") @@ -39,7 +40,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("AnnotatedAnnotation.kt") @@ -96,7 +97,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInClassMembers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/classMembers"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/classMembers"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassObjectPropertyField.kt") @@ -164,7 +165,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/classes"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/classes"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("AnnotationInClassObject.kt") @@ -252,7 +253,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInPackageMembers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/packageMembers"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/packageMembers"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("DelegatedProperty.kt") @@ -305,7 +306,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/parameters"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/parameters"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Constructor.kt") @@ -378,7 +379,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInPropertiesWithoutBackingFields() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Class.kt") @@ -431,7 +432,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/types"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/types"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassLiteralArgument.kt") @@ -489,7 +490,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInWithUseSiteTarget() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/withUseSiteTarget"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/withUseSiteTarget"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("DelegateTarget.kt") @@ -523,7 +524,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/class"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/class"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Class.kt") @@ -720,7 +721,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInJavaBean() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/class/javaBean"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/class/javaBean"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("DifferentGetterAndSetter.kt") @@ -764,7 +765,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInClassFun() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/classFun"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/classFun"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassInParamUsedInFun.kt") @@ -802,7 +803,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInClassObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/classObject"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/classObject"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassObjectDeclaresVal.kt") @@ -880,7 +881,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/constructor"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/constructor"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Constructor0.kt") @@ -972,7 +973,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInVararg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/constructor/vararg"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/constructor/vararg"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ConstructorNonLastVararg.kt") @@ -996,7 +997,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInCoroutines() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Basic.kt") @@ -1014,7 +1015,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInDataClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/dataClass"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/dataClass"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("MixedComponents.kt") @@ -1047,7 +1048,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/enum"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/enum"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("enumVisibility.kt") @@ -1090,7 +1091,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInFromLoadJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ArrayTypeVariance.kt") @@ -1277,7 +1278,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInKotlinSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ArrayType.kt") @@ -1369,7 +1370,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInError() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ConflictingProjectionKind.kt") @@ -1512,7 +1513,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInPropagation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("PropagateTypeArgumentNullable.kt") @@ -1529,7 +1530,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ChangeProjectionKind1.kt") @@ -1702,7 +1703,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInReturn() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("CantMakeImmutableInSubclass.kt") @@ -1855,7 +1856,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInTypeParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/typeParameter"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/typeParameter"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("InheritMutability.kt") @@ -1915,7 +1916,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInLibrary() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/library"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/library"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("LoadIterable.kt") @@ -1943,7 +1944,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInModality() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/modality"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/modality"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ModalityOfFakeOverrides.kt") @@ -1961,7 +1962,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInNotNull() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/notNull"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/notNull"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("NotNullField.kt") @@ -2000,7 +2001,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInFun() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Assert.kt") @@ -2067,7 +2068,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInGenericWithTypeVariables() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/genericWithTypeVariables"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/genericWithTypeVariables"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("FunGenericParam.kt") @@ -2130,7 +2131,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInGenericWithoutTypeVariables() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/genericWithoutTypeVariables"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/genericWithoutTypeVariables"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("FunClassParamNotNull.kt") @@ -2168,7 +2169,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInNonGeneric() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassFun.kt") @@ -2261,7 +2262,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInVararg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/vararg"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/vararg"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("nonLastVararg.kt") @@ -2290,7 +2291,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/inline"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/inline"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("inlineFunction.kt") @@ -2308,7 +2309,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInMemberOrder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/memberOrder"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/memberOrder"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("callablesNameClash.kt") @@ -2351,7 +2352,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInNested() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/nested"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/nested"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("deepInnerGeneric.kt") @@ -2379,7 +2380,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInPlatformTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/platformTypes"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/platformTypes"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("notnullTypeArgument.kt") @@ -2402,7 +2403,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInProp() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/prop"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/prop"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassVal.kt") @@ -2584,7 +2585,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInDefaultAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/prop/defaultAccessors"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/prop/defaultAccessors"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassVal.kt") @@ -2648,7 +2649,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/type"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/type"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Any.kt") @@ -2816,7 +2817,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInTypealias() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/typealias"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/typealias"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Annotations.kt") @@ -2849,7 +2850,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInVisibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/visibility"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/visibility"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("InternalClass.kt") @@ -2918,7 +2919,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInCompiledJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava"), Pattern.compile("^(.+)\\.java$"), null, true, "sam", "kotlinSignature/propagation"); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava"), Pattern.compile("^(.+)\\.java$"), null, true, "sam", "kotlinSignature/propagation"); } @TestMetadata("ArrayInGenericArguments.java") @@ -3160,7 +3161,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/annotations"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/annotations"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("AnnotatedAnnotation.java") @@ -3363,7 +3364,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/constructor"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/constructor"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("ConstructorGenericDeep.java") @@ -3391,7 +3392,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/enum"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/enum"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("EnumMembers.java") @@ -3419,7 +3420,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInJavaBean() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/javaBean"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/javaBean"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("DifferentGetterAndSetter.java") @@ -3467,7 +3468,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInKotlinSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature"), Pattern.compile("^(.+)\\.java$"), null, true, "propagation"); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature"), Pattern.compile("^(.+)\\.java$"), null, true, "propagation"); } @TestMetadata("ArrayType.java") @@ -3554,7 +3555,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInError() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/error"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/kotlinSignature/error"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("WrongProjectionKind.java") @@ -3588,7 +3589,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInLibrary() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/library"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/library"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("LoadIterable.java") @@ -3616,7 +3617,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInModality() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/modality"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/modality"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("ModalityOfFakeOverrides.java") @@ -3634,7 +3635,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInMutability() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/mutability"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/mutability"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("LoadIterable.java") @@ -3672,7 +3673,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInNotNull() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/notNull"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/notNull"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("NotNullField.java") @@ -3710,7 +3711,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInProtectedPackage() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/protectedPackage"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/protectedPackage"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("ProtectedPackageConstructor.java") @@ -3738,7 +3739,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInProtectedStatic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/protectedStatic"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/protectedStatic"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("ConstructorInProtectedStaticNestedClass.java") @@ -3756,7 +3757,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInRendering() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/rendering"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/rendering"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("Rendering.java") @@ -3774,7 +3775,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInSignatureAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/signatureAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/signatureAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("StableName.java") @@ -3792,7 +3793,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInSignaturePropagation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/signaturePropagation"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/signaturePropagation"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("ArraysInSubtypes.java") @@ -3850,7 +3851,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInStatic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/static"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/static"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("DeeplyInnerClass.java") @@ -3918,7 +3919,7 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD } public void testAllFilesPresentInVararg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/vararg"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledJava/vararg"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("VarargInt.java") diff --git a/idea/idea-android/tests/org/jetbrains/kotlin/android/annotator/AndroidGutterIconTestGenerated.java b/idea/idea-android/tests/org/jetbrains/kotlin/android/annotator/AndroidGutterIconTestGenerated.java index 07d284c98c1..579a2ab1ef5 100644 --- a/idea/idea-android/tests/org/jetbrains/kotlin/android/annotator/AndroidGutterIconTestGenerated.java +++ b/idea/idea-android/tests/org/jetbrains/kotlin/android/annotator/AndroidGutterIconTestGenerated.java @@ -26,7 +26,7 @@ public class AndroidGutterIconTestGenerated extends AbstractAndroidGutterIconTes } public void testAllFilesPresentInGutterIcon() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/gutterIcon"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/gutterIcon"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); } @TestMetadata("color.kt") @@ -68,7 +68,7 @@ public class AndroidGutterIconTestGenerated extends AbstractAndroidGutterIconTes } public void testAllFilesPresentInRes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/gutterIcon/res"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/gutterIcon/res"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); } @TestMetadata("idea/testData/android/gutterIcon/res/drawable") @@ -80,7 +80,7 @@ public class AndroidGutterIconTestGenerated extends AbstractAndroidGutterIconTes } public void testAllFilesPresentInDrawable() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/gutterIcon/res/drawable"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/gutterIcon/res/drawable"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); } } @@ -93,7 +93,7 @@ public class AndroidGutterIconTestGenerated extends AbstractAndroidGutterIconTes } public void testAllFilesPresentInLayout() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/gutterIcon/res/layout"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/gutterIcon/res/layout"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); } } @@ -106,7 +106,7 @@ public class AndroidGutterIconTestGenerated extends AbstractAndroidGutterIconTes } public void testAllFilesPresentInMipmap_mdpi() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/gutterIcon/res/mipmap-mdpi"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/gutterIcon/res/mipmap-mdpi"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); } } @@ -119,7 +119,7 @@ public class AndroidGutterIconTestGenerated extends AbstractAndroidGutterIconTes } public void testAllFilesPresentInValues() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/gutterIcon/res/values"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/gutterIcon/res/values"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); } } } diff --git a/idea/idea-android/tests/org/jetbrains/kotlin/android/configure/ConfigureProjectTestGenerated.java b/idea/idea-android/tests/org/jetbrains/kotlin/android/configure/ConfigureProjectTestGenerated.java index d07adb862a2..bd76b835f99 100644 --- a/idea/idea-android/tests/org/jetbrains/kotlin/android/configure/ConfigureProjectTestGenerated.java +++ b/idea/idea-android/tests/org/jetbrains/kotlin/android/configure/ConfigureProjectTestGenerated.java @@ -28,7 +28,7 @@ public class ConfigureProjectTestGenerated extends AbstractConfigureProjectTest } public void testAllFilesPresentInAndroid_gradle() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/configuration/android-gradle"), Pattern.compile("(\\w+)_before\\.gradle$"), TargetBackend.ANY, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/configuration/android-gradle"), Pattern.compile("(\\w+)_before\\.gradle$"), TargetBackend.ANY, true); } @TestMetadata("androidStudioDefault_before.gradle") @@ -95,7 +95,7 @@ public class ConfigureProjectTestGenerated extends AbstractConfigureProjectTest } public void testAllFilesPresentInGradleExamples() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/configuration/android-gradle/gradleExamples"), Pattern.compile("(\\w+)_before\\.gradle$"), TargetBackend.ANY, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/configuration/android-gradle/gradleExamples"), Pattern.compile("(\\w+)_before\\.gradle$"), TargetBackend.ANY, true); } @TestMetadata("gradleExample0_before.gradle") @@ -154,7 +154,7 @@ public class ConfigureProjectTestGenerated extends AbstractConfigureProjectTest } public void testAllFilesPresentInAndroid_gsk() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/configuration/android-gsk"), Pattern.compile("(\\w+)_before\\.gradle.kts$"), TargetBackend.ANY, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/configuration/android-gsk"), Pattern.compile("(\\w+)_before\\.gradle.kts$"), TargetBackend.ANY, true); } @TestMetadata("emptyFile_before.gradle.kts") diff --git a/idea/idea-android/tests/org/jetbrains/kotlin/android/folding/AndroidResourceFoldingTestGenerated.java b/idea/idea-android/tests/org/jetbrains/kotlin/android/folding/AndroidResourceFoldingTestGenerated.java index ed1e267dc85..55990d00f8e 100644 --- a/idea/idea-android/tests/org/jetbrains/kotlin/android/folding/AndroidResourceFoldingTestGenerated.java +++ b/idea/idea-android/tests/org/jetbrains/kotlin/android/folding/AndroidResourceFoldingTestGenerated.java @@ -26,7 +26,7 @@ public class AndroidResourceFoldingTestGenerated extends AbstractAndroidResource } public void testAllFilesPresentInFolding() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/folding"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/folding"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); } @TestMetadata("dimensions.kt") diff --git a/idea/idea-android/tests/org/jetbrains/kotlin/android/intention/AndroidIntentionTestGenerated.java b/idea/idea-android/tests/org/jetbrains/kotlin/android/intention/AndroidIntentionTestGenerated.java index 27d69b7c831..6f6f42fc53d 100644 --- a/idea/idea-android/tests/org/jetbrains/kotlin/android/intention/AndroidIntentionTestGenerated.java +++ b/idea/idea-android/tests/org/jetbrains/kotlin/android/intention/AndroidIntentionTestGenerated.java @@ -26,7 +26,7 @@ public class AndroidIntentionTestGenerated extends AbstractAndroidIntentionTest } public void testAllFilesPresentInIntention() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/intention"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), TargetBackend.ANY, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/intention"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), TargetBackend.ANY, true); } @TestMetadata("idea/testData/android/intention/addActivityToManifest") @@ -43,7 +43,7 @@ public class AndroidIntentionTestGenerated extends AbstractAndroidIntentionTest } public void testAllFilesPresentInAddActivityToManifest() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/intention/addActivityToManifest"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), TargetBackend.ANY, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/intention/addActivityToManifest"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), TargetBackend.ANY, true); } @TestMetadata("alreadyExists.kt") @@ -106,7 +106,7 @@ public class AndroidIntentionTestGenerated extends AbstractAndroidIntentionTest } public void testAllFilesPresentInAddBroadcastReceiverToManifest() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/intention/addBroadcastReceiverToManifest"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), TargetBackend.ANY, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/intention/addBroadcastReceiverToManifest"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), TargetBackend.ANY, true); } @TestMetadata("alreadyExists.kt") @@ -169,7 +169,7 @@ public class AndroidIntentionTestGenerated extends AbstractAndroidIntentionTest } public void testAllFilesPresentInAddServiceToManifest() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/intention/addServiceToManifest"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), TargetBackend.ANY, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/intention/addServiceToManifest"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), TargetBackend.ANY, true); } @TestMetadata("alreadyExists.kt") @@ -227,7 +227,7 @@ public class AndroidIntentionTestGenerated extends AbstractAndroidIntentionTest } public void testAllFilesPresentInImplementParcelable() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/intention/implementParcelable"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), TargetBackend.ANY, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/intention/implementParcelable"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), TargetBackend.ANY, true); } @TestMetadata("allNullableTypes.kt") @@ -290,7 +290,7 @@ public class AndroidIntentionTestGenerated extends AbstractAndroidIntentionTest } public void testAllFilesPresentInRedoParcelable() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/intention/redoParcelable"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), TargetBackend.ANY, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/intention/redoParcelable"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), TargetBackend.ANY, true); } @TestMetadata("indirectParcelable.kt") @@ -343,7 +343,7 @@ public class AndroidIntentionTestGenerated extends AbstractAndroidIntentionTest } public void testAllFilesPresentInRemoveParcelable() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/intention/removeParcelable"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), TargetBackend.ANY, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/intention/removeParcelable"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), TargetBackend.ANY, true); } @TestMetadata("inderectParcelable.kt") diff --git a/idea/idea-android/tests/org/jetbrains/kotlin/android/intention/AndroidResourceIntentionTestGenerated.java b/idea/idea-android/tests/org/jetbrains/kotlin/android/intention/AndroidResourceIntentionTestGenerated.java index 428164bb668..09d35368f80 100644 --- a/idea/idea-android/tests/org/jetbrains/kotlin/android/intention/AndroidResourceIntentionTestGenerated.java +++ b/idea/idea-android/tests/org/jetbrains/kotlin/android/intention/AndroidResourceIntentionTestGenerated.java @@ -26,7 +26,7 @@ public class AndroidResourceIntentionTestGenerated extends AbstractAndroidResour } public void testAllFilesPresentInResourceIntention() throws Exception { - KotlinTestUtils.assertAllTestsPresentInSingleGeneratedClass(this.getClass(), new File("idea/testData/android/resourceIntention"), Pattern.compile("^(.+)\\.test$"), TargetBackend.ANY); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentInSingleGeneratedClass(this.getClass(), new File("idea/testData/android/resourceIntention"), Pattern.compile("^(.+)\\.test$"), TargetBackend.ANY); } @TestMetadata("createColorValueResource/alreadyExists/alreadyExists.test") diff --git a/idea/idea-android/tests/org/jetbrains/kotlin/android/lint/KotlinLintTestGenerated.java b/idea/idea-android/tests/org/jetbrains/kotlin/android/lint/KotlinLintTestGenerated.java index ebf7a3698fa..58f0a1ec735 100644 --- a/idea/idea-android/tests/org/jetbrains/kotlin/android/lint/KotlinLintTestGenerated.java +++ b/idea/idea-android/tests/org/jetbrains/kotlin/android/lint/KotlinLintTestGenerated.java @@ -31,7 +31,7 @@ public class KotlinLintTestGenerated extends AbstractKotlinLintTest { } public void testAllFilesPresentInLint() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/lint"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/lint"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); } @TestMetadata("apiCheck.kt") diff --git a/idea/idea-android/tests/org/jetbrains/kotlin/android/quickfix/AndroidLintQuickfixTestGenerated.java b/idea/idea-android/tests/org/jetbrains/kotlin/android/quickfix/AndroidLintQuickfixTestGenerated.java index 4fa48d09f2f..ac4a3c18443 100644 --- a/idea/idea-android/tests/org/jetbrains/kotlin/android/quickfix/AndroidLintQuickfixTestGenerated.java +++ b/idea/idea-android/tests/org/jetbrains/kotlin/android/quickfix/AndroidLintQuickfixTestGenerated.java @@ -26,7 +26,7 @@ public class AndroidLintQuickfixTestGenerated extends AbstractAndroidLintQuickfi } public void testAllFilesPresentInLintQuickfix() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/lintQuickfix"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), TargetBackend.ANY, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/lintQuickfix"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), TargetBackend.ANY, true); } @TestMetadata("idea/testData/android/lintQuickfix/findViewById") @@ -38,7 +38,7 @@ public class AndroidLintQuickfixTestGenerated extends AbstractAndroidLintQuickfi } public void testAllFilesPresentInFindViewById() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/lintQuickfix/findViewById"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), TargetBackend.ANY, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/lintQuickfix/findViewById"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), TargetBackend.ANY, true); } @TestMetadata("nullableType.kt") @@ -61,7 +61,7 @@ public class AndroidLintQuickfixTestGenerated extends AbstractAndroidLintQuickfi } public void testAllFilesPresentInParcelable() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/lintQuickfix/parcelable"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), TargetBackend.ANY, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/lintQuickfix/parcelable"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), TargetBackend.ANY, true); } @TestMetadata("missingCreator.kt") @@ -84,7 +84,7 @@ public class AndroidLintQuickfixTestGenerated extends AbstractAndroidLintQuickfi } public void testAllFilesPresentInRequiresApi() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/lintQuickfix/requiresApi"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), TargetBackend.ANY, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/lintQuickfix/requiresApi"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), TargetBackend.ANY, true); } @TestMetadata("companion.kt") @@ -152,7 +152,7 @@ public class AndroidLintQuickfixTestGenerated extends AbstractAndroidLintQuickfi } public void testAllFilesPresentInSuppressLint() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/lintQuickfix/suppressLint"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), TargetBackend.ANY, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/lintQuickfix/suppressLint"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), TargetBackend.ANY, true); } @TestMetadata("constructorParameter.kt") @@ -200,7 +200,7 @@ public class AndroidLintQuickfixTestGenerated extends AbstractAndroidLintQuickfi } public void testAllFilesPresentInTargetApi() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/lintQuickfix/targetApi"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), TargetBackend.ANY, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/lintQuickfix/targetApi"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), TargetBackend.ANY, true); } @TestMetadata("companion.kt") @@ -258,7 +258,7 @@ public class AndroidLintQuickfixTestGenerated extends AbstractAndroidLintQuickfi } public void testAllFilesPresentInTargetVersionCheck() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/lintQuickfix/targetVersionCheck"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), TargetBackend.ANY, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/lintQuickfix/targetVersionCheck"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), TargetBackend.ANY, true); } @TestMetadata("annotation.kt") diff --git a/idea/idea-android/tests/org/jetbrains/kotlin/android/quickfix/AndroidQuickFixMultiFileTestGenerated.java b/idea/idea-android/tests/org/jetbrains/kotlin/android/quickfix/AndroidQuickFixMultiFileTestGenerated.java index 26b54edf8fc..b19ccc30be8 100644 --- a/idea/idea-android/tests/org/jetbrains/kotlin/android/quickfix/AndroidQuickFixMultiFileTestGenerated.java +++ b/idea/idea-android/tests/org/jetbrains/kotlin/android/quickfix/AndroidQuickFixMultiFileTestGenerated.java @@ -26,7 +26,7 @@ public class AndroidQuickFixMultiFileTestGenerated extends AbstractAndroidQuickF } public void testAllFilesPresentInQuickfix() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/quickfix"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), TargetBackend.ANY, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/quickfix"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), TargetBackend.ANY, true); } @TestMetadata("idea/testData/android/quickfix/autoImports") @@ -38,7 +38,7 @@ public class AndroidQuickFixMultiFileTestGenerated extends AbstractAndroidQuickF } public void testAllFilesPresentInAutoImports() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/quickfix/autoImports"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), TargetBackend.ANY, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/quickfix/autoImports"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), TargetBackend.ANY, true); } @TestMetadata("androidRImport.before.Main.kt") @@ -56,7 +56,7 @@ public class AndroidQuickFixMultiFileTestGenerated extends AbstractAndroidQuickF } public void testAllFilesPresentInViewConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/quickfix/viewConstructor"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), TargetBackend.ANY, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/android/quickfix/viewConstructor"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), TargetBackend.ANY, true); } @TestMetadata("indirect.before.Main.kt") diff --git a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/CompiledKotlinInJavaCompletionTestGenerated.java b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/CompiledKotlinInJavaCompletionTestGenerated.java index d26e57fb5e7..2d9a26f8d33 100644 --- a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/CompiledKotlinInJavaCompletionTestGenerated.java +++ b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/CompiledKotlinInJavaCompletionTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.completion.test; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class CompiledKotlinInJavaCompletionTestGenerated extends AbstractCompile } public void testAllFilesPresentInInjava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/injava"), Pattern.compile("^(.+)\\.java$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/injava"), Pattern.compile("^(.+)\\.java$"), null, false); } @TestMetadata("AnnotationParameter.java") diff --git a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/CompletionIncrementalResolveTestGenerated.java b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/CompletionIncrementalResolveTestGenerated.java index 6d897f7549d..59d492ef1b8 100644 --- a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/CompletionIncrementalResolveTestGenerated.java +++ b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/CompletionIncrementalResolveTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.completion.test; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class CompletionIncrementalResolveTestGenerated extends AbstractCompletio } public void testAllFilesPresentInIncrementalResolve() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/incrementalResolve"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/incrementalResolve"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("codeAboveChanged.kt") diff --git a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/JSBasicCompletionTestGenerated.java b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/JSBasicCompletionTestGenerated.java index 080c63b35b6..026f2f83378 100644 --- a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/JSBasicCompletionTestGenerated.java +++ b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/JSBasicCompletionTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.completion.test; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -37,7 +38,7 @@ public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTes } public void testAllFilesPresentInCommon() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("BasicAny.kt") @@ -774,7 +775,7 @@ public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTes } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/annotations"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/annotations"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Annotated.kt") @@ -932,7 +933,7 @@ public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTes } public void testAllFilesPresentInAutoPopup() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/autoPopup"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/autoPopup"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("AutopopupInFunExtensionReceiver.kt") @@ -1035,7 +1036,7 @@ public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTes } public void testAllFilesPresentInBoldOrGrayed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/boldOrGrayed"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/boldOrGrayed"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ImmediateExtensionMembers1.kt") @@ -1128,7 +1129,7 @@ public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTes } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("EmptyQualifier.kt") @@ -1191,7 +1192,7 @@ public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTes } public void testAllFilesPresentInDslMarker() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/dslMarker"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/dslMarker"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("child.kt") @@ -1229,7 +1230,7 @@ public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTes } public void testAllFilesPresentInExtensionFunctionTypeValues() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/extensionFunctionTypeValues"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/extensionFunctionTypeValues"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ImplicitReceiver.kt") @@ -1262,7 +1263,7 @@ public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTes } public void testAllFilesPresentInExtensionMethodInObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/extensionMethodInObject"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/extensionMethodInObject"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("CompanionObjectExplicitReceiver.kt") @@ -1330,7 +1331,7 @@ public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTes } public void testAllFilesPresentInExtensions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/extensions"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/extensions"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ComplexCapture.kt") @@ -1473,7 +1474,7 @@ public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTes } public void testAllFilesPresentInFromSmart() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/fromSmart"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/fromSmart"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ArrayLiteralAnnotationConstructorAsDefaultValueForArray.kt") @@ -1536,7 +1537,7 @@ public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTes } public void testAllFilesPresentInFromUnresolvedNames() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/fromUnresolvedNames"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/fromUnresolvedNames"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("FunctionInCompanionObject.kt") @@ -1599,7 +1600,7 @@ public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTes } public void testAllFilesPresentInGetOperator() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/getOperator"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/getOperator"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Extension.kt") @@ -1627,7 +1628,7 @@ public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTes } public void testAllFilesPresentInHighOrderFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/highOrderFunctions"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/highOrderFunctions"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ContextVariables1.kt") @@ -1690,7 +1691,7 @@ public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTes } public void testAllFilesPresentInInStringLiterals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/inStringLiterals"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/inStringLiterals"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("EA76497.kt") @@ -1733,7 +1734,7 @@ public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTes } public void testAllFilesPresentInLambdaSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/lambdaSignature"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/lambdaSignature"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ParameterName1.kt") @@ -1811,7 +1812,7 @@ public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTes } public void testAllFilesPresentInNamedArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/namedArguments"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/namedArguments"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("BooleanArgumentExpected.kt") @@ -1919,7 +1920,7 @@ public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTes } public void testAllFilesPresentInNoCompletion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/noCompletion"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/noCompletion"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("DoNotCompleteForErrorReceivers.kt") @@ -1967,7 +1968,7 @@ public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTes } public void testAllFilesPresentInObjects() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/objects"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/objects"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("PropertyFromCompanionObjectFromTypeAliasToNestedInObjectClass.kt") @@ -1995,7 +1996,7 @@ public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTes } public void testAllFilesPresentInOperatorNames() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/operatorNames"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/operatorNames"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("NoOperatorNameForTopLevel.kt") @@ -2043,7 +2044,7 @@ public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTes } public void testAllFilesPresentInOverride() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/override"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/override"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Generics.kt") @@ -2096,7 +2097,7 @@ public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTes } public void testAllFilesPresentInParameterNameAndType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/parameterNameAndType"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/parameterNameAndType"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ByAbbreviation.kt") @@ -2244,7 +2245,7 @@ public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTes } public void testAllFilesPresentInPrimitiveCompletion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/primitiveCompletion"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/primitiveCompletion"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("classExtensionFunctionExplicitReceiver.kt") @@ -2417,7 +2418,7 @@ public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTes } public void testAllFilesPresentInShadowing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/shadowing"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/shadowing"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ExtensionShadows.kt") @@ -2535,7 +2536,7 @@ public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTes } public void testAllFilesPresentInSmartCast() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/smartCast"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/smartCast"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("functionWithContract.kt") @@ -2588,7 +2589,7 @@ public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTes } public void testAllFilesPresentInStaticMembers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/staticMembers"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/staticMembers"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ImportsFromEnumEntry.kt") @@ -2646,7 +2647,7 @@ public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTes } public void testAllFilesPresentInSubstitutedSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/substitutedSignature"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/substitutedSignature"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("SubstitutedSignature1.kt") @@ -2694,7 +2695,7 @@ public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTes } public void testAllFilesPresentInSuper() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/super"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/super"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("QualifierType1.kt") @@ -2752,7 +2753,7 @@ public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTes } public void testAllFilesPresentInTypeArgsOrNot() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/typeArgsOrNot"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/typeArgsOrNot"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ConstructorTypeArg.kt") @@ -2810,7 +2811,7 @@ public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTes } public void testAllFilesPresentInVariableNameAndType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/variableNameAndType"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/variableNameAndType"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Lateinit.kt") @@ -2838,7 +2839,7 @@ public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTes } public void testAllFilesPresentInVisibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/visibility"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/visibility"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("KT9970.kt") @@ -2917,7 +2918,7 @@ public class JSBasicCompletionTestGenerated extends AbstractJSBasicCompletionTes } public void testAllFilesPresentInJs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/js"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/js"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("AutoForceCompletion.kt") diff --git a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/Java8BasicCompletionTestGenerated.java b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/Java8BasicCompletionTestGenerated.java index 8b0490f6fc9..abfcf15a0cf 100644 --- a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/Java8BasicCompletionTestGenerated.java +++ b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/Java8BasicCompletionTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.completion.test; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class Java8BasicCompletionTestGenerated extends AbstractJava8BasicComplet } public void testAllFilesPresentInJava8() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/java8"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/java8"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("CollectionMethods.kt") diff --git a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/JvmBasicCompletionTestGenerated.java b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/JvmBasicCompletionTestGenerated.java index 76be124f413..89335d96b83 100644 --- a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/JvmBasicCompletionTestGenerated.java +++ b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/JvmBasicCompletionTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.completion.test; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -37,7 +38,7 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT } public void testAllFilesPresentInCommon() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("BasicAny.kt") @@ -774,7 +775,7 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/annotations"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/annotations"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Annotated.kt") @@ -932,7 +933,7 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT } public void testAllFilesPresentInAutoPopup() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/autoPopup"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/autoPopup"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("AutopopupInFunExtensionReceiver.kt") @@ -1035,7 +1036,7 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT } public void testAllFilesPresentInBoldOrGrayed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/boldOrGrayed"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/boldOrGrayed"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ImmediateExtensionMembers1.kt") @@ -1128,7 +1129,7 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("EmptyQualifier.kt") @@ -1191,7 +1192,7 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT } public void testAllFilesPresentInDslMarker() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/dslMarker"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/dslMarker"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("child.kt") @@ -1229,7 +1230,7 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT } public void testAllFilesPresentInExtensionFunctionTypeValues() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/extensionFunctionTypeValues"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/extensionFunctionTypeValues"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ImplicitReceiver.kt") @@ -1262,7 +1263,7 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT } public void testAllFilesPresentInExtensionMethodInObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/extensionMethodInObject"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/extensionMethodInObject"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("CompanionObjectExplicitReceiver.kt") @@ -1330,7 +1331,7 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT } public void testAllFilesPresentInExtensions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/extensions"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/extensions"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ComplexCapture.kt") @@ -1473,7 +1474,7 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT } public void testAllFilesPresentInFromSmart() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/fromSmart"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/fromSmart"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ArrayLiteralAnnotationConstructorAsDefaultValueForArray.kt") @@ -1536,7 +1537,7 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT } public void testAllFilesPresentInFromUnresolvedNames() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/fromUnresolvedNames"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/fromUnresolvedNames"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("FunctionInCompanionObject.kt") @@ -1599,7 +1600,7 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT } public void testAllFilesPresentInGetOperator() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/getOperator"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/getOperator"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Extension.kt") @@ -1627,7 +1628,7 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT } public void testAllFilesPresentInHighOrderFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/highOrderFunctions"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/highOrderFunctions"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ContextVariables1.kt") @@ -1690,7 +1691,7 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT } public void testAllFilesPresentInInStringLiterals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/inStringLiterals"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/inStringLiterals"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("EA76497.kt") @@ -1733,7 +1734,7 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT } public void testAllFilesPresentInLambdaSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/lambdaSignature"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/lambdaSignature"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ParameterName1.kt") @@ -1811,7 +1812,7 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT } public void testAllFilesPresentInNamedArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/namedArguments"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/namedArguments"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("BooleanArgumentExpected.kt") @@ -1919,7 +1920,7 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT } public void testAllFilesPresentInNoCompletion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/noCompletion"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/noCompletion"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("DoNotCompleteForErrorReceivers.kt") @@ -1967,7 +1968,7 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT } public void testAllFilesPresentInObjects() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/objects"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/objects"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("PropertyFromCompanionObjectFromTypeAliasToNestedInObjectClass.kt") @@ -1995,7 +1996,7 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT } public void testAllFilesPresentInOperatorNames() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/operatorNames"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/operatorNames"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("NoOperatorNameForTopLevel.kt") @@ -2043,7 +2044,7 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT } public void testAllFilesPresentInOverride() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/override"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/override"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Generics.kt") @@ -2096,7 +2097,7 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT } public void testAllFilesPresentInParameterNameAndType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/parameterNameAndType"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/parameterNameAndType"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ByAbbreviation.kt") @@ -2244,7 +2245,7 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT } public void testAllFilesPresentInPrimitiveCompletion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/primitiveCompletion"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/primitiveCompletion"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("classExtensionFunctionExplicitReceiver.kt") @@ -2417,7 +2418,7 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT } public void testAllFilesPresentInShadowing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/shadowing"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/shadowing"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ExtensionShadows.kt") @@ -2535,7 +2536,7 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT } public void testAllFilesPresentInSmartCast() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/smartCast"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/smartCast"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("functionWithContract.kt") @@ -2588,7 +2589,7 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT } public void testAllFilesPresentInStaticMembers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/staticMembers"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/staticMembers"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ImportsFromEnumEntry.kt") @@ -2646,7 +2647,7 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT } public void testAllFilesPresentInSubstitutedSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/substitutedSignature"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/substitutedSignature"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("SubstitutedSignature1.kt") @@ -2694,7 +2695,7 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT } public void testAllFilesPresentInSuper() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/super"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/super"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("QualifierType1.kt") @@ -2752,7 +2753,7 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT } public void testAllFilesPresentInTypeArgsOrNot() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/typeArgsOrNot"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/typeArgsOrNot"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ConstructorTypeArg.kt") @@ -2810,7 +2811,7 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT } public void testAllFilesPresentInVariableNameAndType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/variableNameAndType"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/variableNameAndType"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Lateinit.kt") @@ -2838,7 +2839,7 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT } public void testAllFilesPresentInVisibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/visibility"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/visibility"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("KT9970.kt") @@ -2917,7 +2918,7 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT } public void testAllFilesPresentInJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/java"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/java"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("AutoForceCompletion.kt") @@ -3029,7 +3030,7 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT } public void testAllFilesPresentInBoldOrGrayed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/java/boldOrGrayed"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/java/boldOrGrayed"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ImmediateMembersForPlatformType.kt") @@ -3067,7 +3068,7 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT } public void testAllFilesPresentInImportAliases() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/java/importAliases"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/java/importAliases"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Class.kt") @@ -3125,7 +3126,7 @@ public class JvmBasicCompletionTestGenerated extends AbstractJvmBasicCompletionT } public void testAllFilesPresentInSyntheticExtensions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/java/syntheticExtensions"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/java/syntheticExtensions"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("DoNotHideGetterWhenExtensionCannotBeUsed.kt") diff --git a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/JvmSmartCompletionTestGenerated.java b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/JvmSmartCompletionTestGenerated.java index d9926713526..6be5ae13daa 100644 --- a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/JvmSmartCompletionTestGenerated.java +++ b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/JvmSmartCompletionTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.completion.test; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -45,7 +46,7 @@ public class JvmSmartCompletionTestGenerated extends AbstractJvmSmartCompletionT } public void testAllFilesPresentInSmart() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/smart"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/smart"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("AnyExpected.kt") @@ -542,7 +543,7 @@ public class JvmSmartCompletionTestGenerated extends AbstractJvmSmartCompletionT } public void testAllFilesPresentInAfterAs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/smart/afterAs"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/smart/afterAs"), Pattern.compile("^(.+)\\.kt$"), null, true); } } @@ -565,7 +566,7 @@ public class JvmSmartCompletionTestGenerated extends AbstractJvmSmartCompletionT } public void testAllFilesPresentInAnonymousObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/smart/anonymousObject"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/smart/anonymousObject"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ForJavaInterface.kt") @@ -598,7 +599,7 @@ public class JvmSmartCompletionTestGenerated extends AbstractJvmSmartCompletionT } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/smart/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/smart/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassLiteral.kt") @@ -721,7 +722,7 @@ public class JvmSmartCompletionTestGenerated extends AbstractJvmSmartCompletionT } public void testAllFilesPresentInConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/smart/constructor"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/smart/constructor"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ConstructorViaTypeAlias.kt") @@ -829,7 +830,7 @@ public class JvmSmartCompletionTestGenerated extends AbstractJvmSmartCompletionT } public void testAllFilesPresentInForLoopRange() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/smart/forLoopRange"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/smart/forLoopRange"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ExtensionIteratorMethod.kt") @@ -897,7 +898,7 @@ public class JvmSmartCompletionTestGenerated extends AbstractJvmSmartCompletionT } public void testAllFilesPresentInFunctionLiterals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/smart/functionLiterals"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/smart/functionLiterals"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ExplicitParameterTypesRequired.kt") @@ -975,7 +976,7 @@ public class JvmSmartCompletionTestGenerated extends AbstractJvmSmartCompletionT } public void testAllFilesPresentInGenerics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/smart/generics"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/smart/generics"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("GenericFunction1.kt") @@ -1018,7 +1019,7 @@ public class JvmSmartCompletionTestGenerated extends AbstractJvmSmartCompletionT } public void testAllFilesPresentInHeuristicSignatures() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/smart/heuristicSignatures"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/smart/heuristicSignatures"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Contains.kt") @@ -1116,7 +1117,7 @@ public class JvmSmartCompletionTestGenerated extends AbstractJvmSmartCompletionT } public void testAllFilesPresentInIfValue() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/smart/ifValue"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/smart/ifValue"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("InBlock1.kt") @@ -1169,7 +1170,7 @@ public class JvmSmartCompletionTestGenerated extends AbstractJvmSmartCompletionT } public void testAllFilesPresentInInElvisOperator() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/smart/inElvisOperator"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/smart/inElvisOperator"), Pattern.compile("^(.+)\\.kt$"), null, true); } } @@ -1182,7 +1183,7 @@ public class JvmSmartCompletionTestGenerated extends AbstractJvmSmartCompletionT } public void testAllFilesPresentInInOperator() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/smart/inOperator"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/smart/inOperator"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ExtensionContains.kt") @@ -1260,7 +1261,7 @@ public class JvmSmartCompletionTestGenerated extends AbstractJvmSmartCompletionT } public void testAllFilesPresentInInheritors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/smart/inheritors"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/smart/inheritors"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("GenericClass1.kt") @@ -1303,7 +1304,7 @@ public class JvmSmartCompletionTestGenerated extends AbstractJvmSmartCompletionT } public void testAllFilesPresentInLambdaSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/smart/lambdaSignature"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/smart/lambdaSignature"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ExplicitParameterTypesRequired.kt") @@ -1406,7 +1407,7 @@ public class JvmSmartCompletionTestGenerated extends AbstractJvmSmartCompletionT } public void testAllFilesPresentInMultipleArgsItem() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/smart/multipleArgsItem"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/smart/multipleArgsItem"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("CallWithBrackets.kt") @@ -1429,7 +1430,7 @@ public class JvmSmartCompletionTestGenerated extends AbstractJvmSmartCompletionT } public void testAllFilesPresentInPropertyDelegate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/smart/propertyDelegate"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/smart/propertyDelegate"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ConflictingSubstitutors.kt") @@ -1562,7 +1563,7 @@ public class JvmSmartCompletionTestGenerated extends AbstractJvmSmartCompletionT } public void testAllFilesPresentInSmartCasts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/smart/smartCasts"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/smart/smartCasts"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("AutoNotNullThisType.kt") @@ -1625,7 +1626,7 @@ public class JvmSmartCompletionTestGenerated extends AbstractJvmSmartCompletionT } public void testAllFilesPresentInThis() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/smart/this"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/smart/this"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("NoQualifiedThisOfAnonymousObject.kt") @@ -1703,7 +1704,7 @@ public class JvmSmartCompletionTestGenerated extends AbstractJvmSmartCompletionT } public void testAllFilesPresentInVararg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/smart/vararg"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/smart/vararg"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("NamedArgumentAfterStar.kt") @@ -1771,7 +1772,7 @@ public class JvmSmartCompletionTestGenerated extends AbstractJvmSmartCompletionT } public void testAllFilesPresentInWhenEntry() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/smart/whenEntry"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/smart/whenEntry"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("WhenWithNoSubject1.kt") diff --git a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/JvmWithLibBasicCompletionTestGenerated.java b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/JvmWithLibBasicCompletionTestGenerated.java index d768e121b3d..7ceb149854d 100644 --- a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/JvmWithLibBasicCompletionTestGenerated.java +++ b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/JvmWithLibBasicCompletionTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.completion.test; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class JvmWithLibBasicCompletionTestGenerated extends AbstractJvmWithLibBa } public void testAllFilesPresentInWithLib() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/withLib"), Pattern.compile("^(.+)\\.kt$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/withLib"), Pattern.compile("^(.+)\\.kt$"), null, false); } @TestMetadata("NamedArgumentsJava.kt") diff --git a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/KDocCompletionTestGenerated.java b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/KDocCompletionTestGenerated.java index 4de14b82d4e..adc2bba31f3 100644 --- a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/KDocCompletionTestGenerated.java +++ b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/KDocCompletionTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.completion.test; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -30,7 +31,7 @@ public class KDocCompletionTestGenerated extends AbstractJvmBasicCompletionTest } public void testAllFilesPresentInKdoc() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/kdoc"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/kdoc"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("AutoPopupAfterAtInKDoc.kt") diff --git a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/KeywordCompletionTestGenerated.java b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/KeywordCompletionTestGenerated.java index 98da39a1e69..d92b71fc0e6 100644 --- a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/KeywordCompletionTestGenerated.java +++ b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/KeywordCompletionTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.completion.test; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -95,7 +96,7 @@ public class KeywordCompletionTestGenerated extends AbstractKeywordCompletionTes } public void testAllFilesPresentInKeywords() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/keywords"), Pattern.compile("^(.+)\\.kt$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/keywords"), Pattern.compile("^(.+)\\.kt$"), null, false); } @TestMetadata("BeforeClass.kt") diff --git a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/KotlinSourceInJavaCompletionTestGenerated.java b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/KotlinSourceInJavaCompletionTestGenerated.java index 10a809211eb..2b0bbb8f7c3 100644 --- a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/KotlinSourceInJavaCompletionTestGenerated.java +++ b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/KotlinSourceInJavaCompletionTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.completion.test; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class KotlinSourceInJavaCompletionTestGenerated extends AbstractKotlinSou } public void testAllFilesPresentInInjava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/injava"), Pattern.compile("^(.+)\\.java$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/injava"), Pattern.compile("^(.+)\\.java$"), null, false); } @TestMetadata("AnnotationParameter.java") diff --git a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/KotlinStdLibInJavaCompletionTestGenerated.java b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/KotlinStdLibInJavaCompletionTestGenerated.java index 5e6338aa5b8..55e846764ba 100644 --- a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/KotlinStdLibInJavaCompletionTestGenerated.java +++ b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/KotlinStdLibInJavaCompletionTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.completion.test; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class KotlinStdLibInJavaCompletionTestGenerated extends AbstractKotlinStd } public void testAllFilesPresentInStdlib() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/injava/stdlib"), Pattern.compile("^(.+)\\.java$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/injava/stdlib"), Pattern.compile("^(.+)\\.java$"), null, false); } @TestMetadata("List.java") diff --git a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/MultiFileJvmBasicCompletionTestGenerated.java b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/MultiFileJvmBasicCompletionTestGenerated.java index 9f8db5121ab..f92d09065b4 100644 --- a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/MultiFileJvmBasicCompletionTestGenerated.java +++ b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/MultiFileJvmBasicCompletionTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.completion.test; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class MultiFileJvmBasicCompletionTestGenerated extends AbstractMultiFileJ } public void testAllFilesPresentInMultifile() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/multifile"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/multifile"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("CallableReferenceNotImported") diff --git a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/MultiFilePrimitiveJvmBasicCompletionTestGenerated.java b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/MultiFilePrimitiveJvmBasicCompletionTestGenerated.java index 88ce1a02220..1c870ab1716 100644 --- a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/MultiFilePrimitiveJvmBasicCompletionTestGenerated.java +++ b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/MultiFilePrimitiveJvmBasicCompletionTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.completion.test; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class MultiFilePrimitiveJvmBasicCompletionTestGenerated extends AbstractM } public void testAllFilesPresentInMultifilePrimitive() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/multifilePrimitive"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/multifilePrimitive"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("NestedClassImport") diff --git a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/MultiFileSmartCompletionTestGenerated.java b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/MultiFileSmartCompletionTestGenerated.java index d3b9f7490ee..4417853db96 100644 --- a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/MultiFileSmartCompletionTestGenerated.java +++ b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/MultiFileSmartCompletionTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.completion.test; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class MultiFileSmartCompletionTestGenerated extends AbstractMultiFileSmar } public void testAllFilesPresentInSmartMultiFile() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/smartMultiFile"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/smartMultiFile"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("AnonymousObjectGenericJava") diff --git a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/MultiPlatformCompletionTestGenerated.java b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/MultiPlatformCompletionTestGenerated.java index 9c7818b340e..4131cfec017 100644 --- a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/MultiPlatformCompletionTestGenerated.java +++ b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/MultiPlatformCompletionTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.completion.test; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class MultiPlatformCompletionTestGenerated extends AbstractMultiPlatformC } public void testAllFilesPresentInMultiPlatform() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/multiPlatform"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/multiPlatform"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("classInCommon") diff --git a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/handlers/BasicCompletionHandlerTestGenerated.java b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/handlers/BasicCompletionHandlerTestGenerated.java index f9f3359c784..76f71afcaa2 100644 --- a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/handlers/BasicCompletionHandlerTestGenerated.java +++ b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/handlers/BasicCompletionHandlerTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.completion.test.handlers; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -30,7 +31,7 @@ public class BasicCompletionHandlerTestGenerated extends AbstractBasicCompletion } public void testAllFilesPresentInBasic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("ClassKeywordBeforeName.kt") @@ -247,7 +248,7 @@ public class BasicCompletionHandlerTestGenerated extends AbstractBasicCompletion } public void testAllFilesPresentInAnnotation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/annotation"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/annotation"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("AnnotationInBrackets.kt") @@ -280,7 +281,7 @@ public class BasicCompletionHandlerTestGenerated extends AbstractBasicCompletion } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/callableReference"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/callableReference"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("ClassConstructor.kt") @@ -343,7 +344,7 @@ public class BasicCompletionHandlerTestGenerated extends AbstractBasicCompletion } public void testAllFilesPresentInExclChar() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/exclChar"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/exclChar"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } } @@ -356,7 +357,7 @@ public class BasicCompletionHandlerTestGenerated extends AbstractBasicCompletion } public void testAllFilesPresentInExtensionMethodInObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/extensionMethodInObject"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/extensionMethodInObject"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("CompanionObjectInSameFileExplicitReceiver.kt") @@ -409,7 +410,7 @@ public class BasicCompletionHandlerTestGenerated extends AbstractBasicCompletion } public void testAllFilesPresentInHighOrderFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/highOrderFunctions"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/highOrderFunctions"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("ContextVariable.kt") @@ -537,7 +538,7 @@ public class BasicCompletionHandlerTestGenerated extends AbstractBasicCompletion } public void testAllFilesPresentInImportAliases() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/importAliases"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/importAliases"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("CompanionObject.kt") @@ -605,7 +606,7 @@ public class BasicCompletionHandlerTestGenerated extends AbstractBasicCompletion } public void testAllFilesPresentInOverride() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/override"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/override"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("ExpectClassValOverride.kt") @@ -703,7 +704,7 @@ public class BasicCompletionHandlerTestGenerated extends AbstractBasicCompletion } public void testAllFilesPresentInParameterNameAndType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/parameterNameAndType"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/parameterNameAndType"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("CodeStyleSettings.kt") @@ -781,7 +782,7 @@ public class BasicCompletionHandlerTestGenerated extends AbstractBasicCompletion } public void testAllFilesPresentInStaticMemberOfNotImported() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/staticMemberOfNotImported"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/staticMemberOfNotImported"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("AmbigiousExtension.kt") @@ -819,7 +820,7 @@ public class BasicCompletionHandlerTestGenerated extends AbstractBasicCompletion } public void testAllFilesPresentInStaticMembers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/staticMembers"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/staticMembers"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("classObjectMethod.kt") @@ -897,7 +898,7 @@ public class BasicCompletionHandlerTestGenerated extends AbstractBasicCompletion } public void testAllFilesPresentInStringTemplate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/stringTemplate"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/stringTemplate"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("GlobalVal.kt") @@ -950,7 +951,7 @@ public class BasicCompletionHandlerTestGenerated extends AbstractBasicCompletion } public void testAllFilesPresentInTypeArgsForCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/typeArgsForCall"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/typeArgsForCall"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("ExpectedTypeDoesNotHelp.kt") diff --git a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/handlers/CompletionCharFilterTestGenerated.java b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/handlers/CompletionCharFilterTestGenerated.java index 37c3202ba00..f08998b2bc1 100644 --- a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/handlers/CompletionCharFilterTestGenerated.java +++ b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/handlers/CompletionCharFilterTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.completion.test.handlers; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class CompletionCharFilterTestGenerated extends AbstractCompletionCharFil } public void testAllFilesPresentInCharFilter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/charFilter"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/charFilter"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("Colon.kt") diff --git a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/handlers/KeywordCompletionHandlerTestGenerated.java b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/handlers/KeywordCompletionHandlerTestGenerated.java index 8d9343ba18a..8baf22d54b2 100644 --- a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/handlers/KeywordCompletionHandlerTestGenerated.java +++ b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/handlers/KeywordCompletionHandlerTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.completion.test.handlers; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -30,7 +31,7 @@ public class KeywordCompletionHandlerTestGenerated extends AbstractKeywordComple } public void testAllFilesPresentInKeywords() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/keywords"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/keywords"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Break.kt") diff --git a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/handlers/SmartCompletionHandlerTestGenerated.java b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/handlers/SmartCompletionHandlerTestGenerated.java index fe60a2879cf..d94477f0b1c 100644 --- a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/handlers/SmartCompletionHandlerTestGenerated.java +++ b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/handlers/SmartCompletionHandlerTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.completion.test.handlers; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -50,7 +51,7 @@ public class SmartCompletionHandlerTestGenerated extends AbstractSmartCompletion } public void testAllFilesPresentInSmart() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/smart"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/smart"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("AnonymousObject1.kt") @@ -762,7 +763,7 @@ public class SmartCompletionHandlerTestGenerated extends AbstractSmartCompletion } public void testAllFilesPresentInLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/smart/lambda"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/smart/lambda"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("InsertImport.kt") @@ -790,7 +791,7 @@ public class SmartCompletionHandlerTestGenerated extends AbstractSmartCompletion } public void testAllFilesPresentInLambdaSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/smart/lambdaSignature"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/smart/lambdaSignature"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("NoAdditionalSpace.kt") @@ -813,7 +814,7 @@ public class SmartCompletionHandlerTestGenerated extends AbstractSmartCompletion } public void testAllFilesPresentInSuspendLambdaSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/smart/suspendLambdaSignature"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/smart/suspendLambdaSignature"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("NoAdditionalSpace.kt") diff --git a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/weighers/BasicCompletionWeigherTestGenerated.java b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/weighers/BasicCompletionWeigherTestGenerated.java index 161db59f2cb..68ae502e45f 100644 --- a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/weighers/BasicCompletionWeigherTestGenerated.java +++ b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/weighers/BasicCompletionWeigherTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.completion.test.weighers; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -30,7 +31,7 @@ public class BasicCompletionWeigherTestGenerated extends AbstractBasicCompletion } public void testAllFilesPresentInBasic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/weighers/basic"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/weighers/basic"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); } @TestMetadata("CallableReference_NothingLast.kt") @@ -227,7 +228,7 @@ public class BasicCompletionWeigherTestGenerated extends AbstractBasicCompletion } public void testAllFilesPresentInContextualReturn() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/weighers/basic/contextualReturn"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/weighers/basic/contextualReturn"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); } @TestMetadata("idea/idea-completion/testData/weighers/basic/contextualReturn/noReturnType") @@ -239,7 +240,7 @@ public class BasicCompletionWeigherTestGenerated extends AbstractBasicCompletion } public void testAllFilesPresentInNoReturnType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/weighers/basic/contextualReturn/noReturnType"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/weighers/basic/contextualReturn/noReturnType"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); } @TestMetadata("BeginOfNestedBlock.kt") @@ -307,7 +308,7 @@ public class BasicCompletionWeigherTestGenerated extends AbstractBasicCompletion } public void testAllFilesPresentInWithReturnType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/weighers/basic/contextualReturn/withReturnType"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/weighers/basic/contextualReturn/withReturnType"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); } @TestMetadata("BeginOfNestedBlock.kt") @@ -411,7 +412,7 @@ public class BasicCompletionWeigherTestGenerated extends AbstractBasicCompletion } public void testAllFilesPresentInExpectedInfo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/weighers/basic/expectedInfo"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/weighers/basic/expectedInfo"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); } @TestMetadata("CompanionObjectMethod.kt") @@ -494,7 +495,7 @@ public class BasicCompletionWeigherTestGenerated extends AbstractBasicCompletion } public void testAllFilesPresentInExpectedType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/weighers/basic/expectedType"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/weighers/basic/expectedType"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); } @TestMetadata("ifConditionQualified.kt") @@ -532,7 +533,7 @@ public class BasicCompletionWeigherTestGenerated extends AbstractBasicCompletion } public void testAllFilesPresentInParameterNameAndType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/weighers/basic/parameterNameAndType"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/weighers/basic/parameterNameAndType"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); } @TestMetadata("Deprecated.kt") diff --git a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/weighers/SmartCompletionWeigherTestGenerated.java b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/weighers/SmartCompletionWeigherTestGenerated.java index f7a420c2044..4da4dfd02c5 100644 --- a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/weighers/SmartCompletionWeigherTestGenerated.java +++ b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/weighers/SmartCompletionWeigherTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.completion.test.weighers; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class SmartCompletionWeigherTestGenerated extends AbstractSmartCompletion } public void testAllFilesPresentInSmart() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/weighers/smart"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/weighers/smart"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("BooleanExpected.kt") diff --git a/idea/idea-fir-performance-tests/tests/org/jetbrains/kotlin/idea/highlighter/FirHighlightingPerformanceTestGenerated.java b/idea/idea-fir-performance-tests/tests/org/jetbrains/kotlin/idea/highlighter/FirHighlightingPerformanceTestGenerated.java index a70aa64fa57..8efc8e6bca5 100644 --- a/idea/idea-fir-performance-tests/tests/org/jetbrains/kotlin/idea/highlighter/FirHighlightingPerformanceTestGenerated.java +++ b/idea/idea-fir-performance-tests/tests/org/jetbrains/kotlin/idea/highlighter/FirHighlightingPerformanceTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.highlighter; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class FirHighlightingPerformanceTestGenerated extends AbstractFirHighligh } public void testAllFilesPresentInHighlighter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/highlighter"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/highlighter"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Annotations.kt") @@ -177,7 +178,7 @@ public class FirHighlightingPerformanceTestGenerated extends AbstractFirHighligh } public void testAllFilesPresentInDeprecated() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/highlighter/deprecated"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/highlighter/deprecated"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Class.kt") diff --git a/idea/idea-fir-performance-tests/tests/org/jetbrains/kotlin/idea/perf/HighLevelPerformanceBasicCompletionHandlerTestGenerated.java b/idea/idea-fir-performance-tests/tests/org/jetbrains/kotlin/idea/perf/HighLevelPerformanceBasicCompletionHandlerTestGenerated.java index 5fc49b522b6..f5b4cbd53e4 100644 --- a/idea/idea-fir-performance-tests/tests/org/jetbrains/kotlin/idea/perf/HighLevelPerformanceBasicCompletionHandlerTestGenerated.java +++ b/idea/idea-fir-performance-tests/tests/org/jetbrains/kotlin/idea/perf/HighLevelPerformanceBasicCompletionHandlerTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.perf; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -30,7 +31,7 @@ public class HighLevelPerformanceBasicCompletionHandlerTestGenerated extends Abs } public void testAllFilesPresentInBasic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("ClassKeywordBeforeName.kt") @@ -247,7 +248,7 @@ public class HighLevelPerformanceBasicCompletionHandlerTestGenerated extends Abs } public void testAllFilesPresentInAnnotation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/annotation"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/annotation"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("AnnotationInBrackets.kt") @@ -280,7 +281,7 @@ public class HighLevelPerformanceBasicCompletionHandlerTestGenerated extends Abs } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/callableReference"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/callableReference"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("ClassConstructor.kt") @@ -343,7 +344,7 @@ public class HighLevelPerformanceBasicCompletionHandlerTestGenerated extends Abs } public void testAllFilesPresentInExclChar() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/exclChar"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/exclChar"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } } @@ -356,7 +357,7 @@ public class HighLevelPerformanceBasicCompletionHandlerTestGenerated extends Abs } public void testAllFilesPresentInExtensionMethodInObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/extensionMethodInObject"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/extensionMethodInObject"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("CompanionObjectInSameFileExplicitReceiver.kt") @@ -409,7 +410,7 @@ public class HighLevelPerformanceBasicCompletionHandlerTestGenerated extends Abs } public void testAllFilesPresentInHighOrderFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/highOrderFunctions"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/highOrderFunctions"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("ContextVariable.kt") @@ -537,7 +538,7 @@ public class HighLevelPerformanceBasicCompletionHandlerTestGenerated extends Abs } public void testAllFilesPresentInImportAliases() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/importAliases"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/importAliases"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("CompanionObject.kt") @@ -605,7 +606,7 @@ public class HighLevelPerformanceBasicCompletionHandlerTestGenerated extends Abs } public void testAllFilesPresentInOverride() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/override"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/override"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("ExpectClassValOverride.kt") @@ -703,7 +704,7 @@ public class HighLevelPerformanceBasicCompletionHandlerTestGenerated extends Abs } public void testAllFilesPresentInParameterNameAndType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/parameterNameAndType"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/parameterNameAndType"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("CodeStyleSettings.kt") @@ -781,7 +782,7 @@ public class HighLevelPerformanceBasicCompletionHandlerTestGenerated extends Abs } public void testAllFilesPresentInStaticMemberOfNotImported() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/staticMemberOfNotImported"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/staticMemberOfNotImported"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("AmbigiousExtension.kt") @@ -819,7 +820,7 @@ public class HighLevelPerformanceBasicCompletionHandlerTestGenerated extends Abs } public void testAllFilesPresentInStaticMembers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/staticMembers"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/staticMembers"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("classObjectMethod.kt") @@ -897,7 +898,7 @@ public class HighLevelPerformanceBasicCompletionHandlerTestGenerated extends Abs } public void testAllFilesPresentInStringTemplate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/stringTemplate"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/stringTemplate"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("GlobalVal.kt") @@ -950,7 +951,7 @@ public class HighLevelPerformanceBasicCompletionHandlerTestGenerated extends Abs } public void testAllFilesPresentInTypeArgsForCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/typeArgsForCall"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/typeArgsForCall"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("ExpectedTypeDoesNotHelp.kt") diff --git a/idea/idea-fir/tests/org/jetbrains/kotlin/asJava/classes/FirClassLoadingTestGenerated.java b/idea/idea-fir/tests/org/jetbrains/kotlin/asJava/classes/FirClassLoadingTestGenerated.java index e3396f98fbb..c727513bbe8 100644 --- a/idea/idea-fir/tests/org/jetbrains/kotlin/asJava/classes/FirClassLoadingTestGenerated.java +++ b/idea/idea-fir/tests/org/jetbrains/kotlin/asJava/classes/FirClassLoadingTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.asJava.classes; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class FirClassLoadingTestGenerated extends AbstractFirClassLoadingTest { } public void testAllFilesPresentInUltraLightClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/ultraLightClasses"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/ultraLightClasses"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("annotationWithSetParamPropertyModifier.kt") diff --git a/idea/idea-fir/tests/org/jetbrains/kotlin/asJava/classes/FirLightClassTestGenerated.java b/idea/idea-fir/tests/org/jetbrains/kotlin/asJava/classes/FirLightClassTestGenerated.java index 9281c68683a..a063a2f4df6 100644 --- a/idea/idea-fir/tests/org/jetbrains/kotlin/asJava/classes/FirLightClassTestGenerated.java +++ b/idea/idea-fir/tests/org/jetbrains/kotlin/asJava/classes/FirLightClassTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.asJava.classes; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class FirLightClassTestGenerated extends AbstractFirLightClassTest { } public void testAllFilesPresentInLightClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses"), Pattern.compile("^([^.]+)\\.kt$"), null, true, "delegation", "script"); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses"), Pattern.compile("^([^.]+)\\.kt$"), null, true, "delegation", "script"); } @TestMetadata("AnnotatedParameterInEnumConstructor.kt") @@ -177,7 +178,7 @@ public class FirLightClassTestGenerated extends AbstractFirLightClassTest { } public void testAllFilesPresentInCompilationErrors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/compilationErrors"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/compilationErrors"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("AllInlineOnly.kt") @@ -270,7 +271,7 @@ public class FirLightClassTestGenerated extends AbstractFirLightClassTest { } public void testAllFilesPresentInFacades() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/facades"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/facades"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("AllPrivate.kt") @@ -303,7 +304,7 @@ public class FirLightClassTestGenerated extends AbstractFirLightClassTest { } public void testAllFilesPresentInIdeRegression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/ideRegression"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/ideRegression"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("AllOpenAnnotatedClasses.kt") @@ -356,7 +357,7 @@ public class FirLightClassTestGenerated extends AbstractFirLightClassTest { } public void testAllFilesPresentInNullabilityAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/nullabilityAnnotations"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/nullabilityAnnotations"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("Class.kt") @@ -459,7 +460,7 @@ public class FirLightClassTestGenerated extends AbstractFirLightClassTest { } public void testAllFilesPresentInObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/object"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/object"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("SimpleObject.kt") @@ -477,7 +478,7 @@ public class FirLightClassTestGenerated extends AbstractFirLightClassTest { } public void testAllFilesPresentInPublicField() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/publicField"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/publicField"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("CompanionObject.kt") diff --git a/idea/idea-fir/tests/org/jetbrains/kotlin/asJava/classes/FirLightFacadeClassTestGenerated.java b/idea/idea-fir/tests/org/jetbrains/kotlin/asJava/classes/FirLightFacadeClassTestGenerated.java index c35f7fcfdae..e5e70fc3d2e 100644 --- a/idea/idea-fir/tests/org/jetbrains/kotlin/asJava/classes/FirLightFacadeClassTestGenerated.java +++ b/idea/idea-fir/tests/org/jetbrains/kotlin/asJava/classes/FirLightFacadeClassTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.asJava.classes; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class FirLightFacadeClassTestGenerated extends AbstractFirLightFacadeClas } public void testAllFilesPresentInUltraLightFacades() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/ultraLightFacades"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/ultraLightFacades"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("coroutines.kt") diff --git a/idea/idea-fir/tests/org/jetbrains/kotlin/checkers/FirPsiCheckerTestGenerated.java b/idea/idea-fir/tests/org/jetbrains/kotlin/checkers/FirPsiCheckerTestGenerated.java index 92071ef3f9f..18ee0339b63 100644 --- a/idea/idea-fir/tests/org/jetbrains/kotlin/checkers/FirPsiCheckerTestGenerated.java +++ b/idea/idea-fir/tests/org/jetbrains/kotlin/checkers/FirPsiCheckerTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.checkers; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -32,7 +33,7 @@ public class FirPsiCheckerTestGenerated extends AbstractFirPsiCheckerTest { } public void testAllFilesPresentInChecker() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/checker"), Pattern.compile("^(.+)\\.kt$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/checker"), Pattern.compile("^(.+)\\.kt$"), null, false); } @TestMetadata("AnnotationOnFile.kt") @@ -370,7 +371,7 @@ public class FirPsiCheckerTestGenerated extends AbstractFirPsiCheckerTest { } public void testAllFilesPresentInRegression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/checker/regression"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/checker/regression"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("AmbiguityOnLazyTypeComputation.kt") @@ -613,7 +614,7 @@ public class FirPsiCheckerTestGenerated extends AbstractFirPsiCheckerTest { } public void testAllFilesPresentInRecovery() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/checker/recovery"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/checker/recovery"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("namelessMembers.kt") @@ -641,7 +642,7 @@ public class FirPsiCheckerTestGenerated extends AbstractFirPsiCheckerTest { } public void testAllFilesPresentInRendering() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/checker/rendering"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/checker/rendering"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("TypeInferenceError.kt") @@ -659,7 +660,7 @@ public class FirPsiCheckerTestGenerated extends AbstractFirPsiCheckerTest { } public void testAllFilesPresentInInfos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/checker/infos"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/checker/infos"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("CapturedConstructorParameter.kt") @@ -752,7 +753,7 @@ public class FirPsiCheckerTestGenerated extends AbstractFirPsiCheckerTest { } public void testAllFilesPresentInDiagnosticsMessage() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/checker/diagnosticsMessage"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/checker/diagnosticsMessage"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("fullPackageFQNameOnVisiblityError.kt") diff --git a/idea/idea-fir/tests/org/jetbrains/kotlin/findUsages/FindUsagesFirTestGenerated.java b/idea/idea-fir/tests/org/jetbrains/kotlin/findUsages/FindUsagesFirTestGenerated.java index 5c3bd70c6d9..f2a07fabddf 100644 --- a/idea/idea-fir/tests/org/jetbrains/kotlin/findUsages/FindUsagesFirTestGenerated.java +++ b/idea/idea-fir/tests/org/jetbrains/kotlin/findUsages/FindUsagesFirTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.findUsages; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -27,7 +28,7 @@ public class FindUsagesFirTestGenerated extends AbstractFindUsagesFirTest { } public void testAllFilesPresentInKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("idea/testData/findUsages/kotlin/companionObject") @@ -39,7 +40,7 @@ public class FindUsagesFirTestGenerated extends AbstractFindUsagesFirTest { } public void testAllFilesPresentInCompanionObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/companionObject"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/companionObject"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("inContainingClass.0.kt") @@ -72,7 +73,7 @@ public class FindUsagesFirTestGenerated extends AbstractFindUsagesFirTest { } public void testAllFilesPresentInConventions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/conventions"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/conventions"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("compareTo.0.kt") @@ -169,7 +170,7 @@ public class FindUsagesFirTestGenerated extends AbstractFindUsagesFirTest { } public void testAllFilesPresentInComponents() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/conventions/components"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/conventions/components"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("callableReferences.0.kt") @@ -278,7 +279,7 @@ public class FindUsagesFirTestGenerated extends AbstractFindUsagesFirTest { } public void testAllFilesPresentInFindClassUsages() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findClassUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findClassUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("classUsedInPlainText.0.kt") @@ -581,7 +582,7 @@ public class FindUsagesFirTestGenerated extends AbstractFindUsagesFirTest { } public void testAllFilesPresentInFindFunctionUsages() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findFunctionUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findFunctionUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("enumFunctionUsages.0.kt") @@ -779,7 +780,7 @@ public class FindUsagesFirTestGenerated extends AbstractFindUsagesFirTest { } public void testAllFilesPresentInFindJavaPropertyUsages() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findJavaPropertyUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findJavaPropertyUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("javaPropertyUsagesK.0.kt") @@ -807,7 +808,7 @@ public class FindUsagesFirTestGenerated extends AbstractFindUsagesFirTest { } public void testAllFilesPresentInFindObjectUsages() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findObjectUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findObjectUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("javaObjectUsages.0.kt") @@ -855,7 +856,7 @@ public class FindUsagesFirTestGenerated extends AbstractFindUsagesFirTest { } public void testAllFilesPresentInFindPackageUsages() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findPackageUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findPackageUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("kotlinPackageUsages.0.kt") @@ -873,7 +874,7 @@ public class FindUsagesFirTestGenerated extends AbstractFindUsagesFirTest { } public void testAllFilesPresentInFindParameterUsages() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findParameterUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findParameterUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("kotlinAnnotationConstructorParameterUsages.0.kt") @@ -921,7 +922,7 @@ public class FindUsagesFirTestGenerated extends AbstractFindUsagesFirTest { } public void testAllFilesPresentInFindPrimaryConstructorUsages() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findPrimaryConstructorUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findPrimaryConstructorUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("annotationEntry.0.kt") @@ -969,7 +970,7 @@ public class FindUsagesFirTestGenerated extends AbstractFindUsagesFirTest { } public void testAllFilesPresentInFindPropertyUsages() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findPropertyUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findPropertyUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("extensionPropertyUsages.0.kt") @@ -1127,7 +1128,7 @@ public class FindUsagesFirTestGenerated extends AbstractFindUsagesFirTest { } public void testAllFilesPresentInFindSecondaryConstructorUsages() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findSecondaryConstructorUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findSecondaryConstructorUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("constructorCall.0.kt") @@ -1160,7 +1161,7 @@ public class FindUsagesFirTestGenerated extends AbstractFindUsagesFirTest { } public void testAllFilesPresentInFindTypeAliasUsages() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findTypeAliasUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findTypeAliasUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("objectAlias.0.kt") @@ -1178,7 +1179,7 @@ public class FindUsagesFirTestGenerated extends AbstractFindUsagesFirTest { } public void testAllFilesPresentInFindTypeParameterUsages() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findTypeParameterUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findTypeParameterUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("kotlinClassTypeParameterUsages.0.kt") @@ -1206,7 +1207,7 @@ public class FindUsagesFirTestGenerated extends AbstractFindUsagesFirTest { } public void testAllFilesPresentInFindWithFilteringImports() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findWithFilteringImports"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findWithFilteringImports"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("findWithFilteringImports.0.kt") @@ -1224,7 +1225,7 @@ public class FindUsagesFirTestGenerated extends AbstractFindUsagesFirTest { } public void testAllFilesPresentInFindWithStructuralGrouping() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findWithStructuralGrouping"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findWithStructuralGrouping"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("kotlinClassAllUsages.0.kt") @@ -1252,7 +1253,7 @@ public class FindUsagesFirTestGenerated extends AbstractFindUsagesFirTest { } public void testAllFilesPresentInInternal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/internal"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/internal"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("idea/testData/findUsages/kotlin/internal/findFunctionUsages") @@ -1264,7 +1265,7 @@ public class FindUsagesFirTestGenerated extends AbstractFindUsagesFirTest { } public void testAllFilesPresentInFindFunctionUsages() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/internal/findFunctionUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/internal/findFunctionUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("enumFunctionUsages.0.kt") @@ -1312,7 +1313,7 @@ public class FindUsagesFirTestGenerated extends AbstractFindUsagesFirTest { } public void testAllFilesPresentInFindPrimaryConstructorUsages() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/internal/findPrimaryConstructorUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/internal/findPrimaryConstructorUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("constructorCall.0.kt") @@ -1335,7 +1336,7 @@ public class FindUsagesFirTestGenerated extends AbstractFindUsagesFirTest { } public void testAllFilesPresentInFindPropertyUsages() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/internal/findPropertyUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/internal/findPropertyUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("kotlinClassObjectPropertyUsage.0.kt") @@ -1368,7 +1369,7 @@ public class FindUsagesFirTestGenerated extends AbstractFindUsagesFirTest { } public void testAllFilesPresentInFindSecondaryConstructorUsages() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/internal/findSecondaryConstructorUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/internal/findSecondaryConstructorUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("constructorCall.0.kt") @@ -1397,7 +1398,7 @@ public class FindUsagesFirTestGenerated extends AbstractFindUsagesFirTest { } public void testAllFilesPresentInPropertyFiles() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/propertyFiles"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/propertyFiles"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("propertyFileUsagesByRef.0.kt") @@ -1420,7 +1421,7 @@ public class FindUsagesFirTestGenerated extends AbstractFindUsagesFirTest { } public void testAllFilesPresentInScript() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/script"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/script"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("anonymousObject.0.kts") @@ -1458,7 +1459,7 @@ public class FindUsagesFirTestGenerated extends AbstractFindUsagesFirTest { } public void testAllFilesPresentInUnresolvedAnnotation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/unresolvedAnnotation"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/unresolvedAnnotation"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("unresolvedAnnotation.0.kt") @@ -1476,7 +1477,7 @@ public class FindUsagesFirTestGenerated extends AbstractFindUsagesFirTest { } public void testAllFilesPresentInVariable() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/variable"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/variable"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("plusAssignFun.0.kt") @@ -1510,7 +1511,7 @@ public class FindUsagesFirTestGenerated extends AbstractFindUsagesFirTest { } public void testAllFilesPresentInJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/java"), Pattern.compile("^(.+)\\.0\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/java"), Pattern.compile("^(.+)\\.0\\.java$"), null, true); } @TestMetadata("idea/testData/findUsages/java/findConstructorUsages") @@ -1522,7 +1523,7 @@ public class FindUsagesFirTestGenerated extends AbstractFindUsagesFirTest { } public void testAllFilesPresentInFindConstructorUsages() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/java/findConstructorUsages"), Pattern.compile("^(.+)\\.0\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/java/findConstructorUsages"), Pattern.compile("^(.+)\\.0\\.java$"), null, true); } @TestMetadata("javaConstructorInDelegationCall.0.java") @@ -1565,7 +1566,7 @@ public class FindUsagesFirTestGenerated extends AbstractFindUsagesFirTest { } public void testAllFilesPresentInFindJavaClassUsages() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/java/findJavaClassUsages"), Pattern.compile("^(.+)\\.0\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/java/findJavaClassUsages"), Pattern.compile("^(.+)\\.0\\.java$"), null, true); } @TestMetadata("JKAliasedClassAllUsages.0.java") @@ -1693,7 +1694,7 @@ public class FindUsagesFirTestGenerated extends AbstractFindUsagesFirTest { } public void testAllFilesPresentInFindJavaFieldUsages() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/java/findJavaFieldUsages"), Pattern.compile("^(.+)\\.0\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/java/findJavaFieldUsages"), Pattern.compile("^(.+)\\.0\\.java$"), null, true); } @TestMetadata("JKFieldUsages.0.java") @@ -1711,7 +1712,7 @@ public class FindUsagesFirTestGenerated extends AbstractFindUsagesFirTest { } public void testAllFilesPresentInFindJavaMethodUsages() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/java/findJavaMethodUsages"), Pattern.compile("^(.+)\\.0\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/java/findJavaMethodUsages"), Pattern.compile("^(.+)\\.0\\.java$"), null, true); } @TestMetadata("ConventionUsages.0.java") @@ -1794,7 +1795,7 @@ public class FindUsagesFirTestGenerated extends AbstractFindUsagesFirTest { } public void testAllFilesPresentInFindJavaPropertyUsages() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/java/findJavaPropertyUsages"), Pattern.compile("^(.+)\\.0\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/java/findJavaPropertyUsages"), Pattern.compile("^(.+)\\.0\\.java$"), null, true); } @TestMetadata("javaPropertyGetterUsagesKJ.0.java") @@ -1818,7 +1819,7 @@ public class FindUsagesFirTestGenerated extends AbstractFindUsagesFirTest { } public void testAllFilesPresentInPropertyFiles() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/propertyFiles"), Pattern.compile("^(.+)\\.0\\.properties$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/propertyFiles"), Pattern.compile("^(.+)\\.0\\.properties$"), null, true); } @TestMetadata("propertyFileUsages.0.properties") diff --git a/idea/idea-fir/tests/org/jetbrains/kotlin/findUsages/FindUsagesWithDisableComponentSearchFirTestGenerated.java b/idea/idea-fir/tests/org/jetbrains/kotlin/findUsages/FindUsagesWithDisableComponentSearchFirTestGenerated.java index 9e4d9eeea3f..3d3911e983e 100644 --- a/idea/idea-fir/tests/org/jetbrains/kotlin/findUsages/FindUsagesWithDisableComponentSearchFirTestGenerated.java +++ b/idea/idea-fir/tests/org/jetbrains/kotlin/findUsages/FindUsagesWithDisableComponentSearchFirTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.findUsages; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class FindUsagesWithDisableComponentSearchFirTestGenerated extends Abstra } public void testAllFilesPresentInComponents() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/conventions/components"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/conventions/components"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("callableReferences.0.kt") diff --git a/idea/idea-fir/tests/org/jetbrains/kotlin/findUsages/KotlinFindUsagesWithLibraryFirTestGenerated.java b/idea/idea-fir/tests/org/jetbrains/kotlin/findUsages/KotlinFindUsagesWithLibraryFirTestGenerated.java index 7e2057a2d60..e870fa38516 100644 --- a/idea/idea-fir/tests/org/jetbrains/kotlin/findUsages/KotlinFindUsagesWithLibraryFirTestGenerated.java +++ b/idea/idea-fir/tests/org/jetbrains/kotlin/findUsages/KotlinFindUsagesWithLibraryFirTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.findUsages; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class KotlinFindUsagesWithLibraryFirTestGenerated extends AbstractKotlinF } public void testAllFilesPresentInLibraryUsages() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/libraryUsages"), Pattern.compile("^(.+)\\.0\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/libraryUsages"), Pattern.compile("^(.+)\\.0\\.kt$"), null, true); } @TestMetadata("idea/testData/findUsages/libraryUsages/javaLibrary") @@ -37,7 +38,7 @@ public class KotlinFindUsagesWithLibraryFirTestGenerated extends AbstractKotlinF } public void testAllFilesPresentInJavaLibrary() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/libraryUsages/javaLibrary"), Pattern.compile("^(.+)\\.0\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/libraryUsages/javaLibrary"), Pattern.compile("^(.+)\\.0\\.kt$"), null, true); } @TestMetadata("LibraryClassUsages.0.kt") @@ -80,7 +81,7 @@ public class KotlinFindUsagesWithLibraryFirTestGenerated extends AbstractKotlinF } public void testAllFilesPresentInKotlinLibrary() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/libraryUsages/kotlinLibrary"), Pattern.compile("^(.+)\\.0\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/libraryUsages/kotlinLibrary"), Pattern.compile("^(.+)\\.0\\.kt$"), null, true); } @TestMetadata("LibraryClassUsages.0.kt") @@ -153,7 +154,7 @@ public class KotlinFindUsagesWithLibraryFirTestGenerated extends AbstractKotlinF } public void testAllFilesPresentIn_library() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/libraryUsages/_library"), Pattern.compile("^(.+)\\.0\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/libraryUsages/_library"), Pattern.compile("^(.+)\\.0\\.kt$"), null, true); } @TestMetadata("idea/testData/findUsages/libraryUsages/_library/library") @@ -165,7 +166,7 @@ public class KotlinFindUsagesWithLibraryFirTestGenerated extends AbstractKotlinF } public void testAllFilesPresentInLibrary() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/libraryUsages/_library/library"), Pattern.compile("^(.+)\\.0\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/libraryUsages/_library/library"), Pattern.compile("^(.+)\\.0\\.kt$"), null, true); } } } diff --git a/idea/idea-fir/tests/org/jetbrains/kotlin/findUsages/KotlinFindUsagesWithStdlibFirTestGenerated.java b/idea/idea-fir/tests/org/jetbrains/kotlin/findUsages/KotlinFindUsagesWithStdlibFirTestGenerated.java index 1d81e8806a4..6c8379e6eef 100644 --- a/idea/idea-fir/tests/org/jetbrains/kotlin/findUsages/KotlinFindUsagesWithStdlibFirTestGenerated.java +++ b/idea/idea-fir/tests/org/jetbrains/kotlin/findUsages/KotlinFindUsagesWithStdlibFirTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.findUsages; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class KotlinFindUsagesWithStdlibFirTestGenerated extends AbstractKotlinFi } public void testAllFilesPresentInStdlibUsages() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/stdlibUsages"), Pattern.compile("^(.+)\\.0\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/stdlibUsages"), Pattern.compile("^(.+)\\.0\\.kt$"), null, true); } @TestMetadata("LibraryMemberFunctionUsagesInStdlib.0.kt") diff --git a/idea/idea-fir/tests/org/jetbrains/kotlin/idea/completion/HighLevelJvmBasicCompletionTestGenerated.java b/idea/idea-fir/tests/org/jetbrains/kotlin/idea/completion/HighLevelJvmBasicCompletionTestGenerated.java index 9e2cc499aff..96d547e3c10 100644 --- a/idea/idea-fir/tests/org/jetbrains/kotlin/idea/completion/HighLevelJvmBasicCompletionTestGenerated.java +++ b/idea/idea-fir/tests/org/jetbrains/kotlin/idea/completion/HighLevelJvmBasicCompletionTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.completion; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -37,7 +38,7 @@ public class HighLevelJvmBasicCompletionTestGenerated extends AbstractHighLevelJ } public void testAllFilesPresentInCommon() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("BasicAny.kt") @@ -774,7 +775,7 @@ public class HighLevelJvmBasicCompletionTestGenerated extends AbstractHighLevelJ } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/annotations"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/annotations"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Annotated.kt") @@ -932,7 +933,7 @@ public class HighLevelJvmBasicCompletionTestGenerated extends AbstractHighLevelJ } public void testAllFilesPresentInAutoPopup() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/autoPopup"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/autoPopup"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("AutopopupInFunExtensionReceiver.kt") @@ -1035,7 +1036,7 @@ public class HighLevelJvmBasicCompletionTestGenerated extends AbstractHighLevelJ } public void testAllFilesPresentInBoldOrGrayed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/boldOrGrayed"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/boldOrGrayed"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ImmediateExtensionMembers1.kt") @@ -1128,7 +1129,7 @@ public class HighLevelJvmBasicCompletionTestGenerated extends AbstractHighLevelJ } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("EmptyQualifier.kt") @@ -1191,7 +1192,7 @@ public class HighLevelJvmBasicCompletionTestGenerated extends AbstractHighLevelJ } public void testAllFilesPresentInDslMarker() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/dslMarker"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/dslMarker"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("child.kt") @@ -1229,7 +1230,7 @@ public class HighLevelJvmBasicCompletionTestGenerated extends AbstractHighLevelJ } public void testAllFilesPresentInExtensionFunctionTypeValues() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/extensionFunctionTypeValues"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/extensionFunctionTypeValues"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ImplicitReceiver.kt") @@ -1262,7 +1263,7 @@ public class HighLevelJvmBasicCompletionTestGenerated extends AbstractHighLevelJ } public void testAllFilesPresentInExtensionMethodInObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/extensionMethodInObject"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/extensionMethodInObject"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("CompanionObjectExplicitReceiver.kt") @@ -1330,7 +1331,7 @@ public class HighLevelJvmBasicCompletionTestGenerated extends AbstractHighLevelJ } public void testAllFilesPresentInExtensions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/extensions"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/extensions"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ComplexCapture.kt") @@ -1473,7 +1474,7 @@ public class HighLevelJvmBasicCompletionTestGenerated extends AbstractHighLevelJ } public void testAllFilesPresentInFromSmart() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/fromSmart"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/fromSmart"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ArrayLiteralAnnotationConstructorAsDefaultValueForArray.kt") @@ -1536,7 +1537,7 @@ public class HighLevelJvmBasicCompletionTestGenerated extends AbstractHighLevelJ } public void testAllFilesPresentInFromUnresolvedNames() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/fromUnresolvedNames"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/fromUnresolvedNames"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("FunctionInCompanionObject.kt") @@ -1599,7 +1600,7 @@ public class HighLevelJvmBasicCompletionTestGenerated extends AbstractHighLevelJ } public void testAllFilesPresentInGetOperator() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/getOperator"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/getOperator"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Extension.kt") @@ -1627,7 +1628,7 @@ public class HighLevelJvmBasicCompletionTestGenerated extends AbstractHighLevelJ } public void testAllFilesPresentInHighOrderFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/highOrderFunctions"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/highOrderFunctions"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ContextVariables1.kt") @@ -1690,7 +1691,7 @@ public class HighLevelJvmBasicCompletionTestGenerated extends AbstractHighLevelJ } public void testAllFilesPresentInInStringLiterals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/inStringLiterals"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/inStringLiterals"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("EA76497.kt") @@ -1733,7 +1734,7 @@ public class HighLevelJvmBasicCompletionTestGenerated extends AbstractHighLevelJ } public void testAllFilesPresentInLambdaSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/lambdaSignature"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/lambdaSignature"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ParameterName1.kt") @@ -1811,7 +1812,7 @@ public class HighLevelJvmBasicCompletionTestGenerated extends AbstractHighLevelJ } public void testAllFilesPresentInNamedArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/namedArguments"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/namedArguments"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("BooleanArgumentExpected.kt") @@ -1919,7 +1920,7 @@ public class HighLevelJvmBasicCompletionTestGenerated extends AbstractHighLevelJ } public void testAllFilesPresentInNoCompletion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/noCompletion"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/noCompletion"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("DoNotCompleteForErrorReceivers.kt") @@ -1967,7 +1968,7 @@ public class HighLevelJvmBasicCompletionTestGenerated extends AbstractHighLevelJ } public void testAllFilesPresentInObjects() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/objects"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/objects"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("PropertyFromCompanionObjectFromTypeAliasToNestedInObjectClass.kt") @@ -1995,7 +1996,7 @@ public class HighLevelJvmBasicCompletionTestGenerated extends AbstractHighLevelJ } public void testAllFilesPresentInOperatorNames() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/operatorNames"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/operatorNames"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("NoOperatorNameForTopLevel.kt") @@ -2043,7 +2044,7 @@ public class HighLevelJvmBasicCompletionTestGenerated extends AbstractHighLevelJ } public void testAllFilesPresentInOverride() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/override"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/override"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Generics.kt") @@ -2096,7 +2097,7 @@ public class HighLevelJvmBasicCompletionTestGenerated extends AbstractHighLevelJ } public void testAllFilesPresentInParameterNameAndType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/parameterNameAndType"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/parameterNameAndType"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ByAbbreviation.kt") @@ -2244,7 +2245,7 @@ public class HighLevelJvmBasicCompletionTestGenerated extends AbstractHighLevelJ } public void testAllFilesPresentInPrimitiveCompletion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/primitiveCompletion"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/primitiveCompletion"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("classExtensionFunctionExplicitReceiver.kt") @@ -2417,7 +2418,7 @@ public class HighLevelJvmBasicCompletionTestGenerated extends AbstractHighLevelJ } public void testAllFilesPresentInShadowing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/shadowing"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/shadowing"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ExtensionShadows.kt") @@ -2535,7 +2536,7 @@ public class HighLevelJvmBasicCompletionTestGenerated extends AbstractHighLevelJ } public void testAllFilesPresentInSmartCast() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/smartCast"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/smartCast"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("functionWithContract.kt") @@ -2588,7 +2589,7 @@ public class HighLevelJvmBasicCompletionTestGenerated extends AbstractHighLevelJ } public void testAllFilesPresentInStaticMembers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/staticMembers"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/staticMembers"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ImportsFromEnumEntry.kt") @@ -2646,7 +2647,7 @@ public class HighLevelJvmBasicCompletionTestGenerated extends AbstractHighLevelJ } public void testAllFilesPresentInSubstitutedSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/substitutedSignature"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/substitutedSignature"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("SubstitutedSignature1.kt") @@ -2694,7 +2695,7 @@ public class HighLevelJvmBasicCompletionTestGenerated extends AbstractHighLevelJ } public void testAllFilesPresentInSuper() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/super"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/super"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("QualifierType1.kt") @@ -2752,7 +2753,7 @@ public class HighLevelJvmBasicCompletionTestGenerated extends AbstractHighLevelJ } public void testAllFilesPresentInTypeArgsOrNot() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/typeArgsOrNot"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/typeArgsOrNot"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ConstructorTypeArg.kt") @@ -2810,7 +2811,7 @@ public class HighLevelJvmBasicCompletionTestGenerated extends AbstractHighLevelJ } public void testAllFilesPresentInVariableNameAndType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/variableNameAndType"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/variableNameAndType"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Lateinit.kt") @@ -2838,7 +2839,7 @@ public class HighLevelJvmBasicCompletionTestGenerated extends AbstractHighLevelJ } public void testAllFilesPresentInVisibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/visibility"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/common/visibility"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("KT9970.kt") @@ -2917,7 +2918,7 @@ public class HighLevelJvmBasicCompletionTestGenerated extends AbstractHighLevelJ } public void testAllFilesPresentInJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/java"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/java"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("AutoForceCompletion.kt") @@ -3029,7 +3030,7 @@ public class HighLevelJvmBasicCompletionTestGenerated extends AbstractHighLevelJ } public void testAllFilesPresentInBoldOrGrayed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/java/boldOrGrayed"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/java/boldOrGrayed"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ImmediateMembersForPlatformType.kt") @@ -3067,7 +3068,7 @@ public class HighLevelJvmBasicCompletionTestGenerated extends AbstractHighLevelJ } public void testAllFilesPresentInImportAliases() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/java/importAliases"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/java/importAliases"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Class.kt") @@ -3125,7 +3126,7 @@ public class HighLevelJvmBasicCompletionTestGenerated extends AbstractHighLevelJ } public void testAllFilesPresentInSyntheticExtensions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/java/syntheticExtensions"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/java/syntheticExtensions"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("DoNotHideGetterWhenExtensionCannotBeUsed.kt") diff --git a/idea/idea-fir/tests/org/jetbrains/kotlin/idea/completion/test/handlers/HighLevelBasicCompletionHandlerTestGenerated.java b/idea/idea-fir/tests/org/jetbrains/kotlin/idea/completion/test/handlers/HighLevelBasicCompletionHandlerTestGenerated.java index a50fba9ea1d..71d7824c096 100644 --- a/idea/idea-fir/tests/org/jetbrains/kotlin/idea/completion/test/handlers/HighLevelBasicCompletionHandlerTestGenerated.java +++ b/idea/idea-fir/tests/org/jetbrains/kotlin/idea/completion/test/handlers/HighLevelBasicCompletionHandlerTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.completion.test.handlers; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -30,7 +31,7 @@ public class HighLevelBasicCompletionHandlerTestGenerated extends AbstractHighLe } public void testAllFilesPresentInBasic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("ClassKeywordBeforeName.kt") @@ -247,7 +248,7 @@ public class HighLevelBasicCompletionHandlerTestGenerated extends AbstractHighLe } public void testAllFilesPresentInAnnotation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/annotation"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/annotation"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("AnnotationInBrackets.kt") @@ -280,7 +281,7 @@ public class HighLevelBasicCompletionHandlerTestGenerated extends AbstractHighLe } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/callableReference"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/callableReference"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("ClassConstructor.kt") @@ -343,7 +344,7 @@ public class HighLevelBasicCompletionHandlerTestGenerated extends AbstractHighLe } public void testAllFilesPresentInExclChar() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/exclChar"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/exclChar"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } } @@ -356,7 +357,7 @@ public class HighLevelBasicCompletionHandlerTestGenerated extends AbstractHighLe } public void testAllFilesPresentInExtensionMethodInObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/extensionMethodInObject"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/extensionMethodInObject"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("CompanionObjectInSameFileExplicitReceiver.kt") @@ -409,7 +410,7 @@ public class HighLevelBasicCompletionHandlerTestGenerated extends AbstractHighLe } public void testAllFilesPresentInHighOrderFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/highOrderFunctions"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/highOrderFunctions"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("ContextVariable.kt") @@ -537,7 +538,7 @@ public class HighLevelBasicCompletionHandlerTestGenerated extends AbstractHighLe } public void testAllFilesPresentInImportAliases() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/importAliases"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/importAliases"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("CompanionObject.kt") @@ -605,7 +606,7 @@ public class HighLevelBasicCompletionHandlerTestGenerated extends AbstractHighLe } public void testAllFilesPresentInOverride() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/override"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/override"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("ExpectClassValOverride.kt") @@ -703,7 +704,7 @@ public class HighLevelBasicCompletionHandlerTestGenerated extends AbstractHighLe } public void testAllFilesPresentInParameterNameAndType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/parameterNameAndType"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/parameterNameAndType"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("CodeStyleSettings.kt") @@ -781,7 +782,7 @@ public class HighLevelBasicCompletionHandlerTestGenerated extends AbstractHighLe } public void testAllFilesPresentInStaticMemberOfNotImported() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/staticMemberOfNotImported"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/staticMemberOfNotImported"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("AmbigiousExtension.kt") @@ -819,7 +820,7 @@ public class HighLevelBasicCompletionHandlerTestGenerated extends AbstractHighLe } public void testAllFilesPresentInStaticMembers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/staticMembers"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/staticMembers"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("classObjectMethod.kt") @@ -897,7 +898,7 @@ public class HighLevelBasicCompletionHandlerTestGenerated extends AbstractHighLe } public void testAllFilesPresentInStringTemplate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/stringTemplate"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/stringTemplate"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("GlobalVal.kt") @@ -950,7 +951,7 @@ public class HighLevelBasicCompletionHandlerTestGenerated extends AbstractHighLe } public void testAllFilesPresentInTypeArgsForCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/typeArgsForCall"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/typeArgsForCall"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("ExpectedTypeDoesNotHelp.kt") diff --git a/idea/idea-fir/tests/org/jetbrains/kotlin/idea/completion/wheigher/HighLevelWeigherTestGenerated.java b/idea/idea-fir/tests/org/jetbrains/kotlin/idea/completion/wheigher/HighLevelWeigherTestGenerated.java index cce33472ca0..0f44b0e5780 100644 --- a/idea/idea-fir/tests/org/jetbrains/kotlin/idea/completion/wheigher/HighLevelWeigherTestGenerated.java +++ b/idea/idea-fir/tests/org/jetbrains/kotlin/idea/completion/wheigher/HighLevelWeigherTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.completion.wheigher; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -30,7 +31,7 @@ public class HighLevelWeigherTestGenerated extends AbstractHighLevelWeigherTest } public void testAllFilesPresentInBasic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/weighers/basic"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/weighers/basic"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); } @TestMetadata("CallableReference_NothingLast.kt") @@ -227,7 +228,7 @@ public class HighLevelWeigherTestGenerated extends AbstractHighLevelWeigherTest } public void testAllFilesPresentInContextualReturn() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/weighers/basic/contextualReturn"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/weighers/basic/contextualReturn"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); } @TestMetadata("idea/idea-completion/testData/weighers/basic/contextualReturn/noReturnType") @@ -239,7 +240,7 @@ public class HighLevelWeigherTestGenerated extends AbstractHighLevelWeigherTest } public void testAllFilesPresentInNoReturnType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/weighers/basic/contextualReturn/noReturnType"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/weighers/basic/contextualReturn/noReturnType"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); } @TestMetadata("BeginOfNestedBlock.kt") @@ -307,7 +308,7 @@ public class HighLevelWeigherTestGenerated extends AbstractHighLevelWeigherTest } public void testAllFilesPresentInWithReturnType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/weighers/basic/contextualReturn/withReturnType"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/weighers/basic/contextualReturn/withReturnType"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); } @TestMetadata("BeginOfNestedBlock.kt") @@ -411,7 +412,7 @@ public class HighLevelWeigherTestGenerated extends AbstractHighLevelWeigherTest } public void testAllFilesPresentInExpectedInfo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/weighers/basic/expectedInfo"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/weighers/basic/expectedInfo"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); } @TestMetadata("CompanionObjectMethod.kt") @@ -494,7 +495,7 @@ public class HighLevelWeigherTestGenerated extends AbstractHighLevelWeigherTest } public void testAllFilesPresentInExpectedType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/weighers/basic/expectedType"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/weighers/basic/expectedType"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); } @TestMetadata("ifConditionQualified.kt") @@ -532,7 +533,7 @@ public class HighLevelWeigherTestGenerated extends AbstractHighLevelWeigherTest } public void testAllFilesPresentInParameterNameAndType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/weighers/basic/parameterNameAndType"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/weighers/basic/parameterNameAndType"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); } @TestMetadata("Deprecated.kt") diff --git a/idea/idea-fir/tests/org/jetbrains/kotlin/idea/highlighter/FirHighlightingTestGenerated.java b/idea/idea-fir/tests/org/jetbrains/kotlin/idea/highlighter/FirHighlightingTestGenerated.java index e3d59a659fd..43ca483ce98 100644 --- a/idea/idea-fir/tests/org/jetbrains/kotlin/idea/highlighter/FirHighlightingTestGenerated.java +++ b/idea/idea-fir/tests/org/jetbrains/kotlin/idea/highlighter/FirHighlightingTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.highlighter; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -27,7 +28,7 @@ public class FirHighlightingTestGenerated extends AbstractFirHighlightingTest { } public void testAllFilesPresentInHighlighter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/highlighter"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/highlighter"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Annotations.kt") @@ -179,7 +180,7 @@ public class FirHighlightingTestGenerated extends AbstractFirHighlightingTest { } public void testAllFilesPresentInDeprecated() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/highlighter/deprecated"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/highlighter/deprecated"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Class.kt") @@ -273,7 +274,7 @@ public class FirHighlightingTestGenerated extends AbstractFirHighlightingTest { } public void testAllFilesPresentInHighlighterFir() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-fir/testData/highlighterFir"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-fir/testData/highlighterFir"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("consturctor.kt") diff --git a/idea/idea-fir/tests/org/jetbrains/kotlin/idea/resolve/FirReferenceResolveTestGenerated.java b/idea/idea-fir/tests/org/jetbrains/kotlin/idea/resolve/FirReferenceResolveTestGenerated.java index 581090d26c6..63c9ac08348 100644 --- a/idea/idea-fir/tests/org/jetbrains/kotlin/idea/resolve/FirReferenceResolveTestGenerated.java +++ b/idea/idea-fir/tests/org/jetbrains/kotlin/idea/resolve/FirReferenceResolveTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.resolve; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class FirReferenceResolveTestGenerated extends AbstractFirReferenceResolv } public void testAllFilesPresentInReferences() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/references"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/references"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("AnnotationForClass.kt") @@ -427,7 +428,7 @@ public class FirReferenceResolveTestGenerated extends AbstractFirReferenceResolv } public void testAllFilesPresentInArrayAccess() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/references/arrayAccess"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/references/arrayAccess"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("get.kt") @@ -450,7 +451,7 @@ public class FirReferenceResolveTestGenerated extends AbstractFirReferenceResolv } public void testAllFilesPresentInConstructorDelegatingReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/references/constructorDelegatingReference"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/references/constructorDelegatingReference"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("toPrimary.kt") @@ -473,7 +474,7 @@ public class FirReferenceResolveTestGenerated extends AbstractFirReferenceResolv } public void testAllFilesPresentInDelegatedPropertyAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/references/delegatedPropertyAccessors"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/references/delegatedPropertyAccessors"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("unresolved.kt") @@ -490,7 +491,7 @@ public class FirReferenceResolveTestGenerated extends AbstractFirReferenceResolv } public void testAllFilesPresentInInSource() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/references/delegatedPropertyAccessors/inSource"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/references/delegatedPropertyAccessors/inSource"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("getExtension.kt") @@ -523,7 +524,7 @@ public class FirReferenceResolveTestGenerated extends AbstractFirReferenceResolv } public void testAllFilesPresentInInStandardLibrary() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/references/delegatedPropertyAccessors/inStandardLibrary"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/references/delegatedPropertyAccessors/inStandardLibrary"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("lazy.kt") @@ -547,7 +548,7 @@ public class FirReferenceResolveTestGenerated extends AbstractFirReferenceResolv } public void testAllFilesPresentInForLoopIn() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/references/forLoopIn"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/references/forLoopIn"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("unresolvedIterator.kt") @@ -564,7 +565,7 @@ public class FirReferenceResolveTestGenerated extends AbstractFirReferenceResolv } public void testAllFilesPresentInInBuiltIns() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/references/forLoopIn/inBuiltIns"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/references/forLoopIn/inBuiltIns"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("extension.kt") @@ -587,7 +588,7 @@ public class FirReferenceResolveTestGenerated extends AbstractFirReferenceResolv } public void testAllFilesPresentInInLibrary() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/references/forLoopIn/inLibrary"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/references/forLoopIn/inLibrary"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("extension.kt") @@ -610,7 +611,7 @@ public class FirReferenceResolveTestGenerated extends AbstractFirReferenceResolv } public void testAllFilesPresentInInSource() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/references/forLoopIn/inSource"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/references/forLoopIn/inSource"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("allMembers.kt") @@ -634,7 +635,7 @@ public class FirReferenceResolveTestGenerated extends AbstractFirReferenceResolv } public void testAllFilesPresentInInvoke() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/references/invoke"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/references/invoke"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("lambdaAndParens.kt") @@ -717,7 +718,7 @@ public class FirReferenceResolveTestGenerated extends AbstractFirReferenceResolv } public void testAllFilesPresentInNestedTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/references/nestedTypes"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/references/nestedTypes"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("ResolveCompanionInCompanionType.kt") diff --git a/idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/FirLazyDeclarationResolveTestGenerated.java b/idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/FirLazyDeclarationResolveTestGenerated.java index 5b91809221e..212bf8832b4 100644 --- a/idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/FirLazyDeclarationResolveTestGenerated.java +++ b/idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/FirLazyDeclarationResolveTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.fir.low.level.api; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class FirLazyDeclarationResolveTestGenerated extends AbstractFirLazyDecla } public void testAllFilesPresentInLazyResolve() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-frontend-fir/idea-fir-low-level-api/testdata/lazyResolve"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-frontend-fir/idea-fir-low-level-api/testdata/lazyResolve"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("classMembers.kt") diff --git a/idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/FirLazyResolveTestGenerated.java b/idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/FirLazyResolveTestGenerated.java index fe203a2cb91..29e581f23bc 100644 --- a/idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/FirLazyResolveTestGenerated.java +++ b/idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/FirLazyResolveTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.fir.low.level.api; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class FirLazyResolveTestGenerated extends AbstractFirLazyResolveTest { } public void testAllFilesPresentInLazyResolve() throws Exception { - KotlinTestUtils.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File("idea/testData/fir/lazyResolve"), Pattern.compile("^(.+)\\.test$"), null); + KtTestUtil.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File("idea/testData/fir/lazyResolve"), Pattern.compile("^(.+)\\.test$"), null); } @TestMetadata("elvis/elvis.test") diff --git a/idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/FirMultiModuleLazyResolveTestGenerated.java b/idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/FirMultiModuleLazyResolveTestGenerated.java index f5bf00ed14b..2af0a8a96b8 100644 --- a/idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/FirMultiModuleLazyResolveTestGenerated.java +++ b/idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/FirMultiModuleLazyResolveTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.fir.low.level.api; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class FirMultiModuleLazyResolveTestGenerated extends AbstractFirMultiModu } public void testAllFilesPresentInMultiModuleLazyResolve() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-frontend-fir/idea-fir-low-level-api/testdata/multiModuleLazyResolve"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-frontend-fir/idea-fir-low-level-api/testdata/multiModuleLazyResolve"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("javaExtendsKotlinExtendsJava") diff --git a/idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/FirMultiModuleResolveTestGenerated.java b/idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/FirMultiModuleResolveTestGenerated.java index f92f3500044..9529ecccf43 100644 --- a/idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/FirMultiModuleResolveTestGenerated.java +++ b/idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/FirMultiModuleResolveTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.fir.low.level.api; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,6 +26,6 @@ public class FirMultiModuleResolveTestGenerated extends AbstractFirMultiModuleRe } public void testAllFilesPresentInMultiModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/fir/multiModule"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/fir/multiModule"), Pattern.compile("^([^\\.]+)$"), null, false); } } diff --git a/idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/file/structure/FileStructureAndOutOfBlockModificationTrackerConsistencyTestGenerated.java b/idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/file/structure/FileStructureAndOutOfBlockModificationTrackerConsistencyTestGenerated.java index 5f2d976ca41..078f3847319 100644 --- a/idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/file/structure/FileStructureAndOutOfBlockModificationTrackerConsistencyTestGenerated.java +++ b/idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/file/structure/FileStructureAndOutOfBlockModificationTrackerConsistencyTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.fir.low.level.api.file.structure; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class FileStructureAndOutOfBlockModificationTrackerConsistencyTestGenerat } public void testAllFilesPresentInOutOfBlockProjectWide() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-frontend-fir/idea-fir-low-level-api/testdata/outOfBlockProjectWide"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-frontend-fir/idea-fir-low-level-api/testdata/outOfBlockProjectWide"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("localFun.kt") diff --git a/idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/file/structure/FileStructureTestGenerated.java b/idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/file/structure/FileStructureTestGenerated.java index 5bf5f17f1ed..8b7a8a167d5 100644 --- a/idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/file/structure/FileStructureTestGenerated.java +++ b/idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/file/structure/FileStructureTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.fir.low.level.api.file.structure; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class FileStructureTestGenerated extends AbstractFileStructureTest { } public void testAllFilesPresentInFileStructure() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-frontend-fir/idea-fir-low-level-api/testdata/fileStructure"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-frontend-fir/idea-fir-low-level-api/testdata/fileStructure"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("class.kt") diff --git a/idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/sessions/SessionsInvalidationTestGenerated.java b/idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/sessions/SessionsInvalidationTestGenerated.java index eabea64952c..f128753fd00 100644 --- a/idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/sessions/SessionsInvalidationTestGenerated.java +++ b/idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/sessions/SessionsInvalidationTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.fir.low.level.api.sessions; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class SessionsInvalidationTestGenerated extends AbstractSessionsInvalidat } public void testAllFilesPresentInSessionInvalidation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-frontend-fir/idea-fir-low-level-api/testdata/sessionInvalidation"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-frontend-fir/idea-fir-low-level-api/testdata/sessionInvalidation"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("binaryTree") diff --git a/idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/trackers/ProjectWideOutOfBlockKotlinModificationTrackerTestGenerated.java b/idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/trackers/ProjectWideOutOfBlockKotlinModificationTrackerTestGenerated.java index fb8abeebde0..38eacdb55b6 100644 --- a/idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/trackers/ProjectWideOutOfBlockKotlinModificationTrackerTestGenerated.java +++ b/idea/idea-frontend-fir/idea-fir-low-level-api/tests/org/jetbrains/kotlin/idea/fir/low/level/api/trackers/ProjectWideOutOfBlockKotlinModificationTrackerTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.fir.low.level.api.trackers; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class ProjectWideOutOfBlockKotlinModificationTrackerTestGenerated extends } public void testAllFilesPresentInOutOfBlockProjectWide() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-frontend-fir/idea-fir-low-level-api/testdata/outOfBlockProjectWide"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-frontend-fir/idea-fir-low-level-api/testdata/outOfBlockProjectWide"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("localFun.kt") diff --git a/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/fir/KtDeclarationAndFirDeclarationEqualityCheckerGenerated.java b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/fir/KtDeclarationAndFirDeclarationEqualityCheckerGenerated.java index 367970ae44f..a4a408766ae 100644 --- a/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/fir/KtDeclarationAndFirDeclarationEqualityCheckerGenerated.java +++ b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/fir/KtDeclarationAndFirDeclarationEqualityCheckerGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.fir; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class KtDeclarationAndFirDeclarationEqualityCheckerGenerated extends Abst } public void testAllFilesPresentInKtDeclarationAndFirDeclarationEqualityChecker() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-frontend-fir/testData/ktDeclarationAndFirDeclarationEqualityChecker"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-frontend-fir/testData/ktDeclarationAndFirDeclarationEqualityChecker"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("extensionMethods.kt") diff --git a/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/components/ExpectedExpressionTypeTestGenerated.java b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/components/ExpectedExpressionTypeTestGenerated.java index b5cf808bcc0..45f4db69fa8 100644 --- a/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/components/ExpectedExpressionTypeTestGenerated.java +++ b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/components/ExpectedExpressionTypeTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.frontend.api.components; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class ExpectedExpressionTypeTestGenerated extends AbstractExpectedExpress } public void testAllFilesPresentInExpectedExpressionType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-frontend-fir/testData/components/expectedExpressionType"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-frontend-fir/testData/components/expectedExpressionType"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("functionLambdaParam.kt") diff --git a/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/components/ReturnExpressionTargetTestGenerated.java b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/components/ReturnExpressionTargetTestGenerated.java index 661b661367d..64808b71ce0 100644 --- a/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/components/ReturnExpressionTargetTestGenerated.java +++ b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/components/ReturnExpressionTargetTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.frontend.api.components; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class ReturnExpressionTargetTestGenerated extends AbstractReturnExpressio } public void testAllFilesPresentInReturnExpressionTarget() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-frontend-fir/testData/components/returnExpressionTarget"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-frontend-fir/testData/components/returnExpressionTarget"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("returnFromFunctionViaLambdaWithoutLabel.kt") diff --git a/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/fir/ResolveCallTestGenerated.java b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/fir/ResolveCallTestGenerated.java index 676a9dd5d57..ff4c42df83a 100644 --- a/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/fir/ResolveCallTestGenerated.java +++ b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/fir/ResolveCallTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.frontend.api.fir; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class ResolveCallTestGenerated extends AbstractResolveCallTest { } public void testAllFilesPresentInResolveCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-frontend-fir/testData/analysisSession/resolveCall"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-frontend-fir/testData/analysisSession/resolveCall"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("functionCallInTheSameFile.kt") diff --git a/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/scopes/FileScopeTestGenerated.java b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/scopes/FileScopeTestGenerated.java index abd237e6f29..6c028e8adb6 100644 --- a/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/scopes/FileScopeTestGenerated.java +++ b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/scopes/FileScopeTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.frontend.api.scopes; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class FileScopeTestGenerated extends AbstractFileScopeTest { } public void testAllFilesPresentInFileScopeTest() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-frontend-fir/testData/fileScopeTest"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-frontend-fir/testData/fileScopeTest"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("simpleFileScope.kt") diff --git a/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/scopes/MemberScopeByFqNameTestGenerated.java b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/scopes/MemberScopeByFqNameTestGenerated.java index 3ba3533e509..98c71f7b2d3 100644 --- a/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/scopes/MemberScopeByFqNameTestGenerated.java +++ b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/scopes/MemberScopeByFqNameTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.frontend.api.scopes; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class MemberScopeByFqNameTestGenerated extends AbstractMemberScopeByFqNam } public void testAllFilesPresentInMemberScopeByFqName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-frontend-fir/testData/memberScopeByFqName"), Pattern.compile("^(.+)\\.txt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-frontend-fir/testData/memberScopeByFqName"), Pattern.compile("^(.+)\\.txt$"), null, true); } @TestMetadata("Int.txt") diff --git a/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/symbols/MemoryLeakInSymbolsTestGenerated.java b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/symbols/MemoryLeakInSymbolsTestGenerated.java index ed8ef8de4a2..8f92f41267e 100644 --- a/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/symbols/MemoryLeakInSymbolsTestGenerated.java +++ b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/symbols/MemoryLeakInSymbolsTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.frontend.api.symbols; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class MemoryLeakInSymbolsTestGenerated extends AbstractMemoryLeakInSymbol } public void testAllFilesPresentInSymbolMemoryLeak() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-frontend-fir/testData/symbolMemoryLeak"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-frontend-fir/testData/symbolMemoryLeak"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("symbols.kt") diff --git a/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/symbols/SymbolFromLibraryPointerRestoreTestGenerated.java b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/symbols/SymbolFromLibraryPointerRestoreTestGenerated.java index c04ce715f1f..2c08adeae03 100644 --- a/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/symbols/SymbolFromLibraryPointerRestoreTestGenerated.java +++ b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/symbols/SymbolFromLibraryPointerRestoreTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.frontend.api.symbols; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class SymbolFromLibraryPointerRestoreTestGenerated extends AbstractSymbol } public void testAllFilesPresentInResoreSymbolFromLibrary() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-frontend-fir/testData/resoreSymbolFromLibrary"), Pattern.compile("^(.+)\\.txt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-frontend-fir/testData/resoreSymbolFromLibrary"), Pattern.compile("^(.+)\\.txt$"), null, true); } @TestMetadata("class.txt") diff --git a/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/symbols/SymbolFromSourcePointerRestoreTestGenerated.java b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/symbols/SymbolFromSourcePointerRestoreTestGenerated.java index 7cb3d981295..981bd9d58ef 100644 --- a/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/symbols/SymbolFromSourcePointerRestoreTestGenerated.java +++ b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/symbols/SymbolFromSourcePointerRestoreTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.frontend.api.symbols; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class SymbolFromSourcePointerRestoreTestGenerated extends AbstractSymbolF } public void testAllFilesPresentInSymbolPointer() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-frontend-fir/testData/symbolPointer"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-frontend-fir/testData/symbolPointer"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("class.kt") diff --git a/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/symbols/SymbolsByFqNameBuildingTestGenerated.java b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/symbols/SymbolsByFqNameBuildingTestGenerated.java index 23f01d9eaff..8f803bcb471 100644 --- a/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/symbols/SymbolsByFqNameBuildingTestGenerated.java +++ b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/symbols/SymbolsByFqNameBuildingTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.frontend.api.symbols; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class SymbolsByFqNameBuildingTestGenerated extends AbstractSymbolsByFqNam } public void testAllFilesPresentInSymbolsByFqName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-frontend-fir/testData/symbolsByFqName"), Pattern.compile("^(.+)\\.txt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-frontend-fir/testData/symbolsByFqName"), Pattern.compile("^(.+)\\.txt$"), null, true); } @TestMetadata("fileWalkDirectionEnum.txt") diff --git a/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/symbols/SymbolsByPsiBuildingTestGenerated.java b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/symbols/SymbolsByPsiBuildingTestGenerated.java index a3e8eee3c46..6a5b31bd59c 100644 --- a/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/symbols/SymbolsByPsiBuildingTestGenerated.java +++ b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/symbols/SymbolsByPsiBuildingTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.frontend.api.symbols; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class SymbolsByPsiBuildingTestGenerated extends AbstractSymbolsByPsiBuild } public void testAllFilesPresentInSymbolsByPsi() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-frontend-fir/testData/symbolsByPsi"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-frontend-fir/testData/symbolsByPsi"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("annotations.kt") diff --git a/idea/idea-gradle/tests/org/jetbrains/kotlin/idea/configuration/GradleConfigureProjectByChangingFileTestGenerated.java b/idea/idea-gradle/tests/org/jetbrains/kotlin/idea/configuration/GradleConfigureProjectByChangingFileTestGenerated.java index 69910f49fae..1f6c4dab454 100644 --- a/idea/idea-gradle/tests/org/jetbrains/kotlin/idea/configuration/GradleConfigureProjectByChangingFileTestGenerated.java +++ b/idea/idea-gradle/tests/org/jetbrains/kotlin/idea/configuration/GradleConfigureProjectByChangingFileTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.configuration; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -27,7 +28,7 @@ public class GradleConfigureProjectByChangingFileTestGenerated extends AbstractG } public void testAllFilesPresentInGradle() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/configuration/gradle"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/configuration/gradle"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("default") @@ -85,7 +86,7 @@ public class GradleConfigureProjectByChangingFileTestGenerated extends AbstractG } public void testAllFilesPresentInGsk() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/configuration/gsk"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/configuration/gsk"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("eap11Version") diff --git a/idea/idea-maven/test/org/jetbrains/kotlin/idea/maven/KotlinMavenInspectionTestGenerated.java b/idea/idea-maven/test/org/jetbrains/kotlin/idea/maven/KotlinMavenInspectionTestGenerated.java index 6cdc1ddf1ad..7fb6017e042 100644 --- a/idea/idea-maven/test/org/jetbrains/kotlin/idea/maven/KotlinMavenInspectionTestGenerated.java +++ b/idea/idea-maven/test/org/jetbrains/kotlin/idea/maven/KotlinMavenInspectionTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.maven; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class KotlinMavenInspectionTestGenerated extends AbstractKotlinMavenInspe } public void testAllFilesPresentInMaven_inspections() throws Exception { - KotlinTestUtils.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File("idea/idea-maven/testData/maven-inspections"), Pattern.compile("^([\\w\\-]+).xml$"), null); + KtTestUtil.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File("idea/idea-maven/testData/maven-inspections"), Pattern.compile("^([\\w\\-]+).xml$"), null); } @TestMetadata("bothCompileAndTestCompileInTheSameExecution.xml") diff --git a/idea/idea-maven/test/org/jetbrains/kotlin/idea/maven/configuration/MavenConfigureProjectByChangingFileTestGenerated.java b/idea/idea-maven/test/org/jetbrains/kotlin/idea/maven/configuration/MavenConfigureProjectByChangingFileTestGenerated.java index 23bd8ede145..689fa83fa26 100644 --- a/idea/idea-maven/test/org/jetbrains/kotlin/idea/maven/configuration/MavenConfigureProjectByChangingFileTestGenerated.java +++ b/idea/idea-maven/test/org/jetbrains/kotlin/idea/maven/configuration/MavenConfigureProjectByChangingFileTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.maven.configuration; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -27,7 +28,7 @@ public class MavenConfigureProjectByChangingFileTestGenerated extends AbstractMa } public void testAllFilesPresentInJvm() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-maven/testData/configurator/jvm"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-maven/testData/configurator/jvm"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("fixExisting") @@ -85,7 +86,7 @@ public class MavenConfigureProjectByChangingFileTestGenerated extends AbstractMa } public void testAllFilesPresentInJs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-maven/testData/configurator/js"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-maven/testData/configurator/js"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("libraryMissed") diff --git a/idea/idea-new-project-wizard/tests/org/jetbrains/kotlin/tools/projectWizard/wizard/ProjectTemplateNewWizardProjectImportTestGenerated.java b/idea/idea-new-project-wizard/tests/org/jetbrains/kotlin/tools/projectWizard/wizard/ProjectTemplateNewWizardProjectImportTestGenerated.java index 78f9ad3e146..d0a45a47c67 100644 --- a/idea/idea-new-project-wizard/tests/org/jetbrains/kotlin/tools/projectWizard/wizard/ProjectTemplateNewWizardProjectImportTestGenerated.java +++ b/idea/idea-new-project-wizard/tests/org/jetbrains/kotlin/tools/projectWizard/wizard/ProjectTemplateNewWizardProjectImportTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.tools.projectWizard.wizard; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -27,7 +28,7 @@ public class ProjectTemplateNewWizardProjectImportTestGenerated extends Abstract } public void testAllFilesPresentInGradleKts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("libraries/tools/new-project-wizard/new-project-wizard-cli/testData/projectTemplatesBuildFileGeneration"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("libraries/tools/new-project-wizard/new-project-wizard-cli/testData/projectTemplatesBuildFileGeneration"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("backendApplication") @@ -95,7 +96,7 @@ public class ProjectTemplateNewWizardProjectImportTestGenerated extends Abstract } public void testAllFilesPresentInGradleGroovy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("libraries/tools/new-project-wizard/new-project-wizard-cli/testData/projectTemplatesBuildFileGeneration"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("libraries/tools/new-project-wizard/new-project-wizard-cli/testData/projectTemplatesBuildFileGeneration"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("backendApplication") @@ -163,7 +164,7 @@ public class ProjectTemplateNewWizardProjectImportTestGenerated extends Abstract } public void testAllFilesPresentInMaven() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("libraries/tools/new-project-wizard/new-project-wizard-cli/testData/projectTemplatesBuildFileGeneration"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("libraries/tools/new-project-wizard/new-project-wizard-cli/testData/projectTemplatesBuildFileGeneration"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("backendApplication") diff --git a/idea/idea-new-project-wizard/tests/org/jetbrains/kotlin/tools/projectWizard/wizard/YamlNewWizardProjectImportTestGenerated.java b/idea/idea-new-project-wizard/tests/org/jetbrains/kotlin/tools/projectWizard/wizard/YamlNewWizardProjectImportTestGenerated.java index 8bd5a319fee..929e8356699 100644 --- a/idea/idea-new-project-wizard/tests/org/jetbrains/kotlin/tools/projectWizard/wizard/YamlNewWizardProjectImportTestGenerated.java +++ b/idea/idea-new-project-wizard/tests/org/jetbrains/kotlin/tools/projectWizard/wizard/YamlNewWizardProjectImportTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.tools.projectWizard.wizard; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -27,7 +28,7 @@ public class YamlNewWizardProjectImportTestGenerated extends AbstractYamlNewWiza } public void testAllFilesPresentInGradleKts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("libraries/tools/new-project-wizard/new-project-wizard-cli/testData/buildFileGeneration"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("libraries/tools/new-project-wizard/new-project-wizard-cli/testData/buildFileGeneration"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("android") @@ -100,7 +101,7 @@ public class YamlNewWizardProjectImportTestGenerated extends AbstractYamlNewWiza } public void testAllFilesPresentInGradleGroovy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("libraries/tools/new-project-wizard/new-project-wizard-cli/testData/buildFileGeneration"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("libraries/tools/new-project-wizard/new-project-wizard-cli/testData/buildFileGeneration"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("android") @@ -173,7 +174,7 @@ public class YamlNewWizardProjectImportTestGenerated extends AbstractYamlNewWiza } public void testAllFilesPresentInMaven() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("libraries/tools/new-project-wizard/new-project-wizard-cli/testData/buildFileGeneration"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("libraries/tools/new-project-wizard/new-project-wizard-cli/testData/buildFileGeneration"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("android") diff --git a/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/AsyncStackTraceTestGenerated.java b/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/AsyncStackTraceTestGenerated.java index d03d2e8b2d1..b5e03f3c5ba 100644 --- a/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/AsyncStackTraceTestGenerated.java +++ b/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/AsyncStackTraceTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.debugger.test; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class AsyncStackTraceTestGenerated extends AbstractAsyncStackTraceTest { } public void testAllFilesPresentInAsyncStackTrace() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/asyncStackTrace"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/asyncStackTrace"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("asyncFunctions.kt") diff --git a/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/BreakpointApplicabilityTestGenerated.java b/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/BreakpointApplicabilityTestGenerated.java index 4e8d37478b7..498b24516fc 100644 --- a/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/BreakpointApplicabilityTestGenerated.java +++ b/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/BreakpointApplicabilityTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.debugger.test; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class BreakpointApplicabilityTestGenerated extends AbstractBreakpointAppl } public void testAllFilesPresentInBreakpointApplicability() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/breakpointApplicability"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/breakpointApplicability"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("constructors.kt") diff --git a/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/ContinuationStackTraceTestGenerated.java b/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/ContinuationStackTraceTestGenerated.java index 9112c7bc424..2902ca37de2 100644 --- a/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/ContinuationStackTraceTestGenerated.java +++ b/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/ContinuationStackTraceTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.debugger.test; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class ContinuationStackTraceTestGenerated extends AbstractContinuationSta } public void testAllFilesPresentInContinuation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/continuation"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/continuation"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("suspendFun.kt") diff --git a/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/CoroutineDumpTestGenerated.java b/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/CoroutineDumpTestGenerated.java index e299741b9a4..602d0d0a4a6 100644 --- a/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/CoroutineDumpTestGenerated.java +++ b/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/CoroutineDumpTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.debugger.test; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class CoroutineDumpTestGenerated extends AbstractCoroutineDumpTest { } public void testAllFilesPresentInCoroutines() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("noCoroutines.kt") diff --git a/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/FileRankingTestGenerated.java b/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/FileRankingTestGenerated.java index d9bb72dd12d..370546d1fec 100644 --- a/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/FileRankingTestGenerated.java +++ b/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/FileRankingTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.debugger.test; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class FileRankingTestGenerated extends AbstractFileRankingTest { } public void testAllFilesPresentInFileRanking() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/fileRanking"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/fileRanking"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("anonymousClasses.kt") diff --git a/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/IrKotlinEvaluateExpressionTestGenerated.java b/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/IrKotlinEvaluateExpressionTestGenerated.java index bb86570616d..d4db231afd2 100644 --- a/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/IrKotlinEvaluateExpressionTestGenerated.java +++ b/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/IrKotlinEvaluateExpressionTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.debugger.test; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -38,7 +39,7 @@ public class IrKotlinEvaluateExpressionTestGenerated extends AbstractIrKotlinEva } public void testAllFilesPresentInSingleBreakpoint() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/evaluation/singleBreakpoint"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/evaluation/singleBreakpoint"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("annotationValue.kt") @@ -525,7 +526,7 @@ public class IrKotlinEvaluateExpressionTestGenerated extends AbstractIrKotlinEva } public void testAllFilesPresentInCompilingEvaluator() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/evaluation/singleBreakpoint/compilingEvaluator"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/evaluation/singleBreakpoint/compilingEvaluator"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("ceAnonymousObject.kt") @@ -593,7 +594,7 @@ public class IrKotlinEvaluateExpressionTestGenerated extends AbstractIrKotlinEva } public void testAllFilesPresentInCoroutines() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/evaluation/singleBreakpoint/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/evaluation/singleBreakpoint/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("anyUpdateInvokeStatic.kt") @@ -646,7 +647,7 @@ public class IrKotlinEvaluateExpressionTestGenerated extends AbstractIrKotlinEva } public void testAllFilesPresentInCreateExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/evaluation/singleBreakpoint/createExpression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/evaluation/singleBreakpoint/createExpression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("createExpressionCastToBuiltIn.kt") @@ -674,7 +675,7 @@ public class IrKotlinEvaluateExpressionTestGenerated extends AbstractIrKotlinEva } public void testAllFilesPresentInExtraVariables() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/evaluation/singleBreakpoint/extraVariables"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/evaluation/singleBreakpoint/extraVariables"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("evBreakpointOnPropertyDeclaration.kt") @@ -742,7 +743,7 @@ public class IrKotlinEvaluateExpressionTestGenerated extends AbstractIrKotlinEva } public void testAllFilesPresentInFrame() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/evaluation/singleBreakpoint/frame"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/evaluation/singleBreakpoint/frame"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("capturedValues1.kt") @@ -995,7 +996,7 @@ public class IrKotlinEvaluateExpressionTestGenerated extends AbstractIrKotlinEva } public void testAllFilesPresentInJavaContext() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/evaluation/singleBreakpoint/javaContext"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/evaluation/singleBreakpoint/javaContext"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("jcBlock.kt") @@ -1038,7 +1039,7 @@ public class IrKotlinEvaluateExpressionTestGenerated extends AbstractIrKotlinEva } public void testAllFilesPresentInLabels() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/evaluation/singleBreakpoint/labels"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/evaluation/singleBreakpoint/labels"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("lCallOnLabeledObj.kt") @@ -1076,7 +1077,7 @@ public class IrKotlinEvaluateExpressionTestGenerated extends AbstractIrKotlinEva } public void testAllFilesPresentInLambdas() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/evaluation/singleBreakpoint/lambdas"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/evaluation/singleBreakpoint/lambdas"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("destructuringParam.kt") @@ -1139,7 +1140,7 @@ public class IrKotlinEvaluateExpressionTestGenerated extends AbstractIrKotlinEva } public void testAllFilesPresentInRenderer() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/evaluation/singleBreakpoint/renderer"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/evaluation/singleBreakpoint/renderer"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("toStringRenderer.kt") @@ -1158,7 +1159,7 @@ public class IrKotlinEvaluateExpressionTestGenerated extends AbstractIrKotlinEva } public void testAllFilesPresentInMultipleBreakpoints() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/evaluation/multipleBreakpoints"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/evaluation/multipleBreakpoints"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("clearCache.kt") @@ -1295,7 +1296,7 @@ public class IrKotlinEvaluateExpressionTestGenerated extends AbstractIrKotlinEva } public void testAllFilesPresentInLibrary() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/evaluation/multipleBreakpoints/library"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/evaluation/multipleBreakpoints/library"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("customLibClassName.kt") diff --git a/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/IrKotlinSteppingTestGenerated.java b/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/IrKotlinSteppingTestGenerated.java index 6bbd6b16013..777e8c3d723 100644 --- a/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/IrKotlinSteppingTestGenerated.java +++ b/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/IrKotlinSteppingTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.debugger.test; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -27,7 +28,7 @@ public class IrKotlinSteppingTestGenerated extends AbstractIrKotlinSteppingTest } public void testAllFilesPresentInStepInto() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/stepping/stepIntoAndSmartStepInto"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/stepping/stepIntoAndSmartStepInto"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("classObjectFunFromClass.kt") @@ -120,7 +121,7 @@ public class IrKotlinSteppingTestGenerated extends AbstractIrKotlinSteppingTest } public void testAllFilesPresentInSmartStepInto() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/stepping/stepIntoAndSmartStepInto"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/stepping/stepIntoAndSmartStepInto"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("classObjectFunFromClass.kt") @@ -218,7 +219,7 @@ public class IrKotlinSteppingTestGenerated extends AbstractIrKotlinSteppingTest } public void testAllFilesPresentInStepIntoOnly() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/stepping/stepInto"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/stepping/stepInto"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("continueLabel.kt") @@ -341,7 +342,7 @@ public class IrKotlinSteppingTestGenerated extends AbstractIrKotlinSteppingTest } public void testAllFilesPresentInStepOut() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/stepping/stepOut"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/stepping/stepOut"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("fwBackingField.kt") @@ -399,7 +400,7 @@ public class IrKotlinSteppingTestGenerated extends AbstractIrKotlinSteppingTest } public void testAllFilesPresentInStepOver() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/stepping/stepOver"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/stepping/stepOver"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("asIterableInFor.kt") @@ -941,7 +942,7 @@ public class IrKotlinSteppingTestGenerated extends AbstractIrKotlinSteppingTest } public void testAllFilesPresentInCoroutines() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/stepping/stepOver/coroutines"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/stepping/stepOver/coroutines"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("sequenceNested.kt") @@ -975,7 +976,7 @@ public class IrKotlinSteppingTestGenerated extends AbstractIrKotlinSteppingTest } public void testAllFilesPresentInFilters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/stepping/filters"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/stepping/filters"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("checkNotNull.kt") @@ -1068,7 +1069,7 @@ public class IrKotlinSteppingTestGenerated extends AbstractIrKotlinSteppingTest } public void testAllFilesPresentInCustom() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/stepping/custom"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/stepping/custom"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("anonymousFunAsParamDefaultValue.kt") diff --git a/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/KotlinEvaluateExpressionTestGenerated.java b/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/KotlinEvaluateExpressionTestGenerated.java index 56165e49bf9..a4127bec327 100644 --- a/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/KotlinEvaluateExpressionTestGenerated.java +++ b/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/KotlinEvaluateExpressionTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.debugger.test; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -37,7 +38,7 @@ public class KotlinEvaluateExpressionTestGenerated extends AbstractKotlinEvaluat } public void testAllFilesPresentInSingleBreakpoint() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/evaluation/singleBreakpoint"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/evaluation/singleBreakpoint"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("annotationValue.kt") @@ -524,7 +525,7 @@ public class KotlinEvaluateExpressionTestGenerated extends AbstractKotlinEvaluat } public void testAllFilesPresentInCompilingEvaluator() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/evaluation/singleBreakpoint/compilingEvaluator"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/evaluation/singleBreakpoint/compilingEvaluator"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ceAnonymousObject.kt") @@ -592,7 +593,7 @@ public class KotlinEvaluateExpressionTestGenerated extends AbstractKotlinEvaluat } public void testAllFilesPresentInCoroutines() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/evaluation/singleBreakpoint/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/evaluation/singleBreakpoint/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("anyUpdateInvokeStatic.kt") @@ -645,7 +646,7 @@ public class KotlinEvaluateExpressionTestGenerated extends AbstractKotlinEvaluat } public void testAllFilesPresentInCreateExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/evaluation/singleBreakpoint/createExpression"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/evaluation/singleBreakpoint/createExpression"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("createExpressionCastToBuiltIn.kt") @@ -673,7 +674,7 @@ public class KotlinEvaluateExpressionTestGenerated extends AbstractKotlinEvaluat } public void testAllFilesPresentInExtraVariables() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/evaluation/singleBreakpoint/extraVariables"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/evaluation/singleBreakpoint/extraVariables"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("evBreakpointOnPropertyDeclaration.kt") @@ -741,7 +742,7 @@ public class KotlinEvaluateExpressionTestGenerated extends AbstractKotlinEvaluat } public void testAllFilesPresentInFrame() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/evaluation/singleBreakpoint/frame"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/evaluation/singleBreakpoint/frame"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("capturedValues1.kt") @@ -994,7 +995,7 @@ public class KotlinEvaluateExpressionTestGenerated extends AbstractKotlinEvaluat } public void testAllFilesPresentInJavaContext() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/evaluation/singleBreakpoint/javaContext"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/evaluation/singleBreakpoint/javaContext"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("jcBlock.kt") @@ -1037,7 +1038,7 @@ public class KotlinEvaluateExpressionTestGenerated extends AbstractKotlinEvaluat } public void testAllFilesPresentInLabels() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/evaluation/singleBreakpoint/labels"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/evaluation/singleBreakpoint/labels"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("lCallOnLabeledObj.kt") @@ -1075,7 +1076,7 @@ public class KotlinEvaluateExpressionTestGenerated extends AbstractKotlinEvaluat } public void testAllFilesPresentInLambdas() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/evaluation/singleBreakpoint/lambdas"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/evaluation/singleBreakpoint/lambdas"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("destructuringParam.kt") @@ -1138,7 +1139,7 @@ public class KotlinEvaluateExpressionTestGenerated extends AbstractKotlinEvaluat } public void testAllFilesPresentInRenderer() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/evaluation/singleBreakpoint/renderer"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/evaluation/singleBreakpoint/renderer"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("toStringRenderer.kt") @@ -1157,7 +1158,7 @@ public class KotlinEvaluateExpressionTestGenerated extends AbstractKotlinEvaluat } public void testAllFilesPresentInMultipleBreakpoints() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/evaluation/multipleBreakpoints"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/evaluation/multipleBreakpoints"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("clearCache.kt") @@ -1294,7 +1295,7 @@ public class KotlinEvaluateExpressionTestGenerated extends AbstractKotlinEvaluat } public void testAllFilesPresentInLibrary() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/evaluation/multipleBreakpoints/library"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/evaluation/multipleBreakpoints/library"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("customLibClassName.kt") diff --git a/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/KotlinSteppingTestGenerated.java b/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/KotlinSteppingTestGenerated.java index 7c68964a9f1..c6e6fce0238 100644 --- a/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/KotlinSteppingTestGenerated.java +++ b/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/KotlinSteppingTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.debugger.test; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -27,7 +28,7 @@ public class KotlinSteppingTestGenerated extends AbstractKotlinSteppingTest { } public void testAllFilesPresentInStepInto() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/stepping/stepIntoAndSmartStepInto"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/stepping/stepIntoAndSmartStepInto"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("classObjectFunFromClass.kt") @@ -120,7 +121,7 @@ public class KotlinSteppingTestGenerated extends AbstractKotlinSteppingTest { } public void testAllFilesPresentInSmartStepInto() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/stepping/stepIntoAndSmartStepInto"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/stepping/stepIntoAndSmartStepInto"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("classObjectFunFromClass.kt") @@ -218,7 +219,7 @@ public class KotlinSteppingTestGenerated extends AbstractKotlinSteppingTest { } public void testAllFilesPresentInStepIntoOnly() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/stepping/stepInto"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/stepping/stepInto"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("continueLabel.kt") @@ -341,7 +342,7 @@ public class KotlinSteppingTestGenerated extends AbstractKotlinSteppingTest { } public void testAllFilesPresentInStepOut() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/stepping/stepOut"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/stepping/stepOut"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("fwBackingField.kt") @@ -399,7 +400,7 @@ public class KotlinSteppingTestGenerated extends AbstractKotlinSteppingTest { } public void testAllFilesPresentInStepOver() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/stepping/stepOver"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/stepping/stepOver"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("asIterableInFor.kt") @@ -941,7 +942,7 @@ public class KotlinSteppingTestGenerated extends AbstractKotlinSteppingTest { } public void testAllFilesPresentInCoroutines() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/stepping/stepOver/coroutines"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/stepping/stepOver/coroutines"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("sequenceNested.kt") @@ -975,7 +976,7 @@ public class KotlinSteppingTestGenerated extends AbstractKotlinSteppingTest { } public void testAllFilesPresentInFilters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/stepping/filters"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/stepping/filters"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("checkNotNull.kt") @@ -1068,7 +1069,7 @@ public class KotlinSteppingTestGenerated extends AbstractKotlinSteppingTest { } public void testAllFilesPresentInCustom() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/stepping/custom"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/stepping/custom"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("anonymousFunAsParamDefaultValue.kt") diff --git a/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/PositionManagerTestGenerated.java b/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/PositionManagerTestGenerated.java index 9432d149dcb..0e93984cc6b 100644 --- a/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/PositionManagerTestGenerated.java +++ b/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/PositionManagerTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.debugger.test; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -27,7 +28,7 @@ public class PositionManagerTestGenerated extends AbstractPositionManagerTest { } public void testAllFilesPresentInSingleFile() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/positionManager"), Pattern.compile("^(.+)\\.kt$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/positionManager"), Pattern.compile("^(.+)\\.kt$"), null, false); } @TestMetadata("anonymousFunction.kt") @@ -140,7 +141,7 @@ public class PositionManagerTestGenerated extends AbstractPositionManagerTest { } public void testAllFilesPresentInMultiFile() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/positionManager"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/positionManager"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("multiFilePackage") diff --git a/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/SelectExpressionForDebuggerTestGenerated.java b/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/SelectExpressionForDebuggerTestGenerated.java index 149ade39f53..d64c1d7bd6e 100644 --- a/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/SelectExpressionForDebuggerTestGenerated.java +++ b/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/SelectExpressionForDebuggerTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.debugger.test; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -27,7 +28,7 @@ public class SelectExpressionForDebuggerTestGenerated extends AbstractSelectExpr } public void testAllFilesPresentInSelectExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/selectExpression"), Pattern.compile("^(.+)\\.kt$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/selectExpression"), Pattern.compile("^(.+)\\.kt$"), null, false); } @TestMetadata("annotation.kt") @@ -230,7 +231,7 @@ public class SelectExpressionForDebuggerTestGenerated extends AbstractSelectExpr } public void testAllFilesPresentInDisallowMethodCalls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/selectExpression/disallowMethodCalls"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/selectExpression/disallowMethodCalls"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("binaryExpression.kt") diff --git a/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/SmartStepIntoTestGenerated.java b/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/SmartStepIntoTestGenerated.java index 931a30a148d..36972b2681b 100644 --- a/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/SmartStepIntoTestGenerated.java +++ b/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/SmartStepIntoTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.debugger.test; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class SmartStepIntoTestGenerated extends AbstractSmartStepIntoTest { } public void testAllFilesPresentInSmartStepInto() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/smartStepInto"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/smartStepInto"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("annotation.kt") diff --git a/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/XCoroutinesStackTraceTestGenerated.java b/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/XCoroutinesStackTraceTestGenerated.java index e0d92f91886..758d9f93b5e 100644 --- a/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/XCoroutinesStackTraceTestGenerated.java +++ b/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/XCoroutinesStackTraceTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.debugger.test; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class XCoroutinesStackTraceTestGenerated extends AbstractXCoroutinesStack } public void testAllFilesPresentInXcoroutines() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/xcoroutines"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/xcoroutines"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("coroutineSuspendFun.kt") diff --git a/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/sequence/exec/SequenceTraceTestCaseGenerated.java b/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/sequence/exec/SequenceTraceTestCaseGenerated.java index f1ac5db3701..0da64e99e7b 100644 --- a/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/sequence/exec/SequenceTraceTestCaseGenerated.java +++ b/idea/jvm-debugger/jvm-debugger-test/test/org/jetbrains/kotlin/idea/debugger/test/sequence/exec/SequenceTraceTestCaseGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.debugger.test.sequence.exec; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class SequenceTraceTestCaseGenerated extends AbstractSequenceTraceTestCas } public void testAllFilesPresentInSequence() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/sequence/streams/sequence"), Pattern.compile("^(.+)\\.kt$"), null, true, "terminal"); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/sequence/streams/sequence"), Pattern.compile("^(.+)\\.kt$"), null, true, "terminal"); } @TestMetadata("idea/jvm-debugger/jvm-debugger-test/testData/sequence/streams/sequence/append") @@ -37,7 +38,7 @@ public class SequenceTraceTestCaseGenerated extends AbstractSequenceTraceTestCas } public void testAllFilesPresentInAppend() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/sequence/streams/sequence/append"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/sequence/streams/sequence/append"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("PlusArray.kt") @@ -70,7 +71,7 @@ public class SequenceTraceTestCaseGenerated extends AbstractSequenceTraceTestCas } public void testAllFilesPresentInDistinct() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/sequence/streams/sequence/distinct"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/sequence/streams/sequence/distinct"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Distinct.kt") @@ -118,7 +119,7 @@ public class SequenceTraceTestCaseGenerated extends AbstractSequenceTraceTestCas } public void testAllFilesPresentInFilter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/sequence/streams/sequence/filter"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/sequence/streams/sequence/filter"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Drop.kt") @@ -181,7 +182,7 @@ public class SequenceTraceTestCaseGenerated extends AbstractSequenceTraceTestCas } public void testAllFilesPresentInFlatMap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/sequence/streams/sequence/flatMap"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/sequence/streams/sequence/flatMap"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("FlatMap.kt") @@ -204,7 +205,7 @@ public class SequenceTraceTestCaseGenerated extends AbstractSequenceTraceTestCas } public void testAllFilesPresentInMap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/sequence/streams/sequence/map"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/sequence/streams/sequence/map"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Map.kt") @@ -237,7 +238,7 @@ public class SequenceTraceTestCaseGenerated extends AbstractSequenceTraceTestCas } public void testAllFilesPresentInMisc() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/sequence/streams/sequence/misc"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/sequence/streams/sequence/misc"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("AsSequence.kt") @@ -325,7 +326,7 @@ public class SequenceTraceTestCaseGenerated extends AbstractSequenceTraceTestCas } public void testAllFilesPresentInSort() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/sequence/streams/sequence/sort"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/jvm-debugger/jvm-debugger-test/testData/sequence/streams/sequence/sort"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Sorted.kt") diff --git a/idea/performanceTests/test/org/jetbrains/kotlin/idea/perf/PerformanceAddImportTestGenerated.java b/idea/performanceTests/test/org/jetbrains/kotlin/idea/perf/PerformanceAddImportTestGenerated.java index 170bc2cfc4e..525c5ad9cfe 100644 --- a/idea/performanceTests/test/org/jetbrains/kotlin/idea/perf/PerformanceAddImportTestGenerated.java +++ b/idea/performanceTests/test/org/jetbrains/kotlin/idea/perf/PerformanceAddImportTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.perf; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class PerformanceAddImportTestGenerated extends AbstractPerformanceAddImp } public void testAllFilesPresentInAddImport() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/addImport"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/addImport"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("CannotImportClass1.kt") diff --git a/idea/performanceTests/test/org/jetbrains/kotlin/idea/perf/PerformanceBasicCompletionHandlerTestGenerated.java b/idea/performanceTests/test/org/jetbrains/kotlin/idea/perf/PerformanceBasicCompletionHandlerTestGenerated.java index cff818af6b6..7be52c6a9b3 100644 --- a/idea/performanceTests/test/org/jetbrains/kotlin/idea/perf/PerformanceBasicCompletionHandlerTestGenerated.java +++ b/idea/performanceTests/test/org/jetbrains/kotlin/idea/perf/PerformanceBasicCompletionHandlerTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.perf; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -30,7 +31,7 @@ public class PerformanceBasicCompletionHandlerTestGenerated extends AbstractPerf } public void testAllFilesPresentInBasic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("ClassKeywordBeforeName.kt") @@ -247,7 +248,7 @@ public class PerformanceBasicCompletionHandlerTestGenerated extends AbstractPerf } public void testAllFilesPresentInAnnotation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/annotation"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/annotation"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("AnnotationInBrackets.kt") @@ -280,7 +281,7 @@ public class PerformanceBasicCompletionHandlerTestGenerated extends AbstractPerf } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/callableReference"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/callableReference"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("ClassConstructor.kt") @@ -343,7 +344,7 @@ public class PerformanceBasicCompletionHandlerTestGenerated extends AbstractPerf } public void testAllFilesPresentInExclChar() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/exclChar"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/exclChar"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } } @@ -356,7 +357,7 @@ public class PerformanceBasicCompletionHandlerTestGenerated extends AbstractPerf } public void testAllFilesPresentInExtensionMethodInObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/extensionMethodInObject"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/extensionMethodInObject"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("CompanionObjectInSameFileExplicitReceiver.kt") @@ -409,7 +410,7 @@ public class PerformanceBasicCompletionHandlerTestGenerated extends AbstractPerf } public void testAllFilesPresentInHighOrderFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/highOrderFunctions"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/highOrderFunctions"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("ContextVariable.kt") @@ -537,7 +538,7 @@ public class PerformanceBasicCompletionHandlerTestGenerated extends AbstractPerf } public void testAllFilesPresentInImportAliases() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/importAliases"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/importAliases"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("CompanionObject.kt") @@ -605,7 +606,7 @@ public class PerformanceBasicCompletionHandlerTestGenerated extends AbstractPerf } public void testAllFilesPresentInOverride() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/override"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/override"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("ExpectClassValOverride.kt") @@ -703,7 +704,7 @@ public class PerformanceBasicCompletionHandlerTestGenerated extends AbstractPerf } public void testAllFilesPresentInParameterNameAndType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/parameterNameAndType"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/parameterNameAndType"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("CodeStyleSettings.kt") @@ -781,7 +782,7 @@ public class PerformanceBasicCompletionHandlerTestGenerated extends AbstractPerf } public void testAllFilesPresentInStaticMemberOfNotImported() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/staticMemberOfNotImported"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/staticMemberOfNotImported"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("AmbigiousExtension.kt") @@ -819,7 +820,7 @@ public class PerformanceBasicCompletionHandlerTestGenerated extends AbstractPerf } public void testAllFilesPresentInStaticMembers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/staticMembers"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/staticMembers"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("classObjectMethod.kt") @@ -897,7 +898,7 @@ public class PerformanceBasicCompletionHandlerTestGenerated extends AbstractPerf } public void testAllFilesPresentInStringTemplate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/stringTemplate"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/stringTemplate"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("GlobalVal.kt") @@ -950,7 +951,7 @@ public class PerformanceBasicCompletionHandlerTestGenerated extends AbstractPerf } public void testAllFilesPresentInTypeArgsForCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/typeArgsForCall"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/basic/typeArgsForCall"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("ExpectedTypeDoesNotHelp.kt") diff --git a/idea/performanceTests/test/org/jetbrains/kotlin/idea/perf/PerformanceCompletionCharFilterTestGenerated.java b/idea/performanceTests/test/org/jetbrains/kotlin/idea/perf/PerformanceCompletionCharFilterTestGenerated.java index bba87ccbeb2..c3d7c931b51 100644 --- a/idea/performanceTests/test/org/jetbrains/kotlin/idea/perf/PerformanceCompletionCharFilterTestGenerated.java +++ b/idea/performanceTests/test/org/jetbrains/kotlin/idea/perf/PerformanceCompletionCharFilterTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.perf; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class PerformanceCompletionCharFilterTestGenerated extends AbstractPerfor } public void testAllFilesPresentInCharFilter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/charFilter"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/charFilter"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("Colon.kt") diff --git a/idea/performanceTests/test/org/jetbrains/kotlin/idea/perf/PerformanceCompletionIncrementalResolveTestGenerated.java b/idea/performanceTests/test/org/jetbrains/kotlin/idea/perf/PerformanceCompletionIncrementalResolveTestGenerated.java index 4def01c89d9..0e5d2e6075f 100644 --- a/idea/performanceTests/test/org/jetbrains/kotlin/idea/perf/PerformanceCompletionIncrementalResolveTestGenerated.java +++ b/idea/performanceTests/test/org/jetbrains/kotlin/idea/perf/PerformanceCompletionIncrementalResolveTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.perf; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class PerformanceCompletionIncrementalResolveTestGenerated extends Abstra } public void testAllFilesPresentInIncrementalResolve() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/incrementalResolve"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/incrementalResolve"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("codeAboveChanged.kt") diff --git a/idea/performanceTests/test/org/jetbrains/kotlin/idea/perf/PerformanceHighlightingTestGenerated.java b/idea/performanceTests/test/org/jetbrains/kotlin/idea/perf/PerformanceHighlightingTestGenerated.java index 04ea5832cdb..936dc925a7e 100644 --- a/idea/performanceTests/test/org/jetbrains/kotlin/idea/perf/PerformanceHighlightingTestGenerated.java +++ b/idea/performanceTests/test/org/jetbrains/kotlin/idea/perf/PerformanceHighlightingTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.perf; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class PerformanceHighlightingTestGenerated extends AbstractPerformanceHig } public void testAllFilesPresentInHighlighter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/highlighter"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/highlighter"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Annotations.kt") @@ -177,7 +178,7 @@ public class PerformanceHighlightingTestGenerated extends AbstractPerformanceHig } public void testAllFilesPresentInDeprecated() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/highlighter/deprecated"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/highlighter/deprecated"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Class.kt") diff --git a/idea/performanceTests/test/org/jetbrains/kotlin/idea/perf/PerformanceJavaToKotlinCopyPasteConversionTestGenerated.java b/idea/performanceTests/test/org/jetbrains/kotlin/idea/perf/PerformanceJavaToKotlinCopyPasteConversionTestGenerated.java index f6dad3c3c11..7b31d208b40 100644 --- a/idea/performanceTests/test/org/jetbrains/kotlin/idea/perf/PerformanceJavaToKotlinCopyPasteConversionTestGenerated.java +++ b/idea/performanceTests/test/org/jetbrains/kotlin/idea/perf/PerformanceJavaToKotlinCopyPasteConversionTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.perf; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -60,7 +61,7 @@ public class PerformanceJavaToKotlinCopyPasteConversionTestGenerated extends Abs } public void testAllFilesPresentInConversion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/copyPaste/conversion"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/copyPaste/conversion"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("Arithmetic.java") diff --git a/idea/performanceTests/test/org/jetbrains/kotlin/idea/perf/PerformanceKeywordCompletionHandlerTestGenerated.java b/idea/performanceTests/test/org/jetbrains/kotlin/idea/perf/PerformanceKeywordCompletionHandlerTestGenerated.java index 406b3942085..d34495ddd65 100644 --- a/idea/performanceTests/test/org/jetbrains/kotlin/idea/perf/PerformanceKeywordCompletionHandlerTestGenerated.java +++ b/idea/performanceTests/test/org/jetbrains/kotlin/idea/perf/PerformanceKeywordCompletionHandlerTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.perf; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -30,7 +31,7 @@ public class PerformanceKeywordCompletionHandlerTestGenerated extends AbstractPe } public void testAllFilesPresentInKeywords() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/keywords"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/keywords"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Break.kt") diff --git a/idea/performanceTests/test/org/jetbrains/kotlin/idea/perf/PerformanceLiteralKotlinToKotlinCopyPasteTestGenerated.java b/idea/performanceTests/test/org/jetbrains/kotlin/idea/perf/PerformanceLiteralKotlinToKotlinCopyPasteTestGenerated.java index 3608da192a0..aad67210fb1 100644 --- a/idea/performanceTests/test/org/jetbrains/kotlin/idea/perf/PerformanceLiteralKotlinToKotlinCopyPasteTestGenerated.java +++ b/idea/performanceTests/test/org/jetbrains/kotlin/idea/perf/PerformanceLiteralKotlinToKotlinCopyPasteTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.perf; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class PerformanceLiteralKotlinToKotlinCopyPasteTestGenerated extends Abst } public void testAllFilesPresentInLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/copyPaste/literal"), Pattern.compile("^([^\\.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/copyPaste/literal"), Pattern.compile("^([^\\.]+)\\.kt$"), null, true); } @TestMetadata("CollectionLiteralReference.kt") diff --git a/idea/performanceTests/test/org/jetbrains/kotlin/idea/perf/PerformanceNewJavaToKotlinCopyPasteConversionTestGenerated.java b/idea/performanceTests/test/org/jetbrains/kotlin/idea/perf/PerformanceNewJavaToKotlinCopyPasteConversionTestGenerated.java index 2a0c83e68f7..22eba79b560 100644 --- a/idea/performanceTests/test/org/jetbrains/kotlin/idea/perf/PerformanceNewJavaToKotlinCopyPasteConversionTestGenerated.java +++ b/idea/performanceTests/test/org/jetbrains/kotlin/idea/perf/PerformanceNewJavaToKotlinCopyPasteConversionTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.perf; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -60,7 +61,7 @@ public class PerformanceNewJavaToKotlinCopyPasteConversionTestGenerated extends } public void testAllFilesPresentInConversion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/copyPaste/conversion"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/copyPaste/conversion"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("Arithmetic.java") diff --git a/idea/performanceTests/test/org/jetbrains/kotlin/idea/perf/PerformanceSmartCompletionHandlerTestGenerated.java b/idea/performanceTests/test/org/jetbrains/kotlin/idea/perf/PerformanceSmartCompletionHandlerTestGenerated.java index d1d5d499f3b..b0e4228992a 100644 --- a/idea/performanceTests/test/org/jetbrains/kotlin/idea/perf/PerformanceSmartCompletionHandlerTestGenerated.java +++ b/idea/performanceTests/test/org/jetbrains/kotlin/idea/perf/PerformanceSmartCompletionHandlerTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.perf; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -50,7 +51,7 @@ public class PerformanceSmartCompletionHandlerTestGenerated extends AbstractPerf } public void testAllFilesPresentInSmart() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/smart"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/smart"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("AnonymousObject1.kt") @@ -762,7 +763,7 @@ public class PerformanceSmartCompletionHandlerTestGenerated extends AbstractPerf } public void testAllFilesPresentInLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/smart/lambda"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/smart/lambda"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("InsertImport.kt") @@ -790,7 +791,7 @@ public class PerformanceSmartCompletionHandlerTestGenerated extends AbstractPerf } public void testAllFilesPresentInLambdaSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/smart/lambdaSignature"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/smart/lambdaSignature"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("NoAdditionalSpace.kt") @@ -813,7 +814,7 @@ public class PerformanceSmartCompletionHandlerTestGenerated extends AbstractPerf } public void testAllFilesPresentInSuspendLambdaSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/smart/suspendLambdaSignature"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/smart/suspendLambdaSignature"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("NoAdditionalSpace.kt") diff --git a/idea/performanceTests/test/org/jetbrains/kotlin/idea/perf/PerformanceTypingIndentationTestGenerated.java b/idea/performanceTests/test/org/jetbrains/kotlin/idea/perf/PerformanceTypingIndentationTestGenerated.java index 0d3745feae0..cbaa6d2e6ee 100644 --- a/idea/performanceTests/test/org/jetbrains/kotlin/idea/perf/PerformanceTypingIndentationTestGenerated.java +++ b/idea/performanceTests/test/org/jetbrains/kotlin/idea/perf/PerformanceTypingIndentationTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.perf; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -70,7 +71,7 @@ public class PerformanceTypingIndentationTestGenerated extends AbstractPerforman } public void testAllFilesPresentInIndentationOnNewline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); } @TestMetadata("Annotation.kt") @@ -262,7 +263,7 @@ public class PerformanceTypingIndentationTestGenerated extends AbstractPerforman } public void testAllFilesPresentInArrayAccess() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/arrayAccess"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/arrayAccess"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); } @TestMetadata("listAccess.kt") @@ -280,7 +281,7 @@ public class PerformanceTypingIndentationTestGenerated extends AbstractPerforman } public void testAllFilesPresentInControlFlowConstructions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/controlFlowConstructions"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/controlFlowConstructions"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); } @TestMetadata("Catch.kt") @@ -553,7 +554,7 @@ public class PerformanceTypingIndentationTestGenerated extends AbstractPerforman } public void testAllFilesPresentInElvis() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/elvis"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/elvis"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); } @TestMetadata("BeforeElvis.kt") @@ -576,7 +577,7 @@ public class PerformanceTypingIndentationTestGenerated extends AbstractPerforman } public void testAllFilesPresentInEmptyBraces() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/emptyBraces"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/emptyBraces"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); } @TestMetadata("ClassWithConstructor.kt") @@ -634,7 +635,7 @@ public class PerformanceTypingIndentationTestGenerated extends AbstractPerforman } public void testAllFilesPresentInEmptyParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/emptyParameters"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/emptyParameters"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); } @TestMetadata("EmptyArgumentInCallByArrayAccess.kt") @@ -932,7 +933,7 @@ public class PerformanceTypingIndentationTestGenerated extends AbstractPerforman } public void testAllFilesPresentInEmptyParenthesisInBinaryExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/emptyParenthesisInBinaryExpression"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/emptyParenthesisInBinaryExpression"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); } @TestMetadata("AssignmentAfterEq.kt") @@ -1060,7 +1061,7 @@ public class PerformanceTypingIndentationTestGenerated extends AbstractPerforman } public void testAllFilesPresentInExpressionBody() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/expressionBody"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/expressionBody"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); } @TestMetadata("FunctionWithExplicitType.kt") @@ -1118,7 +1119,7 @@ public class PerformanceTypingIndentationTestGenerated extends AbstractPerforman } public void testAllFilesPresentInScript() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/script"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/script"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); } @TestMetadata("ScriptAfterClosingBrace.kts") @@ -1161,7 +1162,7 @@ public class PerformanceTypingIndentationTestGenerated extends AbstractPerforman } public void testAllFilesPresentInTemplates() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/templates"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/templates"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); } @TestMetadata("LargeFileWithStringTemplate.kt") diff --git a/idea/scripting-support/test/org/jetbrains/kotlin/idea/scratch/ScratchLineMarkersTestGenerated.java b/idea/scripting-support/test/org/jetbrains/kotlin/idea/scratch/ScratchLineMarkersTestGenerated.java index 1ce83e6e4a4..2024a6f0b6d 100644 --- a/idea/scripting-support/test/org/jetbrains/kotlin/idea/scratch/ScratchLineMarkersTestGenerated.java +++ b/idea/scripting-support/test/org/jetbrains/kotlin/idea/scratch/ScratchLineMarkersTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.scratch; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class ScratchLineMarkersTestGenerated extends AbstractScratchLineMarkersT } public void testAllFilesPresentInLineMarker() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/scripting-support/testData/scratch/lineMarker"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/scripting-support/testData/scratch/lineMarker"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("binaryExpression.kts") diff --git a/idea/scripting-support/test/org/jetbrains/kotlin/idea/scratch/ScratchRunActionTestGenerated.java b/idea/scripting-support/test/org/jetbrains/kotlin/idea/scratch/ScratchRunActionTestGenerated.java index 41945b9d85f..58a941e2496 100644 --- a/idea/scripting-support/test/org/jetbrains/kotlin/idea/scratch/ScratchRunActionTestGenerated.java +++ b/idea/scripting-support/test/org/jetbrains/kotlin/idea/scratch/ScratchRunActionTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.scratch; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -27,7 +28,7 @@ public class ScratchRunActionTestGenerated extends AbstractScratchRunActionTest } public void testAllFilesPresentInScratchCompiling() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/scripting-support/testData/scratch"), Pattern.compile("^(.+)\\.kts$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/scripting-support/testData/scratch"), Pattern.compile("^(.+)\\.kts$"), null, false); } @TestMetadata("for.kts") @@ -115,7 +116,7 @@ public class ScratchRunActionTestGenerated extends AbstractScratchRunActionTest } public void testAllFilesPresentInScratchRepl() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/scripting-support/testData/scratch"), Pattern.compile("^(.+)\\.kts$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/scripting-support/testData/scratch"), Pattern.compile("^(.+)\\.kts$"), null, false); } @TestMetadata("for.kts") @@ -203,7 +204,7 @@ public class ScratchRunActionTestGenerated extends AbstractScratchRunActionTest } public void testAllFilesPresentInScratchMultiFile() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/scripting-support/testData/scratch/multiFile"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/scripting-support/testData/scratch/multiFile"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("inlineFun") @@ -226,7 +227,7 @@ public class ScratchRunActionTestGenerated extends AbstractScratchRunActionTest } public void testAllFilesPresentInWorksheetCompiling() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/scripting-support/testData/worksheet"), Pattern.compile("^(.+)\\.ws.kts$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/scripting-support/testData/worksheet"), Pattern.compile("^(.+)\\.ws.kts$"), null, false); } @TestMetadata("simpleScriptRuntime.ws.kts") @@ -244,7 +245,7 @@ public class ScratchRunActionTestGenerated extends AbstractScratchRunActionTest } public void testAllFilesPresentInWorksheetRepl() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/scripting-support/testData/worksheet"), Pattern.compile("^(.+)\\.ws.kts$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/scripting-support/testData/worksheet"), Pattern.compile("^(.+)\\.ws.kts$"), null, false); } @TestMetadata("simpleScriptRuntime.ws.kts") @@ -262,7 +263,7 @@ public class ScratchRunActionTestGenerated extends AbstractScratchRunActionTest } public void testAllFilesPresentInWorksheetMultiFile() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/scripting-support/testData/worksheet/multiFile"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/scripting-support/testData/worksheet/multiFile"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("inlineFunScriptRuntime") @@ -285,7 +286,7 @@ public class ScratchRunActionTestGenerated extends AbstractScratchRunActionTest } public void testAllFilesPresentInScratchRightPanelOutput() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/scripting-support/testData/scratch/rightPanelOutput"), Pattern.compile("^(.+)\\.kts$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/scripting-support/testData/scratch/rightPanelOutput"), Pattern.compile("^(.+)\\.kts$"), null, false); } @TestMetadata("bigSequentialOutputs.kts") diff --git a/idea/scripting-support/test/org/jetbrains/kotlin/idea/script/ScriptTemplatesFromDependenciesTestGenerated.java b/idea/scripting-support/test/org/jetbrains/kotlin/idea/script/ScriptTemplatesFromDependenciesTestGenerated.java index 105cc6349ca..894e6d121b7 100644 --- a/idea/scripting-support/test/org/jetbrains/kotlin/idea/script/ScriptTemplatesFromDependenciesTestGenerated.java +++ b/idea/scripting-support/test/org/jetbrains/kotlin/idea/script/ScriptTemplatesFromDependenciesTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.script; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class ScriptTemplatesFromDependenciesTestGenerated extends AbstractScript } public void testAllFilesPresentInTemplatesFromDependencies() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/scripting-support/testData/script/templatesFromDependencies"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/scripting-support/testData/script/templatesFromDependencies"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("inJar") diff --git a/idea/tests/org/jetbrains/kotlin/DataFlowValueRenderingTestGenerated.java b/idea/tests/org/jetbrains/kotlin/DataFlowValueRenderingTestGenerated.java index c1d049d72cb..39f22c6fb31 100644 --- a/idea/tests/org/jetbrains/kotlin/DataFlowValueRenderingTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/DataFlowValueRenderingTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class DataFlowValueRenderingTestGenerated extends AbstractDataFlowValueRe } public void testAllFilesPresentInDataFlowValueRendering() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/dataFlowValueRendering"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/dataFlowValueRendering"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("classProperty.kt") diff --git a/idea/tests/org/jetbrains/kotlin/addImport/AddImportTestGenerated.java b/idea/tests/org/jetbrains/kotlin/addImport/AddImportTestGenerated.java index dfe85913370..25804e2336c 100644 --- a/idea/tests/org/jetbrains/kotlin/addImport/AddImportTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/addImport/AddImportTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.addImport; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class AddImportTestGenerated extends AbstractAddImportTest { } public void testAllFilesPresentInAddImport() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/addImport"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/addImport"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("CannotImportClass1.kt") diff --git a/idea/tests/org/jetbrains/kotlin/addImportAlias/AddImportAliasTestGenerated.java b/idea/tests/org/jetbrains/kotlin/addImportAlias/AddImportAliasTestGenerated.java index aa31a6aa721..a6504bd13a7 100644 --- a/idea/tests/org/jetbrains/kotlin/addImportAlias/AddImportAliasTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/addImportAlias/AddImportAliasTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.addImportAlias; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class AddImportAliasTestGenerated extends AbstractAddImportAliasTest { } public void testAllFilesPresentInAddImportAlias() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/addImportAlias"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/addImportAlias"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("JavaAlias.kt") diff --git a/idea/tests/org/jetbrains/kotlin/asJava/classes/UltraLightClassLoadingTestGenerated.java b/idea/tests/org/jetbrains/kotlin/asJava/classes/UltraLightClassLoadingTestGenerated.java index c5ada24b6db..f8137a90ff4 100644 --- a/idea/tests/org/jetbrains/kotlin/asJava/classes/UltraLightClassLoadingTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/asJava/classes/UltraLightClassLoadingTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.asJava.classes; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class UltraLightClassLoadingTestGenerated extends AbstractUltraLightClass } public void testAllFilesPresentInUltraLightClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/ultraLightClasses"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/ultraLightClasses"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("annotationWithSetParamPropertyModifier.kt") diff --git a/idea/tests/org/jetbrains/kotlin/asJava/classes/UltraLightClassSanityTestGenerated.java b/idea/tests/org/jetbrains/kotlin/asJava/classes/UltraLightClassSanityTestGenerated.java index 660fef98e8f..27d9a8ce67c 100644 --- a/idea/tests/org/jetbrains/kotlin/asJava/classes/UltraLightClassSanityTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/asJava/classes/UltraLightClassSanityTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.asJava.classes; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class UltraLightClassSanityTestGenerated extends AbstractUltraLightClassS } public void testAllFilesPresentInLightClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("AnnotatedParameterInEnumConstructor.kt") @@ -177,7 +178,7 @@ public class UltraLightClassSanityTestGenerated extends AbstractUltraLightClassS } public void testAllFilesPresentInCompilationErrors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/compilationErrors"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/compilationErrors"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("AllInlineOnly.kt") @@ -270,7 +271,7 @@ public class UltraLightClassSanityTestGenerated extends AbstractUltraLightClassS } public void testAllFilesPresentInDelegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/delegation"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/delegation"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("Function.kt") @@ -298,7 +299,7 @@ public class UltraLightClassSanityTestGenerated extends AbstractUltraLightClassS } public void testAllFilesPresentInFacades() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/facades"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/facades"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("AllPrivate.kt") @@ -336,7 +337,7 @@ public class UltraLightClassSanityTestGenerated extends AbstractUltraLightClassS } public void testAllFilesPresentInIdeRegression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/ideRegression"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/ideRegression"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("AllOpenAnnotatedClasses.kt") @@ -404,7 +405,7 @@ public class UltraLightClassSanityTestGenerated extends AbstractUltraLightClassS } public void testAllFilesPresentInNullabilityAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/nullabilityAnnotations"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/nullabilityAnnotations"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("Class.kt") @@ -507,7 +508,7 @@ public class UltraLightClassSanityTestGenerated extends AbstractUltraLightClassS } public void testAllFilesPresentInObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/object"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/object"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("SimpleObject.kt") @@ -525,7 +526,7 @@ public class UltraLightClassSanityTestGenerated extends AbstractUltraLightClassS } public void testAllFilesPresentInPublicField() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/publicField"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/publicField"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("CompanionObject.kt") @@ -548,7 +549,7 @@ public class UltraLightClassSanityTestGenerated extends AbstractUltraLightClassS } public void testAllFilesPresentInScript() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/script"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/script"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("HelloWorld.kts") diff --git a/idea/tests/org/jetbrains/kotlin/asJava/classes/UltraLightFacadeClassTestGenerated.java b/idea/tests/org/jetbrains/kotlin/asJava/classes/UltraLightFacadeClassTestGenerated.java index 6d55267b12d..48bcd4d4c84 100644 --- a/idea/tests/org/jetbrains/kotlin/asJava/classes/UltraLightFacadeClassTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/asJava/classes/UltraLightFacadeClassTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.asJava.classes; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class UltraLightFacadeClassTestGenerated extends AbstractUltraLightFacade } public void testAllFilesPresentInUltraLightFacades() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/ultraLightFacades"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/ultraLightFacades"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("coroutines.kt") diff --git a/idea/tests/org/jetbrains/kotlin/asJava/classes/UltraLightScriptLoadingTestGenerated.java b/idea/tests/org/jetbrains/kotlin/asJava/classes/UltraLightScriptLoadingTestGenerated.java index caab4e55ace..2fec318c54d 100644 --- a/idea/tests/org/jetbrains/kotlin/asJava/classes/UltraLightScriptLoadingTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/asJava/classes/UltraLightScriptLoadingTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.asJava.classes; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class UltraLightScriptLoadingTestGenerated extends AbstractUltraLightScri } public void testAllFilesPresentInUltraLightScripts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/ultraLightScripts"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/ultraLightScripts"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("FunsPropsAndFields.kts") diff --git a/idea/tests/org/jetbrains/kotlin/checkers/JavaAgainstKotlinBinariesCheckerTestGenerated.java b/idea/tests/org/jetbrains/kotlin/checkers/JavaAgainstKotlinBinariesCheckerTestGenerated.java index abf3d8c43ca..9ddff115850 100644 --- a/idea/tests/org/jetbrains/kotlin/checkers/JavaAgainstKotlinBinariesCheckerTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/checkers/JavaAgainstKotlinBinariesCheckerTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.checkers; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class JavaAgainstKotlinBinariesCheckerTestGenerated extends AbstractJavaA } public void testAllFilesPresentInJavaAgainstKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/kotlinAndJavaChecker/javaAgainstKotlin"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/kotlinAndJavaChecker/javaAgainstKotlin"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("AssignKotlinClassToObjectInJava.kt") diff --git a/idea/tests/org/jetbrains/kotlin/checkers/JavaAgainstKotlinSourceCheckerTestGenerated.java b/idea/tests/org/jetbrains/kotlin/checkers/JavaAgainstKotlinSourceCheckerTestGenerated.java index bf86d87ae46..66740bfa5cf 100644 --- a/idea/tests/org/jetbrains/kotlin/checkers/JavaAgainstKotlinSourceCheckerTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/checkers/JavaAgainstKotlinSourceCheckerTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.checkers; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -27,7 +28,7 @@ public class JavaAgainstKotlinSourceCheckerTestGenerated extends AbstractJavaAga } public void testAllFilesPresentInJavaAgainstKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/kotlinAndJavaChecker/javaAgainstKotlin"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/kotlinAndJavaChecker/javaAgainstKotlin"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("AssignKotlinClassToObjectInJava.kt") @@ -210,7 +211,7 @@ public class JavaAgainstKotlinSourceCheckerTestGenerated extends AbstractJavaAga } public void testAllFilesPresentInJavaWithKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/kotlinAndJavaChecker/javaWithKotlin"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/kotlinAndJavaChecker/javaWithKotlin"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("InnerClassWithoutName.kt") diff --git a/idea/tests/org/jetbrains/kotlin/checkers/JavaAgainstKotlinSourceCheckerWithoutUltraLightTestGenerated.java b/idea/tests/org/jetbrains/kotlin/checkers/JavaAgainstKotlinSourceCheckerWithoutUltraLightTestGenerated.java index 634a7cc0227..20d0a4fa8c3 100644 --- a/idea/tests/org/jetbrains/kotlin/checkers/JavaAgainstKotlinSourceCheckerWithoutUltraLightTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/checkers/JavaAgainstKotlinSourceCheckerWithoutUltraLightTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.checkers; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -27,7 +28,7 @@ public class JavaAgainstKotlinSourceCheckerWithoutUltraLightTestGenerated extend } public void testAllFilesPresentInJavaAgainstKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/kotlinAndJavaChecker/javaAgainstKotlin"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/kotlinAndJavaChecker/javaAgainstKotlin"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("AssignKotlinClassToObjectInJava.kt") @@ -210,7 +211,7 @@ public class JavaAgainstKotlinSourceCheckerWithoutUltraLightTestGenerated extend } public void testAllFilesPresentInJavaWithKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/kotlinAndJavaChecker/javaWithKotlin"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/kotlinAndJavaChecker/javaWithKotlin"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("InnerClassWithoutName.kt") diff --git a/idea/tests/org/jetbrains/kotlin/checkers/JsCheckerTestGenerated.java b/idea/tests/org/jetbrains/kotlin/checkers/JsCheckerTestGenerated.java index cebee2b7bfe..75608eedd8d 100644 --- a/idea/tests/org/jetbrains/kotlin/checkers/JsCheckerTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/checkers/JsCheckerTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.checkers; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class JsCheckerTestGenerated extends AbstractJsCheckerTest { } public void testAllFilesPresentInJs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/checker/js"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/checker/js"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("basic.kt") diff --git a/idea/tests/org/jetbrains/kotlin/checkers/PsiCheckerTestGenerated.java b/idea/tests/org/jetbrains/kotlin/checkers/PsiCheckerTestGenerated.java index 5dcc2c5fc6e..3a6ffcd766b 100644 --- a/idea/tests/org/jetbrains/kotlin/checkers/PsiCheckerTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/checkers/PsiCheckerTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.checkers; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -32,7 +33,7 @@ public class PsiCheckerTestGenerated extends AbstractPsiCheckerTest { } public void testAllFilesPresentInChecker() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/checker"), Pattern.compile("^(.+)\\.kt$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/checker"), Pattern.compile("^(.+)\\.kt$"), null, false); } @TestMetadata("AnnotationOnFile.kt") @@ -370,7 +371,7 @@ public class PsiCheckerTestGenerated extends AbstractPsiCheckerTest { } public void testAllFilesPresentInRegression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/checker/regression"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/checker/regression"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("AmbiguityOnLazyTypeComputation.kt") @@ -613,7 +614,7 @@ public class PsiCheckerTestGenerated extends AbstractPsiCheckerTest { } public void testAllFilesPresentInRecovery() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/checker/recovery"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/checker/recovery"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("namelessMembers.kt") @@ -641,7 +642,7 @@ public class PsiCheckerTestGenerated extends AbstractPsiCheckerTest { } public void testAllFilesPresentInRendering() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/checker/rendering"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/checker/rendering"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("TypeInferenceError.kt") @@ -659,7 +660,7 @@ public class PsiCheckerTestGenerated extends AbstractPsiCheckerTest { } public void testAllFilesPresentInScripts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/checker/scripts"), Pattern.compile("^(.+)\\.kts$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/checker/scripts"), Pattern.compile("^(.+)\\.kts$"), null, true); } @TestMetadata("if.kts") @@ -692,7 +693,7 @@ public class PsiCheckerTestGenerated extends AbstractPsiCheckerTest { } public void testAllFilesPresentInDuplicateJvmSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/checker/duplicateJvmSignature"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/checker/duplicateJvmSignature"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("idea/testData/checker/duplicateJvmSignature/fields") @@ -704,7 +705,7 @@ public class PsiCheckerTestGenerated extends AbstractPsiCheckerTest { } public void testAllFilesPresentInFields() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/checker/duplicateJvmSignature/fields"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/checker/duplicateJvmSignature/fields"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("classObjectCopiedFieldObject.kt") @@ -722,7 +723,7 @@ public class PsiCheckerTestGenerated extends AbstractPsiCheckerTest { } public void testAllFilesPresentInFunctionAndProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/checker/duplicateJvmSignature/functionAndProperty"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/checker/duplicateJvmSignature/functionAndProperty"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ambiguous.kt") @@ -785,7 +786,7 @@ public class PsiCheckerTestGenerated extends AbstractPsiCheckerTest { } public void testAllFilesPresentInTraitImpl() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/checker/duplicateJvmSignature/traitImpl"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/checker/duplicateJvmSignature/traitImpl"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("twoTraits.kt") @@ -804,7 +805,7 @@ public class PsiCheckerTestGenerated extends AbstractPsiCheckerTest { } public void testAllFilesPresentInInfos() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/checker/infos"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/checker/infos"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("CapturedConstructorParameter.kt") @@ -897,7 +898,7 @@ public class PsiCheckerTestGenerated extends AbstractPsiCheckerTest { } public void testAllFilesPresentInDiagnosticsMessage() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/checker/diagnosticsMessage"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/checker/diagnosticsMessage"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("fullPackageFQNameOnVisiblityError.kt") diff --git a/idea/tests/org/jetbrains/kotlin/copyright/UpdateKotlinCopyrightTestGenerated.java b/idea/tests/org/jetbrains/kotlin/copyright/UpdateKotlinCopyrightTestGenerated.java index e8c61bd4018..d882a4a5ad6 100644 --- a/idea/tests/org/jetbrains/kotlin/copyright/UpdateKotlinCopyrightTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/copyright/UpdateKotlinCopyrightTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.copyright; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class UpdateKotlinCopyrightTestGenerated extends AbstractUpdateKotlinCopy } public void testAllFilesPresentInCopyright() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/copyright"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/copyright"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("ClassDocComment.kt") diff --git a/idea/tests/org/jetbrains/kotlin/findUsages/FindUsagesTestGenerated.java b/idea/tests/org/jetbrains/kotlin/findUsages/FindUsagesTestGenerated.java index a265b4125eb..4d1f56ef4a6 100644 --- a/idea/tests/org/jetbrains/kotlin/findUsages/FindUsagesTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/findUsages/FindUsagesTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.findUsages; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -27,7 +28,7 @@ public class FindUsagesTestGenerated extends AbstractFindUsagesTest { } public void testAllFilesPresentInKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("idea/testData/findUsages/kotlin/companionObject") @@ -39,7 +40,7 @@ public class FindUsagesTestGenerated extends AbstractFindUsagesTest { } public void testAllFilesPresentInCompanionObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/companionObject"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/companionObject"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("inContainingClass.0.kt") @@ -72,7 +73,7 @@ public class FindUsagesTestGenerated extends AbstractFindUsagesTest { } public void testAllFilesPresentInConventions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/conventions"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/conventions"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("compareTo.0.kt") @@ -169,7 +170,7 @@ public class FindUsagesTestGenerated extends AbstractFindUsagesTest { } public void testAllFilesPresentInComponents() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/conventions/components"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/conventions/components"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("callableReferences.0.kt") @@ -278,7 +279,7 @@ public class FindUsagesTestGenerated extends AbstractFindUsagesTest { } public void testAllFilesPresentInFindClassUsages() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findClassUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findClassUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("classUsedInPlainText.0.kt") @@ -581,7 +582,7 @@ public class FindUsagesTestGenerated extends AbstractFindUsagesTest { } public void testAllFilesPresentInFindFunctionUsages() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findFunctionUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findFunctionUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("enumFunctionUsages.0.kt") @@ -779,7 +780,7 @@ public class FindUsagesTestGenerated extends AbstractFindUsagesTest { } public void testAllFilesPresentInFindJavaPropertyUsages() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findJavaPropertyUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findJavaPropertyUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("javaPropertyUsagesK.0.kt") @@ -807,7 +808,7 @@ public class FindUsagesTestGenerated extends AbstractFindUsagesTest { } public void testAllFilesPresentInFindObjectUsages() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findObjectUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findObjectUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("javaObjectUsages.0.kt") @@ -855,7 +856,7 @@ public class FindUsagesTestGenerated extends AbstractFindUsagesTest { } public void testAllFilesPresentInFindPackageUsages() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findPackageUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findPackageUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("kotlinPackageUsages.0.kt") @@ -873,7 +874,7 @@ public class FindUsagesTestGenerated extends AbstractFindUsagesTest { } public void testAllFilesPresentInFindParameterUsages() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findParameterUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findParameterUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("kotlinAnnotationConstructorParameterUsages.0.kt") @@ -921,7 +922,7 @@ public class FindUsagesTestGenerated extends AbstractFindUsagesTest { } public void testAllFilesPresentInFindPrimaryConstructorUsages() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findPrimaryConstructorUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findPrimaryConstructorUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("annotationEntry.0.kt") @@ -969,7 +970,7 @@ public class FindUsagesTestGenerated extends AbstractFindUsagesTest { } public void testAllFilesPresentInFindPropertyUsages() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findPropertyUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findPropertyUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("extensionPropertyUsages.0.kt") @@ -1127,7 +1128,7 @@ public class FindUsagesTestGenerated extends AbstractFindUsagesTest { } public void testAllFilesPresentInFindSecondaryConstructorUsages() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findSecondaryConstructorUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findSecondaryConstructorUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("constructorCall.0.kt") @@ -1160,7 +1161,7 @@ public class FindUsagesTestGenerated extends AbstractFindUsagesTest { } public void testAllFilesPresentInFindTypeAliasUsages() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findTypeAliasUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findTypeAliasUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("objectAlias.0.kt") @@ -1178,7 +1179,7 @@ public class FindUsagesTestGenerated extends AbstractFindUsagesTest { } public void testAllFilesPresentInFindTypeParameterUsages() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findTypeParameterUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findTypeParameterUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("kotlinClassTypeParameterUsages.0.kt") @@ -1206,7 +1207,7 @@ public class FindUsagesTestGenerated extends AbstractFindUsagesTest { } public void testAllFilesPresentInFindWithFilteringImports() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findWithFilteringImports"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findWithFilteringImports"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("findWithFilteringImports.0.kt") @@ -1224,7 +1225,7 @@ public class FindUsagesTestGenerated extends AbstractFindUsagesTest { } public void testAllFilesPresentInFindWithStructuralGrouping() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findWithStructuralGrouping"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/findWithStructuralGrouping"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("kotlinClassAllUsages.0.kt") @@ -1252,7 +1253,7 @@ public class FindUsagesTestGenerated extends AbstractFindUsagesTest { } public void testAllFilesPresentInInternal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/internal"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/internal"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("idea/testData/findUsages/kotlin/internal/findFunctionUsages") @@ -1264,7 +1265,7 @@ public class FindUsagesTestGenerated extends AbstractFindUsagesTest { } public void testAllFilesPresentInFindFunctionUsages() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/internal/findFunctionUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/internal/findFunctionUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("enumFunctionUsages.0.kt") @@ -1312,7 +1313,7 @@ public class FindUsagesTestGenerated extends AbstractFindUsagesTest { } public void testAllFilesPresentInFindPrimaryConstructorUsages() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/internal/findPrimaryConstructorUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/internal/findPrimaryConstructorUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("constructorCall.0.kt") @@ -1335,7 +1336,7 @@ public class FindUsagesTestGenerated extends AbstractFindUsagesTest { } public void testAllFilesPresentInFindPropertyUsages() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/internal/findPropertyUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/internal/findPropertyUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("kotlinClassObjectPropertyUsage.0.kt") @@ -1368,7 +1369,7 @@ public class FindUsagesTestGenerated extends AbstractFindUsagesTest { } public void testAllFilesPresentInFindSecondaryConstructorUsages() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/internal/findSecondaryConstructorUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/internal/findSecondaryConstructorUsages"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("constructorCall.0.kt") @@ -1397,7 +1398,7 @@ public class FindUsagesTestGenerated extends AbstractFindUsagesTest { } public void testAllFilesPresentInPropertyFiles() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/propertyFiles"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/propertyFiles"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("propertyFileUsagesByRef.0.kt") @@ -1420,7 +1421,7 @@ public class FindUsagesTestGenerated extends AbstractFindUsagesTest { } public void testAllFilesPresentInScript() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/script"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/script"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("anonymousObject.0.kts") @@ -1458,7 +1459,7 @@ public class FindUsagesTestGenerated extends AbstractFindUsagesTest { } public void testAllFilesPresentInUnresolvedAnnotation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/unresolvedAnnotation"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/unresolvedAnnotation"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("unresolvedAnnotation.0.kt") @@ -1476,7 +1477,7 @@ public class FindUsagesTestGenerated extends AbstractFindUsagesTest { } public void testAllFilesPresentInVariable() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/variable"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/variable"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("plusAssignFun.0.kt") @@ -1510,7 +1511,7 @@ public class FindUsagesTestGenerated extends AbstractFindUsagesTest { } public void testAllFilesPresentInJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/java"), Pattern.compile("^(.+)\\.0\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/java"), Pattern.compile("^(.+)\\.0\\.java$"), null, true); } @TestMetadata("idea/testData/findUsages/java/findConstructorUsages") @@ -1522,7 +1523,7 @@ public class FindUsagesTestGenerated extends AbstractFindUsagesTest { } public void testAllFilesPresentInFindConstructorUsages() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/java/findConstructorUsages"), Pattern.compile("^(.+)\\.0\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/java/findConstructorUsages"), Pattern.compile("^(.+)\\.0\\.java$"), null, true); } @TestMetadata("javaConstructorInDelegationCall.0.java") @@ -1565,7 +1566,7 @@ public class FindUsagesTestGenerated extends AbstractFindUsagesTest { } public void testAllFilesPresentInFindJavaClassUsages() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/java/findJavaClassUsages"), Pattern.compile("^(.+)\\.0\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/java/findJavaClassUsages"), Pattern.compile("^(.+)\\.0\\.java$"), null, true); } @TestMetadata("JKAliasedClassAllUsages.0.java") @@ -1693,7 +1694,7 @@ public class FindUsagesTestGenerated extends AbstractFindUsagesTest { } public void testAllFilesPresentInFindJavaFieldUsages() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/java/findJavaFieldUsages"), Pattern.compile("^(.+)\\.0\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/java/findJavaFieldUsages"), Pattern.compile("^(.+)\\.0\\.java$"), null, true); } @TestMetadata("JKFieldUsages.0.java") @@ -1711,7 +1712,7 @@ public class FindUsagesTestGenerated extends AbstractFindUsagesTest { } public void testAllFilesPresentInFindJavaMethodUsages() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/java/findJavaMethodUsages"), Pattern.compile("^(.+)\\.0\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/java/findJavaMethodUsages"), Pattern.compile("^(.+)\\.0\\.java$"), null, true); } @TestMetadata("ConventionUsages.0.java") @@ -1794,7 +1795,7 @@ public class FindUsagesTestGenerated extends AbstractFindUsagesTest { } public void testAllFilesPresentInFindJavaPropertyUsages() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/java/findJavaPropertyUsages"), Pattern.compile("^(.+)\\.0\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/java/findJavaPropertyUsages"), Pattern.compile("^(.+)\\.0\\.java$"), null, true); } @TestMetadata("javaPropertyGetterUsagesKJ.0.java") @@ -1818,7 +1819,7 @@ public class FindUsagesTestGenerated extends AbstractFindUsagesTest { } public void testAllFilesPresentInPropertyFiles() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/propertyFiles"), Pattern.compile("^(.+)\\.0\\.properties$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/propertyFiles"), Pattern.compile("^(.+)\\.0\\.properties$"), null, true); } @TestMetadata("propertyFileUsages.0.properties") diff --git a/idea/tests/org/jetbrains/kotlin/findUsages/FindUsagesWithDisableComponentSearchTestGenerated.java b/idea/tests/org/jetbrains/kotlin/findUsages/FindUsagesWithDisableComponentSearchTestGenerated.java index aa4242e6f4e..6f93d2b2418 100644 --- a/idea/tests/org/jetbrains/kotlin/findUsages/FindUsagesWithDisableComponentSearchTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/findUsages/FindUsagesWithDisableComponentSearchTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.findUsages; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class FindUsagesWithDisableComponentSearchTestGenerated extends AbstractF } public void testAllFilesPresentInComponents() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/conventions/components"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/kotlin/conventions/components"), Pattern.compile("^(.+)\\.0\\.(kt|kts)$"), null, true); } @TestMetadata("callableReferences.0.kt") diff --git a/idea/tests/org/jetbrains/kotlin/findUsages/KotlinFindUsagesWithLibraryTestGenerated.java b/idea/tests/org/jetbrains/kotlin/findUsages/KotlinFindUsagesWithLibraryTestGenerated.java index 3973886b308..d92e634bb5b 100644 --- a/idea/tests/org/jetbrains/kotlin/findUsages/KotlinFindUsagesWithLibraryTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/findUsages/KotlinFindUsagesWithLibraryTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.findUsages; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class KotlinFindUsagesWithLibraryTestGenerated extends AbstractKotlinFind } public void testAllFilesPresentInLibraryUsages() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/libraryUsages"), Pattern.compile("^(.+)\\.0\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/libraryUsages"), Pattern.compile("^(.+)\\.0\\.kt$"), null, true); } @TestMetadata("idea/testData/findUsages/libraryUsages/javaLibrary") @@ -37,7 +38,7 @@ public class KotlinFindUsagesWithLibraryTestGenerated extends AbstractKotlinFind } public void testAllFilesPresentInJavaLibrary() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/libraryUsages/javaLibrary"), Pattern.compile("^(.+)\\.0\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/libraryUsages/javaLibrary"), Pattern.compile("^(.+)\\.0\\.kt$"), null, true); } @TestMetadata("LibraryClassUsages.0.kt") @@ -80,7 +81,7 @@ public class KotlinFindUsagesWithLibraryTestGenerated extends AbstractKotlinFind } public void testAllFilesPresentInKotlinLibrary() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/libraryUsages/kotlinLibrary"), Pattern.compile("^(.+)\\.0\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/libraryUsages/kotlinLibrary"), Pattern.compile("^(.+)\\.0\\.kt$"), null, true); } @TestMetadata("LibraryClassUsages.0.kt") @@ -153,7 +154,7 @@ public class KotlinFindUsagesWithLibraryTestGenerated extends AbstractKotlinFind } public void testAllFilesPresentIn_library() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/libraryUsages/_library"), Pattern.compile("^(.+)\\.0\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/libraryUsages/_library"), Pattern.compile("^(.+)\\.0\\.kt$"), null, true); } @TestMetadata("idea/testData/findUsages/libraryUsages/_library/library") @@ -165,7 +166,7 @@ public class KotlinFindUsagesWithLibraryTestGenerated extends AbstractKotlinFind } public void testAllFilesPresentInLibrary() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/libraryUsages/_library/library"), Pattern.compile("^(.+)\\.0\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/libraryUsages/_library/library"), Pattern.compile("^(.+)\\.0\\.kt$"), null, true); } } } diff --git a/idea/tests/org/jetbrains/kotlin/findUsages/KotlinFindUsagesWithStdlibTestGenerated.java b/idea/tests/org/jetbrains/kotlin/findUsages/KotlinFindUsagesWithStdlibTestGenerated.java index 7887ae11647..c69109cc1d1 100644 --- a/idea/tests/org/jetbrains/kotlin/findUsages/KotlinFindUsagesWithStdlibTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/findUsages/KotlinFindUsagesWithStdlibTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.findUsages; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class KotlinFindUsagesWithStdlibTestGenerated extends AbstractKotlinFindU } public void testAllFilesPresentInStdlibUsages() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/stdlibUsages"), Pattern.compile("^(.+)\\.0\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/findUsages/stdlibUsages"), Pattern.compile("^(.+)\\.0\\.kt$"), null, true); } @TestMetadata("LibraryMemberFunctionUsagesInStdlib.0.kt") diff --git a/idea/tests/org/jetbrains/kotlin/formatter/FormatterTestGenerated.java b/idea/tests/org/jetbrains/kotlin/formatter/FormatterTestGenerated.java index 1495e2c96a7..4df86e8e637 100644 --- a/idea/tests/org/jetbrains/kotlin/formatter/FormatterTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/formatter/FormatterTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.formatter; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -32,7 +33,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInFormatter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); } @TestMetadata("AnnotationBeforeExpression.after.kt") @@ -904,7 +905,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInCallChain() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/callChain"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/callChain"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); } @TestMetadata("CallChainWrapping.after.kt") @@ -1007,7 +1008,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInFileAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/fileAnnotations"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/fileAnnotations"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); } @TestMetadata("beforeDeclaration.after.kt") @@ -1060,7 +1061,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInModifierList() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/modifierList"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/modifierList"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); } @TestMetadata("funAnnotationBeforeAnnotation.after.kt") @@ -1153,7 +1154,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInParameterList() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/parameterList"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/parameterList"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); } @TestMetadata("ArgumentListChopAsNeeded.after.kt") @@ -1221,7 +1222,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInTrailingComma() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); } @TestMetadata("idea/testData/formatter/trailingComma/collectionLiteralExpression") @@ -1233,7 +1234,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInCollectionLiteralExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/collectionLiteralExpression"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/collectionLiteralExpression"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); } @TestMetadata("CollectionLiteralInAnnotation.after.kt") @@ -1251,7 +1252,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInDestructuringDeclarations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/destructuringDeclarations"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/destructuringDeclarations"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); } @TestMetadata("DestructuringDeclarationsInLambda.after.kt") @@ -1274,7 +1275,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInEnumEntry() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/enumEntry"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/enumEntry"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); } @TestMetadata("Enum.after.kt") @@ -1292,7 +1293,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInIndices() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/indices"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/indices"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); } @TestMetadata("IndicesAccess.after.kt") @@ -1310,7 +1311,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInLambdaParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/lambdaParameters"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/lambdaParameters"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); } @TestMetadata("LambdaParameterList.after.kt") @@ -1328,7 +1329,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInTypeArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/typeArguments"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/typeArguments"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); } @TestMetadata("TypeArgumentList.after.kt") @@ -1346,7 +1347,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInTypeParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/typeParameters"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/typeParameters"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); } @TestMetadata("TypeParameterList.after.kt") @@ -1364,7 +1365,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInValueArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/valueArguments"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/valueArguments"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); } @TestMetadata("ArgumentListChopAsNeeded.after.kt") @@ -1397,7 +1398,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInValueParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/valueParameters"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/valueParameters"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); } @TestMetadata("LambdaValueParameters.after.kt") @@ -1435,7 +1436,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInWhenEntry() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/whenEntry"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/whenEntry"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); } @TestMetadata("WhenEntry.after.kt") @@ -1455,7 +1456,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInFormatterCallSite() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.kt.*$"), null, true); } @TestMetadata("idea/testData/formatter/trailingComma/collectionLiteralExpression") @@ -1467,7 +1468,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInCollectionLiteralExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/collectionLiteralExpression"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/collectionLiteralExpression"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.kt.*$"), null, true); } @TestMetadata("CollectionLiteralInAnnotation.call.after.kt") @@ -1485,7 +1486,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInDestructuringDeclarations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/destructuringDeclarations"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/destructuringDeclarations"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.kt.*$"), null, true); } } @@ -1498,7 +1499,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInEnumEntry() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/enumEntry"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/enumEntry"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.kt.*$"), null, true); } } @@ -1511,7 +1512,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInIndices() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/indices"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/indices"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.kt.*$"), null, true); } @TestMetadata("IndicesAccess.call.after.kt") @@ -1529,7 +1530,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInLambdaParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/lambdaParameters"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/lambdaParameters"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.kt.*$"), null, true); } @TestMetadata("LambdaParameterList.call.after.kt") @@ -1547,7 +1548,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInTypeArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/typeArguments"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/typeArguments"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.kt.*$"), null, true); } @TestMetadata("TypeArgumentList.call.after.kt") @@ -1565,7 +1566,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInTypeParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/typeParameters"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/typeParameters"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.kt.*$"), null, true); } @TestMetadata("TypeParameterList.call.after.kt") @@ -1583,7 +1584,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInValueArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/valueArguments"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/valueArguments"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.kt.*$"), null, true); } @TestMetadata("ArgumentListWrapAsNeeded.call.after.kt") @@ -1601,7 +1602,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInValueParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/valueParameters"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/valueParameters"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.kt.*$"), null, true); } @TestMetadata("ParameterListWrapAsNeeded.call.after.kt") @@ -1619,7 +1620,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInWhenEntry() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/whenEntry"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/whenEntry"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.kt.*$"), null, true); } } } @@ -1633,7 +1634,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInFormatterInverted() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); } @TestMetadata("AnonymousInitializersLineBreak.after.inv.kt") @@ -1905,7 +1906,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInCallChain() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/callChain"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/callChain"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); } @TestMetadata("CallChainWrapping.after.inv.kt") @@ -1958,7 +1959,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInFileAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/fileAnnotations"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/fileAnnotations"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); } } @@ -1971,7 +1972,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInModifierList() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/modifierList"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/modifierList"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); } } @@ -1984,7 +1985,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInParameterList() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/parameterList"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/parameterList"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); } @TestMetadata("DefaultParameterValues.after.inv.kt") @@ -2002,7 +2003,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInTrailingComma() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); } @TestMetadata("idea/testData/formatter/trailingComma/collectionLiteralExpression") @@ -2014,7 +2015,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInCollectionLiteralExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/collectionLiteralExpression"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/collectionLiteralExpression"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); } @TestMetadata("CollectionLiteralInAnnotation.after.inv.kt") @@ -2032,7 +2033,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInDestructuringDeclarations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/destructuringDeclarations"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/destructuringDeclarations"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); } @TestMetadata("DestructuringDeclarationsInLambda.after.inv.kt") @@ -2055,7 +2056,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInEnumEntry() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/enumEntry"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/enumEntry"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); } @TestMetadata("Enum.after.inv.kt") @@ -2073,7 +2074,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInIndices() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/indices"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/indices"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); } @TestMetadata("IndicesAccess.after.inv.kt") @@ -2091,7 +2092,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInLambdaParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/lambdaParameters"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/lambdaParameters"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); } @TestMetadata("LambdaParameterList.after.inv.kt") @@ -2109,7 +2110,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInTypeArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/typeArguments"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/typeArguments"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); } @TestMetadata("TypeArgumentList.after.inv.kt") @@ -2127,7 +2128,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInTypeParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/typeParameters"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/typeParameters"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); } @TestMetadata("TypeParameterList.after.inv.kt") @@ -2145,7 +2146,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInValueArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/valueArguments"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/valueArguments"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); } @TestMetadata("ArgumentListChopAsNeeded.after.inv.kt") @@ -2178,7 +2179,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInValueParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/valueParameters"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/valueParameters"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); } @TestMetadata("LambdaValueParameters.after.inv.kt") @@ -2216,7 +2217,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInWhenEntry() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/whenEntry"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/whenEntry"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); } @TestMetadata("WhenEntry.after.inv.kt") @@ -2236,7 +2237,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInFormatterInvertedCallSite() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.inv\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.inv\\.kt.*$"), null, true); } @TestMetadata("idea/testData/formatter/trailingComma/collectionLiteralExpression") @@ -2248,7 +2249,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInCollectionLiteralExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/collectionLiteralExpression"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.inv\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/collectionLiteralExpression"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.inv\\.kt.*$"), null, true); } @TestMetadata("CollectionLiteralInAnnotation.call.after.inv.kt") @@ -2266,7 +2267,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInDestructuringDeclarations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/destructuringDeclarations"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.inv\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/destructuringDeclarations"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.inv\\.kt.*$"), null, true); } } @@ -2279,7 +2280,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInEnumEntry() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/enumEntry"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.inv\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/enumEntry"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.inv\\.kt.*$"), null, true); } } @@ -2292,7 +2293,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInIndices() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/indices"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.inv\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/indices"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.inv\\.kt.*$"), null, true); } @TestMetadata("IndicesAccess.call.after.inv.kt") @@ -2310,7 +2311,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInLambdaParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/lambdaParameters"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.inv\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/lambdaParameters"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.inv\\.kt.*$"), null, true); } @TestMetadata("LambdaParameterList.call.after.inv.kt") @@ -2328,7 +2329,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInTypeArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/typeArguments"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.inv\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/typeArguments"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.inv\\.kt.*$"), null, true); } @TestMetadata("TypeArgumentList.call.after.inv.kt") @@ -2346,7 +2347,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInTypeParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/typeParameters"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.inv\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/typeParameters"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.inv\\.kt.*$"), null, true); } @TestMetadata("TypeParameterList.call.after.inv.kt") @@ -2364,7 +2365,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInValueArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/valueArguments"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.inv\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/valueArguments"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.inv\\.kt.*$"), null, true); } @TestMetadata("ArgumentListWrapAsNeeded.call.after.inv.kt") @@ -2382,7 +2383,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInValueParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/valueParameters"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.inv\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/valueParameters"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.inv\\.kt.*$"), null, true); } @TestMetadata("ParameterListWrapAsNeeded.call.after.inv.kt") @@ -2400,7 +2401,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest { } public void testAllFilesPresentInWhenEntry() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/whenEntry"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.inv\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/whenEntry"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.inv\\.kt.*$"), null, true); } } } diff --git a/idea/tests/org/jetbrains/kotlin/formatter/TypingIndentationTestBaseGenerated.java b/idea/tests/org/jetbrains/kotlin/formatter/TypingIndentationTestBaseGenerated.java index 63064b41918..cdb1cad602d 100644 --- a/idea/tests/org/jetbrains/kotlin/formatter/TypingIndentationTestBaseGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/formatter/TypingIndentationTestBaseGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.formatter; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -72,7 +73,7 @@ public class TypingIndentationTestBaseGenerated extends AbstractTypingIndentatio } public void testAllFilesPresentInDirectSettings() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); } @TestMetadata("Annotation.after.kt") @@ -264,7 +265,7 @@ public class TypingIndentationTestBaseGenerated extends AbstractTypingIndentatio } public void testAllFilesPresentInArrayAccess() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/arrayAccess"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/arrayAccess"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); } @TestMetadata("listAccess.after.kt") @@ -282,7 +283,7 @@ public class TypingIndentationTestBaseGenerated extends AbstractTypingIndentatio } public void testAllFilesPresentInControlFlowConstructions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/controlFlowConstructions"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/controlFlowConstructions"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); } @TestMetadata("Catch.after.kt") @@ -555,7 +556,7 @@ public class TypingIndentationTestBaseGenerated extends AbstractTypingIndentatio } public void testAllFilesPresentInElvis() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/elvis"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/elvis"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); } @TestMetadata("BeforeElvis.after.kt") @@ -578,7 +579,7 @@ public class TypingIndentationTestBaseGenerated extends AbstractTypingIndentatio } public void testAllFilesPresentInEmptyBraces() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/emptyBraces"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/emptyBraces"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); } @TestMetadata("ClassWithConstructor.after.kt") @@ -636,7 +637,7 @@ public class TypingIndentationTestBaseGenerated extends AbstractTypingIndentatio } public void testAllFilesPresentInEmptyParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/emptyParameters"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/emptyParameters"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); } @TestMetadata("EmptyArgumentInCallByArrayAccess.after.kt") @@ -934,7 +935,7 @@ public class TypingIndentationTestBaseGenerated extends AbstractTypingIndentatio } public void testAllFilesPresentInEmptyParenthesisInBinaryExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/emptyParenthesisInBinaryExpression"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/emptyParenthesisInBinaryExpression"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); } @TestMetadata("AssignmentAfterEq.after.kt") @@ -1062,7 +1063,7 @@ public class TypingIndentationTestBaseGenerated extends AbstractTypingIndentatio } public void testAllFilesPresentInExpressionBody() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/expressionBody"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/expressionBody"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); } @TestMetadata("FunctionWithExplicitType.after.kt") @@ -1120,7 +1121,7 @@ public class TypingIndentationTestBaseGenerated extends AbstractTypingIndentatio } public void testAllFilesPresentInScript() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/script"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/script"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); } @TestMetadata("ScriptAfterClosingBrace.after.kts") @@ -1163,7 +1164,7 @@ public class TypingIndentationTestBaseGenerated extends AbstractTypingIndentatio } public void testAllFilesPresentInTemplates() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/templates"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/templates"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true); } @TestMetadata("LargeFileWithStringTemplate.after.kt") @@ -1292,7 +1293,7 @@ public class TypingIndentationTestBaseGenerated extends AbstractTypingIndentatio } public void testAllFilesPresentInInvertedSettings() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); } @TestMetadata("ArgumentListNormalIndent.after.inv.kt") @@ -1349,7 +1350,7 @@ public class TypingIndentationTestBaseGenerated extends AbstractTypingIndentatio } public void testAllFilesPresentInArrayAccess() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/arrayAccess"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/arrayAccess"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); } } @@ -1362,7 +1363,7 @@ public class TypingIndentationTestBaseGenerated extends AbstractTypingIndentatio } public void testAllFilesPresentInControlFlowConstructions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/controlFlowConstructions"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/controlFlowConstructions"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); } } @@ -1390,7 +1391,7 @@ public class TypingIndentationTestBaseGenerated extends AbstractTypingIndentatio } public void testAllFilesPresentInElvis() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/elvis"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/elvis"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); } @TestMetadata("BeforeElvis.after.inv.kt") @@ -1413,7 +1414,7 @@ public class TypingIndentationTestBaseGenerated extends AbstractTypingIndentatio } public void testAllFilesPresentInEmptyBraces() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/emptyBraces"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/emptyBraces"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); } } @@ -1426,7 +1427,7 @@ public class TypingIndentationTestBaseGenerated extends AbstractTypingIndentatio } public void testAllFilesPresentInEmptyParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/emptyParameters"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/emptyParameters"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); } @TestMetadata("EmptyConditionInDoWhile.after.inv.kt") @@ -1479,7 +1480,7 @@ public class TypingIndentationTestBaseGenerated extends AbstractTypingIndentatio } public void testAllFilesPresentInEmptyParenthesisInBinaryExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/emptyParenthesisInBinaryExpression"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/emptyParenthesisInBinaryExpression"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); } @TestMetadata("AssignmentAfterEq.after.inv.kt") @@ -1587,7 +1588,7 @@ public class TypingIndentationTestBaseGenerated extends AbstractTypingIndentatio } public void testAllFilesPresentInExpressionBody() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/expressionBody"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/expressionBody"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); } @TestMetadata("FunctionWithExplicitType.after.inv.kt") @@ -1645,7 +1646,7 @@ public class TypingIndentationTestBaseGenerated extends AbstractTypingIndentatio } public void testAllFilesPresentInScript() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/script"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/script"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); } } @@ -1658,7 +1659,7 @@ public class TypingIndentationTestBaseGenerated extends AbstractTypingIndentatio } public void testAllFilesPresentInTemplates() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/templates"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/indentationOnNewline/templates"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true); } } } diff --git a/idea/tests/org/jetbrains/kotlin/idea/ExpressionSelectionTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/ExpressionSelectionTestGenerated.java index b7eed33bca0..4b11877c2f6 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/ExpressionSelectionTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/ExpressionSelectionTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class ExpressionSelectionTestGenerated extends AbstractExpressionSelectio } public void testAllFilesPresentInExpressionSelection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/expressionSelection"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/expressionSelection"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("binaryExpr.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/SmartSelectionTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/SmartSelectionTestGenerated.java index 6c0de34a310..9e641947eb9 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/SmartSelectionTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/SmartSelectionTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class SmartSelectionTestGenerated extends AbstractSmartSelectionTest { } public void testAllFilesPresentInSmartSelection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/smartSelection"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/smartSelection"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("beforeComment.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/actions/GotoTestOrCodeActionTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/actions/GotoTestOrCodeActionTestGenerated.java index 7e45527d302..f1dcd49c15c 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/actions/GotoTestOrCodeActionTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/actions/GotoTestOrCodeActionTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.actions; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class GotoTestOrCodeActionTestGenerated extends AbstractGotoTestOrCodeAct } public void testAllFilesPresentInGotoTestOrCode() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/navigation/gotoTestOrCode"), Pattern.compile("^(.+)\\.main\\..+$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/navigation/gotoTestOrCode"), Pattern.compile("^(.+)\\.main\\..+$"), null, true); } @TestMetadata("fromJavaClassToTest.main.java") diff --git a/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/IdeCompiledLightClassTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/IdeCompiledLightClassTestGenerated.java index 6b5edd4405a..811007b9119 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/IdeCompiledLightClassTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/IdeCompiledLightClassTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.caches.resolve; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class IdeCompiledLightClassTestGenerated extends AbstractIdeCompiledLight } public void testAllFilesPresentInLightClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true, "local", "compilationErrors", "ideRegression"); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true, "local", "compilationErrors", "ideRegression"); } @TestMetadata("AnnotatedParameterInEnumConstructor.kt") @@ -162,7 +163,7 @@ public class IdeCompiledLightClassTestGenerated extends AbstractIdeCompiledLight } public void testAllFilesPresentInDelegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/delegation"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/delegation"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); } @TestMetadata("Function.kt") @@ -185,7 +186,7 @@ public class IdeCompiledLightClassTestGenerated extends AbstractIdeCompiledLight } public void testAllFilesPresentInFacades() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/facades"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/facades"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); } @TestMetadata("AllPrivate.kt") @@ -218,7 +219,7 @@ public class IdeCompiledLightClassTestGenerated extends AbstractIdeCompiledLight } public void testAllFilesPresentInNullabilityAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/nullabilityAnnotations"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/nullabilityAnnotations"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); } @TestMetadata("Class.kt") @@ -321,7 +322,7 @@ public class IdeCompiledLightClassTestGenerated extends AbstractIdeCompiledLight } public void testAllFilesPresentInObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/object"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/object"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); } @TestMetadata("SimpleObject.kt") @@ -339,7 +340,7 @@ public class IdeCompiledLightClassTestGenerated extends AbstractIdeCompiledLight } public void testAllFilesPresentInPublicField() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/publicField"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/publicField"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); } @TestMetadata("CompanionObject.kt") @@ -362,7 +363,7 @@ public class IdeCompiledLightClassTestGenerated extends AbstractIdeCompiledLight } public void testAllFilesPresentInScript() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/script"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/script"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); } @TestMetadata("HelloWorld.kts") diff --git a/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/IdeLightClassForScriptTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/IdeLightClassForScriptTestGenerated.java index 1f31bd992c9..fcea7f305c6 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/IdeLightClassForScriptTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/IdeLightClassForScriptTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.caches.resolve; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class IdeLightClassForScriptTestGenerated extends AbstractIdeLightClassFo } public void testAllFilesPresentInIde() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/script/ide"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/script/ide"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); } @TestMetadata("HelloWorld.kts") diff --git a/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/IdeLightClassTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/IdeLightClassTestGenerated.java index 7239c5544f6..405fccdc2d2 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/IdeLightClassTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/IdeLightClassTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.caches.resolve; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class IdeLightClassTestGenerated extends AbstractIdeLightClassTest { } public void testAllFilesPresentInLightClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses"), Pattern.compile("^([^.]+)\\.kt$"), null, true, "delegation", "script"); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses"), Pattern.compile("^([^.]+)\\.kt$"), null, true, "delegation", "script"); } @TestMetadata("AnnotatedParameterInEnumConstructor.kt") @@ -177,7 +178,7 @@ public class IdeLightClassTestGenerated extends AbstractIdeLightClassTest { } public void testAllFilesPresentInCompilationErrors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/compilationErrors"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/compilationErrors"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("AllInlineOnly.kt") @@ -270,7 +271,7 @@ public class IdeLightClassTestGenerated extends AbstractIdeLightClassTest { } public void testAllFilesPresentInFacades() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/facades"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/facades"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("AllPrivate.kt") @@ -303,7 +304,7 @@ public class IdeLightClassTestGenerated extends AbstractIdeLightClassTest { } public void testAllFilesPresentInIdeRegression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/ideRegression"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/ideRegression"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("AllOpenAnnotatedClasses.kt") @@ -356,7 +357,7 @@ public class IdeLightClassTestGenerated extends AbstractIdeLightClassTest { } public void testAllFilesPresentInNullabilityAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/nullabilityAnnotations"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/nullabilityAnnotations"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("Class.kt") @@ -459,7 +460,7 @@ public class IdeLightClassTestGenerated extends AbstractIdeLightClassTest { } public void testAllFilesPresentInObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/object"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/object"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("SimpleObject.kt") @@ -477,7 +478,7 @@ public class IdeLightClassTestGenerated extends AbstractIdeLightClassTest { } public void testAllFilesPresentInPublicField() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/publicField"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/asJava/lightClasses/publicField"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("CompanionObject.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/MultiModuleLineMarkerTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/MultiModuleLineMarkerTestGenerated.java index 1ffcbb468bb..5b623c4b68f 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/MultiModuleLineMarkerTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/MultiModuleLineMarkerTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.caches.resolve; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -50,7 +51,7 @@ public class MultiModuleLineMarkerTestGenerated extends AbstractMultiModuleLineM } public void testAllFilesPresentInMultiModuleLineMarker() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/multiModuleLineMarker"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/multiModuleLineMarker"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("expectConstructorWithProperties") diff --git a/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/MultiPlatformHighlightingTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/MultiPlatformHighlightingTestGenerated.java index b8df78ec900..e6b6c0e5a72 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/MultiPlatformHighlightingTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/MultiPlatformHighlightingTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.caches.resolve; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -35,7 +36,7 @@ public class MultiPlatformHighlightingTestGenerated extends AbstractMultiPlatfor } public void testAllFilesPresentInMultiplatform() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/multiModuleHighlighting/multiplatform"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/multiModuleHighlighting/multiplatform"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("basic") diff --git a/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/MultiplatformAnalysisTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/MultiplatformAnalysisTestGenerated.java index 28b76bd5015..578f1dac89c 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/MultiplatformAnalysisTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/MultiplatformAnalysisTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.caches.resolve; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -30,7 +31,7 @@ public class MultiplatformAnalysisTestGenerated extends AbstractMultiplatformAna } public void testAllFilesPresentInMultiplatform() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/multiplatform"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/multiplatform"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("callableReferences") diff --git a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/BreadcrumbsTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/BreadcrumbsTestGenerated.java index 9785247e301..861e7e16420 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/BreadcrumbsTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/BreadcrumbsTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.codeInsight; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class BreadcrumbsTestGenerated extends AbstractBreadcrumbsTest { } public void testAllFilesPresentInBreadcrumbs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/breadcrumbs"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/breadcrumbs"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("AnonymousObjects.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/ChangeLocalityDetectorTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/ChangeLocalityDetectorTestGenerated.java index 11270a5702d..ab1d6157441 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/ChangeLocalityDetectorTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/ChangeLocalityDetectorTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.codeInsight; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class ChangeLocalityDetectorTestGenerated extends AbstractChangeLocalityD } public void testAllFilesPresentInChangeLocality() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/changeLocality"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/changeLocality"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("Comment.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/ExpressionTypeTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/ExpressionTypeTestGenerated.java index 6ac96e6d20d..2ebc71aec65 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/ExpressionTypeTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/ExpressionTypeTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.codeInsight; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class ExpressionTypeTestGenerated extends AbstractExpressionTypeTest { } public void testAllFilesPresentInExpressionType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/expressionType"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/expressionType"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("AnonymousObject.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/InsertImportOnPasteTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/InsertImportOnPasteTestGenerated.java index 028a070a4c9..9831d361909 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/InsertImportOnPasteTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/InsertImportOnPasteTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.codeInsight; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -27,7 +28,7 @@ public class InsertImportOnPasteTestGenerated extends AbstractInsertImportOnPast } public void testAllFilesPresentInCopy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/copyPaste/imports"), Pattern.compile("^([^.]+)\\.kt$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/copyPaste/imports"), Pattern.compile("^([^.]+)\\.kt$"), null, false); } @TestMetadata("AlreadyImportedExtensions.kt") @@ -390,7 +391,7 @@ public class InsertImportOnPasteTestGenerated extends AbstractInsertImportOnPast } public void testAllFilesPresentInCut() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/copyPaste/imports"), Pattern.compile("^([^.]+)\\.kt$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/copyPaste/imports"), Pattern.compile("^([^.]+)\\.kt$"), null, false); } @TestMetadata("AlreadyImportedExtensions.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/InspectionTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/InspectionTestGenerated.java index d5b3ec805a2..9c40d004c7c 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/InspectionTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/InspectionTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.codeInsight; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -27,7 +28,7 @@ public class InspectionTestGenerated extends AbstractInspectionTest { } public void testAllFilesPresentInIntentions() throws Exception { - KotlinTestUtils.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File("idea/testData/intentions"), Pattern.compile("^(inspections\\.test)$"), null); + KtTestUtil.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File("idea/testData/intentions"), Pattern.compile("^(inspections\\.test)$"), null); } @TestMetadata("convertToStringTemplate/inspectionData/inspections.test") @@ -75,7 +76,7 @@ public class InspectionTestGenerated extends AbstractInspectionTest { } public void testAllFilesPresentInInspections() throws Exception { - KotlinTestUtils.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File("idea/testData/inspections"), Pattern.compile("^(inspections\\.test)$"), null); + KtTestUtil.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File("idea/testData/inspections"), Pattern.compile("^(inspections\\.test)$"), null); } @TestMetadata("allOpenSimple/inspectionData/inspections.test") @@ -473,7 +474,7 @@ public class InspectionTestGenerated extends AbstractInspectionTest { } public void testAllFilesPresentInInspectionsLocal() throws Exception { - KotlinTestUtils.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal"), Pattern.compile("^(inspections\\.test)$"), null); + KtTestUtil.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal"), Pattern.compile("^(inspections\\.test)$"), null); } @TestMetadata("branched/ifThenToElvis/inspectionData/inspections.test") diff --git a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/LineMarkersTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/LineMarkersTestGenerated.java index 81b7d303b14..8f4a3388e52 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/LineMarkersTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/LineMarkersTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.codeInsight; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class LineMarkersTestGenerated extends AbstractLineMarkersTest { } public void testAllFilesPresentInLineMarker() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/lineMarker"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/lineMarker"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("MethodSeparators.kt") @@ -42,7 +43,7 @@ public class LineMarkersTestGenerated extends AbstractLineMarkersTest { } public void testAllFilesPresentInDslMarker() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/lineMarker/dslMarker"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/lineMarker/dslMarker"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("markerAnnotationDeclaration.kt") @@ -60,7 +61,7 @@ public class LineMarkersTestGenerated extends AbstractLineMarkersTest { } public void testAllFilesPresentInOverrideImplement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/lineMarker/overrideImplement"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/lineMarker/overrideImplement"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("BadCodeNoExceptions.kt") @@ -203,7 +204,7 @@ public class LineMarkersTestGenerated extends AbstractLineMarkersTest { } public void testAllFilesPresentInRecursiveCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/lineMarker/recursiveCall"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/lineMarker/recursiveCall"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("companionInvoke.kt") @@ -306,7 +307,7 @@ public class LineMarkersTestGenerated extends AbstractLineMarkersTest { } public void testAllFilesPresentInRunMarkers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/lineMarker/runMarkers"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/lineMarker/runMarkers"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("jUnitTestClassWithSubclasses.kt") @@ -329,7 +330,7 @@ public class LineMarkersTestGenerated extends AbstractLineMarkersTest { } public void testAllFilesPresentInSuspendCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/lineMarker/suspendCall"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/lineMarker/suspendCall"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("suspendCall.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/LineMarkersTestInLibrarySourcesGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/LineMarkersTestInLibrarySourcesGenerated.java index 42e0f767375..0d0d9fef8d7 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/LineMarkersTestInLibrarySourcesGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/LineMarkersTestInLibrarySourcesGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.codeInsight; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class LineMarkersTestInLibrarySourcesGenerated extends AbstractLineMarker } public void testAllFilesPresentInLineMarker() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsightInLibrary/lineMarker"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsightInLibrary/lineMarker"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("dummy.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/MoveOnCutPasteTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/MoveOnCutPasteTestGenerated.java index 8acc803552f..c1632fc8ee3 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/MoveOnCutPasteTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/MoveOnCutPasteTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.codeInsight; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class MoveOnCutPasteTestGenerated extends AbstractMoveOnCutPasteTest { } public void testAllFilesPresentInMoveDeclarations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/copyPaste/moveDeclarations"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/copyPaste/moveDeclarations"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("ChangePackage.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/MultiFileInspectionTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/MultiFileInspectionTestGenerated.java index 4cef51746a9..8c893b2d52e 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/MultiFileInspectionTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/MultiFileInspectionTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.codeInsight; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class MultiFileInspectionTestGenerated extends AbstractMultiFileInspectio } public void testAllFilesPresentInMultiFileInspections() throws Exception { - KotlinTestUtils.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File("idea/testData/multiFileInspections"), Pattern.compile("^(.+)\\.test$"), null); + KtTestUtil.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File("idea/testData/multiFileInspections"), Pattern.compile("^(.+)\\.test$"), null); } @TestMetadata("fakeJvmFieldConstant/fakeJvmFieldConstant.test") diff --git a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/OutOfBlockModificationTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/OutOfBlockModificationTestGenerated.java index 5b7f50a2a89..82fd081b07e 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/OutOfBlockModificationTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/OutOfBlockModificationTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.codeInsight; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class OutOfBlockModificationTestGenerated extends AbstractOutOfBlockModif } public void testAllFilesPresentInOutOfBlock() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/outOfBlock"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/outOfBlock"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("Comment.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/RenderingKDocTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/RenderingKDocTestGenerated.java index 8ed45cb9a10..aaa23117920 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/RenderingKDocTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/RenderingKDocTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.codeInsight; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class RenderingKDocTestGenerated extends AbstractRenderingKDocTest { } public void testAllFilesPresentInRenderingKDoc() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/renderingKDoc"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/renderingKDoc"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("classRendering.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/codevision/KotlinCodeVisionProviderTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/codevision/KotlinCodeVisionProviderTestGenerated.java index e13df987f3b..d01e9305fd5 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/codevision/KotlinCodeVisionProviderTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/codevision/KotlinCodeVisionProviderTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.codeInsight.codevision; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class KotlinCodeVisionProviderTestGenerated extends AbstractKotlinCodeVis } public void testAllFilesPresentInCodeVision() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/codeVision"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/codeVision"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassFunctionOverrides.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/generate/CodeInsightActionTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/generate/CodeInsightActionTestGenerated.java index 3755b445910..ede23caf675 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/generate/CodeInsightActionTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/generate/CodeInsightActionTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.codeInsight.generate; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class CodeInsightActionTestGenerated extends AbstractCodeInsightActionTes } public void testAllFilesPresentInSecondaryConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/generate/secondaryConstructors"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/generate/secondaryConstructors"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("empty.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/generate/GenerateHashCodeAndEqualsActionTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/generate/GenerateHashCodeAndEqualsActionTestGenerated.java index a94a10a09bf..17750306d39 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/generate/GenerateHashCodeAndEqualsActionTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/generate/GenerateHashCodeAndEqualsActionTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.codeInsight.generate; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class GenerateHashCodeAndEqualsActionTestGenerated extends AbstractGenera } public void testAllFilesPresentInEqualsWithHashCode() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/generate/equalsWithHashCode"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/generate/equalsWithHashCode"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("annotation.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/generate/GenerateTestSupportMethodActionTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/generate/GenerateTestSupportMethodActionTestGenerated.java index 69b2909adc8..84c7a3143f0 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/generate/GenerateTestSupportMethodActionTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/generate/GenerateTestSupportMethodActionTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.codeInsight.generate; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class GenerateTestSupportMethodActionTestGenerated extends AbstractGenera } public void testAllFilesPresentInTestFrameworkSupport() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/generate/testFrameworkSupport"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/generate/testFrameworkSupport"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("idea/testData/codeInsight/generate/testFrameworkSupport/jUnit4") @@ -37,7 +38,7 @@ public class GenerateTestSupportMethodActionTestGenerated extends AbstractGenera } public void testAllFilesPresentInJUnit4() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/generate/testFrameworkSupport/jUnit4"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/generate/testFrameworkSupport/jUnit4"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("dataMethod.kt") @@ -85,7 +86,7 @@ public class GenerateTestSupportMethodActionTestGenerated extends AbstractGenera } public void testAllFilesPresentInJunit3() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/generate/testFrameworkSupport/junit3"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/generate/testFrameworkSupport/junit3"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("setUp.kt") @@ -123,7 +124,7 @@ public class GenerateTestSupportMethodActionTestGenerated extends AbstractGenera } public void testAllFilesPresentInTestNG() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/generate/testFrameworkSupport/testNG"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/generate/testFrameworkSupport/testNG"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("dataMethod.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/generate/GenerateToStringActionTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/generate/GenerateToStringActionTestGenerated.java index 37df43e3eb9..70b67b557bb 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/generate/GenerateToStringActionTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/generate/GenerateToStringActionTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.codeInsight.generate; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class GenerateToStringActionTestGenerated extends AbstractGenerateToStrin } public void testAllFilesPresentInToString() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/generate/toString"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/generate/toString"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("idea/testData/codeInsight/generate/toString/common") @@ -37,7 +38,7 @@ public class GenerateToStringActionTestGenerated extends AbstractGenerateToStrin } public void testAllFilesPresentInCommon() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/generate/toString/common"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/generate/toString/common"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("annotation.kt") @@ -65,7 +66,7 @@ public class GenerateToStringActionTestGenerated extends AbstractGenerateToStrin } public void testAllFilesPresentInMultipeTemplates() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/generate/toString/multipeTemplates"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/generate/toString/multipeTemplates"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("arrays.kt") @@ -123,7 +124,7 @@ public class GenerateToStringActionTestGenerated extends AbstractGenerateToStrin } public void testAllFilesPresentInSingleTemplate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/generate/toString/singleTemplate"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/generate/toString/singleTemplate"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("arrays.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/hints/KotlinReferenceTypeHintsProviderTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/hints/KotlinReferenceTypeHintsProviderTestGenerated.java index 6b38c92c6f5..21373640619 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/hints/KotlinReferenceTypeHintsProviderTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/hints/KotlinReferenceTypeHintsProviderTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.codeInsight.hints; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class KotlinReferenceTypeHintsProviderTestGenerated extends AbstractKotli } public void testAllFilesPresentInTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/hints/types"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/hints/types"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("AnonymousObject.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/moveUpDown/MoveLeftRightTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/moveUpDown/MoveLeftRightTestGenerated.java index 8c395ed99bc..fe4066b159b 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/moveUpDown/MoveLeftRightTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/moveUpDown/MoveLeftRightTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.codeInsight.moveUpDown; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class MoveLeftRightTestGenerated extends AbstractMoveLeftRightTest { } public void testAllFilesPresentInMoveLeftRight() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/moveLeftRight"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/moveLeftRight"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("annotationParams.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/moveUpDown/MoveStatementTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/moveUpDown/MoveStatementTestGenerated.java index 654d7f104d8..35039821be9 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/moveUpDown/MoveStatementTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/moveUpDown/MoveStatementTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.codeInsight.moveUpDown; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -27,7 +28,7 @@ public class MoveStatementTestGenerated extends AbstractMoveStatementTest { } public void testAllFilesPresentInClassBodyDeclarations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/moveUpDown/classBodyDeclarations"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/moveUpDown/classBodyDeclarations"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("idea/testData/codeInsight/moveUpDown/classBodyDeclarations/accessors") @@ -59,7 +60,7 @@ public class MoveStatementTestGenerated extends AbstractMoveStatementTest { } public void testAllFilesPresentInAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/moveUpDown/classBodyDeclarations/accessors"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/moveUpDown/classBodyDeclarations/accessors"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } } @@ -72,7 +73,7 @@ public class MoveStatementTestGenerated extends AbstractMoveStatementTest { } public void testAllFilesPresentInClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/moveUpDown/classBodyDeclarations/class"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/moveUpDown/classBodyDeclarations/class"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("classAtBrace1.kt") @@ -240,7 +241,7 @@ public class MoveStatementTestGenerated extends AbstractMoveStatementTest { } public void testAllFilesPresentInClassInitializer() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/moveUpDown/classBodyDeclarations/classInitializer"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/moveUpDown/classBodyDeclarations/classInitializer"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("classInitializerAtBrace1.kt") @@ -313,7 +314,7 @@ public class MoveStatementTestGenerated extends AbstractMoveStatementTest { } public void testAllFilesPresentInEnums() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/moveUpDown/classBodyDeclarations/enums"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/moveUpDown/classBodyDeclarations/enums"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("enum1.kt") @@ -366,7 +367,7 @@ public class MoveStatementTestGenerated extends AbstractMoveStatementTest { } public void testAllFilesPresentInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/moveUpDown/classBodyDeclarations/function"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/moveUpDown/classBodyDeclarations/function"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("functionAtBrace1.kt") @@ -474,7 +475,7 @@ public class MoveStatementTestGenerated extends AbstractMoveStatementTest { } public void testAllFilesPresentInFunctionAnchors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/moveUpDown/classBodyDeclarations/functionAnchors"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/moveUpDown/classBodyDeclarations/functionAnchors"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("keyword.kt") @@ -517,7 +518,7 @@ public class MoveStatementTestGenerated extends AbstractMoveStatementTest { } public void testAllFilesPresentInProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/moveUpDown/classBodyDeclarations/property"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/moveUpDown/classBodyDeclarations/property"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("propertyAtBrace1.kt") @@ -610,7 +611,7 @@ public class MoveStatementTestGenerated extends AbstractMoveStatementTest { } public void testAllFilesPresentInPropertyAnchors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/moveUpDown/classBodyDeclarations/propertyAnchors"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/moveUpDown/classBodyDeclarations/propertyAnchors"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("keyword.kt") @@ -639,7 +640,7 @@ public class MoveStatementTestGenerated extends AbstractMoveStatementTest { } public void testAllFilesPresentInClosingBraces() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/moveUpDown/closingBraces"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/moveUpDown/closingBraces"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("idea/testData/codeInsight/moveUpDown/closingBraces/for") @@ -651,7 +652,7 @@ public class MoveStatementTestGenerated extends AbstractMoveStatementTest { } public void testAllFilesPresentInFor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/moveUpDown/closingBraces/for"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/moveUpDown/closingBraces/for"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("for1.kt") @@ -674,7 +675,7 @@ public class MoveStatementTestGenerated extends AbstractMoveStatementTest { } public void testAllFilesPresentInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/moveUpDown/closingBraces/function"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/moveUpDown/closingBraces/function"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("function1.kt") @@ -707,7 +708,7 @@ public class MoveStatementTestGenerated extends AbstractMoveStatementTest { } public void testAllFilesPresentInIf() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/moveUpDown/closingBraces/if"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/moveUpDown/closingBraces/if"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("if1.kt") @@ -740,7 +741,7 @@ public class MoveStatementTestGenerated extends AbstractMoveStatementTest { } public void testAllFilesPresentInNested() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/moveUpDown/closingBraces/nested"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/moveUpDown/closingBraces/nested"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("nested1.kt") @@ -763,7 +764,7 @@ public class MoveStatementTestGenerated extends AbstractMoveStatementTest { } public void testAllFilesPresentInWhen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/moveUpDown/closingBraces/when"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/moveUpDown/closingBraces/when"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("when1.kt") @@ -806,7 +807,7 @@ public class MoveStatementTestGenerated extends AbstractMoveStatementTest { } public void testAllFilesPresentInWhile() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/moveUpDown/closingBraces/while"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/moveUpDown/closingBraces/while"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("while1.kt") @@ -840,7 +841,7 @@ public class MoveStatementTestGenerated extends AbstractMoveStatementTest { } public void testAllFilesPresentInExpressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/moveUpDown/expressions"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/moveUpDown/expressions"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("binaryExpr1.kt") @@ -1348,7 +1349,7 @@ public class MoveStatementTestGenerated extends AbstractMoveStatementTest { } public void testAllFilesPresentInLine() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/moveUpDown/line"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/moveUpDown/line"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("fileAnnotation.kt") @@ -1366,7 +1367,7 @@ public class MoveStatementTestGenerated extends AbstractMoveStatementTest { } public void testAllFilesPresentInParametersAndArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/moveUpDown/parametersAndArguments"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/moveUpDown/parametersAndArguments"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("callArgs1.kt") @@ -1534,7 +1535,7 @@ public class MoveStatementTestGenerated extends AbstractMoveStatementTest { } public void testAllFilesPresentInTrailingComma() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/moveUpDown/trailingComma"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/moveUpDown/trailingComma"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("callArgs1.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/postfix/PostfixTemplateProviderTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/postfix/PostfixTemplateProviderTestGenerated.java index 2f3ffc2be0a..eab8eabdfe8 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/postfix/PostfixTemplateProviderTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/postfix/PostfixTemplateProviderTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.codeInsight.postfix; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class PostfixTemplateProviderTestGenerated extends AbstractPostfixTemplat } public void testAllFilesPresentInPostfix() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/postfix"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/postfix"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("arg.kt") @@ -237,7 +238,7 @@ public class PostfixTemplateProviderTestGenerated extends AbstractPostfixTemplat } public void testAllFilesPresentInWrapWithCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/postfix/wrapWithCall"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/postfix/wrapWithCall"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("arrayOfStatement.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/surroundWith/SurroundWithTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/surroundWith/SurroundWithTestGenerated.java index db62dcc4179..56c963a5911 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/surroundWith/SurroundWithTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/surroundWith/SurroundWithTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.codeInsight.surroundWith; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -27,7 +28,7 @@ public class SurroundWithTestGenerated extends AbstractSurroundWithTest { } public void testAllFilesPresentInIf() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/surroundWith/if"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/surroundWith/if"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("block.kt") @@ -74,7 +75,7 @@ public class SurroundWithTestGenerated extends AbstractSurroundWithTest { } public void testAllFilesPresentInMoveDeclarationsOut() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/surroundWith/if/moveDeclarationsOut"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/surroundWith/if/moveDeclarationsOut"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("idea/testData/codeInsight/surroundWith/if/moveDeclarationsOut/class") @@ -86,7 +87,7 @@ public class SurroundWithTestGenerated extends AbstractSurroundWithTest { } public void testAllFilesPresentInClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/surroundWith/if/moveDeclarationsOut/class"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/surroundWith/if/moveDeclarationsOut/class"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("classInType.kt") @@ -109,7 +110,7 @@ public class SurroundWithTestGenerated extends AbstractSurroundWithTest { } public void testAllFilesPresentInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/surroundWith/if/moveDeclarationsOut/function"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/surroundWith/if/moveDeclarationsOut/function"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("firstChildLocalFun.kt") @@ -137,7 +138,7 @@ public class SurroundWithTestGenerated extends AbstractSurroundWithTest { } public void testAllFilesPresentInObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/surroundWith/if/moveDeclarationsOut/object"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/surroundWith/if/moveDeclarationsOut/object"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("localObject.kt") @@ -155,7 +156,7 @@ public class SurroundWithTestGenerated extends AbstractSurroundWithTest { } public void testAllFilesPresentInOrder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/surroundWith/if/moveDeclarationsOut/order"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/surroundWith/if/moveDeclarationsOut/order"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("twoClasses.kt") @@ -183,7 +184,7 @@ public class SurroundWithTestGenerated extends AbstractSurroundWithTest { } public void testAllFilesPresentInVal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/surroundWith/if/moveDeclarationsOut/val"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/surroundWith/if/moveDeclarationsOut/val"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("fullQualifiedType.kt") @@ -221,7 +222,7 @@ public class SurroundWithTestGenerated extends AbstractSurroundWithTest { } public void testAllFilesPresentInVar() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/surroundWith/if/moveDeclarationsOut/var"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/surroundWith/if/moveDeclarationsOut/var"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("varWithNotNullableTypeWithInitializer.kt") @@ -248,7 +249,7 @@ public class SurroundWithTestGenerated extends AbstractSurroundWithTest { } public void testAllFilesPresentInDefaultValue() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/surroundWith/if/moveDeclarationsOut/var/defaultValue"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/surroundWith/if/moveDeclarationsOut/var/defaultValue"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("boolean.kt") @@ -279,7 +280,7 @@ public class SurroundWithTestGenerated extends AbstractSurroundWithTest { } public void testAllFilesPresentInIfElse() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/surroundWith/ifElse"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/surroundWith/ifElse"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("block.kt") @@ -332,7 +333,7 @@ public class SurroundWithTestGenerated extends AbstractSurroundWithTest { } public void testAllFilesPresentInIfElseExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/surroundWith/ifElseExpression"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/surroundWith/ifElseExpression"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("asStatement.kt") @@ -360,7 +361,7 @@ public class SurroundWithTestGenerated extends AbstractSurroundWithTest { } public void testAllFilesPresentInIfElseExpressionBraces() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/surroundWith/ifElseExpressionBraces"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/surroundWith/ifElseExpressionBraces"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("asStatement.kt") @@ -383,7 +384,7 @@ public class SurroundWithTestGenerated extends AbstractSurroundWithTest { } public void testAllFilesPresentInNot() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/surroundWith/not"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/surroundWith/not"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("booleanExpr.kt") @@ -431,7 +432,7 @@ public class SurroundWithTestGenerated extends AbstractSurroundWithTest { } public void testAllFilesPresentInParentheses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/surroundWith/parentheses"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/surroundWith/parentheses"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("expr.kt") @@ -458,7 +459,7 @@ public class SurroundWithTestGenerated extends AbstractSurroundWithTest { } public void testAllFilesPresentInNotApplicable() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/surroundWith/parentheses/notApplicable"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/surroundWith/parentheses/notApplicable"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("if.kt") @@ -517,7 +518,7 @@ public class SurroundWithTestGenerated extends AbstractSurroundWithTest { } public void testAllFilesPresentInStringTemplate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/surroundWith/stringTemplate"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/surroundWith/stringTemplate"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("multiExpression.kt") @@ -550,7 +551,7 @@ public class SurroundWithTestGenerated extends AbstractSurroundWithTest { } public void testAllFilesPresentInWhen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/surroundWith/when"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/surroundWith/when"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("enum.kt") @@ -578,7 +579,7 @@ public class SurroundWithTestGenerated extends AbstractSurroundWithTest { } public void testAllFilesPresentInTryCatch() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/surroundWith/tryCatch"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/surroundWith/tryCatch"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("moveDeclarationsOut.kt") @@ -616,7 +617,7 @@ public class SurroundWithTestGenerated extends AbstractSurroundWithTest { } public void testAllFilesPresentInTryCatchExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/surroundWith/tryCatchExpression"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/surroundWith/tryCatchExpression"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("asStatement.kt") @@ -639,7 +640,7 @@ public class SurroundWithTestGenerated extends AbstractSurroundWithTest { } public void testAllFilesPresentInTryCatchFinally() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/surroundWith/tryCatchFinally"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/surroundWith/tryCatchFinally"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("multiExpression.kt") @@ -667,7 +668,7 @@ public class SurroundWithTestGenerated extends AbstractSurroundWithTest { } public void testAllFilesPresentInTryCatchFinallyExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/surroundWith/tryCatchFinallyExpression"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/surroundWith/tryCatchFinallyExpression"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("asStatement.kt") @@ -690,7 +691,7 @@ public class SurroundWithTestGenerated extends AbstractSurroundWithTest { } public void testAllFilesPresentInTryFinally() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/surroundWith/tryFinally"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/surroundWith/tryFinally"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("multiExpression.kt") @@ -718,7 +719,7 @@ public class SurroundWithTestGenerated extends AbstractSurroundWithTest { } public void testAllFilesPresentInFunctionLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/surroundWith/functionLiteral"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/surroundWith/functionLiteral"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("moveDeclarationsOut.kt") @@ -746,7 +747,7 @@ public class SurroundWithTestGenerated extends AbstractSurroundWithTest { } public void testAllFilesPresentInWithIfExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/surroundWith/withIfExpression"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/surroundWith/withIfExpression"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("complexBoolean.kt") @@ -769,7 +770,7 @@ public class SurroundWithTestGenerated extends AbstractSurroundWithTest { } public void testAllFilesPresentInWithIfElseExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/surroundWith/withIfElseExpression"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/surroundWith/withIfElseExpression"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("complexBoolean.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/unwrap/UnwrapRemoveTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/unwrap/UnwrapRemoveTestGenerated.java index 19bb20c365f..200c182913b 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/codeInsight/unwrap/UnwrapRemoveTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/codeInsight/unwrap/UnwrapRemoveTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.codeInsight.unwrap; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -27,7 +28,7 @@ public class UnwrapRemoveTestGenerated extends AbstractUnwrapRemoveTest { } public void testAllFilesPresentInRemoveExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/unwrapAndRemove/removeExpression"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/unwrapAndRemove/removeExpression"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ifInBlock.kt") @@ -65,7 +66,7 @@ public class UnwrapRemoveTestGenerated extends AbstractUnwrapRemoveTest { } public void testAllFilesPresentInUnwrapThen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/unwrapAndRemove/unwrapThen"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/unwrapAndRemove/unwrapThen"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("thenCompoundInBlock.kt") @@ -93,7 +94,7 @@ public class UnwrapRemoveTestGenerated extends AbstractUnwrapRemoveTest { } public void testAllFilesPresentInUnwrapElse() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/unwrapAndRemove/unwrapElse"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/unwrapAndRemove/unwrapElse"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("elseCompoundInBlock.kt") @@ -121,7 +122,7 @@ public class UnwrapRemoveTestGenerated extends AbstractUnwrapRemoveTest { } public void testAllFilesPresentInRemoveElse() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/unwrapAndRemove/removeElse"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/unwrapAndRemove/removeElse"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("else.kt") @@ -139,7 +140,7 @@ public class UnwrapRemoveTestGenerated extends AbstractUnwrapRemoveTest { } public void testAllFilesPresentInUnwrapLoop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/unwrapAndRemove/unwrapLoop"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/unwrapAndRemove/unwrapLoop"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("doWhile.kt") @@ -167,7 +168,7 @@ public class UnwrapRemoveTestGenerated extends AbstractUnwrapRemoveTest { } public void testAllFilesPresentInUnwrapTry() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/unwrapAndRemove/unwrapTry"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/unwrapAndRemove/unwrapTry"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("tryCompoundInBlock.kt") @@ -195,7 +196,7 @@ public class UnwrapRemoveTestGenerated extends AbstractUnwrapRemoveTest { } public void testAllFilesPresentInUnwrapCatch() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/unwrapAndRemove/unwrapCatch"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/unwrapAndRemove/unwrapCatch"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("catchCompoundInBlock.kt") @@ -223,7 +224,7 @@ public class UnwrapRemoveTestGenerated extends AbstractUnwrapRemoveTest { } public void testAllFilesPresentInRemoveCatch() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/unwrapAndRemove/removeCatch"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/unwrapAndRemove/removeCatch"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("catch.kt") @@ -241,7 +242,7 @@ public class UnwrapRemoveTestGenerated extends AbstractUnwrapRemoveTest { } public void testAllFilesPresentInUnwrapFinally() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/unwrapAndRemove/unwrapFinally"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/unwrapAndRemove/unwrapFinally"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("finallyCompoundInBlock.kt") @@ -269,7 +270,7 @@ public class UnwrapRemoveTestGenerated extends AbstractUnwrapRemoveTest { } public void testAllFilesPresentInRemoveFinally() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/unwrapAndRemove/removeFinally"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/unwrapAndRemove/removeFinally"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("finallyInBlock.kt") @@ -292,7 +293,7 @@ public class UnwrapRemoveTestGenerated extends AbstractUnwrapRemoveTest { } public void testAllFilesPresentInUnwrapLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/unwrapAndRemove/unwrapLambda"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/unwrapAndRemove/unwrapLambda"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("lambdaCallCompoundInBlock.kt") @@ -355,7 +356,7 @@ public class UnwrapRemoveTestGenerated extends AbstractUnwrapRemoveTest { } public void testAllFilesPresentInUnwrapFunctionParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/unwrapAndRemove/unwrapFunctionParameter"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/codeInsight/unwrapAndRemove/unwrapFunctionParameter"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("functionHasMultiParam.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/conversion/copy/JavaToKotlinCopyPasteConversionTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/conversion/copy/JavaToKotlinCopyPasteConversionTestGenerated.java index 8131e7f5a4d..7a752dd93d6 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/conversion/copy/JavaToKotlinCopyPasteConversionTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/conversion/copy/JavaToKotlinCopyPasteConversionTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.conversion.copy; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -60,7 +61,7 @@ public class JavaToKotlinCopyPasteConversionTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInConversion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/copyPaste/conversion"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/copyPaste/conversion"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("Arithmetic.java") diff --git a/idea/tests/org/jetbrains/kotlin/idea/conversion/copy/LiteralKotlinToKotlinCopyPasteTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/conversion/copy/LiteralKotlinToKotlinCopyPasteTestGenerated.java index bcced660ade..4c3bcab1a47 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/conversion/copy/LiteralKotlinToKotlinCopyPasteTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/conversion/copy/LiteralKotlinToKotlinCopyPasteTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.conversion.copy; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class LiteralKotlinToKotlinCopyPasteTestGenerated extends AbstractLiteral } public void testAllFilesPresentInLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/copyPaste/literal"), Pattern.compile("^([^\\.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/copyPaste/literal"), Pattern.compile("^([^\\.]+)\\.kt$"), null, true); } @TestMetadata("CollectionLiteralReference.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/conversion/copy/LiteralTextToKotlinCopyPasteTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/conversion/copy/LiteralTextToKotlinCopyPasteTestGenerated.java index 388512ab069..dea43c393ad 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/conversion/copy/LiteralTextToKotlinCopyPasteTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/conversion/copy/LiteralTextToKotlinCopyPasteTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.conversion.copy; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class LiteralTextToKotlinCopyPasteTestGenerated extends AbstractLiteralTe } public void testAllFilesPresentInPlainTextLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/copyPaste/plainTextLiteral"), Pattern.compile("^([^\\.]+)\\.txt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/copyPaste/plainTextLiteral"), Pattern.compile("^([^\\.]+)\\.txt$"), null, true); } @TestMetadata("BrokenEntries.txt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/conversion/copy/TextJavaToKotlinCopyPasteConversionTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/conversion/copy/TextJavaToKotlinCopyPasteConversionTestGenerated.java index cefdbe80626..f9c0b922a29 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/conversion/copy/TextJavaToKotlinCopyPasteConversionTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/conversion/copy/TextJavaToKotlinCopyPasteConversionTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.conversion.copy; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class TextJavaToKotlinCopyPasteConversionTestGenerated extends AbstractTe } public void testAllFilesPresentInPlainTextConversion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/copyPaste/plainTextConversion"), Pattern.compile("^([^\\.]+)\\.txt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/copyPaste/plainTextConversion"), Pattern.compile("^([^\\.]+)\\.txt$"), null, true); } @TestMetadata("AsExpression.txt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/coverage/KotlinCoverageOutputFilesTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/coverage/KotlinCoverageOutputFilesTestGenerated.java index f9ad1b765fa..75a041fdd1d 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/coverage/KotlinCoverageOutputFilesTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/coverage/KotlinCoverageOutputFilesTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.coverage; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class KotlinCoverageOutputFilesTestGenerated extends AbstractKotlinCovera } public void testAllFilesPresentInOutputFiles() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/coverage/outputFiles"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/coverage/outputFiles"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("NotInlinedLambda.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/CodeFragmentAutoImportTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/CodeFragmentAutoImportTestGenerated.java index 278abcf0357..270444fbc01 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/CodeFragmentAutoImportTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/CodeFragmentAutoImportTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.debugger.evaluate; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class CodeFragmentAutoImportTestGenerated extends AbstractCodeFragmentAut } public void testAllFilesPresentInCodeFragmentAutoImport() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix.special/codeFragmentAutoImport"), Pattern.compile("^(.+)\\.kt$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix.special/codeFragmentAutoImport"), Pattern.compile("^(.+)\\.kt$"), null, false); } @TestMetadata("ExtensionFun.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/CodeFragmentCompletionHandlerTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/CodeFragmentCompletionHandlerTestGenerated.java index 9763cfa4988..54bde85a853 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/CodeFragmentCompletionHandlerTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/CodeFragmentCompletionHandlerTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.debugger.evaluate; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class CodeFragmentCompletionHandlerTestGenerated extends AbstractCodeFrag } public void testAllFilesPresentInRuntimeCast() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/runtimeCast"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/handlers/runtimeCast"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("CastPrivateFun.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/CodeFragmentCompletionTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/CodeFragmentCompletionTestGenerated.java index 514ff29ab6d..9a169b120f2 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/CodeFragmentCompletionTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/CodeFragmentCompletionTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.debugger.evaluate; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class CodeFragmentCompletionTestGenerated extends AbstractCodeFragmentCom } public void testAllFilesPresentInCodeFragments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/codeFragments"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/codeFragments"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("blockCodeFragment.kt") @@ -92,7 +93,7 @@ public class CodeFragmentCompletionTestGenerated extends AbstractCodeFragmentCom } public void testAllFilesPresentInRuntimeType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/codeFragments/runtimeType"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/idea-completion/testData/basic/codeFragments/runtimeType"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("castWithGenerics.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/CodeFragmentHighlightingTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/CodeFragmentHighlightingTestGenerated.java index 5c773739106..d08c86558d0 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/CodeFragmentHighlightingTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/CodeFragmentHighlightingTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.debugger.evaluate; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -27,7 +28,7 @@ public class CodeFragmentHighlightingTestGenerated extends AbstractCodeFragmentH } public void testAllFilesPresentInCodeFragments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/checker/codeFragments"), Pattern.compile("^(.+)\\.kt$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/checker/codeFragments"), Pattern.compile("^(.+)\\.kt$"), null, false); } @TestMetadata("anonymousObject.kt") @@ -170,7 +171,7 @@ public class CodeFragmentHighlightingTestGenerated extends AbstractCodeFragmentH } public void testAllFilesPresentInImports() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/checker/codeFragments/imports"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/checker/codeFragments/imports"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("hashMap.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigateJavaToLibrarySourceTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigateJavaToLibrarySourceTestGenerated.java index d4651f82671..5caf8699d86 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigateJavaToLibrarySourceTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigateJavaToLibrarySourceTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.decompiler.navigation; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class NavigateJavaToLibrarySourceTestGenerated extends AbstractNavigateJa } public void testAllFilesPresentInUserJavaCode() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/navigation/userJavaCode"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/navigation/userJavaCode"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("ClassAndConstuctors.java") diff --git a/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigateToDecompiledLibraryTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigateToDecompiledLibraryTestGenerated.java index d456ba6bd1a..1f5ecc423fb 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigateToDecompiledLibraryTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigateToDecompiledLibraryTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.decompiler.navigation; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class NavigateToDecompiledLibraryTestGenerated extends AbstractNavigateTo } public void testAllFilesPresentInUsercode() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/navigation/usercode"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/navigation/usercode"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassObject.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigateToLibrarySourceTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigateToLibrarySourceTestGenerated.java index 15cefa3c1ab..06400df387b 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigateToLibrarySourceTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigateToLibrarySourceTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.decompiler.navigation; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class NavigateToLibrarySourceTestGenerated extends AbstractNavigateToLibr } public void testAllFilesPresentInUsercode() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/navigation/usercode"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/navigation/usercode"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassObject.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigateToLibrarySourceTestWithJSGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigateToLibrarySourceTestWithJSGenerated.java index ee52643950d..99e4ae1b0e2 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigateToLibrarySourceTestWithJSGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/decompiler/navigation/NavigateToLibrarySourceTestWithJSGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.decompiler.navigation; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class NavigateToLibrarySourceTestWithJSGenerated extends AbstractNavigate } public void testAllFilesPresentInUsercodeWithJSModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/navigation/usercode"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/navigation/usercode"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassObject.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClsStubBuilderTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClsStubBuilderTestGenerated.java index f56fc1333f0..2431153cbc9 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClsStubBuilderTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClsStubBuilderTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.decompiler.stubBuilder; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class ClsStubBuilderTestGenerated extends AbstractClsStubBuilderTest { } public void testAllFilesPresentInStubBuilder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/stubBuilder"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/stubBuilder"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("AnnotatedFlexibleTypes") diff --git a/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/LoadJavaClsStubTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/LoadJavaClsStubTestGenerated.java index 87f40ddf715..87255e45791 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/LoadJavaClsStubTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/LoadJavaClsStubTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.decompiler.stubBuilder; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class LoadJavaClsStubTestGenerated extends AbstractLoadJavaClsStubTest { } public void testAllFilesPresentInCompiledKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/testData/loadJava/compiledKotlin/annotations") @@ -37,7 +38,7 @@ public class LoadJavaClsStubTestGenerated extends AbstractLoadJavaClsStubTest { } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("AnnotatedAnnotation.kt") @@ -94,7 +95,7 @@ public class LoadJavaClsStubTestGenerated extends AbstractLoadJavaClsStubTest { } public void testAllFilesPresentInClassMembers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/classMembers"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/classMembers"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassObjectPropertyField.kt") @@ -162,7 +163,7 @@ public class LoadJavaClsStubTestGenerated extends AbstractLoadJavaClsStubTest { } public void testAllFilesPresentInClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/classes"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/classes"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("AnnotationInClassObject.kt") @@ -250,7 +251,7 @@ public class LoadJavaClsStubTestGenerated extends AbstractLoadJavaClsStubTest { } public void testAllFilesPresentInPackageMembers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/packageMembers"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/packageMembers"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("DelegatedProperty.kt") @@ -303,7 +304,7 @@ public class LoadJavaClsStubTestGenerated extends AbstractLoadJavaClsStubTest { } public void testAllFilesPresentInParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/parameters"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/parameters"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Constructor.kt") @@ -376,7 +377,7 @@ public class LoadJavaClsStubTestGenerated extends AbstractLoadJavaClsStubTest { } public void testAllFilesPresentInPropertiesWithoutBackingFields() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Class.kt") @@ -429,7 +430,7 @@ public class LoadJavaClsStubTestGenerated extends AbstractLoadJavaClsStubTest { } public void testAllFilesPresentInTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/types"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/types"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassLiteralArgument.kt") @@ -487,7 +488,7 @@ public class LoadJavaClsStubTestGenerated extends AbstractLoadJavaClsStubTest { } public void testAllFilesPresentInWithUseSiteTarget() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/withUseSiteTarget"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/withUseSiteTarget"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("DelegateTarget.kt") @@ -521,7 +522,7 @@ public class LoadJavaClsStubTestGenerated extends AbstractLoadJavaClsStubTest { } public void testAllFilesPresentInClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/class"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/class"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Class.kt") @@ -718,7 +719,7 @@ public class LoadJavaClsStubTestGenerated extends AbstractLoadJavaClsStubTest { } public void testAllFilesPresentInJavaBean() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/class/javaBean"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/class/javaBean"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("DifferentGetterAndSetter.kt") @@ -762,7 +763,7 @@ public class LoadJavaClsStubTestGenerated extends AbstractLoadJavaClsStubTest { } public void testAllFilesPresentInClassFun() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/classFun"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/classFun"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassInParamUsedInFun.kt") @@ -800,7 +801,7 @@ public class LoadJavaClsStubTestGenerated extends AbstractLoadJavaClsStubTest { } public void testAllFilesPresentInClassObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/classObject"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/classObject"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassObjectDeclaresVal.kt") @@ -878,7 +879,7 @@ public class LoadJavaClsStubTestGenerated extends AbstractLoadJavaClsStubTest { } public void testAllFilesPresentInConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/constructor"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/constructor"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Constructor0.kt") @@ -970,7 +971,7 @@ public class LoadJavaClsStubTestGenerated extends AbstractLoadJavaClsStubTest { } public void testAllFilesPresentInVararg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/constructor/vararg"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/constructor/vararg"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ConstructorNonLastVararg.kt") @@ -994,7 +995,7 @@ public class LoadJavaClsStubTestGenerated extends AbstractLoadJavaClsStubTest { } public void testAllFilesPresentInCoroutines() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Basic.kt") @@ -1012,7 +1013,7 @@ public class LoadJavaClsStubTestGenerated extends AbstractLoadJavaClsStubTest { } public void testAllFilesPresentInDataClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/dataClass"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/dataClass"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("MixedComponents.kt") @@ -1045,7 +1046,7 @@ public class LoadJavaClsStubTestGenerated extends AbstractLoadJavaClsStubTest { } public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/enum"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/enum"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("enumVisibility.kt") @@ -1088,7 +1089,7 @@ public class LoadJavaClsStubTestGenerated extends AbstractLoadJavaClsStubTest { } public void testAllFilesPresentInFromLoadJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ArrayTypeVariance.kt") @@ -1275,7 +1276,7 @@ public class LoadJavaClsStubTestGenerated extends AbstractLoadJavaClsStubTest { } public void testAllFilesPresentInKotlinSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ArrayType.kt") @@ -1367,7 +1368,7 @@ public class LoadJavaClsStubTestGenerated extends AbstractLoadJavaClsStubTest { } public void testAllFilesPresentInError() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ConflictingProjectionKind.kt") @@ -1510,7 +1511,7 @@ public class LoadJavaClsStubTestGenerated extends AbstractLoadJavaClsStubTest { } public void testAllFilesPresentInPropagation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("PropagateTypeArgumentNullable.kt") @@ -1527,7 +1528,7 @@ public class LoadJavaClsStubTestGenerated extends AbstractLoadJavaClsStubTest { } public void testAllFilesPresentInParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ChangeProjectionKind1.kt") @@ -1700,7 +1701,7 @@ public class LoadJavaClsStubTestGenerated extends AbstractLoadJavaClsStubTest { } public void testAllFilesPresentInReturn() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("CantMakeImmutableInSubclass.kt") @@ -1853,7 +1854,7 @@ public class LoadJavaClsStubTestGenerated extends AbstractLoadJavaClsStubTest { } public void testAllFilesPresentInTypeParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/typeParameter"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/typeParameter"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("InheritMutability.kt") @@ -1913,7 +1914,7 @@ public class LoadJavaClsStubTestGenerated extends AbstractLoadJavaClsStubTest { } public void testAllFilesPresentInLibrary() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/library"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/library"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("LoadIterable.kt") @@ -1941,7 +1942,7 @@ public class LoadJavaClsStubTestGenerated extends AbstractLoadJavaClsStubTest { } public void testAllFilesPresentInModality() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/modality"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/modality"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ModalityOfFakeOverrides.kt") @@ -1959,7 +1960,7 @@ public class LoadJavaClsStubTestGenerated extends AbstractLoadJavaClsStubTest { } public void testAllFilesPresentInNotNull() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/notNull"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/notNull"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("NotNullField.kt") @@ -1998,7 +1999,7 @@ public class LoadJavaClsStubTestGenerated extends AbstractLoadJavaClsStubTest { } public void testAllFilesPresentInFun() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Assert.kt") @@ -2065,7 +2066,7 @@ public class LoadJavaClsStubTestGenerated extends AbstractLoadJavaClsStubTest { } public void testAllFilesPresentInGenericWithTypeVariables() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/genericWithTypeVariables"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/genericWithTypeVariables"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("FunGenericParam.kt") @@ -2128,7 +2129,7 @@ public class LoadJavaClsStubTestGenerated extends AbstractLoadJavaClsStubTest { } public void testAllFilesPresentInGenericWithoutTypeVariables() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/genericWithoutTypeVariables"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/genericWithoutTypeVariables"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("FunClassParamNotNull.kt") @@ -2166,7 +2167,7 @@ public class LoadJavaClsStubTestGenerated extends AbstractLoadJavaClsStubTest { } public void testAllFilesPresentInNonGeneric() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassFun.kt") @@ -2259,7 +2260,7 @@ public class LoadJavaClsStubTestGenerated extends AbstractLoadJavaClsStubTest { } public void testAllFilesPresentInVararg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/vararg"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/vararg"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("nonLastVararg.kt") @@ -2288,7 +2289,7 @@ public class LoadJavaClsStubTestGenerated extends AbstractLoadJavaClsStubTest { } public void testAllFilesPresentInInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/inline"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/inline"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("inlineFunction.kt") @@ -2306,7 +2307,7 @@ public class LoadJavaClsStubTestGenerated extends AbstractLoadJavaClsStubTest { } public void testAllFilesPresentInMemberOrder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/memberOrder"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/memberOrder"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("callablesNameClash.kt") @@ -2349,7 +2350,7 @@ public class LoadJavaClsStubTestGenerated extends AbstractLoadJavaClsStubTest { } public void testAllFilesPresentInNested() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/nested"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/nested"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("deepInnerGeneric.kt") @@ -2377,7 +2378,7 @@ public class LoadJavaClsStubTestGenerated extends AbstractLoadJavaClsStubTest { } public void testAllFilesPresentInPlatformTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/platformTypes"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/platformTypes"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("notnullTypeArgument.kt") @@ -2400,7 +2401,7 @@ public class LoadJavaClsStubTestGenerated extends AbstractLoadJavaClsStubTest { } public void testAllFilesPresentInProp() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/prop"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/prop"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassVal.kt") @@ -2582,7 +2583,7 @@ public class LoadJavaClsStubTestGenerated extends AbstractLoadJavaClsStubTest { } public void testAllFilesPresentInDefaultAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/prop/defaultAccessors"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/prop/defaultAccessors"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassVal.kt") @@ -2646,7 +2647,7 @@ public class LoadJavaClsStubTestGenerated extends AbstractLoadJavaClsStubTest { } public void testAllFilesPresentInType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/type"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/type"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Any.kt") @@ -2814,7 +2815,7 @@ public class LoadJavaClsStubTestGenerated extends AbstractLoadJavaClsStubTest { } public void testAllFilesPresentInTypealias() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/typealias"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/typealias"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Annotations.kt") @@ -2847,7 +2848,7 @@ public class LoadJavaClsStubTestGenerated extends AbstractLoadJavaClsStubTest { } public void testAllFilesPresentInVisibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/visibility"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/visibility"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("InternalClass.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/CommonDecompiledTextFromJsMetadataTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/CommonDecompiledTextFromJsMetadataTestGenerated.java index 7925cd5369e..67ff56f6ccd 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/CommonDecompiledTextFromJsMetadataTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/CommonDecompiledTextFromJsMetadataTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.decompiler.textBuilder; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class CommonDecompiledTextFromJsMetadataTestGenerated extends AbstractCom } public void testAllFilesPresentInDecompiledText() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); } @TestMetadata("AnnotatedEnumEntry") @@ -148,7 +149,7 @@ public class CommonDecompiledTextFromJsMetadataTestGenerated extends AbstractCom } public void testAllFilesPresentInAnnotatedEnumEntry() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/AnnotatedEnumEntry"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/AnnotatedEnumEntry"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); } } @@ -161,7 +162,7 @@ public class CommonDecompiledTextFromJsMetadataTestGenerated extends AbstractCom } public void testAllFilesPresentInAnnotatedParameterInEnumConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/AnnotatedParameterInEnumConstructor"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/AnnotatedParameterInEnumConstructor"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); } } @@ -174,7 +175,7 @@ public class CommonDecompiledTextFromJsMetadataTestGenerated extends AbstractCom } public void testAllFilesPresentInAnnotatedParameterInInnerClassConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/AnnotatedParameterInInnerClassConstructor"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/AnnotatedParameterInInnerClassConstructor"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); } } @@ -187,7 +188,7 @@ public class CommonDecompiledTextFromJsMetadataTestGenerated extends AbstractCom } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/Annotations"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/Annotations"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); } } @@ -200,7 +201,7 @@ public class CommonDecompiledTextFromJsMetadataTestGenerated extends AbstractCom } public void testAllFilesPresentInAnnotationsOnPrimaryCtr() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/AnnotationsOnPrimaryCtr"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/AnnotationsOnPrimaryCtr"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); } } @@ -213,7 +214,7 @@ public class CommonDecompiledTextFromJsMetadataTestGenerated extends AbstractCom } public void testAllFilesPresentInClassWithClassObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/ClassWithClassObject"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/ClassWithClassObject"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); } } @@ -226,7 +227,7 @@ public class CommonDecompiledTextFromJsMetadataTestGenerated extends AbstractCom } public void testAllFilesPresentInClassWithNamedClassObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/ClassWithNamedClassObject"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/ClassWithNamedClassObject"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); } } @@ -239,7 +240,7 @@ public class CommonDecompiledTextFromJsMetadataTestGenerated extends AbstractCom } public void testAllFilesPresentInConst() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/Const"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/Const"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); } } @@ -252,7 +253,7 @@ public class CommonDecompiledTextFromJsMetadataTestGenerated extends AbstractCom } public void testAllFilesPresentInDependencyOnNestedClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/DependencyOnNestedClasses"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/DependencyOnNestedClasses"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); } } @@ -265,7 +266,7 @@ public class CommonDecompiledTextFromJsMetadataTestGenerated extends AbstractCom } public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/Enum"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/Enum"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); } } @@ -278,7 +279,7 @@ public class CommonDecompiledTextFromJsMetadataTestGenerated extends AbstractCom } public void testAllFilesPresentInFlexibleTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/FlexibleTypes"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/FlexibleTypes"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); } } @@ -291,7 +292,7 @@ public class CommonDecompiledTextFromJsMetadataTestGenerated extends AbstractCom } public void testAllFilesPresentInFunInterfaceDeclaration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/FunInterfaceDeclaration"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/FunInterfaceDeclaration"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); } } @@ -304,7 +305,7 @@ public class CommonDecompiledTextFromJsMetadataTestGenerated extends AbstractCom } public void testAllFilesPresentInFunctionTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/FunctionTypes"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/FunctionTypes"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); } } @@ -317,7 +318,7 @@ public class CommonDecompiledTextFromJsMetadataTestGenerated extends AbstractCom } public void testAllFilesPresentInFunctionalTypeWithNamedArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/FunctionalTypeWithNamedArguments"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/FunctionalTypeWithNamedArguments"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); } } @@ -330,7 +331,7 @@ public class CommonDecompiledTextFromJsMetadataTestGenerated extends AbstractCom } public void testAllFilesPresentInInherited() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/Inherited"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/Inherited"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); } } @@ -343,7 +344,7 @@ public class CommonDecompiledTextFromJsMetadataTestGenerated extends AbstractCom } public void testAllFilesPresentInInnerClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/InnerClasses"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/InnerClasses"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); } } @@ -356,7 +357,7 @@ public class CommonDecompiledTextFromJsMetadataTestGenerated extends AbstractCom } public void testAllFilesPresentInLocalClassAsTypeWithArgument() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/LocalClassAsTypeWithArgument"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/LocalClassAsTypeWithArgument"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); } } @@ -369,7 +370,7 @@ public class CommonDecompiledTextFromJsMetadataTestGenerated extends AbstractCom } public void testAllFilesPresentInModifiers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/Modifiers"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/Modifiers"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); } } @@ -382,7 +383,7 @@ public class CommonDecompiledTextFromJsMetadataTestGenerated extends AbstractCom } public void testAllFilesPresentInNestedClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/NestedClasses"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/NestedClasses"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); } } @@ -395,7 +396,7 @@ public class CommonDecompiledTextFromJsMetadataTestGenerated extends AbstractCom } public void testAllFilesPresentInObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/Object"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/Object"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); } } @@ -408,7 +409,7 @@ public class CommonDecompiledTextFromJsMetadataTestGenerated extends AbstractCom } public void testAllFilesPresentInSecondaryConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/SecondaryConstructors"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/SecondaryConstructors"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); } } @@ -421,7 +422,7 @@ public class CommonDecompiledTextFromJsMetadataTestGenerated extends AbstractCom } public void testAllFilesPresentInSimpleClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/SimpleClass"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/SimpleClass"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); } } @@ -434,7 +435,7 @@ public class CommonDecompiledTextFromJsMetadataTestGenerated extends AbstractCom } public void testAllFilesPresentInTypeModifiers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/TypeModifiers"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/TypeModifiers"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); } } } diff --git a/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/CommonDecompiledTextTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/CommonDecompiledTextTestGenerated.java index 58c03281877..55c621d5f6d 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/CommonDecompiledTextTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/CommonDecompiledTextTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.decompiler.textBuilder; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class CommonDecompiledTextTestGenerated extends AbstractCommonDecompiledT } public void testAllFilesPresentInDecompiledText() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("AnnotatedEnumEntry") @@ -152,7 +153,7 @@ public class CommonDecompiledTextTestGenerated extends AbstractCommonDecompiledT } public void testAllFilesPresentInAnnotatedEnumEntry() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/AnnotatedEnumEntry"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/AnnotatedEnumEntry"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -165,7 +166,7 @@ public class CommonDecompiledTextTestGenerated extends AbstractCommonDecompiledT } public void testAllFilesPresentInAnnotatedParameterInEnumConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/AnnotatedParameterInEnumConstructor"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/AnnotatedParameterInEnumConstructor"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -178,7 +179,7 @@ public class CommonDecompiledTextTestGenerated extends AbstractCommonDecompiledT } public void testAllFilesPresentInAnnotatedParameterInInnerClassConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/AnnotatedParameterInInnerClassConstructor"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/AnnotatedParameterInInnerClassConstructor"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -191,7 +192,7 @@ public class CommonDecompiledTextTestGenerated extends AbstractCommonDecompiledT } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/Annotations"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/Annotations"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -204,7 +205,7 @@ public class CommonDecompiledTextTestGenerated extends AbstractCommonDecompiledT } public void testAllFilesPresentInAnnotationsOnPrimaryCtr() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/AnnotationsOnPrimaryCtr"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/AnnotationsOnPrimaryCtr"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -217,7 +218,7 @@ public class CommonDecompiledTextTestGenerated extends AbstractCommonDecompiledT } public void testAllFilesPresentInClassWithClassObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/ClassWithClassObject"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/ClassWithClassObject"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -230,7 +231,7 @@ public class CommonDecompiledTextTestGenerated extends AbstractCommonDecompiledT } public void testAllFilesPresentInClassWithNamedClassObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/ClassWithNamedClassObject"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/ClassWithNamedClassObject"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -243,7 +244,7 @@ public class CommonDecompiledTextTestGenerated extends AbstractCommonDecompiledT } public void testAllFilesPresentInConst() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/Const"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/Const"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -256,7 +257,7 @@ public class CommonDecompiledTextTestGenerated extends AbstractCommonDecompiledT } public void testAllFilesPresentInDependencyOnNestedClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/DependencyOnNestedClasses"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/DependencyOnNestedClasses"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -269,7 +270,7 @@ public class CommonDecompiledTextTestGenerated extends AbstractCommonDecompiledT } public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/Enum"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/Enum"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -282,7 +283,7 @@ public class CommonDecompiledTextTestGenerated extends AbstractCommonDecompiledT } public void testAllFilesPresentInFlexibleTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/FlexibleTypes"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/FlexibleTypes"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -295,7 +296,7 @@ public class CommonDecompiledTextTestGenerated extends AbstractCommonDecompiledT } public void testAllFilesPresentInFunInterfaceDeclaration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/FunInterfaceDeclaration"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/FunInterfaceDeclaration"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -308,7 +309,7 @@ public class CommonDecompiledTextTestGenerated extends AbstractCommonDecompiledT } public void testAllFilesPresentInFunctionTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/FunctionTypes"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/FunctionTypes"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -321,7 +322,7 @@ public class CommonDecompiledTextTestGenerated extends AbstractCommonDecompiledT } public void testAllFilesPresentInFunctionalTypeWithNamedArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/FunctionalTypeWithNamedArguments"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/FunctionalTypeWithNamedArguments"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -334,7 +335,7 @@ public class CommonDecompiledTextTestGenerated extends AbstractCommonDecompiledT } public void testAllFilesPresentInInherited() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/Inherited"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/Inherited"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -347,7 +348,7 @@ public class CommonDecompiledTextTestGenerated extends AbstractCommonDecompiledT } public void testAllFilesPresentInInnerClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/InnerClasses"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/InnerClasses"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -360,7 +361,7 @@ public class CommonDecompiledTextTestGenerated extends AbstractCommonDecompiledT } public void testAllFilesPresentInLocalClassAsTypeWithArgument() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/LocalClassAsTypeWithArgument"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/LocalClassAsTypeWithArgument"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -373,7 +374,7 @@ public class CommonDecompiledTextTestGenerated extends AbstractCommonDecompiledT } public void testAllFilesPresentInModifiers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/Modifiers"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/Modifiers"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -386,7 +387,7 @@ public class CommonDecompiledTextTestGenerated extends AbstractCommonDecompiledT } public void testAllFilesPresentInNestedClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/NestedClasses"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/NestedClasses"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -399,7 +400,7 @@ public class CommonDecompiledTextTestGenerated extends AbstractCommonDecompiledT } public void testAllFilesPresentInObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/Object"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/Object"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -412,7 +413,7 @@ public class CommonDecompiledTextTestGenerated extends AbstractCommonDecompiledT } public void testAllFilesPresentInSecondaryConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/SecondaryConstructors"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/SecondaryConstructors"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -425,7 +426,7 @@ public class CommonDecompiledTextTestGenerated extends AbstractCommonDecompiledT } public void testAllFilesPresentInSimpleClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/SimpleClass"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/SimpleClass"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -438,7 +439,7 @@ public class CommonDecompiledTextTestGenerated extends AbstractCommonDecompiledT } public void testAllFilesPresentInTypeModifiers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/TypeModifiers"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledText/TypeModifiers"), Pattern.compile("^([^\\.]+)$"), null, true); } } } diff --git a/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/JsDecompiledTextFromJsMetadataTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/JsDecompiledTextFromJsMetadataTestGenerated.java index 0694fd7062e..1f838deee58 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/JsDecompiledTextFromJsMetadataTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/JsDecompiledTextFromJsMetadataTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.decompiler.textBuilder; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class JsDecompiledTextFromJsMetadataTestGenerated extends AbstractJsDecom } public void testAllFilesPresentInDecompiledTextJs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledTextJs"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledTextJs"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); } @TestMetadata("TestPackage") @@ -48,7 +49,7 @@ public class JsDecompiledTextFromJsMetadataTestGenerated extends AbstractJsDecom } public void testAllFilesPresentInTestPackage() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledTextJs/TestPackage"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledTextJs/TestPackage"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); } } @@ -61,7 +62,7 @@ public class JsDecompiledTextFromJsMetadataTestGenerated extends AbstractJsDecom } public void testAllFilesPresentInTypeAliases() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledTextJs/TypeAliases"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledTextJs/TypeAliases"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JS, true); } } } diff --git a/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/JvmDecompiledTextTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/JvmDecompiledTextTestGenerated.java index 87e4a3c3920..c957b3fb5ef 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/JvmDecompiledTextTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/JvmDecompiledTextTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.decompiler.textBuilder; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class JvmDecompiledTextTestGenerated extends AbstractJvmDecompiledTextTes } public void testAllFilesPresentInDecompiledTextJvm() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledTextJvm"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledTextJvm"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("EnumWithQuotes") @@ -77,7 +78,7 @@ public class JvmDecompiledTextTestGenerated extends AbstractJvmDecompiledTextTes } public void testAllFilesPresentInEnumWithQuotes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledTextJvm/EnumWithQuotes"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledTextJvm/EnumWithQuotes"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -90,7 +91,7 @@ public class JvmDecompiledTextTestGenerated extends AbstractJvmDecompiledTextTes } public void testAllFilesPresentInModifiers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledTextJvm/Modifiers"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledTextJvm/Modifiers"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -103,7 +104,7 @@ public class JvmDecompiledTextTestGenerated extends AbstractJvmDecompiledTextTes } public void testAllFilesPresentInMultifileClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledTextJvm/MultifileClass"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledTextJvm/MultifileClass"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -116,7 +117,7 @@ public class JvmDecompiledTextTestGenerated extends AbstractJvmDecompiledTextTes } public void testAllFilesPresentInPackageWithQuotes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledTextJvm/PackageWithQuotes"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledTextJvm/PackageWithQuotes"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -129,7 +130,7 @@ public class JvmDecompiledTextTestGenerated extends AbstractJvmDecompiledTextTes } public void testAllFilesPresentInParameterName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledTextJvm/ParameterName"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledTextJvm/ParameterName"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -142,7 +143,7 @@ public class JvmDecompiledTextTestGenerated extends AbstractJvmDecompiledTextTes } public void testAllFilesPresentInPrivateConstField() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledTextJvm/PrivateConstField"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledTextJvm/PrivateConstField"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -155,7 +156,7 @@ public class JvmDecompiledTextTestGenerated extends AbstractJvmDecompiledTextTes } public void testAllFilesPresentInTestKt() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledTextJvm/TestKt"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledTextJvm/TestKt"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -168,7 +169,7 @@ public class JvmDecompiledTextTestGenerated extends AbstractJvmDecompiledTextTes } public void testAllFilesPresentInTypeAliases() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledTextJvm/TypeAliases"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/decompiler/decompiledTextJvm/TypeAliases"), Pattern.compile("^([^\\.]+)$"), null, true); } } } diff --git a/idea/tests/org/jetbrains/kotlin/idea/editor/EnterAfterUnmatchedBraceHandlerTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/editor/EnterAfterUnmatchedBraceHandlerTestGenerated.java index ba4fc84e2b7..556ecd2af31 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/editor/EnterAfterUnmatchedBraceHandlerTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/editor/EnterAfterUnmatchedBraceHandlerTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.editor; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class EnterAfterUnmatchedBraceHandlerTestGenerated extends AbstractEnterA } public void testAllFilesPresentInAfterUnmatchedBrace() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/editor/enterHandler/afterUnmatchedBrace"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/editor/enterHandler/afterUnmatchedBrace"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("lambdaArgumentBeforeFunctionInitializer.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/editor/MultiLineStringIndentTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/editor/MultiLineStringIndentTestGenerated.java index 1988c40be1a..7c5ebff1e72 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/editor/MultiLineStringIndentTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/editor/MultiLineStringIndentTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.editor; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class MultiLineStringIndentTestGenerated extends AbstractMultiLineStringI } public void testAllFilesPresentInMultilineString() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/editor/enterHandler/multilineString"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/editor/enterHandler/multilineString"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("idea/testData/editor/enterHandler/multilineString/spaces") @@ -37,7 +38,7 @@ public class MultiLineStringIndentTestGenerated extends AbstractMultiLineStringI } public void testAllFilesPresentInSpaces() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/editor/enterHandler/multilineString/spaces"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/editor/enterHandler/multilineString/spaces"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("dontAddMarginCharWhenMultilineWithoutMargins.kt") @@ -240,7 +241,7 @@ public class MultiLineStringIndentTestGenerated extends AbstractMultiLineStringI } public void testAllFilesPresentInWithTabs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/editor/enterHandler/multilineString/withTabs"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/editor/enterHandler/multilineString/withTabs"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("idea/testData/editor/enterHandler/multilineString/withTabs/tabs2") @@ -252,7 +253,7 @@ public class MultiLineStringIndentTestGenerated extends AbstractMultiLineStringI } public void testAllFilesPresentInTabs2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/editor/enterHandler/multilineString/withTabs/tabs2"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/editor/enterHandler/multilineString/withTabs/tabs2"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("dontInsertTrimMarginCall.kt") @@ -320,7 +321,7 @@ public class MultiLineStringIndentTestGenerated extends AbstractMultiLineStringI } public void testAllFilesPresentInTabs4() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/editor/enterHandler/multilineString/withTabs/tabs4"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/editor/enterHandler/multilineString/withTabs/tabs4"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("dontInsertTrimMarginCall.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/editor/backspaceHandler/BackspaceHandlerTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/editor/backspaceHandler/BackspaceHandlerTestGenerated.java index 36ec48e0172..6ae6b70551a 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/editor/backspaceHandler/BackspaceHandlerTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/editor/backspaceHandler/BackspaceHandlerTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.editor.backspaceHandler; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class BackspaceHandlerTestGenerated extends AbstractBackspaceHandlerTest } public void testAllFilesPresentInBackspaceHandler() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/editor/backspaceHandler"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/editor/backspaceHandler"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("rawStringDelete.kt") @@ -57,7 +58,7 @@ public class BackspaceHandlerTestGenerated extends AbstractBackspaceHandlerTest } public void testAllFilesPresentInStringTemplate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/editor/backspaceHandler/stringTemplate"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/editor/backspaceHandler/stringTemplate"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("escapedStringTemplate.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/editor/quickDoc/QuickDocProviderTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/editor/quickDoc/QuickDocProviderTestGenerated.java index 644745482b1..d6224939bcc 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/editor/quickDoc/QuickDocProviderTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/editor/quickDoc/QuickDocProviderTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.editor.quickDoc; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class QuickDocProviderTestGenerated extends AbstractQuickDocProviderTest } public void testAllFilesPresentInQuickDoc() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/editor/quickDoc"), Pattern.compile("^([^_]+)\\.(kt|java)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/editor/quickDoc"), Pattern.compile("^([^_]+)\\.(kt|java)$"), null, true); } @TestMetadata("AnonymousObjectLocalVariable.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/filters/KotlinExceptionFilterTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/filters/KotlinExceptionFilterTestGenerated.java index 512cd946c62..161a0d7e3e6 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/filters/KotlinExceptionFilterTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/filters/KotlinExceptionFilterTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.filters; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class KotlinExceptionFilterTestGenerated extends AbstractKotlinExceptionF } public void testAllFilesPresentInExceptionFilter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/debugger/exceptionFilter"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/debugger/exceptionFilter"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("breakpointReachedAt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/folding/KotlinFoldingTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/folding/KotlinFoldingTestGenerated.java index d9590f15202..a3c73c6ad7a 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/folding/KotlinFoldingTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/folding/KotlinFoldingTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.folding; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -27,7 +28,7 @@ public class KotlinFoldingTestGenerated extends AbstractKotlinFoldingTest { } public void testAllFilesPresentInNoCollapse() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/folding/noCollapse"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/folding/noCollapse"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("class.kt") @@ -80,7 +81,7 @@ public class KotlinFoldingTestGenerated extends AbstractKotlinFoldingTest { } public void testAllFilesPresentInCheckCollapse() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/folding/checkCollapse"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/folding/checkCollapse"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("collectionFactoryFunctions.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/hierarchy/HierarchyTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/hierarchy/HierarchyTestGenerated.java index 7de0742a893..4b0cf5ed842 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/hierarchy/HierarchyTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/hierarchy/HierarchyTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.hierarchy; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -27,7 +28,7 @@ public class HierarchyTestGenerated extends AbstractHierarchyTest { } public void testAllFilesPresentInType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/hierarchy/class/type"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/hierarchy/class/type"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("CaretAtAnnotation") @@ -185,7 +186,7 @@ public class HierarchyTestGenerated extends AbstractHierarchyTest { } public void testAllFilesPresentInSuper() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/hierarchy/class/super"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/hierarchy/class/super"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("JetList") @@ -218,7 +219,7 @@ public class HierarchyTestGenerated extends AbstractHierarchyTest { } public void testAllFilesPresentInSub() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/hierarchy/class/sub"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/hierarchy/class/sub"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("AllFromClass") @@ -301,7 +302,7 @@ public class HierarchyTestGenerated extends AbstractHierarchyTest { } public void testAllFilesPresentInCallers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/hierarchy/calls/callers"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/hierarchy/calls/callers"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("callInsideAnonymousFun") @@ -429,7 +430,7 @@ public class HierarchyTestGenerated extends AbstractHierarchyTest { } public void testAllFilesPresentInCallersJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/hierarchy/calls/callersJava"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/hierarchy/calls/callersJava"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("javaMethod") @@ -447,7 +448,7 @@ public class HierarchyTestGenerated extends AbstractHierarchyTest { } public void testAllFilesPresentInCallees() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/hierarchy/calls/callees"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/hierarchy/calls/callees"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("kotlinAnonymousObject") @@ -525,7 +526,7 @@ public class HierarchyTestGenerated extends AbstractHierarchyTest { } public void testAllFilesPresentInOverrides() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/hierarchy/overrides"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/hierarchy/overrides"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("kotlinBuiltInMemberFunction") diff --git a/idea/tests/org/jetbrains/kotlin/idea/hierarchy/HierarchyWithLibTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/hierarchy/HierarchyWithLibTestGenerated.java index cef708f2561..2bb353a0d98 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/hierarchy/HierarchyWithLibTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/hierarchy/HierarchyWithLibTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.hierarchy; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class HierarchyWithLibTestGenerated extends AbstractHierarchyWithLibTest } public void testAllFilesPresentInWithLib() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/hierarchy/withLib"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/hierarchy/withLib"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("annotation") diff --git a/idea/tests/org/jetbrains/kotlin/idea/highlighter/DiagnosticMessageJsTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/highlighter/DiagnosticMessageJsTestGenerated.java index 0b5e8edae89..48c775e991f 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/highlighter/DiagnosticMessageJsTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/highlighter/DiagnosticMessageJsTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.highlighter; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class DiagnosticMessageJsTestGenerated extends AbstractDiagnosticMessageJ } public void testAllFilesPresentInJs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/diagnosticMessage/js"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/diagnosticMessage/js"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, false); } @TestMetadata("jsCodeErrorHtml.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/highlighter/DiagnosticMessageTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/highlighter/DiagnosticMessageTestGenerated.java index 3c3e60ba209..fe7356c5bd4 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/highlighter/DiagnosticMessageTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/highlighter/DiagnosticMessageTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.highlighter; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -30,7 +31,7 @@ public class DiagnosticMessageTestGenerated extends AbstractDiagnosticMessageTes } public void testAllFilesPresentInDiagnosticMessage() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/diagnosticMessage"), Pattern.compile("^(.+)\\.kt$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/diagnosticMessage"), Pattern.compile("^(.+)\\.kt$"), null, false); } @TestMetadata("annotationsForResolve.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/highlighter/DslHighlighterTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/highlighter/DslHighlighterTestGenerated.java index 2f2b2a4130b..ab6403ad221 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/highlighter/DslHighlighterTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/highlighter/DslHighlighterTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.highlighter; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class DslHighlighterTestGenerated extends AbstractDslHighlighterTest { } public void testAllFilesPresentInDslHighlighter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/dslHighlighter"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/dslHighlighter"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("functionCalls.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/highlighter/HighlightExitPointsTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/highlighter/HighlightExitPointsTestGenerated.java index 6c637861e79..e19b942152d 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/highlighter/HighlightExitPointsTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/highlighter/HighlightExitPointsTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.highlighter; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class HighlightExitPointsTestGenerated extends AbstractHighlightExitPoint } public void testAllFilesPresentInExitPoints() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/exitPoints"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/exitPoints"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("getter.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/highlighter/HighlightingTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/highlighter/HighlightingTestGenerated.java index 4c4cafcb96f..df8a62e69e2 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/highlighter/HighlightingTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/highlighter/HighlightingTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.highlighter; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class HighlightingTestGenerated extends AbstractHighlightingTest { } public void testAllFilesPresentInHighlighter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/highlighter"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/highlighter"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Annotations.kt") @@ -177,7 +178,7 @@ public class HighlightingTestGenerated extends AbstractHighlightingTest { } public void testAllFilesPresentInDeprecated() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/highlighter/deprecated"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/highlighter/deprecated"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Class.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/highlighter/UsageHighlightingTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/highlighter/UsageHighlightingTestGenerated.java index 676b2fe4d83..c462b299369 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/highlighter/UsageHighlightingTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/highlighter/UsageHighlightingTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.highlighter; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class UsageHighlightingTestGenerated extends AbstractUsageHighlightingTes } public void testAllFilesPresentInUsageHighlighter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/usageHighlighter"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/usageHighlighter"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("implicitIt.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/imports/JsOptimizeImportsTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/imports/JsOptimizeImportsTestGenerated.java index e4419306d6d..9a77dcfd75c 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/imports/JsOptimizeImportsTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/imports/JsOptimizeImportsTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.imports; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -27,7 +28,7 @@ public class JsOptimizeImportsTestGenerated extends AbstractJsOptimizeImportsTes } public void testAllFilesPresentInJs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/editor/optimizeImports/js"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/editor/optimizeImports/js"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("DefaultJsImports.kt") @@ -45,7 +46,7 @@ public class JsOptimizeImportsTestGenerated extends AbstractJsOptimizeImportsTes } public void testAllFilesPresentInCommon() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/editor/optimizeImports/common"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/editor/optimizeImports/common"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("ArrayAccessExpression.kt") @@ -242,7 +243,7 @@ public class JsOptimizeImportsTestGenerated extends AbstractJsOptimizeImportsTes } public void testAllFilesPresentInKt21515() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/editor/optimizeImports/common/kt21515"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/editor/optimizeImports/common/kt21515"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("callableReferenceOnClass.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/imports/JvmOptimizeImportsTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/imports/JvmOptimizeImportsTestGenerated.java index e3da075e714..7cea1ff9044 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/imports/JvmOptimizeImportsTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/imports/JvmOptimizeImportsTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.imports; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -27,7 +28,7 @@ public class JvmOptimizeImportsTestGenerated extends AbstractJvmOptimizeImportsT } public void testAllFilesPresentInJvm() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/editor/optimizeImports/jvm"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/editor/optimizeImports/jvm"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); } @TestMetadata("AlreadyOptimized.kt") @@ -179,7 +180,7 @@ public class JvmOptimizeImportsTestGenerated extends AbstractJvmOptimizeImportsT } public void testAllFilesPresentInAllUnderImports() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/editor/optimizeImports/jvm/allUnderImports"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/editor/optimizeImports/jvm/allUnderImports"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); } @TestMetadata("ClassNameConflict.kt") @@ -243,7 +244,7 @@ public class JvmOptimizeImportsTestGenerated extends AbstractJvmOptimizeImportsT } public void testAllFilesPresentInCommon() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/editor/optimizeImports/common"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/editor/optimizeImports/common"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("ArrayAccessExpression.kt") @@ -440,7 +441,7 @@ public class JvmOptimizeImportsTestGenerated extends AbstractJvmOptimizeImportsT } public void testAllFilesPresentInKt21515() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/editor/optimizeImports/common/kt21515"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/editor/optimizeImports/common/kt21515"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("callableReferenceOnClass.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/index/KotlinTypeAliasByExpansionShortNameIndexTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/index/KotlinTypeAliasByExpansionShortNameIndexTestGenerated.java index f9bd08ce8e4..dd0097e274b 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/index/KotlinTypeAliasByExpansionShortNameIndexTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/index/KotlinTypeAliasByExpansionShortNameIndexTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.index; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class KotlinTypeAliasByExpansionShortNameIndexTestGenerated extends Abstr } public void testAllFilesPresentInTypealiasExpansionIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/typealiasExpansionIndex"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/typealiasExpansionIndex"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("functionalTypes.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/inspections/LocalInspectionTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/inspections/LocalInspectionTestGenerated.java index e5d4e063f74..1923ac3731f 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/inspections/LocalInspectionTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/inspections/LocalInspectionTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.inspections; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInInspectionsLocal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("idea/testData/inspectionsLocal/addOperatorModifier") @@ -37,7 +38,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInAddOperatorModifier() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/addOperatorModifier"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/addOperatorModifier"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("containsBool.kt") @@ -85,7 +86,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInArrayInDataClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/arrayInDataClass"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/arrayInDataClass"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("test.kt") @@ -103,7 +104,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInBooleanLiteralArgument() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/booleanLiteralArgument"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/booleanLiteralArgument"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("boolean.kt") @@ -176,7 +177,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInBranched() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/branched"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/branched"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("idea/testData/inspectionsLocal/branched/ifThenToElvis") @@ -188,7 +189,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInIfThenToElvis() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/branched/ifThenToElvis"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/branched/ifThenToElvis"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("applicableForLocalStableVar.kt") @@ -475,7 +476,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInInspectionData() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/branched/ifThenToElvis/inspectionData"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/branched/ifThenToElvis/inspectionData"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } } } @@ -489,7 +490,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInIfThenToSafeAccess() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/branched/ifThenToSafeAccess"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/branched/ifThenToSafeAccess"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("blockHasMoreThanOneStatement.kt") @@ -811,7 +812,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInInspectionData() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/branched/ifThenToSafeAccess/inspectionData"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/branched/ifThenToSafeAccess/inspectionData"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } } } @@ -825,7 +826,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInIntroduceWhenSubject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/branched/introduceWhenSubject"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/branched/introduceWhenSubject"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("lineBreaksAndComments.kt") @@ -919,7 +920,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInCanBeVal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/canBeVal"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/canBeVal"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("lateinitVar.kt") @@ -937,7 +938,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInCascadeIf() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/cascadeIf"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/cascadeIf"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("complex.kt") @@ -1005,7 +1006,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInCollections() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/collections"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/collections"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence") @@ -1017,7 +1018,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInConvertCallChainIntoSequence() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("allTransformations.kt") @@ -1164,7 +1165,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInTermination() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/collections/convertCallChainIntoSequence/termination"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("any.kt") @@ -1613,7 +1614,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInRedundantAsSequence() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/collections/redundantAsSequence"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/collections/redundantAsSequence"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("hasComment.kt") @@ -1661,7 +1662,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInSimplifiableCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/collections/simplifiableCall"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/collections/simplifiableCall"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("arrayFlatMap.kt") @@ -1784,7 +1785,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInSimplifiableCallChain() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/collections/simplifiableCallChain"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/collections/simplifiableCallChain"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("filterFirst.kt") @@ -2041,7 +2042,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInPrimitiveArray() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/collections/simplifiableCallChain/primitiveArray"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/collections/simplifiableCallChain/primitiveArray"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("filterFirst.kt") @@ -2110,7 +2111,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInUselessCallOnCollection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/collections/uselessCallOnCollection"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/collections/uselessCallOnCollection"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("FilterIsExactInstance.kt") @@ -2238,7 +2239,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInUselessCallOnNotNull() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/collections/uselessCallOnNotNull"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/collections/uselessCallOnNotNull"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("NotNullType.kt") @@ -2302,7 +2303,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInComplexRedundantLet() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/complexRedundantLet"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/complexRedundantLet"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("assignment.kt") @@ -2680,7 +2681,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInConstantConditionIf() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/constantConditionIf"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/constantConditionIf"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("constant.kt") @@ -2818,7 +2819,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInControlFlowWithEmptyBody() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/controlFlowWithEmptyBody"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/controlFlowWithEmptyBody"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("idea/testData/inspectionsLocal/controlFlowWithEmptyBody/also") @@ -2830,7 +2831,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInAlso() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/controlFlowWithEmptyBody/also"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/controlFlowWithEmptyBody/also"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("anonymousFunction.kt") @@ -2888,7 +2889,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInDoWhile() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/controlFlowWithEmptyBody/doWhile"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/controlFlowWithEmptyBody/doWhile"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("block.kt") @@ -2926,7 +2927,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInFor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/controlFlowWithEmptyBody/for"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/controlFlowWithEmptyBody/for"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("block.kt") @@ -2964,7 +2965,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInIf() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/controlFlowWithEmptyBody/if"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/controlFlowWithEmptyBody/if"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("block.kt") @@ -3017,7 +3018,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInIfElse() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/controlFlowWithEmptyBody/ifElse"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/controlFlowWithEmptyBody/ifElse"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("block.kt") @@ -3055,7 +3056,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInWhen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/controlFlowWithEmptyBody/when"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/controlFlowWithEmptyBody/when"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("block.kt") @@ -3088,7 +3089,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInWhile() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/controlFlowWithEmptyBody/while"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/controlFlowWithEmptyBody/while"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("block.kt") @@ -3127,7 +3128,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInConventionNameCalls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/conventionNameCalls"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/conventionNameCalls"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("idea/testData/inspectionsLocal/conventionNameCalls/replaceCallWithBinaryOperator") @@ -3139,7 +3140,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInReplaceCallWithBinaryOperator() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/conventionNameCalls/replaceCallWithBinaryOperator"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/conventionNameCalls/replaceCallWithBinaryOperator"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("compareToFromJava.kt") @@ -3367,7 +3368,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInReplaceGetOrSet() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/conventionNameCalls/replaceGetOrSet"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/conventionNameCalls/replaceGetOrSet"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("argumentAndFunction.kt") @@ -3499,7 +3500,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInInspectionData() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/conventionNameCalls/replaceGetOrSet/inspectionData"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/conventionNameCalls/replaceGetOrSet/inspectionData"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } } } @@ -3514,7 +3515,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInConvertNaNEquality() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/convertNaNEquality"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/convertNaNEquality"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("float.kt") @@ -3562,7 +3563,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInConvertPairConstructorToToFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/convertPairConstructorToToFunction"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/convertPairConstructorToToFunction"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("invalidArgs.kt") @@ -3585,7 +3586,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInConvertSealedSubClassToObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/convertSealedSubClassToObject"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/convertSealedSubClassToObject"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("annotation.kt") @@ -3708,7 +3709,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInConvertTwoComparisonsToRangeCheck() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/convertTwoComparisonsToRangeCheck"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/convertTwoComparisonsToRangeCheck"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("binary.kt") @@ -3886,7 +3887,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInCopyWithoutNamedArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/copyWithoutNamedArguments"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/copyWithoutNamedArguments"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("base.kt") @@ -3914,7 +3915,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInCoroutines() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/coroutines"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/coroutines"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("idea/testData/inspectionsLocal/coroutines/deferredIsResult") @@ -3931,7 +3932,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInDeferredIsResult() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/coroutines/deferredIsResult"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/coroutines/deferredIsResult"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("complex.kt") @@ -3969,7 +3970,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInDirectUseOfResultType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/coroutines/directUseOfResultType"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/coroutines/directUseOfResultType"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("anonymous.kt") @@ -4027,7 +4028,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInRedundantAsync() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/coroutines/redundantAsync"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/coroutines/redundantAsync"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("experimental.kt") @@ -4095,7 +4096,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInRedundantRunCatching() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/coroutines/redundantRunCatching"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/coroutines/redundantRunCatching"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("simple.kt") @@ -4113,7 +4114,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInSuspendFunctionOnCoroutineScope() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/coroutines/suspendFunctionOnCoroutineScope"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/coroutines/suspendFunctionOnCoroutineScope"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("anonymous.kt") @@ -4222,7 +4223,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInCovariantEquals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/covariantEquals"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/covariantEquals"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("basic.kt") @@ -4285,7 +4286,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInDelegationToVarProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/delegationToVarProperty"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/delegationToVarProperty"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("parameter.kt") @@ -4318,7 +4319,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInDeprecatedCallableAddReplaceWith() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/deprecatedCallableAddReplaceWith"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/deprecatedCallableAddReplaceWith"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("AlreadyWithReplaceWith.kt") @@ -4455,7 +4456,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInInspectionData() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/deprecatedCallableAddReplaceWith/inspectionData"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/deprecatedCallableAddReplaceWith/inspectionData"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } } } @@ -4469,7 +4470,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInDoubleNegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/doubleNegation"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/doubleNegation"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("function.kt") @@ -4502,7 +4503,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInEmptyRange() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/emptyRange"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/emptyRange"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("simple.kt") @@ -4520,7 +4521,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInEqualsBetweenInconvertibleTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/equalsBetweenInconvertibleTypes"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/equalsBetweenInconvertibleTypes"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("enumEqEnum.kt") @@ -4643,7 +4644,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInExplicitThis() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/explicitThis"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/explicitThis"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("differentReceiverInstance.kt") @@ -4791,7 +4792,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInFoldInitializerAndIfToElvis() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/foldInitializerAndIfToElvis"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/foldInitializerAndIfToElvis"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("Break.kt") @@ -4964,7 +4965,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInForEachParameterNotUsed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/forEachParameterNotUsed"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/forEachParameterNotUsed"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("invoke.kt") @@ -5007,7 +5008,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInFunctionWithLambdaExpressionBody() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/functionWithLambdaExpressionBody"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/functionWithLambdaExpressionBody"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("functionHasArrow.kt") @@ -5069,7 +5070,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInAddArrow() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/functionWithLambdaExpressionBody/addArrow"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/functionWithLambdaExpressionBody/addArrow"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("function.kt") @@ -5092,7 +5093,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInRemoveBraces() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/functionWithLambdaExpressionBody/removeBraces"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/functionWithLambdaExpressionBody/removeBraces"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("function.kt") @@ -5130,7 +5131,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInSpecifyType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/functionWithLambdaExpressionBody/specifyType"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/functionWithLambdaExpressionBody/specifyType"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("function.kt") @@ -5153,7 +5154,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInWrapRun() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/functionWithLambdaExpressionBody/wrapRun"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/functionWithLambdaExpressionBody/wrapRun"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("function.kt") @@ -5192,7 +5193,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInImplicitNullableNothingType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/implicitNullableNothingType"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/implicitNullableNothingType"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("final.kt") @@ -5250,7 +5251,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInImplicitThis() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/implicitThis"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/implicitThis"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("already.kt") @@ -5323,7 +5324,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInIncompleteDestructuringInspection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/incompleteDestructuringInspection"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/incompleteDestructuringInspection"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("basic.kt") @@ -5351,7 +5352,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInJavaCollectionsStaticMethod() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/javaCollectionsStaticMethod"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/javaCollectionsStaticMethod"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("fill.kt") @@ -5419,7 +5420,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInJavaMapForEach() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/javaMapForEach"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/javaMapForEach"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("destructuringDeclaration.kt") @@ -5472,7 +5473,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInKdocMissingDocumentation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/kdocMissingDocumentation"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/kdocMissingDocumentation"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("primaryConstructorProperty.kt") @@ -5500,7 +5501,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInLateinitVarOverridesLateinitVar() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/lateinitVarOverridesLateinitVar"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/lateinitVarOverridesLateinitVar"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("basic.kt") @@ -5528,7 +5529,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInLeakingThis() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/leakingThis"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/leakingThis"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("enum.kt") @@ -5591,7 +5592,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInLiftOut() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/liftOut"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/liftOut"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("idea/testData/inspectionsLocal/liftOut/ifToAssignment") @@ -5603,7 +5604,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInIfToAssignment() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/liftOut/ifToAssignment"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/liftOut/ifToAssignment"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("cascadeIf.kt") @@ -5771,7 +5772,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInIfToReturn() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/liftOut/ifToReturn"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/liftOut/ifToReturn"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("cascadeIf.kt") @@ -5834,7 +5835,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInTryToAssignment() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/liftOut/tryToAssignment"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/liftOut/tryToAssignment"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("basic.kt") @@ -5912,7 +5913,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInTryToReturn() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/liftOut/tryToReturn"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/liftOut/tryToReturn"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("basic.kt") @@ -5970,7 +5971,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInWhenToAssignment() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/liftOut/whenToAssignment"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/liftOut/whenToAssignment"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("cascadeWhen.kt") @@ -6058,7 +6059,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInWhenToReturn() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/liftOut/whenToReturn"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/liftOut/whenToReturn"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("cascadeWhen.kt") @@ -6147,7 +6148,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInLogging() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/logging"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/logging"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("idea/testData/inspectionsLocal/logging/loggerInitializedWithForeignClass") @@ -6159,7 +6160,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInLoggerInitializedWithForeignClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/logging/loggerInitializedWithForeignClass"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/logging/loggerInitializedWithForeignClass"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("idea/testData/inspectionsLocal/logging/loggerInitializedWithForeignClass/commons") @@ -6171,7 +6172,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInCommons() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/logging/loggerInitializedWithForeignClass/commons"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/logging/loggerInitializedWithForeignClass/commons"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("canonicalName.kt") @@ -6234,7 +6235,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInLog4j() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/logging/loggerInitializedWithForeignClass/log4j"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/logging/loggerInitializedWithForeignClass/log4j"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("simple.kt") @@ -6252,7 +6253,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInLog4j2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/logging/loggerInitializedWithForeignClass/log4j2"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/logging/loggerInitializedWithForeignClass/log4j2"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("simple.kt") @@ -6270,7 +6271,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInSlf4j() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/logging/loggerInitializedWithForeignClass/slf4j"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/logging/loggerInitializedWithForeignClass/slf4j"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("simple.kt") @@ -6288,7 +6289,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInUtil() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/logging/loggerInitializedWithForeignClass/util"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/logging/loggerInitializedWithForeignClass/util"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("simple.kt") @@ -6313,7 +6314,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInMainFunctionReturnUnit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/mainFunctionReturnUnit"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/mainFunctionReturnUnit"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("junit4Test.kt") @@ -6361,7 +6362,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInMapGetWithNotNullAssertionOperator() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/mapGetWithNotNullAssertionOperator"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/mapGetWithNotNullAssertionOperator"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("get.kt") @@ -6409,7 +6410,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInMayBeConstant() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/mayBeConstant"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/mayBeConstant"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("array.kt") @@ -6542,7 +6543,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInMemberVisibilityCanBePrivate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/memberVisibilityCanBePrivate"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/memberVisibilityCanBePrivate"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("annotation.kt") @@ -6585,7 +6586,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInMigrateDiagnosticSuppression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/migrateDiagnosticSuppression"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/migrateDiagnosticSuppression"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("base.kt") @@ -6613,7 +6614,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInMoveLambdaOutsideParentheses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/moveLambdaOutsideParentheses"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/moveLambdaOutsideParentheses"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("ambigousOverload.kt") @@ -6751,7 +6752,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInMoveSuspiciousCallableReferenceIntoParentheses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/moveSuspiciousCallableReferenceIntoParentheses"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/moveSuspiciousCallableReferenceIntoParentheses"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("defaultParameter.kt") @@ -6859,7 +6860,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInMoveVariableDeclarationIntoWhen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/moveVariableDeclarationIntoWhen"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/moveVariableDeclarationIntoWhen"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("hasBreak.kt") @@ -6987,7 +6988,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInNestedLambdaShadowedImplicitParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/nestedLambdaShadowedImplicitParameter"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/nestedLambdaShadowedImplicitParameter"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("explicit.kt") @@ -7075,7 +7076,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInNullChecksToSafeCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/nullChecksToSafeCall"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/nullChecksToSafeCall"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("andCase.kt") @@ -7128,7 +7129,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInNullableBooleanElvis() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/nullableBooleanElvis"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/nullableBooleanElvis"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("inIf.kt") @@ -7166,7 +7167,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInObjectLiteralToLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/objectLiteralToLambda"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/objectLiteralToLambda"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("notMatchFunctionParameterType.kt") @@ -7184,7 +7185,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInProhibitJvmOverloadsOnConstructorsOfAnnotationClassesMigration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/prohibitJvmOverloadsOnConstructorsOfAnnotationClassesMigration"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/prohibitJvmOverloadsOnConstructorsOfAnnotationClassesMigration"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("simple.kt") @@ -7202,7 +7203,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInProhibitRepeatedUseSiteTargetAnnotationsMigration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/prohibitRepeatedUseSiteTargetAnnotationsMigration"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/prohibitRepeatedUseSiteTargetAnnotationsMigration"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("notApplicable.kt") @@ -7250,7 +7251,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInProhibitTypeParametersForLocalVariablesMigration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/prohibitTypeParametersForLocalVariablesMigration"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/prohibitTypeParametersForLocalVariablesMigration"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("simple.kt") @@ -7268,7 +7269,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInProhibitUseSiteTargetAnnotationsOnSuperTypesMigration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/prohibitUseSiteTargetAnnotationsOnSuperTypesMigration"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/prohibitUseSiteTargetAnnotationsOnSuperTypesMigration"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("simple.kt") @@ -7306,7 +7307,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInRecursiveEqualsCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/recursiveEqualsCall"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/recursiveEqualsCall"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("recursive.kt") @@ -7369,7 +7370,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInRedundantCompanionReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/redundantCompanionReference"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/redundantCompanionReference"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("basic.kt") @@ -7617,7 +7618,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInRedundantElseInIf() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/redundantElseInIf"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/redundantElseInIf"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("empty.kt") @@ -7690,7 +7691,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInRedundantElvisReturnNull() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/redundantElvisReturnNull"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/redundantElvisReturnNull"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("basic.kt") @@ -7723,7 +7724,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInRedundantEmptyInitializerBlock() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/redundantEmptyInitializerBlock"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/redundantEmptyInitializerBlock"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("empty.kt") @@ -7751,7 +7752,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInRedundantEnumConstructorInvocation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/redundantEnumConstructorInvocation"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/redundantEnumConstructorInvocation"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("basic.kt") @@ -7784,7 +7785,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInRedundantExplicitType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/redundantExplicitType"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/redundantExplicitType"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("boolean.kt") @@ -7877,7 +7878,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInRedundantGetter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/redundantGetter"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/redundantGetter"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("annotation.kt") @@ -7955,7 +7956,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInRedundantInnerClassModifier() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/redundantInnerClassModifier"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/redundantInnerClassModifier"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("extendClass.kt") @@ -8103,7 +8104,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInRedundantLabelMigration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/redundantLabelMigration"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/redundantLabelMigration"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("simple.kt") @@ -8126,7 +8127,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInRedundantLambdaArrow() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/redundantLambdaArrow"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/redundantLambdaArrow"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("forEach.kt") @@ -8309,7 +8310,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInRedundantNullableReturnType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/redundantNullableReturnType"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/redundantNullableReturnType"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("idea/testData/inspectionsLocal/redundantNullableReturnType/function") @@ -8321,7 +8322,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/redundantNullableReturnType/function"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/redundantNullableReturnType/function"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("blockBody.kt") @@ -8394,7 +8395,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/redundantNullableReturnType/property"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/redundantNullableReturnType/property"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("getter.kt") @@ -8438,7 +8439,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInRedundantObjectTypeCheck() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/redundantObjectTypeCheck"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/redundantObjectTypeCheck"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("isClass.kt") @@ -8486,7 +8487,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInRedundantOverride() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/redundantOverride"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/redundantOverride"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("annotated.kt") @@ -8639,7 +8640,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInRedundantRequireNotNullCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/redundantRequireNotNullCall"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/redundantRequireNotNullCall"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("checkNotNull.kt") @@ -8702,7 +8703,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInRedundantReturnLabel() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/redundantReturnLabel"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/redundantReturnLabel"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("inAnonymousFunction.kt") @@ -8735,7 +8736,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInRedundantSamConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/redundantSamConstructor"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/redundantSamConstructor"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("conversionPerArgumentDisabled1.kt") @@ -8843,7 +8844,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInRedundantSemicolon() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/redundantSemicolon"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/redundantSemicolon"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("beforeAnnotationAndLambda.kt") @@ -8951,7 +8952,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInRedundantSetter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/redundantSetter"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/redundantSetter"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("annotation.kt") @@ -9054,7 +9055,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInRedundantSuspend() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/redundantSuspend"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/redundantSuspend"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("coroutineContext.kt") @@ -9087,7 +9088,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInRedundantUnitExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/redundantUnitExpression"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/redundantUnitExpression"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("atLastAfterClass.kt") @@ -9295,7 +9296,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInRedundantVisibilityModifier() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/redundantVisibilityModifier"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/redundantVisibilityModifier"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("internalInPrivateClass.kt") @@ -9348,7 +9349,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInRedundantWith() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/redundantWith"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/redundantWith"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("asInitializer.kt") @@ -9471,7 +9472,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInRemoveCurlyBracesFromTemplate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/removeCurlyBracesFromTemplate"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/removeCurlyBracesFromTemplate"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("necessaryBrackets1.kt") @@ -9569,7 +9570,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInRemoveEmptyParenthesesFromAnnotationEntry() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/removeEmptyParenthesesFromAnnotationEntry"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/removeEmptyParenthesesFromAnnotationEntry"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("allParameterHaveDefaults.kt") @@ -9612,7 +9613,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInRemoveRedundantBackticks() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/removeRedundantBackticks"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/removeRedundantBackticks"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("functionArgument.kt") @@ -9685,7 +9686,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInRemoveRedundantQualifierName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/removeRedundantQualifierName"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/removeRedundantQualifierName"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("asReceiver.kt") @@ -10118,7 +10119,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInRemoveRedundantSpreadOperator() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/removeRedundantSpreadOperator"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/removeRedundantSpreadOperator"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("basic.kt") @@ -10236,7 +10237,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInRemoveSetterParameterType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/removeSetterParameterType"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/removeSetterParameterType"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("emptyType.kt") @@ -10254,7 +10255,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInRemoveToStringInStringTemplate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/removeToStringInStringTemplate"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/removeToStringInStringTemplate"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("caretInReceiver.kt") @@ -10277,7 +10278,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInReplaceArrayEqualityOpWithArraysEquals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceArrayEqualityOpWithArraysEquals"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceArrayEqualityOpWithArraysEquals"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("arrayAndOtherTypeEQEQ.kt") @@ -10310,7 +10311,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInReplaceArrayOfWithLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceArrayOfWithLiteral"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceArrayOfWithLiteral"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("base.kt") @@ -10378,7 +10379,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInReplaceAssertBooleanWithAssertEquality() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceAssertBooleanWithAssertEquality"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceAssertBooleanWithAssertEquality"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("assertFalse.kt") @@ -10451,7 +10452,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInReplaceAssociateFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceAssociateFunction"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceAssociateFunction"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("version1_2.kt") @@ -10468,7 +10469,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInAssociateBy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceAssociateFunction/associateBy"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceAssociateFunction/associateBy"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("array.kt") @@ -10491,7 +10492,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInAssociateByKeyAndValue() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceAssociateFunction/associateByKeyAndValue"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceAssociateFunction/associateByKeyAndValue"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("array.kt") @@ -10539,7 +10540,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInAssociateByTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceAssociateFunction/associateByTo"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceAssociateFunction/associateByTo"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("array.kt") @@ -10562,7 +10563,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInAssociateByToKeyAndValue() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceAssociateFunction/associateByToKeyAndValue"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceAssociateFunction/associateByToKeyAndValue"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("array.kt") @@ -10600,7 +10601,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInAssociateWith() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceAssociateFunction/associateWith"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceAssociateFunction/associateWith"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("array.kt") @@ -10673,7 +10674,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInAssociateWithTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceAssociateFunction/associateWithTo"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceAssociateFunction/associateWithTo"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("array.kt") @@ -10717,7 +10718,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInReplaceCollectionCountWithSize() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceCollectionCountWithSize"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceCollectionCountWithSize"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("countOfArray.kt") @@ -10765,7 +10766,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInReplaceGuardClauseWithFunctionCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceGuardClauseWithFunctionCall"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceGuardClauseWithFunctionCall"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("notStringArgument.kt") @@ -10797,7 +10798,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInCheck() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceGuardClauseWithFunctionCall/check"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceGuardClauseWithFunctionCall/check"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("basic.kt") @@ -10815,7 +10816,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInCheckNotNull() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceGuardClauseWithFunctionCall/checkNotNull"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceGuardClauseWithFunctionCall/checkNotNull"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("basic.kt") @@ -10833,7 +10834,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInRequire() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceGuardClauseWithFunctionCall/require"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceGuardClauseWithFunctionCall/require"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("basic.kt") @@ -10891,7 +10892,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInRequireNotNull() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceGuardClauseWithFunctionCall/requireNotNull"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceGuardClauseWithFunctionCall/requireNotNull"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("basic.kt") @@ -10915,7 +10916,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInReplaceJavaStaticMethodWithKotlinAnalog() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceJavaStaticMethodWithKotlinAnalog"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceJavaStaticMethodWithKotlinAnalog"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("idea/testData/inspectionsLocal/replaceJavaStaticMethodWithKotlinAnalog/collections") @@ -10927,7 +10928,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInCollections() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceJavaStaticMethodWithKotlinAnalog/collections"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceJavaStaticMethodWithKotlinAnalog/collections"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("asList.kt") @@ -11055,7 +11056,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInCompare() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceJavaStaticMethodWithKotlinAnalog/compare"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceJavaStaticMethodWithKotlinAnalog/compare"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("byte.kt") @@ -11103,7 +11104,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInIo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceJavaStaticMethodWithKotlinAnalog/io"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceJavaStaticMethodWithKotlinAnalog/io"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("notApplicablePrint.kt") @@ -11196,7 +11197,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInMath() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceJavaStaticMethodWithKotlinAnalog/math"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceJavaStaticMethodWithKotlinAnalog/math"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("asin.kt") @@ -11374,7 +11375,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInSystem() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceJavaStaticMethodWithKotlinAnalog/system"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceJavaStaticMethodWithKotlinAnalog/system"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("exit.kt") @@ -11392,7 +11393,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInToString() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceJavaStaticMethodWithKotlinAnalog/toString"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceJavaStaticMethodWithKotlinAnalog/toString"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("byteToString.kt") @@ -11496,7 +11497,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInReplaceManualRangeWithIndicesCalls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceManualRangeWithIndicesCalls"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceManualRangeWithIndicesCalls"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("forNotTarget.kt") @@ -11539,7 +11540,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInReplaceNegatedIsEmptyWithIsNotEmpty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceNegatedIsEmptyWithIsNotEmpty"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceNegatedIsEmptyWithIsNotEmpty"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("notNegateBlank.kt") @@ -11587,7 +11588,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInReplaceNotNullAssertionWithElvisReturn() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceNotNullAssertionWithElvisReturn"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceNotNullAssertionWithElvisReturn"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("basic.kt") @@ -11670,7 +11671,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInReplacePutWithAssignment() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replacePutWithAssignment"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replacePutWithAssignment"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("beforeElvis.kt") @@ -11748,7 +11749,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInReplaceRangeStartEndInclusiveWithFirstLast() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceRangeStartEndInclusiveWithFirstLast"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceRangeStartEndInclusiveWithFirstLast"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("customRange.kt") @@ -11796,7 +11797,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInReplaceRangeToWithUntil() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceRangeToWithUntil"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceRangeToWithUntil"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("closedRange.kt") @@ -11849,7 +11850,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInReplaceStringFormatWithLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceStringFormatWithLiteral"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceStringFormatWithLiteral"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("curlyBraces.kt") @@ -11912,7 +11913,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInReplaceSubstring() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceSubstring"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceSubstring"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("idea/testData/inspectionsLocal/replaceSubstring/withDropLast") @@ -11924,7 +11925,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInWithDropLast() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceSubstring/withDropLast"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceSubstring/withDropLast"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("immutableProperty.kt") @@ -11962,7 +11963,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInWithIndexingOperation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceSubstring/withIndexingOperation"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceSubstring/withIndexingOperation"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("oneFirstTwoSecondArgument.kt") @@ -11990,7 +11991,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInWithSubstringAfter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceSubstring/withSubstringAfter"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceSubstring/withSubstringAfter"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("immutableProperty.kt") @@ -12023,7 +12024,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInWithSubstringBefore() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceSubstring/withSubstringBefore"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceSubstring/withSubstringBefore"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("immutableProperty.kt") @@ -12061,7 +12062,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInWithTake() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceSubstring/withTake"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceSubstring/withTake"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("constantAsFirstArgument.kt") @@ -12100,7 +12101,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInReplaceToStringWithStringTemplate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceToStringWithStringTemplate"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceToStringWithStringTemplate"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("callExpression.kt") @@ -12133,7 +12134,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInReplaceToWithInfixForm() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceToWithInfixForm"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceToWithInfixForm"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("base.kt") @@ -12161,7 +12162,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInReplaceWithEnumMap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceWithEnumMap"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceWithEnumMap"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("inferred.kt") @@ -12199,7 +12200,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInReplaceWithIgnoreCaseEquals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceWithIgnoreCaseEquals"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceWithIgnoreCaseEquals"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("extension.kt") @@ -12267,7 +12268,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInReplaceWithOperatorAssignment() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceWithOperatorAssignment"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/replaceWithOperatorAssignment"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("flexibleTypeBug.kt") @@ -12355,7 +12356,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInRestrictReturnStatementTargetMigration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/restrictReturnStatementTargetMigration"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/restrictReturnStatementTargetMigration"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("simple.kt") @@ -12378,7 +12379,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInSafeCastWithReturn() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/safeCastWithReturn"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/safeCastWithReturn"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("castNeverSucceeds.kt") @@ -12431,7 +12432,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInScopeFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/scopeFunctions"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/scopeFunctions"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("idea/testData/inspectionsLocal/scopeFunctions/alsoToApply") @@ -12443,7 +12444,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInAlsoToApply() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/scopeFunctions/alsoToApply"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/scopeFunctions/alsoToApply"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("simple.kt") @@ -12461,7 +12462,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInApplyToAlso() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/scopeFunctions/applyToAlso"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/scopeFunctions/applyToAlso"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("arrow.kt") @@ -12529,7 +12530,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInLetToRun() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/scopeFunctions/letToRun"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/scopeFunctions/letToRun"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("nestedLambda.kt") @@ -12582,7 +12583,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInRunToLet() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/scopeFunctions/runToLet"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/scopeFunctions/runToLet"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("capturedIt.kt") @@ -12611,7 +12612,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInSelfAssignment() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/selfAssignment"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/selfAssignment"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("applyCorrect.kt") @@ -12734,7 +12735,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInSelfReferenceConstructorParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/selfReferenceConstructorParameter"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/selfReferenceConstructorParameter"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("basic.kt") @@ -12762,7 +12763,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInSetterBackingFieldAssignment() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/setterBackingFieldAssignment"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/setterBackingFieldAssignment"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("assignment.kt") @@ -12860,7 +12861,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInSimpleRedundantLet() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/simpleRedundantLet"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/simpleRedundantLet"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("assignment.kt") @@ -13268,7 +13269,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInSimplifyAssertNotNull() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/simplifyAssertNotNull"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/simplifyAssertNotNull"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("comments.kt") @@ -13336,7 +13337,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInSimplifyNegatedBinaryExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/simplifyNegatedBinaryExpression"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/simplifyNegatedBinaryExpression"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("equals.kt") @@ -13408,7 +13409,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInInspectionData() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/simplifyNegatedBinaryExpression/inspectionData"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/simplifyNegatedBinaryExpression/inspectionData"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } } } @@ -13422,7 +13423,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInSimplifyNestedEachInScope() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/simplifyNestedEachInScope"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/simplifyNestedEachInScope"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("also.kt") @@ -13500,7 +13501,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInSimplifyWhenWithBooleanConstantCondition() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/simplifyWhenWithBooleanConstantCondition"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/simplifyWhenWithBooleanConstantCondition"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("falseAndElse1.kt") @@ -13583,7 +13584,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInSortModifiers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/sortModifiers"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/sortModifiers"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("annotatedBefore.kt") @@ -13636,7 +13637,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInSuspiciousAsDynamic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/suspiciousAsDynamic"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/suspiciousAsDynamic"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("simple.kt") @@ -13654,7 +13655,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInSuspiciousCollectionReassignment() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/suspiciousCollectionReassignment"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/suspiciousCollectionReassignment"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("hasError.kt") @@ -13717,7 +13718,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInSuspiciousVarProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/suspiciousVarProperty"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/suspiciousVarProperty"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("hasBackingFieldRef.kt") @@ -13755,7 +13756,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInThrowableNotThrown() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/throwableNotThrown"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/throwableNotThrown"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("basic.kt") @@ -13913,7 +13914,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInTrailingComma() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/trailingComma"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/trailingComma"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("changeCommaPosition.kt") @@ -14041,7 +14042,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInUnlabeledReturnInsideLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/unlabeledReturnInsideLambda"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/unlabeledReturnInsideLambda"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("labeledReturn.kt") @@ -14074,7 +14075,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInUnnecessaryVariable() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/unnecessaryVariable"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/unnecessaryVariable"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("copyOfVal.kt") @@ -14167,7 +14168,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInUnsafeCastFromDynamic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/unsafeCastFromDynamic"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/unsafeCastFromDynamic"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("binaryExpression.kt") @@ -14195,7 +14196,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInUnusedDataClassCopyResult() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/unusedDataClassCopyResult"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/unusedDataClassCopyResult"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("basic.kt") @@ -14228,7 +14229,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInUnusedEquals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/unusedEquals"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/unusedEquals"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("equals.kt") @@ -14261,7 +14262,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInUnusedLambdaExpressionBody() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/unusedLambdaExpressionBody"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/unusedLambdaExpressionBody"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("inEnumEntry.kt") @@ -14284,7 +14285,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInUnusedMainParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/unusedMainParameter"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/unusedMainParameter"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("future.kt") @@ -14317,7 +14318,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInUnusedReceiverParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/unusedReceiverParameter"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/unusedReceiverParameter"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("anonymousFunction.kt") @@ -14430,7 +14431,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInUnusedSymbol() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/unusedSymbol"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/unusedSymbol"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("asDefaultConstructorParameter.kt") @@ -14618,7 +14619,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInUnusedUnaryOperator() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/unusedUnaryOperator"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/unusedUnaryOperator"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("annotation.kt") @@ -14676,7 +14677,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInUseExpressionBody() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/useExpressionBody"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/useExpressionBody"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("if.kt") @@ -14723,7 +14724,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInConvertToExpressionBody() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/useExpressionBody/convertToExpressionBody"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/useExpressionBody/convertToExpressionBody"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("anonymousObjectExpression.kt") @@ -14955,7 +14956,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInKeepComments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/useExpressionBody/convertToExpressionBody/keepComments"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/useExpressionBody/convertToExpressionBody/keepComments"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } } } @@ -14970,7 +14971,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInUsePropertyAccessSyntax() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/usePropertyAccessSyntax"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/usePropertyAccessSyntax"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("caretOnValueArgumentList.kt") @@ -14998,7 +14999,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInWarningOnMainUnusedParameterMigration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/warningOnMainUnusedParameterMigration"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/warningOnMainUnusedParameterMigration"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("notApplicable.kt") @@ -15021,7 +15022,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInWhenWithOnlyElse() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/whenWithOnlyElse"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/whenWithOnlyElse"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("complexExpression.kt") @@ -15053,7 +15054,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInSubjectVariable() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/whenWithOnlyElse/subjectVariable"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/whenWithOnlyElse/subjectVariable"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("hasAnnotation.kt") @@ -15090,7 +15091,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInBlockElse() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/whenWithOnlyElse/subjectVariable/blockElse"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/whenWithOnlyElse/subjectVariable/blockElse"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("multiReference.kt") @@ -15123,7 +15124,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInBlockElseUsedAsExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/whenWithOnlyElse/subjectVariable/blockElseUsedAsExpression"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/whenWithOnlyElse/subjectVariable/blockElseUsedAsExpression"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("multiReference.kt") @@ -15156,7 +15157,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInSingleElse() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/whenWithOnlyElse/subjectVariable/singleElse"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/whenWithOnlyElse/subjectVariable/singleElse"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("multiReference.kt") @@ -15211,7 +15212,7 @@ public class LocalInspectionTestGenerated extends AbstractLocalInspectionTest { } public void testAllFilesPresentInWrapUnaryOperator() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/wrapUnaryOperator"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/inspectionsLocal/wrapUnaryOperator"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("simple.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/inspections/MultiFileLocalInspectionTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/inspections/MultiFileLocalInspectionTestGenerated.java index a94d9769223..5176234a2bc 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/inspections/MultiFileLocalInspectionTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/inspections/MultiFileLocalInspectionTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.inspections; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class MultiFileLocalInspectionTestGenerated extends AbstractMultiFileLoca } public void testAllFilesPresentInMultiFileLocalInspections() throws Exception { - KotlinTestUtils.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File("idea/testData/multiFileLocalInspections"), Pattern.compile("^(.+)\\.test$"), null); + KtTestUtil.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File("idea/testData/multiFileLocalInspections"), Pattern.compile("^(.+)\\.test$"), null); } @TestMetadata("convertSealedSubClassToObject/convertCallableReferenceUsages/convertCallableReferenceUsages.test") diff --git a/idea/tests/org/jetbrains/kotlin/idea/intentions/ConcatenatedStringGeneratorTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/intentions/ConcatenatedStringGeneratorTestGenerated.java index c3da26aae78..4ad784ec5bd 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/intentions/ConcatenatedStringGeneratorTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/intentions/ConcatenatedStringGeneratorTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.intentions; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class ConcatenatedStringGeneratorTestGenerated extends AbstractConcatenat } public void testAllFilesPresentInConcatenatedStringGenerator() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/concatenatedStringGenerator"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/concatenatedStringGenerator"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("constants.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/intentions/IntentionTest2Generated.java b/idea/tests/org/jetbrains/kotlin/idea/intentions/IntentionTest2Generated.java index edbc4dc1c13..4cc062e3cc1 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/intentions/IntentionTest2Generated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/intentions/IntentionTest2Generated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.intentions; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class IntentionTest2Generated extends AbstractIntentionTest2 { } public void testAllFilesPresentInLoopToCallChain() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("array.kt") @@ -102,7 +103,7 @@ public class IntentionTest2Generated extends AbstractIntentionTest2 { } public void testAllFilesPresentInAny() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/any"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/any"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("anyNotNull.kt") @@ -215,7 +216,7 @@ public class IntentionTest2Generated extends AbstractIntentionTest2 { } public void testAllFilesPresentInContains() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/contains"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/contains"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } } @@ -238,7 +239,7 @@ public class IntentionTest2Generated extends AbstractIntentionTest2 { } public void testAllFilesPresentInCount() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/count"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/count"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("countIsInstance.kt") @@ -291,7 +292,7 @@ public class IntentionTest2Generated extends AbstractIntentionTest2 { } public void testAllFilesPresentInFilter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/filter"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/filter"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("assign.kt") @@ -554,7 +555,7 @@ public class IntentionTest2Generated extends AbstractIntentionTest2 { } public void testAllFilesPresentInFirstOrNull() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/firstOrNull"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/firstOrNull"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("assignmentInitialization.kt") @@ -667,7 +668,7 @@ public class IntentionTest2Generated extends AbstractIntentionTest2 { } public void testAllFilesPresentInFlatMap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/flatMap"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/flatMap"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("break.kt") @@ -735,7 +736,7 @@ public class IntentionTest2Generated extends AbstractIntentionTest2 { } public void testAllFilesPresentInForEach() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/forEach"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/forEach"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("indexed.kt") @@ -783,7 +784,7 @@ public class IntentionTest2Generated extends AbstractIntentionTest2 { } public void testAllFilesPresentInIndexOf() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/indexOf"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/indexOf"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("indexOf.kt") @@ -831,7 +832,7 @@ public class IntentionTest2Generated extends AbstractIntentionTest2 { } public void testAllFilesPresentInIntroduceIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/introduceIndex"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/introduceIndex"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("indexPlusPlusInsideExpression.kt") @@ -884,7 +885,7 @@ public class IntentionTest2Generated extends AbstractIntentionTest2 { } public void testAllFilesPresentInMap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/map"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/map"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("assignMap.kt") @@ -1037,7 +1038,7 @@ public class IntentionTest2Generated extends AbstractIntentionTest2 { } public void testAllFilesPresentInMaxMin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/maxMin"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/maxMin"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("KT14210.kt") @@ -1115,7 +1116,7 @@ public class IntentionTest2Generated extends AbstractIntentionTest2 { } public void testAllFilesPresentInSmartCasts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/smartCasts"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/smartCasts"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("errorOutsideLoop.kt") @@ -1203,7 +1204,7 @@ public class IntentionTest2Generated extends AbstractIntentionTest2 { } public void testAllFilesPresentInSum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/sum"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/sum"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("bytes.kt") @@ -1301,7 +1302,7 @@ public class IntentionTest2Generated extends AbstractIntentionTest2 { } public void testAllFilesPresentInTakeWhile() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/takeWhile"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/takeWhile"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("ifElse1.kt") @@ -1349,7 +1350,7 @@ public class IntentionTest2Generated extends AbstractIntentionTest2 { } public void testAllFilesPresentInToCollection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/toCollection"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/toCollection"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("badReceiver1.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/intentions/IntentionTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/intentions/IntentionTestGenerated.java index ec83710c5e7..ffc098cf01e 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/intentions/IntentionTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/intentions/IntentionTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.intentions; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInIntentions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("idea/testData/intentions/addAnnotationUseSiteTarget") @@ -37,7 +38,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInAddAnnotationUseSiteTarget() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addAnnotationUseSiteTarget"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addAnnotationUseSiteTarget"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("hasAnnotationArgs.kt") @@ -69,7 +70,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addAnnotationUseSiteTarget/constructor"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addAnnotationUseSiteTarget/constructor"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("parameter.kt") @@ -91,7 +92,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInVal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addAnnotationUseSiteTarget/constructor/val"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addAnnotationUseSiteTarget/constructor/val"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("delegate.kt") @@ -149,7 +150,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInVar() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addAnnotationUseSiteTarget/constructor/var"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addAnnotationUseSiteTarget/constructor/var"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("delegate.kt") @@ -208,7 +209,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInExtension() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addAnnotationUseSiteTarget/extension"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addAnnotationUseSiteTarget/extension"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("idea/testData/intentions/addAnnotationUseSiteTarget/extension/function") @@ -220,7 +221,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addAnnotationUseSiteTarget/extension/function"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addAnnotationUseSiteTarget/extension/function"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("delegate.kt") @@ -278,7 +279,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addAnnotationUseSiteTarget/extension/property"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addAnnotationUseSiteTarget/extension/property"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("delegate.kt") @@ -337,7 +338,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addAnnotationUseSiteTarget/property"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addAnnotationUseSiteTarget/property"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("local.kt") @@ -354,7 +355,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInDelegate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addAnnotationUseSiteTarget/property/delegate"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addAnnotationUseSiteTarget/property/delegate"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("delegate.kt") @@ -412,7 +413,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInVal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addAnnotationUseSiteTarget/property/val"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addAnnotationUseSiteTarget/property/val"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("delegate.kt") @@ -470,7 +471,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInValNoBacking() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addAnnotationUseSiteTarget/property/valNoBacking"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addAnnotationUseSiteTarget/property/valNoBacking"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("delegate.kt") @@ -528,7 +529,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInVar() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addAnnotationUseSiteTarget/property/var"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addAnnotationUseSiteTarget/property/var"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("delegate.kt") @@ -586,7 +587,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInVarNoBacking() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addAnnotationUseSiteTarget/property/varNoBacking"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addAnnotationUseSiteTarget/property/varNoBacking"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("delegate.kt") @@ -746,7 +747,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInAddBraces() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addBraces"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addBraces"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("doWhileWithComment.kt") @@ -819,7 +820,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInAddConstModifier() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addConstModifier"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addConstModifier"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("inapplicableToConst.kt") @@ -857,7 +858,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInAddForLoopIndices() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addForLoopIndices"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addForLoopIndices"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("explicitParamType.kt") @@ -940,7 +941,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInAddJvmOverloads() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addJvmOverloads"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addJvmOverloads"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("alreadyHasAnnotation.kt") @@ -998,7 +999,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInAddJvmStatic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addJvmStatic"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addJvmStatic"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("constVal.kt") @@ -1071,7 +1072,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInAddLabeledReturnInLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addLabeledReturnInLambda"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addLabeledReturnInLambda"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("insideParenthesis.kt") @@ -1154,7 +1155,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInAddMissingClassKeyword() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addMissingClassKeyword"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addMissingClassKeyword"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("annottion.kt") @@ -1202,7 +1203,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInAddMissingDestructuring() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addMissingDestructuring"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addMissingDestructuring"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("empty.kt") @@ -1240,7 +1241,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInAddNameToArgument() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addNameToArgument"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addNameToArgument"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("alreadyNamed.kt") @@ -1393,7 +1394,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInAddNamesToCallArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addNamesToCallArguments"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addNamesToCallArguments"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("allNamed.kt") @@ -1471,7 +1472,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInAddNamesToFollowingArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addNamesToFollowingArguments"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addNamesToFollowingArguments"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("first.kt") @@ -1509,7 +1510,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInAddOpenModifier() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addOpenModifier"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addOpenModifier"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("alreadyOpen.kt") @@ -1582,7 +1583,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInAddPropertyAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addPropertyAccessors"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addPropertyAccessors"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("idea/testData/intentions/addPropertyAccessors/both") @@ -1599,7 +1600,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInBoth() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addPropertyAccessors/both"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addPropertyAccessors/both"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("delegate.kt") @@ -1672,7 +1673,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInGetter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addPropertyAccessors/getter"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addPropertyAccessors/getter"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("delegate.kt") @@ -1750,7 +1751,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInSetter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addPropertyAccessors/setter"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addPropertyAccessors/setter"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("delegate.kt") @@ -1819,7 +1820,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInAddThrowsAnnotation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addThrowsAnnotation"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addThrowsAnnotation"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("fqName.kt") @@ -1972,7 +1973,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInAddValOrVar() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addValOrVar"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addValOrVar"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("dataClass.kt") @@ -2035,7 +2036,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInAddWhenRemainingBranches() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addWhenRemainingBranches"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/addWhenRemainingBranches"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("noElse.kt") @@ -2063,7 +2064,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInAnonymousFunctionToLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/anonymousFunctionToLambda"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/anonymousFunctionToLambda"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("callMultiline.kt") @@ -2161,7 +2162,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInBranched() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/branched"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/branched"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("idea/testData/intentions/branched/doubleBangToIfThen") @@ -2173,7 +2174,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInDoubleBangToIfThen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/branched/doubleBangToIfThen"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/branched/doubleBangToIfThen"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("callExpression.kt") @@ -2266,7 +2267,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInElvisToIfThen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/branched/elvisToIfThen"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/branched/elvisToIfThen"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("assignmentAndBreak.kt") @@ -2389,7 +2390,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInFolding() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/branched/folding"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/branched/folding"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("idea/testData/intentions/branched/folding/ifToReturnAsymmetrically") @@ -2401,7 +2402,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInIfToReturnAsymmetrically() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/branched/folding/ifToReturnAsymmetrically"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/branched/folding/ifToReturnAsymmetrically"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("simpleIf.kt") @@ -2430,7 +2431,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInIfWhen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/branched/ifWhen"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/branched/ifWhen"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("idea/testData/intentions/branched/ifWhen/ifToWhen") @@ -2442,7 +2443,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInIfToWhen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/branched/ifWhen/ifToWhen"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/branched/ifWhen/ifToWhen"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("combinedIf.kt") @@ -2640,7 +2641,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInWhenToIf() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/branched/ifWhen/whenToIf"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/branched/ifWhen/whenToIf"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("comment.kt") @@ -2749,7 +2750,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInSafeAccessToIfThen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/branched/safeAccessToIfThen"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/branched/safeAccessToIfThen"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("assignment.kt") @@ -2917,7 +2918,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInUnfolding() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/branched/unfolding"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/branched/unfolding"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("idea/testData/intentions/branched/unfolding/assignmentToIf") @@ -2929,7 +2930,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInAssignmentToIf() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/branched/unfolding/assignmentToIf"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/branched/unfolding/assignmentToIf"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("innerIfTransformed.kt") @@ -2977,7 +2978,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInAssignmentToWhen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/branched/unfolding/assignmentToWhen"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/branched/unfolding/assignmentToWhen"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("innerWhenTransformed.kt") @@ -3010,7 +3011,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInPropertyToIf() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/branched/unfolding/propertyToIf"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/branched/unfolding/propertyToIf"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("nestedIfs.kt") @@ -3068,7 +3069,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInPropertyToWhen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/branched/unfolding/propertyToWhen"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/branched/unfolding/propertyToWhen"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("nonLocalProperty.kt") @@ -3116,7 +3117,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInReturnToIf() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/branched/unfolding/returnToIf"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/branched/unfolding/returnToIf"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("ifWithBreak.kt") @@ -3174,7 +3175,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInReturnToWhen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/branched/unfolding/returnToWhen"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/branched/unfolding/returnToWhen"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("innerWhenTransformed.kt") @@ -3233,7 +3234,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInWhen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/branched/when"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/branched/when"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("idea/testData/intentions/branched/when/eliminateSubject") @@ -3245,7 +3246,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInEliminateSubject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/branched/when/eliminateSubject"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/branched/when/eliminateSubject"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("lineBreaksAndComments.kt") @@ -3313,7 +3314,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInFlatten() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/branched/when/flatten"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/branched/when/flatten"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("flattenWithSubject.kt") @@ -3343,7 +3344,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInChangeVisibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/changeVisibility"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/changeVisibility"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("idea/testData/intentions/changeVisibility/internal") @@ -3355,7 +3356,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInInternal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/changeVisibility/internal"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/changeVisibility/internal"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("hasJvmFieldInInterfaceCompanion.kt") @@ -3423,7 +3424,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInPrivate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/changeVisibility/private"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/changeVisibility/private"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("annotated.kt") @@ -3621,7 +3622,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInProtected() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/changeVisibility/protected"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/changeVisibility/protected"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("caretAfter.kt") @@ -3684,7 +3685,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInPublic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/changeVisibility/public"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/changeVisibility/public"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("alreadyPublic.kt") @@ -3753,7 +3754,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInChop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/chop"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/chop"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("idea/testData/intentions/chop/argumentList") @@ -3765,7 +3766,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInArgumentList() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/chop/argumentList"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/chop/argumentList"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("leftParOnSameLine.kt") @@ -3803,7 +3804,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInParameterList() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/chop/parameterList"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/chop/parameterList"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("hasAllLineBreaks.kt") @@ -3867,7 +3868,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInConventionNameCalls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/conventionNameCalls"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/conventionNameCalls"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("idea/testData/intentions/conventionNameCalls/replaceCallWithUnaryOperator") @@ -3879,7 +3880,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInReplaceCallWithUnaryOperator() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/conventionNameCalls/replaceCallWithUnaryOperator"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/conventionNameCalls/replaceCallWithUnaryOperator"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("complexPlus.kt") @@ -3967,7 +3968,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInReplaceContains() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/conventionNameCalls/replaceContains"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/conventionNameCalls/replaceContains"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("containsFromJava.kt") @@ -4085,7 +4086,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInReplaceInvoke() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/conventionNameCalls/replaceInvoke"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/conventionNameCalls/replaceInvoke"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("dotQualifiedReceiver.kt") @@ -4179,7 +4180,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInConvertArrayParameterToVararg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertArrayParameterToVararg"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertArrayParameterToVararg"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("arrayGenericType.kt") @@ -4252,7 +4253,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInConvertBinaryExpressionWithDemorgansLaw() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertBinaryExpressionWithDemorgansLaw"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertBinaryExpressionWithDemorgansLaw"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("complexNegation1.kt") @@ -4360,7 +4361,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInConvertBlockCommentToLineComment() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertBlockCommentToLineComment"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertBlockCommentToLineComment"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("beforeStatement.kt") @@ -4403,7 +4404,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInConvertCamelCaseTestFunctionToSpaced() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertCamelCaseTestFunctionToSpaced"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertCamelCaseTestFunctionToSpaced"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("letters.kt") @@ -4451,7 +4452,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInConvertCollectionConstructorToFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertCollectionConstructorToFunction"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertCollectionConstructorToFunction"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("keepArrayListCallWithArgument.kt") @@ -4499,7 +4500,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInConvertEnumToSealedClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertEnumToSealedClass"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertEnumToSealedClass"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("entriesAndMembers.kt") @@ -4542,7 +4543,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInConvertForEachToForLoop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertForEachToForLoop"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertForEachToForLoop"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("complexReceiver.kt") @@ -4650,7 +4651,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInConvertFunctionToProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertFunctionToProperty"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertFunctionToProperty"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("annotationLineBreak.kt") @@ -4793,7 +4794,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInConvertFunctionTypeParameterToReceiver() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertFunctionTypeParameterToReceiver"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertFunctionTypeParameterToReceiver"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("alreadyHasReceiver.kt") @@ -4891,7 +4892,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInConvertFunctionTypeReceiverToParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertFunctionTypeReceiverToParameter"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertFunctionTypeReceiverToParameter"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("function.kt") @@ -4939,7 +4940,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInConvertLambdaToMultiLine() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertLambdaToMultiLine"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertLambdaToMultiLine"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("multiLine.kt") @@ -4987,7 +4988,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInConvertLambdaToReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertLambdaToReference"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertLambdaToReference"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("argumentWithReceiver.kt") @@ -5460,7 +5461,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInConvertLambdaToSingleLine() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertLambdaToSingleLine"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertLambdaToSingleLine"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("hasEolComment.kt") @@ -5528,7 +5529,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInConvertLateinitPropertyToNullable() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertLateinitPropertyToNullable"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertLateinitPropertyToNullable"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("initializer.kt") @@ -5561,7 +5562,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInConvertLazyPropertyToOrdinary() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertLazyPropertyToOrdinary"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertLazyPropertyToOrdinary"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("comment.kt") @@ -5609,7 +5610,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInConvertLineCommentToBlockComment() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertLineCommentToBlockComment"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertLineCommentToBlockComment"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("blankLine.kt") @@ -5662,7 +5663,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInConvertNullablePropertyToLateinit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertNullablePropertyToLateinit"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertNullablePropertyToLateinit"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("delegate.kt") @@ -5755,7 +5756,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInConvertObjectLiteralToClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertObjectLiteralToClass"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertObjectLiteralToClass"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("inClass.kt") @@ -5803,7 +5804,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInConvertOrdinaryPropertyToLazy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertOrdinaryPropertyToLazy"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertOrdinaryPropertyToLazy"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("basic.kt") @@ -5836,7 +5837,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInConvertParameterToReceiver() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertParameterToReceiver"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertParameterToReceiver"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("classParameter.kt") @@ -5939,7 +5940,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInConvertPrimaryConstructorToSecondary() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertPrimaryConstructorToSecondary"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertPrimaryConstructorToSecondary"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("annotatedConstructor.kt") @@ -6137,7 +6138,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInConvertPropertyGetterToInitializer() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertPropertyGetterToInitializer"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertPropertyGetterToInitializer"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("block.kt") @@ -6200,7 +6201,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInConvertPropertyInitializerToGetter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertPropertyInitializerToGetter"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertPropertyInitializerToGetter"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("errorType.kt") @@ -6278,7 +6279,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInConvertPropertyToFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertPropertyToFunction"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertPropertyToFunction"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("annotationUseSiteTarget.kt") @@ -6386,7 +6387,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInConvertRangeCheckToTwoComparisons() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertRangeCheckToTwoComparisons"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertRangeCheckToTwoComparisons"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("double.kt") @@ -6439,7 +6440,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInConvertReceiverToParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertReceiverToParameter"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertReceiverToParameter"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("autoSuggestedName.kt") @@ -6522,7 +6523,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInConvertReferenceToLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertReferenceToLambda"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertReferenceToLambda"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("apply.kt") @@ -6740,7 +6741,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInConvertSealedClassToEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertSealedClassToEnum"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertSealedClassToEnum"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("dropDefaultConstructorCall.kt") @@ -6803,7 +6804,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInConvertSecondaryConstructorToPrimary() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertSecondaryConstructorToPrimary"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertSecondaryConstructorToPrimary"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("defaultValueChain.kt") @@ -6941,7 +6942,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInConvertSnakeCaseTestFunctionToSpaced() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertSnakeCaseTestFunctionToSpaced"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertSnakeCaseTestFunctionToSpaced"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("camel.kt") @@ -6974,7 +6975,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInConvertToBlockBody() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertToBlockBody"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertToBlockBody"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("annotatedExpr.kt") @@ -7117,7 +7118,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInConvertToConcatenatedString() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertToConcatenatedString"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertToConcatenatedString"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("embeddedIf.kt") @@ -7255,7 +7256,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInConvertToForEachFunctionCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertToForEachFunctionCall"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertToForEachFunctionCall"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("binaryExpressionLoopRange.kt") @@ -7353,7 +7354,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInConvertToRawStringTemplate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertToRawStringTemplate"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertToRawStringTemplate"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("basic.kt") @@ -7371,7 +7372,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInConvertToScope() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertToScope"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertToScope"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("idea/testData/intentions/convertToScope/convertToAlso") @@ -7383,7 +7384,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInConvertToAlso() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertToScope/convertToAlso"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertToScope/convertToAlso"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("callExpression.kt") @@ -7506,7 +7507,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInConvertToApply() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertToScope/convertToApply"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertToScope/convertToApply"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("binaryExpression.kt") @@ -7654,7 +7655,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInConvertToRun() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertToScope/convertToRun"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertToScope/convertToRun"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("binaryExpression.kt") @@ -7792,7 +7793,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInConvertToWith() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertToScope/convertToWith"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertToScope/convertToWith"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("callExpression.kt") @@ -7916,7 +7917,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInConvertToStringTemplate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertToStringTemplate"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertToStringTemplate"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("backslashNMultilineString.kt") @@ -8163,7 +8164,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInInspectionData() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertToStringTemplate/inspectionData"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertToStringTemplate/inspectionData"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } } } @@ -8177,7 +8178,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInConvertTryFinallyToUseCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertTryFinallyToUseCall"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertTryFinallyToUseCall"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("catch.kt") @@ -8250,7 +8251,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInConvertUnsafeCastCallToUnsafeCast() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertUnsafeCastCallToUnsafeCast"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertUnsafeCastCallToUnsafeCast"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("call.kt") @@ -8273,7 +8274,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInConvertUnsafeCastToUnsafeCastCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertUnsafeCastToUnsafeCastCall"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertUnsafeCastToUnsafeCastCall"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("cast.kt") @@ -8296,7 +8297,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInConvertVarargParameterToArray() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertVarargParameterToArray"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertVarargParameterToArray"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("genericType.kt") @@ -8344,7 +8345,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInConvertVariableAssignmentToExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertVariableAssignmentToExpression"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/convertVariableAssignmentToExpression"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("complexLhs.kt") @@ -8377,7 +8378,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInCopyConcatenatedStringToClipboard() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/copyConcatenatedStringToClipboard"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/copyConcatenatedStringToClipboard"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("constants.kt") @@ -8415,7 +8416,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInDeclarations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/declarations"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/declarations"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("idea/testData/intentions/declarations/convertMemberToExtension") @@ -8437,7 +8438,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInConvertMemberToExtension() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/declarations/convertMemberToExtension"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/declarations/convertMemberToExtension"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("delegatedProperty.kt") @@ -8655,7 +8656,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInSplit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/declarations/split"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/declarations/split"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("anonymousFunction.kt") @@ -8739,7 +8740,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInDestructuringInLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/destructuringInLambda"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/destructuringInLambda"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("caret.kt") @@ -8841,7 +8842,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInInspectionData() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/destructuringInLambda/inspectionData"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/destructuringInLambda/inspectionData"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } } } @@ -8855,7 +8856,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInDestructuringVariables() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/destructuringVariables"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/destructuringVariables"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("caret.kt") @@ -8908,7 +8909,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInEvaluateCompileTimeExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/evaluateCompileTimeExpression"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/evaluateCompileTimeExpression"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("boolean.kt") @@ -9001,7 +9002,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInExpandBooleanExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/expandBooleanExpression"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/expandBooleanExpression"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("binary.kt") @@ -9074,7 +9075,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInImplementAbstractMember() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/implementAbstractMember"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/implementAbstractMember"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("idea/testData/intentions/implementAbstractMember/function") @@ -9086,7 +9087,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/implementAbstractMember/function"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/implementAbstractMember/function"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("enumClass.kt") @@ -9164,7 +9165,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/implementAbstractMember/property"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/implementAbstractMember/property"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("enumClass.kt") @@ -9243,7 +9244,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInImplementAsConstructorParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/implementAsConstructorParameter"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/implementAsConstructorParameter"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("enumClass.kt") @@ -9311,7 +9312,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInImportAllMembers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/importAllMembers"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/importAllMembers"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("AlreadyImported.kt") @@ -9394,7 +9395,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInImportMember() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/importMember"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/importMember"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("AlreadyImportedSameNameClass.kt") @@ -9517,7 +9518,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInIndentRawString() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/indentRawString"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/indentRawString"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("annotationEntry.kt") @@ -9565,7 +9566,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInInfixCallToOrdinary() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/infixCallToOrdinary"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/infixCallToOrdinary"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("functionCallAfterInfixCall.kt") @@ -9608,7 +9609,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInInsertCurlyBracesToTemplate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/insertCurlyBracesToTemplate"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/insertCurlyBracesToTemplate"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("dontInsertBrackets1.kt") @@ -9661,7 +9662,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInInsertExplicitTypeArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/insertExplicitTypeArguments"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/insertExplicitTypeArguments"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("inapplicableAlreadyTyped.kt") @@ -9774,7 +9775,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInIntroduceBackingProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/introduceBackingProperty"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/introduceBackingProperty"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("backingFieldRef.kt") @@ -9877,7 +9878,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInIntroduceImportAlias() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/introduceImportAlias"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/introduceImportAlias"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("alreadyImportAlias.kt") @@ -10015,7 +10016,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInIntroduceVariable() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/introduceVariable"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/introduceVariable"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("atExpressionEnd.kt") @@ -10068,7 +10069,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInInvertIfCondition() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/invertIfCondition"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/invertIfCondition"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("assignedToValue.kt") @@ -10361,7 +10362,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInIterateExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/iterateExpression"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/iterateExpression"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("collectionIteratorWithComponents.kt") @@ -10439,7 +10440,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInIterationOverMap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/iterationOverMap"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/iterationOverMap"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("AlreadyDestructing.kt") @@ -10651,7 +10652,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInInspectionData() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/iterationOverMap/inspectionData"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/iterationOverMap/inspectionData"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } } } @@ -10665,7 +10666,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInJoinArgumentList() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/joinArgumentList"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/joinArgumentList"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("hasEndOfLineComment.kt") @@ -10713,7 +10714,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInJoinDeclarationAndAssignment() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/joinDeclarationAndAssignment"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/joinDeclarationAndAssignment"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("assignmentForFlexible.kt") @@ -10881,7 +10882,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInJoinParameterList() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/joinParameterList"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/joinParameterList"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("hasEndOfLineComment.kt") @@ -10929,7 +10930,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInLambdaToAnonymousFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/lambdaToAnonymousFunction"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/lambdaToAnonymousFunction"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("argument.kt") @@ -11062,7 +11063,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInLoopToCallChain() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("array.kt") @@ -11139,7 +11140,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInAny() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/any"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/any"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("anyNotNull.kt") @@ -11252,7 +11253,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInContains() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/contains"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/contains"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } } @@ -11275,7 +11276,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInCount() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/count"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/count"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("countIsInstance.kt") @@ -11328,7 +11329,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInFilter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/filter"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/filter"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("assign.kt") @@ -11591,7 +11592,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInFirstOrNull() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/firstOrNull"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/firstOrNull"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("assignmentInitialization.kt") @@ -11704,7 +11705,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInFlatMap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/flatMap"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/flatMap"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("break.kt") @@ -11772,7 +11773,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInForEach() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/forEach"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/forEach"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("indexed.kt") @@ -11820,7 +11821,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInIndexOf() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/indexOf"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/indexOf"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("indexOf.kt") @@ -11868,7 +11869,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInIntroduceIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/introduceIndex"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/introduceIndex"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("indexPlusPlusInsideExpression.kt") @@ -11921,7 +11922,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInMap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/map"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/map"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("assignMap.kt") @@ -12074,7 +12075,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInMaxMin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/maxMin"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/maxMin"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("KT14210.kt") @@ -12152,7 +12153,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInSmartCasts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/smartCasts"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/smartCasts"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("errorOutsideLoop.kt") @@ -12240,7 +12241,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInSum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/sum"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/sum"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("bytes.kt") @@ -12338,7 +12339,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInTakeWhile() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/takeWhile"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/takeWhile"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("ifElse1.kt") @@ -12386,7 +12387,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInToCollection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/toCollection"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/loopToCallChain/toCollection"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("badReceiver1.kt") @@ -12470,7 +12471,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInMergeElseIf() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/mergeElseIf"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/mergeElseIf"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("comments.kt") @@ -12508,7 +12509,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInMergeIfs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/mergeIfs"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/mergeIfs"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("comments.kt") @@ -12556,7 +12557,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInMoveDeclarationToSeparateFile() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/moveDeclarationToSeparateFile"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/moveDeclarationToSeparateFile"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("extendSealed.kt") @@ -12579,7 +12580,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInMoveLambdaInsideParentheses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/moveLambdaInsideParentheses"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/moveLambdaInsideParentheses"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("inapplicable1.kt") @@ -12697,7 +12698,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInMoveMemberToTopLevel() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/moveMemberToTopLevel"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/moveMemberToTopLevel"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("function.kt") @@ -12745,7 +12746,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInMoveOutOfCompanion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/moveOutOfCompanion"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/moveOutOfCompanion"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("companionAsImplicitReceiver.kt") @@ -12808,7 +12809,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInMovePropertyToClassBody() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/movePropertyToClassBody"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/movePropertyToClassBody"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("annotationClass.kt") @@ -12871,7 +12872,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInMovePropertyToConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/movePropertyToConstructor"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/movePropertyToConstructor"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("annotationTarget.kt") @@ -12979,7 +12980,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInMoveToCompanion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/moveToCompanion"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/moveToCompanion"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("doNotQualifyThisLabel.kt") @@ -13092,7 +13093,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInNullableBooleanEqualityCheckToElvis() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/nullableBooleanEqualityCheckToElvis"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/nullableBooleanEqualityCheckToElvis"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("eqFalse.kt") @@ -13130,7 +13131,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInObjectLiteralToLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/objectLiteralToLambda"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/objectLiteralToLambda"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("EmptyBody.kt") @@ -13282,7 +13283,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInInspectionData() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/objectLiteralToLambda/inspectionData"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/objectLiteralToLambda/inspectionData"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } } } @@ -13296,7 +13297,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInOperatorToFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/operatorToFunction"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/operatorToFunction"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("arrayAccessMultipleIndex.kt") @@ -13514,7 +13515,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInReconstructTypeInCastOrIs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/reconstructTypeInCastOrIs"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/reconstructTypeInCastOrIs"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("completeGenericType.kt") @@ -13552,7 +13553,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInRemoveArgumentName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/removeArgumentName"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/removeArgumentName"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("arrayLiteral.kt") @@ -13624,7 +13625,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInMixedNamedArgumentsInTheirOwnPosition() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/removeArgumentName/MixedNamedArgumentsInTheirOwnPosition"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/removeArgumentName/MixedNamedArgumentsInTheirOwnPosition"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("namedArgumentBefore.kt") @@ -13658,7 +13659,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInRemoveBraces() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/removeBraces"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/removeBraces"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("doWhile.kt") @@ -13861,7 +13862,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInRemoveConstructorKeyword() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/removeConstructorKeyword"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/removeConstructorKeyword"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("annotatedParam.kt") @@ -13909,7 +13910,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInRemoveEmptyClassBody() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/removeEmptyClassBody"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/removeEmptyClassBody"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("anonymousInterfaceObject.kt") @@ -14052,7 +14053,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInRemoveEmptyParenthesesFromLambdaCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/removeEmptyParenthesesFromLambdaCall"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/removeEmptyParenthesesFromLambdaCall"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("nextLine.kt") @@ -14080,7 +14081,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInRemoveEmptyPrimaryConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/removeEmptyPrimaryConstructor"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/removeEmptyPrimaryConstructor"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("annotation.kt") @@ -14133,7 +14134,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInRemoveEmptySecondaryConstructorBody() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/removeEmptySecondaryConstructorBody"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/removeEmptySecondaryConstructorBody"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("comment.kt") @@ -14156,7 +14157,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInRemoveExplicitLambdaParameterTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/removeExplicitLambdaParameterTypes"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/removeExplicitLambdaParameterTypes"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("invalidCursorPosition.kt") @@ -14214,7 +14215,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInRemoveExplicitSuperQualifier() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/removeExplicitSuperQualifier"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/removeExplicitSuperQualifier"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("AmbiguousSuperMethod.kt") @@ -14281,7 +14282,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInInspectionData() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/removeExplicitSuperQualifier/inspectionData"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/removeExplicitSuperQualifier/inspectionData"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } } } @@ -14295,7 +14296,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInRemoveExplicitType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/removeExplicitType"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/removeExplicitType"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("anonymousFunctionInitializer.kt") @@ -14438,7 +14439,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInRemoveExplicitTypeArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/removeExplicitTypeArguments"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/removeExplicitTypeArguments"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("blockValue.kt") @@ -14615,7 +14616,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInInspectionData() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/removeExplicitTypeArguments/inspectionData"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/removeExplicitTypeArguments/inspectionData"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } } } @@ -14629,7 +14630,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInRemoveExplicitTypeWithApiMode() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/removeExplicitTypeWithApiMode"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/removeExplicitTypeWithApiMode"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("nonPublicFunction.kt") @@ -14652,7 +14653,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInRemoveForLoopIndices() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/removeForLoopIndices"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/removeForLoopIndices"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("inapplicableForLoop.kt") @@ -14700,7 +14701,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInRemoveLabeledReturnInLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/removeLabeledReturnInLambda"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/removeLabeledReturnInLambda"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("labeledLambda.kt") @@ -14753,7 +14754,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInRemoveRedundantCallsOfConversionMethods() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/removeRedundantCallsOfConversionMethods"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/removeRedundantCallsOfConversionMethods"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("booleanToInt.kt") @@ -14861,7 +14862,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInRemoveSingleExpressionStringTemplate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/removeSingleExpressionStringTemplate"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/removeSingleExpressionStringTemplate"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("emptyString.kt") @@ -14909,7 +14910,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInRemoveUnnecessaryParentheses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/removeUnnecessaryParentheses"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/removeUnnecessaryParentheses"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("callInsideCallWithLambdaOnly.kt") @@ -15042,7 +15043,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInRenameClassToContainingFileName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/renameClassToContainingFileName"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/renameClassToContainingFileName"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("Basic.kt") @@ -15120,7 +15121,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInReplaceAddWithPlusAssign() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/replaceAddWithPlusAssign"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/replaceAddWithPlusAssign"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("nonCollection.kt") @@ -15138,7 +15139,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInReplaceExplicitFunctionLiteralParamWithIt() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/replaceExplicitFunctionLiteralParamWithIt"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/replaceExplicitFunctionLiteralParamWithIt"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("applicable_InIf.kt") @@ -15271,7 +15272,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInReplaceItWithExplicitFunctionLiteralParam() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/replaceItWithExplicitFunctionLiteralParam"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/replaceItWithExplicitFunctionLiteralParam"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("applicable.kt") @@ -15309,7 +15310,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInReplaceMapGetOrDefault() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/replaceMapGetOrDefault"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/replaceMapGetOrDefault"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("inExpression.kt") @@ -15337,7 +15338,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInReplaceSizeCheckWithIsNotEmpty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/replaceSizeCheckWithIsNotEmpty"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/replaceSizeCheckWithIsNotEmpty"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("array.kt") @@ -15435,7 +15436,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInReplaceSizeZeroCheckWithIsEmpty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/replaceSizeZeroCheckWithIsEmpty"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/replaceSizeZeroCheckWithIsEmpty"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("array.kt") @@ -15508,7 +15509,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInReplaceUnderscoreWithParameterName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/replaceUnderscoreWithParameterName"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/replaceUnderscoreWithParameterName"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("anonymous.kt") @@ -15566,7 +15567,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInReplaceUntilWithRangeTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/replaceUntilWithRangeTo"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/replaceUntilWithRangeTo"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("simple.kt") @@ -15584,7 +15585,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInReplaceWithOrdinaryAssignment() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/replaceWithOrdinaryAssignment"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/replaceWithOrdinaryAssignment"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("complexRightExpression.kt") @@ -15617,7 +15618,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInSamConversionToAnonymousObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/samConversionToAnonymousObject"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/samConversionToAnonymousObject"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("funInterface.kt") @@ -15695,7 +15696,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInSimplifyBooleanWithConstants() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/simplifyBooleanWithConstants"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/simplifyBooleanWithConstants"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("assert.kt") @@ -15903,7 +15904,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInSpecifyExplicitLambdaSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/specifyExplicitLambdaSignature"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/specifyExplicitLambdaSignature"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("anonymous.kt") @@ -16001,7 +16002,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInSpecifyTypeExplicitly() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/specifyTypeExplicitly"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/specifyTypeExplicitly"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("anonymousObject.kt") @@ -16189,7 +16190,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInSpecifyTypeExplicitlyInDestructuringAssignment() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/specifyTypeExplicitlyInDestructuringAssignment"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/specifyTypeExplicitlyInDestructuringAssignment"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("in.kt") @@ -16237,7 +16238,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInSplitIf() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/splitIf"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/splitIf"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("and.kt") @@ -16374,7 +16375,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInKeepComments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/splitIf/keepComments"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/splitIf/keepComments"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("ifOrReturn.kt") @@ -16408,7 +16409,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInSwapBinaryExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/swapBinaryExpression"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/swapBinaryExpression"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("assignment.kt") @@ -16636,7 +16637,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInSwapStringEqualsIgnoreCase() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/swapStringEqualsIgnoreCase"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/swapStringEqualsIgnoreCase"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("equals.kt") @@ -16659,7 +16660,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInToInfixCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/toInfixCall"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/toInfixCall"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("binaryExpressionArgument.kt") @@ -16772,7 +16773,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInToOrdinaryStringLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/toOrdinaryStringLiteral"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/toOrdinaryStringLiteral"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("caret1.kt") @@ -16930,7 +16931,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInToRawStringLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/toRawStringLiteral"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/toRawStringLiteral"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("alreadyRaw.kt") @@ -17018,7 +17019,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInTrailingComma() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/trailingComma"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/trailingComma"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("valueParameterList.kt") @@ -17036,7 +17037,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInUnderscoresInNumericLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/underscoresInNumericLiteral"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/underscoresInNumericLiteral"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("idea/testData/intentions/underscoresInNumericLiteral/addUnderscores") @@ -17048,7 +17049,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInAddUnderscores() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/underscoresInNumericLiteral/addUnderscores"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/underscoresInNumericLiteral/addUnderscores"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("binaries.kt") @@ -17101,7 +17102,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInRemoveUnderscores() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/underscoresInNumericLiteral/removeUnderscores"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/underscoresInNumericLiteral/removeUnderscores"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("int.kt") @@ -17135,7 +17136,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInUsePropertyAccessSyntax() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/usePropertyAccessSyntax"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/usePropertyAccessSyntax"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("conflict1.kt") @@ -17308,7 +17309,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInUseWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/useWithIndex"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/useWithIndex"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("alreadyWithIndex.kt") @@ -17361,7 +17362,7 @@ public class IntentionTestGenerated extends AbstractIntentionTest { } public void testAllFilesPresentInValToObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/valToObject"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/intentions/valToObject"), Pattern.compile("^([\\w\\-_]+)\\.(kt|kts)$"), null, true); } @TestMetadata("annotations.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/intentions/MultiFileIntentionTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/intentions/MultiFileIntentionTestGenerated.java index c17ba6c4d35..2750d5dec31 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/intentions/MultiFileIntentionTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/intentions/MultiFileIntentionTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.intentions; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -55,7 +56,7 @@ public class MultiFileIntentionTestGenerated extends AbstractMultiFileIntentionT } public void testAllFilesPresentInMultiFileIntentions() throws Exception { - KotlinTestUtils.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File("idea/testData/multiFileIntentions"), Pattern.compile("^(.+)\\.test$"), null); + KtTestUtil.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File("idea/testData/multiFileIntentions"), Pattern.compile("^(.+)\\.test$"), null); } @TestMetadata("convertMemberToExtension/addImports/addImports.test") diff --git a/idea/tests/org/jetbrains/kotlin/idea/intentions/declarations/JoinLinesTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/intentions/declarations/JoinLinesTestGenerated.java index e030feec7b0..850f8440641 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/intentions/declarations/JoinLinesTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/intentions/declarations/JoinLinesTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.intentions.declarations; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class JoinLinesTestGenerated extends AbstractJoinLinesTest { } public void testAllFilesPresentInJoinLines() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/joinLines"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/joinLines"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("idea/testData/joinLines/addSemicolon") @@ -37,7 +38,7 @@ public class JoinLinesTestGenerated extends AbstractJoinLinesTest { } public void testAllFilesPresentInAddSemicolon() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/joinLines/addSemicolon"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/joinLines/addSemicolon"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassDeclarations.kt") @@ -135,7 +136,7 @@ public class JoinLinesTestGenerated extends AbstractJoinLinesTest { } public void testAllFilesPresentInDeclarationAndAssignment() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/joinLines/declarationAndAssignment"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/joinLines/declarationAndAssignment"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("blankLineBetween.kt") @@ -233,7 +234,7 @@ public class JoinLinesTestGenerated extends AbstractJoinLinesTest { } public void testAllFilesPresentInInitializerAndIfToElvis() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/joinLines/initializerAndIfToElvis"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/joinLines/initializerAndIfToElvis"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("simple.kt") @@ -251,7 +252,7 @@ public class JoinLinesTestGenerated extends AbstractJoinLinesTest { } public void testAllFilesPresentInNestedIfs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/joinLines/nestedIfs"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/joinLines/nestedIfs"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("BlockBody.kt") @@ -294,7 +295,7 @@ public class JoinLinesTestGenerated extends AbstractJoinLinesTest { } public void testAllFilesPresentInRemoveBraces() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/joinLines/removeBraces"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/joinLines/removeBraces"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("CommentAfterStatement.kt") @@ -402,7 +403,7 @@ public class JoinLinesTestGenerated extends AbstractJoinLinesTest { } public void testAllFilesPresentInRemoveTrailingComma() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/joinLines/removeTrailingComma"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/joinLines/removeTrailingComma"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("destructuringDeclarations.kt") @@ -475,7 +476,7 @@ public class JoinLinesTestGenerated extends AbstractJoinLinesTest { } public void testAllFilesPresentInStringTemplate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/joinLines/stringTemplate"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/joinLines/stringTemplate"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("firstLineVariable.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/internal/BytecodeToolWindowTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/internal/BytecodeToolWindowTestGenerated.java index 895b2135ecb..5a99ecee576 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/internal/BytecodeToolWindowTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/internal/BytecodeToolWindowTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.internal; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class BytecodeToolWindowTestGenerated extends AbstractBytecodeToolWindowT } public void testAllFilesPresentInToolWindow() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/internal/toolWindow"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/internal/toolWindow"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("componentInlineFun") diff --git a/idea/tests/org/jetbrains/kotlin/idea/kdoc/KDocHighlightingTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/kdoc/KDocHighlightingTestGenerated.java index 1d0c5ca9670..cf4de71a4ed 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/kdoc/KDocHighlightingTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/kdoc/KDocHighlightingTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.kdoc; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class KDocHighlightingTestGenerated extends AbstractKDocHighlightingTest } public void testAllFilesPresentInHighlighting() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/kdoc/highlighting"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/kdoc/highlighting"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("MissingDocumentation.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/kdoc/KDocTypingTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/kdoc/KDocTypingTestGenerated.java index 44691a76c3e..d9092dcf794 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/kdoc/KDocTypingTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/kdoc/KDocTypingTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.kdoc; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class KDocTypingTestGenerated extends AbstractKDocTypingTest { } public void testAllFilesPresentInTyping() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/kdoc/typing"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/kdoc/typing"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("closingBracketNotInLink.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/kdoc/KdocResolveTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/kdoc/KdocResolveTestGenerated.java index 368cb4d161f..bc202f2b9d5 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/kdoc/KdocResolveTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/kdoc/KdocResolveTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.kdoc; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.idea.resolve.AbstractReferenceResolveTest; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class KdocResolveTestGenerated extends AbstractReferenceResolveTest { } public void testAllFilesPresentInResolve() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/kdoc/resolve"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/kdoc/resolve"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("AmbiguousReference.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/navigation/GotoDeclarationTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/navigation/GotoDeclarationTestGenerated.java index f45d3446944..5b2649e2bc0 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/navigation/GotoDeclarationTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/navigation/GotoDeclarationTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.navigation; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class GotoDeclarationTestGenerated extends AbstractGotoDeclarationTest { } public void testAllFilesPresentInGotoDeclaration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/navigation/gotoDeclaration"), Pattern.compile("^(.+)\\.test$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/navigation/gotoDeclaration"), Pattern.compile("^(.+)\\.test$"), null, true); } @TestMetadata("importAlias.test") diff --git a/idea/tests/org/jetbrains/kotlin/idea/navigation/GotoSuperTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/navigation/GotoSuperTestGenerated.java index e19334247a7..3b695534901 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/navigation/GotoSuperTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/navigation/GotoSuperTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.navigation; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class GotoSuperTestGenerated extends AbstractGotoSuperTest { } public void testAllFilesPresentInGotoSuper() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/navigation/gotoSuper"), Pattern.compile("^(.+)\\.test$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/navigation/gotoSuper"), Pattern.compile("^(.+)\\.test$"), null, false); } @TestMetadata("BadPositionLambdaParameter.test") diff --git a/idea/tests/org/jetbrains/kotlin/idea/navigation/GotoTypeDeclarationTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/navigation/GotoTypeDeclarationTestGenerated.java index daf10cb5dd0..a972eff0767 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/navigation/GotoTypeDeclarationTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/navigation/GotoTypeDeclarationTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.navigation; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class GotoTypeDeclarationTestGenerated extends AbstractGotoTypeDeclaratio } public void testAllFilesPresentInGotoTypeDeclaration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/navigation/gotoTypeDeclaration"), Pattern.compile("^(.+)\\.test$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/navigation/gotoTypeDeclaration"), Pattern.compile("^(.+)\\.test$"), null, true); } @TestMetadata("builtinTypeStdlib.test") diff --git a/idea/tests/org/jetbrains/kotlin/idea/navigation/KotlinGotoImplementationMultiModuleTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/navigation/KotlinGotoImplementationMultiModuleTestGenerated.java index 84df5ed1993..6399b67a1d7 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/navigation/KotlinGotoImplementationMultiModuleTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/navigation/KotlinGotoImplementationMultiModuleTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.navigation; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -30,7 +31,7 @@ public class KotlinGotoImplementationMultiModuleTestGenerated extends AbstractKo } public void testAllFilesPresentInMultiModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/navigation/implementations/multiModule"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/navigation/implementations/multiModule"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("expectClass") diff --git a/idea/tests/org/jetbrains/kotlin/idea/navigation/KotlinGotoImplementationTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/navigation/KotlinGotoImplementationTestGenerated.java index eebd0fd733e..e40e0c2f7d0 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/navigation/KotlinGotoImplementationTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/navigation/KotlinGotoImplementationTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.navigation; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -30,7 +31,7 @@ public class KotlinGotoImplementationTestGenerated extends AbstractKotlinGotoImp } public void testAllFilesPresentInImplementations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/navigation/implementations"), Pattern.compile("^(.+)\\.kt$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/navigation/implementations"), Pattern.compile("^(.+)\\.kt$"), null, false); } @TestMetadata("ClassImplementorsWithDeclaration.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/navigation/KotlinGotoRelatedSymbolMultiModuleTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/navigation/KotlinGotoRelatedSymbolMultiModuleTestGenerated.java index f5d7455a931..fb16dd57f67 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/navigation/KotlinGotoRelatedSymbolMultiModuleTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/navigation/KotlinGotoRelatedSymbolMultiModuleTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.navigation; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class KotlinGotoRelatedSymbolMultiModuleTestGenerated extends AbstractKot } public void testAllFilesPresentInMultiModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/navigation/relatedSymbols/multiModule"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/navigation/relatedSymbols/multiModule"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("fromActualMemberFunToExpect") diff --git a/idea/tests/org/jetbrains/kotlin/idea/navigation/KotlinGotoSuperMultiModuleTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/navigation/KotlinGotoSuperMultiModuleTestGenerated.java index cb48c575d92..3c24b0cfb1d 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/navigation/KotlinGotoSuperMultiModuleTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/navigation/KotlinGotoSuperMultiModuleTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.navigation; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -40,6 +41,6 @@ public class KotlinGotoSuperMultiModuleTestGenerated extends AbstractKotlinGotoS } public void testAllFilesPresentInMultiModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/navigation/gotoSuper/multiModule"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/navigation/gotoSuper/multiModule"), Pattern.compile("^([^\\.]+)$"), null, false); } } diff --git a/idea/tests/org/jetbrains/kotlin/idea/navigation/KotlinGotoTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/navigation/KotlinGotoTestGenerated.java index 065647bfe1a..fd9e7fdc4f3 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/navigation/KotlinGotoTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/navigation/KotlinGotoTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.navigation; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -27,7 +28,7 @@ public class KotlinGotoTestGenerated extends AbstractKotlinGotoTest { } public void testAllFilesPresentInGotoClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/navigation/gotoClass"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/navigation/gotoClass"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("builtInAny.kt") @@ -95,7 +96,7 @@ public class KotlinGotoTestGenerated extends AbstractKotlinGotoTest { } public void testAllFilesPresentInGotoSymbol() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/navigation/gotoSymbol"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/navigation/gotoSymbol"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("builtInArrayOfNulls.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/navigationToolbar/KotlinNavBarTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/navigationToolbar/KotlinNavBarTestGenerated.java index 1a62a8413f7..5e0fea4465a 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/navigationToolbar/KotlinNavBarTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/navigationToolbar/KotlinNavBarTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.navigationToolbar; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class KotlinNavBarTestGenerated extends AbstractKotlinNavBarTest { } public void testAllFilesPresentInNavigationToolbar() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/navigationToolbar"), Pattern.compile("^(.+)\\.kt$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/navigationToolbar"), Pattern.compile("^(.+)\\.kt$"), null, false); } @TestMetadata("ClassProperty.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/parameterInfo/ParameterInfoTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/parameterInfo/ParameterInfoTestGenerated.java index 6fb932ee3d2..600eed7753b 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/parameterInfo/ParameterInfoTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/parameterInfo/ParameterInfoTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.parameterInfo; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class ParameterInfoTestGenerated extends AbstractParameterInfoTest { } public void testAllFilesPresentInParameterInfo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/parameterInfo"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true, "withLib1/sharedLib", "withLib2/sharedLib", "withLib3/sharedLib"); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/parameterInfo"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true, "withLib1/sharedLib", "withLib2/sharedLib", "withLib3/sharedLib"); } @TestMetadata("idea/testData/parameterInfo/annotations") @@ -37,7 +38,7 @@ public class ParameterInfoTestGenerated extends AbstractParameterInfoTest { } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/parameterInfo/annotations"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/parameterInfo/annotations"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("ConstructorCall.kt") @@ -65,7 +66,7 @@ public class ParameterInfoTestGenerated extends AbstractParameterInfoTest { } public void testAllFilesPresentInArrayAccess() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/parameterInfo/arrayAccess"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/parameterInfo/arrayAccess"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("Overloads.kt") @@ -103,7 +104,7 @@ public class ParameterInfoTestGenerated extends AbstractParameterInfoTest { } public void testAllFilesPresentInFunctionCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/parameterInfo/functionCall"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/parameterInfo/functionCall"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("Conflicting.kt") @@ -406,7 +407,7 @@ public class ParameterInfoTestGenerated extends AbstractParameterInfoTest { } public void testAllFilesPresentInTypeArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/parameterInfo/typeArguments"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/parameterInfo/typeArguments"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("BaseClass.kt") @@ -469,7 +470,7 @@ public class ParameterInfoTestGenerated extends AbstractParameterInfoTest { } public void testAllFilesPresentInWithLib1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/parameterInfo/withLib1"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true, "sharedLib"); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/parameterInfo/withLib1"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true, "sharedLib"); } @TestMetadata("useJavaFromLib.kt") @@ -487,7 +488,7 @@ public class ParameterInfoTestGenerated extends AbstractParameterInfoTest { } public void testAllFilesPresentInWithLib2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/parameterInfo/withLib2"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true, "sharedLib"); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/parameterInfo/withLib2"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true, "sharedLib"); } @TestMetadata("useJavaSAMFromLib.kt") @@ -505,7 +506,7 @@ public class ParameterInfoTestGenerated extends AbstractParameterInfoTest { } public void testAllFilesPresentInWithLib3() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/parameterInfo/withLib3"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true, "sharedLib"); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/parameterInfo/withLib3"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true, "sharedLib"); } @TestMetadata("useJavaSAMFromLib.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/quickfix/QuickFixMultiFileTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/quickfix/QuickFixMultiFileTestGenerated.java index 96bb1f1338d..5d652650a92 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/quickfix/QuickFixMultiFileTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/quickfix/QuickFixMultiFileTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.quickfix; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInQuickfix() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("idea/testData/quickfix/abstract") @@ -37,7 +38,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInAbstract() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/abstract"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/abstract"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -50,7 +51,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInAddAnnotationTarget() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addAnnotationTarget"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addAnnotationTarget"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("withJava.before.Main.kt") @@ -68,7 +69,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInAddConstructorParameterFromSuperTypeCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addConstructorParameterFromSuperTypeCall"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addConstructorParameterFromSuperTypeCall"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -81,7 +82,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInAddCrossinline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addCrossinline"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addCrossinline"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -94,7 +95,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInAddDataModifier() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addDataModifier"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addDataModifier"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -107,7 +108,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInAddDefaultConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addDefaultConstructor"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addDefaultConstructor"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -120,7 +121,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInAddEqEqTrue() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addEqEqTrue"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addEqEqTrue"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -133,7 +134,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInAddExclExclCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addExclExclCall"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addExclExclCall"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -146,7 +147,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInAddGenericUpperBound() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addGenericUpperBound"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addGenericUpperBound"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -159,7 +160,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInAddInitializer() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addInitializer"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addInitializer"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -172,7 +173,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInAddInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addInline"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addInline"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -185,7 +186,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInAddInlineToReifiedFunctionFix() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addInlineToReifiedFunctionFix"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addInlineToReifiedFunctionFix"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -198,7 +199,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInAddIsToWhenCondition() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addIsToWhenCondition"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addIsToWhenCondition"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -211,7 +212,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInAddJvmDefault() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addJvmDefault"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addJvmDefault"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("javaDefaultOverride.before.Main.kt") @@ -229,7 +230,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInAddJvmNameAnnotation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addJvmNameAnnotation"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addJvmNameAnnotation"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -242,7 +243,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInAddNewLineAfterAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addNewLineAfterAnnotations"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addNewLineAfterAnnotations"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -255,7 +256,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInAddNoinline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addNoinline"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addNoinline"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -268,7 +269,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInAddPropertyAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addPropertyAccessors"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addPropertyAccessors"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -281,7 +282,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInAddPropertyToSupertype() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addPropertyToSupertype"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addPropertyToSupertype"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -294,7 +295,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInAddReifiedToTypeParameterOfFunctionFix() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addReifiedToTypeParameterOfFunctionFix"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addReifiedToTypeParameterOfFunctionFix"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -307,7 +308,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInAddReturnToLastExpressionInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addReturnToLastExpressionInFunction"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addReturnToLastExpressionInFunction"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -320,7 +321,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInAddReturnToUnusedLastExpressionInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addReturnToUnusedLastExpressionInFunction"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addReturnToUnusedLastExpressionInFunction"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -333,7 +334,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInAddRunBeforeLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addRunBeforeLambda"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addRunBeforeLambda"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -346,7 +347,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInAddSemicolonBeforeLambdaExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addSemicolonBeforeLambdaExpression"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addSemicolonBeforeLambdaExpression"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -359,7 +360,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInAddSpreadOperatorForArrayAsVarargAfterSam() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addSpreadOperatorForArrayAsVarargAfterSam"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addSpreadOperatorForArrayAsVarargAfterSam"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("withError.test") @@ -387,7 +388,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInAddStarProjections() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addStarProjections"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addStarProjections"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("idea/testData/quickfix/addStarProjections/cast") @@ -399,7 +400,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInCast() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addStarProjections/cast"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addStarProjections/cast"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -412,7 +413,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInCheckType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addStarProjections/checkType"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addStarProjections/checkType"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -425,7 +426,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInInner() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addStarProjections/inner"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addStarProjections/inner"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -438,7 +439,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInWhen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addStarProjections/when"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addStarProjections/when"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } } @@ -452,7 +453,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInAddSuspend() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addSuspend"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addSuspend"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -465,7 +466,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInAddTypeAnnotationToValueParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addTypeAnnotationToValueParameter"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addTypeAnnotationToValueParameter"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -478,7 +479,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInAddValVar() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addValVar"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addValVar"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -491,7 +492,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInAddVarianceModifier() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addVarianceModifier"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addVarianceModifier"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -504,7 +505,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInAssignOperatorAmbiguity() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/assignOperatorAmbiguity"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/assignOperatorAmbiguity"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("idea/testData/quickfix/assignOperatorAmbiguity/changeToVal") @@ -516,7 +517,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInChangeToVal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/assignOperatorAmbiguity/changeToVal"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/assignOperatorAmbiguity/changeToVal"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -529,7 +530,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInReplaceWithAssignCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/assignOperatorAmbiguity/replaceWithAssignCall"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/assignOperatorAmbiguity/replaceWithAssignCall"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } } @@ -543,7 +544,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInAssignToProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/assignToProperty"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/assignToProperty"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -556,7 +557,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInAutoImports() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/autoImports"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/autoImports"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("ambiguousNamePreferFromJdk.before.Main.kt") @@ -1138,7 +1139,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInKt21515() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/autoImports/kt21515"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/autoImports/kt21515"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("staticFromJava.test") @@ -1156,7 +1157,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInMismatchingArgs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/autoImports/mismatchingArgs"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/autoImports/mismatchingArgs"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("checkArgumentTypes.test") @@ -1250,7 +1251,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInCanBeParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/canBeParameter"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/canBeParameter"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -1263,7 +1264,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInCanBePrimaryConstructorProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/canBePrimaryConstructorProperty"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/canBePrimaryConstructorProperty"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -1276,7 +1277,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInChangeFeatureSupport() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/changeFeatureSupport"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/changeFeatureSupport"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -1289,7 +1290,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInChangeObjectToClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/changeObjectToClass"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/changeObjectToClass"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -1312,7 +1313,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInChangeSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/changeSignature"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/changeSignature"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("matchFunctionLiteralWithSAMType.before.Main.kt") @@ -1334,7 +1335,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInJk() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/changeSignature/jk"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/changeSignature/jk"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("jkAddFunctionParameter.before.Main.java") @@ -1422,7 +1423,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInKj() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/changeSignature/kj"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/changeSignature/kj"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } } @@ -1436,7 +1437,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInChangeSuperTypeListEntryTypeArgument() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/changeSuperTypeListEntryTypeArgument"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/changeSuperTypeListEntryTypeArgument"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -1449,7 +1450,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInChangeToLabeledReturn() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/changeToLabeledReturn"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/changeToLabeledReturn"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -1462,7 +1463,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInChangeToMutableCollection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/changeToMutableCollection"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/changeToMutableCollection"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -1475,7 +1476,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInChangeToUseSpreadOperator() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/changeToUseSpreadOperator"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/changeToUseSpreadOperator"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -1488,7 +1489,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInCheckArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/checkArguments"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/checkArguments"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("idea/testData/quickfix/checkArguments/addNameToArgument") @@ -1500,7 +1501,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInAddNameToArgument() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/checkArguments/addNameToArgument"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/checkArguments/addNameToArgument"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } } @@ -1514,7 +1515,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInConflictingImports() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/conflictingImports"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/conflictingImports"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -1527,7 +1528,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInConvertJavaInterfaceToClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/convertJavaInterfaceToClass"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/convertJavaInterfaceToClass"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("kotlinInheritor.before.Main.java") @@ -1545,7 +1546,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInConvertLateinitPropertyToNotNullDelegate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/convertLateinitPropertyToNotNullDelegate"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/convertLateinitPropertyToNotNullDelegate"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -1558,7 +1559,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInConvertPropertyInitializerToGetter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/convertPropertyInitializerToGetter"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/convertPropertyInitializerToGetter"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -1571,7 +1572,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInConvertToAnonymousObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/convertToAnonymousObject"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/convertToAnonymousObject"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -1584,7 +1585,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInCreateFromUsage() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("idea/testData/quickfix/createFromUsage/createClass") @@ -1596,7 +1597,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInCreateClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createClass"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createClass"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("idea/testData/quickfix/createFromUsage/createClass/annotationEntry") @@ -1608,7 +1609,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInAnnotationEntry() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createClass/annotationEntry"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createClass/annotationEntry"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("nestedGroovyAnnotation.before.Main.kt") @@ -1636,7 +1637,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInCallExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createClass/callExpression"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createClass/callExpression"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("callInAnnotationEntryWithJavaQualifier.before.Main.kt") @@ -1703,7 +1704,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInTypeArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createClass/callExpression/typeArguments"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createClass/callExpression/typeArguments"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("javaClassMember.before.Main.kt") @@ -1742,7 +1743,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInDelegationSpecifier() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createClass/delegationSpecifier"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createClass/delegationSpecifier"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("delegatorToNestedJavaSupercall.before.Main.kt") @@ -1775,7 +1776,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInImportDirective() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createClass/importDirective"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createClass/importDirective"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("annotationWithJavaQualifier.before.Main.kt") @@ -1822,7 +1823,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInKt21515() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } } @@ -1836,7 +1837,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInReferenceExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createClass/referenceExpression"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createClass/referenceExpression"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("classByNestedGroovyQualifier.before.Main.kt") @@ -1894,7 +1895,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInTypeReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createClass/typeReference"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createClass/typeReference"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("annotationJavaTypeReceiver.before.Main.kt") @@ -1938,7 +1939,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInCreateFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("idea/testData/quickfix/createFromUsage/createFunction/binaryOperations") @@ -1950,7 +1951,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInBinaryOperations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/binaryOperations"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/binaryOperations"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -1963,7 +1964,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/call"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/call"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("extensionFunOnGroovyType.before.Main.kt") @@ -2030,7 +2031,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInAbstract() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/call/abstract"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/call/abstract"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -2043,7 +2044,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInExtensionByExtensionReceiver() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/call/extensionByExtensionReceiver"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/call/extensionByExtensionReceiver"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -2056,7 +2057,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInTypeArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/call/typeArguments"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/call/typeArguments"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("javaClassMember.before.Main.kt") @@ -2085,7 +2086,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInCallableReferences() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/callableReferences"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/callableReferences"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -2098,7 +2099,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInComponent() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/component"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/component"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -2111,7 +2112,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInDelegateAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/delegateAccessors"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/delegateAccessors"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -2124,7 +2125,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInFromJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/fromJava"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/fromJava"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("classMember.before.Main.java") @@ -2157,7 +2158,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInGet() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/get"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/get"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -2170,7 +2171,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInHasNext() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/hasNext"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/hasNext"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -2183,7 +2184,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInInvoke() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/invoke"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/invoke"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -2196,7 +2197,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInIterator() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/iterator"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/iterator"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -2209,7 +2210,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInNext() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/next"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/next"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -2222,7 +2223,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInSet() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/set"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/set"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -2235,7 +2236,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInUnaryOperations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/unaryOperations"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/unaryOperations"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } } @@ -2249,7 +2250,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInCreateSecondaryConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createSecondaryConstructor"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createSecondaryConstructor"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("delegatorToSuperCallJavaClass.before.Main.kt") @@ -2282,7 +2283,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInCreateTypeParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createTypeParameter"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createTypeParameter"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("idea/testData/quickfix/createFromUsage/createTypeParameter/inContainingDeclaration") @@ -2294,7 +2295,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInInContainingDeclaration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createTypeParameter/inContainingDeclaration"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createTypeParameter/inContainingDeclaration"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -2307,7 +2308,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInInReferencedDeclaration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createTypeParameter/inReferencedDeclaration"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createTypeParameter/inReferencedDeclaration"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } } @@ -2321,7 +2322,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInCreateVariable() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createVariable"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createVariable"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("idea/testData/quickfix/createFromUsage/createVariable/localVariable") @@ -2333,7 +2334,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInLocalVariable() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createVariable/localVariable"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createVariable/localVariable"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -2346,7 +2347,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createVariable/parameter"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createVariable/parameter"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("platformType.before.Main.kt") @@ -2364,7 +2365,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInPrimaryParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createVariable/primaryParameter"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createVariable/primaryParameter"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("staticValOnJavaClass.before.Main.kt") @@ -2387,7 +2388,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createVariable/property"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createVariable/property"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("extensionPropertyOnTypeFromAnotherPackage.before.Main.kt") @@ -2454,7 +2455,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInAbstract() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createVariable/property/abstract"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createVariable/property/abstract"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -2467,7 +2468,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInFieldFromJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createVariable/property/fieldFromJava"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createVariable/property/fieldFromJava"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("classMemberLateinitVar.before.Main.java") @@ -2503,7 +2504,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInCreateLabel() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createLabel"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createLabel"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -2516,7 +2517,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInDeclarationCantBeInlined() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/declarationCantBeInlined"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/declarationCantBeInlined"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -2529,7 +2530,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInDecreaseVisibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/decreaseVisibility"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/decreaseVisibility"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -2542,7 +2543,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInDeprecatedJavaAnnotation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedJavaAnnotation"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedJavaAnnotation"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -2555,7 +2556,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInDeprecatedSymbolUsage() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("javaDeprecated.before.Main.kt") @@ -2577,7 +2578,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInArgumentSideEffects() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/argumentSideEffects"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/argumentSideEffects"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -2595,7 +2596,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInClassUsages() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/classUsages"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/classUsages"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("idea/testData/quickfix/deprecatedSymbolUsage/classUsages/wholeProject") @@ -2607,7 +2608,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInWholeProject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/classUsages/wholeProject"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/classUsages/wholeProject"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("annotation.before.Main.kt") @@ -2636,7 +2637,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInFunctionLiteralArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/functionLiteralArguments"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/functionLiteralArguments"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -2694,7 +2695,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInImports() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/imports"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/imports"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("rootPackage.before.Main.kt") @@ -2712,7 +2713,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInKeepComments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/keepComments"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/keepComments"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -2725,7 +2726,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInKeepLineBreaks() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/keepLineBreaks"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/keepLineBreaks"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -2738,7 +2739,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInOperatorCalls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/operatorCalls"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/operatorCalls"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -2751,7 +2752,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInOptionalParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/optionalParameters"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/optionalParameters"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -2764,7 +2765,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/properties"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/properties"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -2777,7 +2778,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInPublishedApi() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/publishedApi"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/publishedApi"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -2790,7 +2791,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInSafeCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/safeCall"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/safeCall"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -2803,7 +2804,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInTypeAliases() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/typeAliases"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/typeAliases"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("idea/testData/quickfix/deprecatedSymbolUsage/typeAliases/wholeProject") @@ -2815,7 +2816,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInWholeProject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/typeAliases/wholeProject"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/typeAliases/wholeProject"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("typealias.before.Main.kt") @@ -2834,7 +2835,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInTypeArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/typeArguments"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/typeArguments"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("platformType.before.Main.kt") @@ -2851,7 +2852,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInWholeProject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/typeArguments/wholeProject"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/typeArguments/wholeProject"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } } @@ -2865,7 +2866,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInVararg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/vararg"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/vararg"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -2878,7 +2879,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInWholeProject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/wholeProject"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/wholeProject"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("function.before.Main.kt") @@ -2902,7 +2903,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInExperimental() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/experimental"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/experimental"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -2915,7 +2916,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInExpressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/expressions"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/expressions"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -2928,7 +2929,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInFoldTryCatch() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/foldTryCatch"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/foldTryCatch"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -2941,7 +2942,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInFunctionWithLambdaExpressionBody() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/functionWithLambdaExpressionBody"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/functionWithLambdaExpressionBody"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("idea/testData/quickfix/functionWithLambdaExpressionBody/removeBraces") @@ -2953,7 +2954,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInRemoveBraces() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/functionWithLambdaExpressionBody/removeBraces"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/functionWithLambdaExpressionBody/removeBraces"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -2966,7 +2967,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInWrapRun() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/functionWithLambdaExpressionBody/wrapRun"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/functionWithLambdaExpressionBody/wrapRun"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } } @@ -2980,7 +2981,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInImplement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/implement"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/implement"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -2993,7 +2994,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInIncreaseVisibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/increaseVisibility"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/increaseVisibility"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("privateMemberToInternalMultiFile.before.Main.kt") @@ -3030,7 +3031,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInInvisibleFake() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/increaseVisibility/invisibleFake"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/increaseVisibility/invisibleFake"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } } @@ -3044,7 +3045,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInInitializeWithConstructorParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/initializeWithConstructorParameter"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/initializeWithConstructorParameter"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -3057,7 +3058,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInInlineClassConstructorNotValParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/inlineClassConstructorNotValParameter"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/inlineClassConstructorNotValParameter"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -3070,7 +3071,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInInlineTypeParameterFix() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/inlineTypeParameterFix"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/inlineTypeParameterFix"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -3083,7 +3084,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInInsertDelegationCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/insertDelegationCall"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/insertDelegationCall"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -3096,7 +3097,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInKdocMissingDocumentation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/kdocMissingDocumentation"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/kdocMissingDocumentation"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -3109,7 +3110,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInLateinit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/lateinit"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/lateinit"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -3122,7 +3123,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInLeakingThis() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/leakingThis"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/leakingThis"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -3135,7 +3136,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInLibraries() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/libraries"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/libraries"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -3148,7 +3149,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInLocalVariableWithTypeParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/localVariableWithTypeParameters"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/localVariableWithTypeParameters"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -3161,7 +3162,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInMakeConstructorParameterProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/makeConstructorParameterProperty"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/makeConstructorParameterProperty"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -3174,7 +3175,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInMakePrivateAndOverrideMember() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/makePrivateAndOverrideMember"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/makePrivateAndOverrideMember"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("parameter.before.Main.kt") @@ -3222,7 +3223,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInMakeTypeParameterReified() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/makeTypeParameterReified"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/makeTypeParameterReified"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -3235,7 +3236,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInMemberVisibilityCanBePrivate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/memberVisibilityCanBePrivate"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/memberVisibilityCanBePrivate"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("getter.before.Main.kt") @@ -3253,7 +3254,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInMigration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/migration"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/migration"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("idea/testData/quickfix/migration/commasInWhenWithoutArgument") @@ -3265,7 +3266,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInCommasInWhenWithoutArgument() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/migration/commasInWhenWithoutArgument"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/migration/commasInWhenWithoutArgument"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -3278,7 +3279,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInConflictingExtension() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/migration/conflictingExtension"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/migration/conflictingExtension"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("removeImports.before.Main.kt") @@ -3301,7 +3302,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInJavaAnnotationPositionedArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/migration/javaAnnotationPositionedArguments"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/migration/javaAnnotationPositionedArguments"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("basicMultiple.before.Main.kt") @@ -3329,7 +3330,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInJsExternal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/migration/jsExternal"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/migration/jsExternal"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -3342,7 +3343,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInMissingConstructorKeyword() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/migration/missingConstructorKeyword"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/migration/missingConstructorKeyword"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -3355,7 +3356,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInObsoleteLabelSyntax() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/migration/obsoleteLabelSyntax"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/migration/obsoleteLabelSyntax"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -3368,7 +3369,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInRemoveNameFromFunctionExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/migration/removeNameFromFunctionExpression"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/migration/removeNameFromFunctionExpression"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -3381,7 +3382,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInTypeParameterList() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/migration/typeParameterList"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/migration/typeParameterList"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } } @@ -3395,7 +3396,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInMissingConstructorBrackets() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/missingConstructorBrackets"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/missingConstructorBrackets"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -3408,7 +3409,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInModifiers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/modifiers"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/modifiers"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("constVal.before.Main.kt") @@ -3425,7 +3426,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInAddOpenToClassDeclaration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/modifiers/addOpenToClassDeclaration"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/modifiers/addOpenToClassDeclaration"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("finalJavaSupertype.before.Main.kt") @@ -3448,7 +3449,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInSuspend() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/modifiers/suspend"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/modifiers/suspend"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } } @@ -3462,7 +3463,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInMoveMemberToCompanionObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/moveMemberToCompanionObject"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/moveMemberToCompanionObject"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -3475,7 +3476,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInMoveReceiverAnnotation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/moveReceiverAnnotation"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/moveReceiverAnnotation"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -3488,7 +3489,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInMoveToConstructorParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/moveToConstructorParameters"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/moveToConstructorParameters"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -3501,7 +3502,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInMoveTypeAliasToTopLevel() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/moveTypeAliasToTopLevel"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/moveTypeAliasToTopLevel"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -3514,7 +3515,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInNullables() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/nullables"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/nullables"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("idea/testData/quickfix/nullables/unsafeInfixCall") @@ -3526,7 +3527,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInUnsafeInfixCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/nullables/unsafeInfixCall"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/nullables/unsafeInfixCall"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } } @@ -3540,7 +3541,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInObsoleteCoroutines() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/obsoleteCoroutines"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/obsoleteCoroutines"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -3553,7 +3554,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInObsoleteKotlinJsPackages() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/obsoleteKotlinJsPackages"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/obsoleteKotlinJsPackages"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -3566,7 +3567,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInOptimizeImports() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/optimizeImports"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/optimizeImports"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("notRemoveImportsForTypeAliases.before.Main.kt") @@ -3589,7 +3590,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInOverride() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/override"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/override"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("idea/testData/quickfix/override/nothingToOverride") @@ -3601,7 +3602,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInNothingToOverride() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/override/nothingToOverride"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/override/nothingToOverride"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("import.before.Main.kt") @@ -3629,7 +3630,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInTypeMismatchOnOverride() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/override/typeMismatchOnOverride"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/override/typeMismatchOnOverride"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } } @@ -3643,7 +3644,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInPlatformClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/platformClasses"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/platformClasses"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -3656,7 +3657,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInPlatformTypesInspection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/platformTypesInspection"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/platformTypesInspection"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -3669,7 +3670,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInPrimitiveCastToConversion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/primitiveCastToConversion"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/primitiveCastToConversion"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -3682,7 +3683,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/properties"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/properties"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("idea/testData/quickfix/properties/extensionPropertyInitializerToGetter") @@ -3694,7 +3695,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInExtensionPropertyInitializerToGetter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/properties/extensionPropertyInitializerToGetter"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/properties/extensionPropertyInitializerToGetter"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } } @@ -3708,7 +3709,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInProtectedInFinal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/protectedInFinal"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/protectedInFinal"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -3721,7 +3722,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInRedundantConst() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/redundantConst"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/redundantConst"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -3734,7 +3735,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInRedundantFun() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/redundantFun"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/redundantFun"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -3747,7 +3748,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInRedundantIf() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/redundantIf"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/redundantIf"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -3760,7 +3761,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInRedundantInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/redundantInline"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/redundantInline"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -3773,7 +3774,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInRedundantLateinit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/redundantLateinit"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/redundantLateinit"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -3786,7 +3787,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInRedundantModalityModifier() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/redundantModalityModifier"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/redundantModalityModifier"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -3799,7 +3800,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInRedundantSemicolon() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/redundantSemicolon"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/redundantSemicolon"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -3812,7 +3813,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInRedundantSuspend() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/redundantSuspend"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/redundantSuspend"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -3825,7 +3826,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInRedundantVisibilityModifier() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/redundantVisibilityModifier"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/redundantVisibilityModifier"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -3838,7 +3839,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInRemoveAnnotation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeAnnotation"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeAnnotation"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -3851,7 +3852,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInRemoveArgument() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeArgument"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeArgument"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -3864,7 +3865,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInRemoveAtFromAnnotationArgument() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeAtFromAnnotationArgument"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeAtFromAnnotationArgument"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -3877,7 +3878,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInRemoveDefaultParameterValue() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeDefaultParameterValue"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeDefaultParameterValue"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -3890,7 +3891,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInRemoveFinalUpperBound() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeFinalUpperBound"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeFinalUpperBound"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -3903,7 +3904,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInRemoveNoConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeNoConstructor"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeNoConstructor"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -3916,7 +3917,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInRemoveRedundantAssignment() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeRedundantAssignment"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeRedundantAssignment"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -3929,7 +3930,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInRemoveRedundantInitializer() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeRedundantInitializer"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeRedundantInitializer"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -3942,7 +3943,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInRemoveRedundantLabel() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeRedundantLabel"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeRedundantLabel"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -3955,7 +3956,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInRemoveRedundantSpreadOperator() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeRedundantSpreadOperator"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeRedundantSpreadOperator"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -3968,7 +3969,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInRemoveSingleLambdaParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeSingleLambdaParameter"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeSingleLambdaParameter"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -3981,7 +3982,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInRemoveSuspend() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeSuspend"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeSuspend"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -3994,7 +3995,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInRemoveToStringInStringTemplate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeToStringInStringTemplate"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeToStringInStringTemplate"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4007,7 +4008,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInRemoveTypeVariance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeTypeVariance"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeTypeVariance"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4020,7 +4021,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInRemoveUnused() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeUnused"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeUnused"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("javaTriangle.before.Main.kt") @@ -4073,7 +4074,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInRemoveUnusedReceiver() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeUnusedReceiver"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeUnusedReceiver"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4086,7 +4087,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInRenameToRem() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/renameToRem"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/renameToRem"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4099,7 +4100,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInRenameToUnderscore() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/renameToUnderscore"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/renameToUnderscore"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4112,7 +4113,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInRenameUnresolvedReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/renameUnresolvedReference"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/renameUnresolvedReference"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4125,7 +4126,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInReplaceInfixOrOperatorCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/replaceInfixOrOperatorCall"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/replaceInfixOrOperatorCall"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4138,7 +4139,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInReplaceJvmFieldWithConst() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/replaceJvmFieldWithConst"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/replaceJvmFieldWithConst"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4151,7 +4152,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInReplaceWithArrayCallInAnnotation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/replaceWithArrayCallInAnnotation"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/replaceWithArrayCallInAnnotation"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4164,7 +4165,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInReplaceWithDotCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/replaceWithDotCall"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/replaceWithDotCall"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4177,7 +4178,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInReplaceWithSafeCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/replaceWithSafeCall"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/replaceWithSafeCall"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4190,7 +4191,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInReplaceWithSafeCallForScopeFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/replaceWithSafeCallForScopeFunction"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/replaceWithSafeCallForScopeFunction"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4203,7 +4204,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInRestrictedRetentionForExpressionAnnotation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/restrictedRetentionForExpressionAnnotation"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/restrictedRetentionForExpressionAnnotation"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("idea/testData/quickfix/restrictedRetentionForExpressionAnnotation/addSourceRetention") @@ -4215,7 +4216,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInAddSourceRetention() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/restrictedRetentionForExpressionAnnotation/addSourceRetention"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/restrictedRetentionForExpressionAnnotation/addSourceRetention"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4228,7 +4229,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInChangeRetentionToSource() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/restrictedRetentionForExpressionAnnotation/changeRetentionToSource"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/restrictedRetentionForExpressionAnnotation/changeRetentionToSource"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4241,7 +4242,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInRemoveExpressionTarget() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/restrictedRetentionForExpressionAnnotation/removeExpressionTarget"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/restrictedRetentionForExpressionAnnotation/removeExpressionTarget"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } } @@ -4255,7 +4256,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInSimplifyComparison() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/simplifyComparison"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/simplifyComparison"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4268,7 +4269,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInSmartCastImpossibleInIfThen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/smartCastImpossibleInIfThen"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/smartCastImpossibleInIfThen"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4281,7 +4282,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInSpecifyOverrideExplicitly() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/specifyOverrideExplicitly"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/specifyOverrideExplicitly"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4294,7 +4295,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInSpecifySuperType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/specifySuperType"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/specifySuperType"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4307,7 +4308,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInSpecifyVisibilityInExplicitApiMode() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/specifyVisibilityInExplicitApiMode"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/specifyVisibilityInExplicitApiMode"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4320,7 +4321,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInSuperTypeIsExtensionType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/superTypeIsExtensionType"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/superTypeIsExtensionType"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4333,7 +4334,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInSupercalls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/supercalls"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/supercalls"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4346,7 +4347,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInSupertypeInitialization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/supertypeInitialization"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/supertypeInitialization"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4359,7 +4360,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInSuppress() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suppress"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suppress"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("idea/testData/quickfix/suppress/annotationPosition") @@ -4371,7 +4372,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInAnnotationPosition() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suppress/annotationPosition"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suppress/annotationPosition"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4384,7 +4385,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInAvailability() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suppress/availability"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suppress/availability"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4397,7 +4398,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInDeclarationKinds() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suppress/declarationKinds"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suppress/declarationKinds"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4410,7 +4411,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInErrorRecovery() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suppress/errorRecovery"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suppress/errorRecovery"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4423,7 +4424,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInExternal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suppress/external"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suppress/external"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4436,7 +4437,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInForStatement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suppress/forStatement"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suppress/forStatement"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("idea/testData/quickfix/suppress/forStatement/unavailable") @@ -4448,7 +4449,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInUnavailable() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suppress/forStatement/unavailable"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suppress/forStatement/unavailable"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } } @@ -4462,7 +4463,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInInspections() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suppress/inspections"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suppress/inspections"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } } @@ -4476,7 +4477,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInSurroundWithArrayOfForNamedArgumentsToVarargs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/surroundWithArrayOfForNamedArgumentsToVarargs"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/surroundWithArrayOfForNamedArgumentsToVarargs"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4489,7 +4490,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInSurroundWithNullCheck() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/surroundWithNullCheck"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/surroundWithNullCheck"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4502,7 +4503,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInSuspiciousCollectionReassignment() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suspiciousCollectionReassignment"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suspiciousCollectionReassignment"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("idea/testData/quickfix/suspiciousCollectionReassignment/changeTypeToMutable") @@ -4514,7 +4515,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInChangeTypeToMutable() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suspiciousCollectionReassignment/changeTypeToMutable"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suspiciousCollectionReassignment/changeTypeToMutable"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4527,7 +4528,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInJoinWithInitializer() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suspiciousCollectionReassignment/joinWithInitializer"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suspiciousCollectionReassignment/joinWithInitializer"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4540,7 +4541,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInReplaceWithAssignment() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suspiciousCollectionReassignment/replaceWithAssignment"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suspiciousCollectionReassignment/replaceWithAssignment"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4553,7 +4554,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInReplaceWithFilter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suspiciousCollectionReassignment/replaceWithFilter"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suspiciousCollectionReassignment/replaceWithFilter"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4566,7 +4567,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInReplaceWithOrdinaryAssignment() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suspiciousCollectionReassignment/replaceWithOrdinaryAssignment"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suspiciousCollectionReassignment/replaceWithOrdinaryAssignment"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } } @@ -4580,7 +4581,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInToString() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/toString"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/toString"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4593,7 +4594,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInTooLongCharLiteralToString() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/tooLongCharLiteralToString"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/tooLongCharLiteralToString"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4606,7 +4607,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInTypeAddition() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeAddition"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeAddition"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4619,7 +4620,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInTypeImports() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeImports"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeImports"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("importFromAnotherFile.before.Main.kt") @@ -4637,7 +4638,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInTypeInferenceExpectedTypeMismatch() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeInferenceExpectedTypeMismatch"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeInferenceExpectedTypeMismatch"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4655,7 +4656,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInTypeMismatch() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeMismatch"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeMismatch"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("paramTypeInOverrides.before.Main.kt") @@ -4672,7 +4673,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInCasts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeMismatch/casts"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeMismatch/casts"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4685,7 +4686,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInComponentFunctionReturnTypeMismatch() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeMismatch/componentFunctionReturnTypeMismatch"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeMismatch/componentFunctionReturnTypeMismatch"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4698,7 +4699,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInConvertCollection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeMismatch/convertCollection"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeMismatch/convertCollection"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4711,7 +4712,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInFixOverloadedOperator() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeMismatch/fixOverloadedOperator"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeMismatch/fixOverloadedOperator"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4724,7 +4725,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInGenericVarianceViolation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeMismatch/genericVarianceViolation"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeMismatch/genericVarianceViolation"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("basicMultiple.before.Main.kt") @@ -4742,7 +4743,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInNumberConversion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeMismatch/numberConversion"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeMismatch/numberConversion"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4755,7 +4756,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInParameterTypeMismatch() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeMismatch/parameterTypeMismatch"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeMismatch/parameterTypeMismatch"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4768,7 +4769,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInRoundNumber() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeMismatch/roundNumber"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeMismatch/roundNumber"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4781,7 +4782,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInTypeMismatchOnReturnedExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4794,7 +4795,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInWrapWithCollectionLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeMismatch/wrapWithCollectionLiteral"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeMismatch/wrapWithCollectionLiteral"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4807,7 +4808,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInWrongPrimitive() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeMismatch/wrongPrimitive"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeMismatch/wrongPrimitive"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } } @@ -4821,7 +4822,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInTypeOfAnnotationMember() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeOfAnnotationMember"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeOfAnnotationMember"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4834,7 +4835,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInTypeParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeParameters"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeParameters"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4847,7 +4848,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInTypeProjection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeProjection"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeProjection"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4860,7 +4861,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInUnnecessaryLateinit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/unnecessaryLateinit"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/unnecessaryLateinit"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4873,7 +4874,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInUnusedSuppressAnnotation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/unusedSuppressAnnotation"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/unusedSuppressAnnotation"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4886,7 +4887,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInVariables() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/variables"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/variables"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("idea/testData/quickfix/variables/changeMutability") @@ -4898,7 +4899,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInChangeMutability() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/variables/changeMutability"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/variables/changeMutability"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } @TestMetadata("idea/testData/quickfix/variables/changeMutability/canBeVal") @@ -4910,7 +4911,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInCanBeVal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/variables/changeMutability/canBeVal"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/variables/changeMutability/canBeVal"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } } @@ -4924,7 +4925,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInChangeToFunctionInvocation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/variables/changeToFunctionInvocation"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/variables/changeToFunctionInvocation"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4937,7 +4938,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInChangeToPropertyAccess() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/variables/changeToPropertyAccess"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/variables/changeToPropertyAccess"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4950,7 +4951,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInRemoveValVarFromParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/variables/removeValVarFromParameter"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/variables/removeValVarFromParameter"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } } @@ -4974,7 +4975,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInWhen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/when"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/when"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -4987,7 +4988,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInWrapWithSafeLetCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/wrapWithSafeLetCall"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/wrapWithSafeLetCall"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -5000,7 +5001,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInWrongLongSuffix() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/wrongLongSuffix"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/wrongLongSuffix"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } @@ -5013,7 +5014,7 @@ public class QuickFixMultiFileTestGenerated extends AbstractQuickFixMultiFileTes } public void testAllFilesPresentInYieldUnsupported() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/yieldUnsupported"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/yieldUnsupported"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), null, true); } } } diff --git a/idea/tests/org/jetbrains/kotlin/idea/quickfix/QuickFixMultiModuleTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/quickfix/QuickFixMultiModuleTestGenerated.java index 0103e0a3b57..6636f875e49 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/quickfix/QuickFixMultiModuleTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/quickfix/QuickFixMultiModuleTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.quickfix; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class QuickFixMultiModuleTestGenerated extends AbstractQuickFixMultiModul } public void testAllFilesPresentInMultiModuleQuickFix() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/multiModuleQuickFix"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/multiModuleQuickFix"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("idea/testData/multiModuleQuickFix/accessibilityChecker") @@ -37,7 +38,7 @@ public class QuickFixMultiModuleTestGenerated extends AbstractQuickFixMultiModul } public void testAllFilesPresentInAccessibilityChecker() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/multiModuleQuickFix/accessibilityChecker"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/multiModuleQuickFix/accessibilityChecker"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("classPrimaryConstructor") @@ -135,7 +136,7 @@ public class QuickFixMultiModuleTestGenerated extends AbstractQuickFixMultiModul } public void testAllFilesPresentInAddMissingActualMembers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/multiModuleQuickFix/addMissingActualMembers"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/multiModuleQuickFix/addMissingActualMembers"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("classFunction") @@ -218,7 +219,7 @@ public class QuickFixMultiModuleTestGenerated extends AbstractQuickFixMultiModul } public void testAllFilesPresentInAddThrowAnnotation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/multiModuleQuickFix/addThrowAnnotation"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/multiModuleQuickFix/addThrowAnnotation"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("common") @@ -251,7 +252,7 @@ public class QuickFixMultiModuleTestGenerated extends AbstractQuickFixMultiModul } public void testAllFilesPresentInChangeModifier() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/multiModuleQuickFix/changeModifier"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/multiModuleQuickFix/changeModifier"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("internal") @@ -279,7 +280,7 @@ public class QuickFixMultiModuleTestGenerated extends AbstractQuickFixMultiModul } public void testAllFilesPresentInChangeSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/multiModuleQuickFix/changeSignature"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/multiModuleQuickFix/changeSignature"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("expect") @@ -337,7 +338,7 @@ public class QuickFixMultiModuleTestGenerated extends AbstractQuickFixMultiModul } public void testAllFilesPresentInCreateActual() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/multiModuleQuickFix/createActual"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/multiModuleQuickFix/createActual"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("annotation") @@ -510,7 +511,7 @@ public class QuickFixMultiModuleTestGenerated extends AbstractQuickFixMultiModul } public void testAllFilesPresentInCreateExpect() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/multiModuleQuickFix/createExpect"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/multiModuleQuickFix/createExpect"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("annotation") @@ -823,7 +824,7 @@ public class QuickFixMultiModuleTestGenerated extends AbstractQuickFixMultiModul } public void testAllFilesPresentInFixNativeThrowsErrors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/multiModuleQuickFix/fixNativeThrowsErrors"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/multiModuleQuickFix/fixNativeThrowsErrors"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("removeEmptyThrows") @@ -851,7 +852,7 @@ public class QuickFixMultiModuleTestGenerated extends AbstractQuickFixMultiModul } public void testAllFilesPresentInMakeOverridenMemberOpen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/multiModuleQuickFix/makeOverridenMemberOpen"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/multiModuleQuickFix/makeOverridenMemberOpen"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("expect") @@ -924,7 +925,7 @@ public class QuickFixMultiModuleTestGenerated extends AbstractQuickFixMultiModul } public void testAllFilesPresentInOther() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/multiModuleQuickFix/other"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/multiModuleQuickFix/other"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("convertActualEnumToSealedClass") diff --git a/idea/tests/org/jetbrains/kotlin/idea/quickfix/QuickFixTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/quickfix/QuickFixTestGenerated.java index b9fa6d427b2..b8d2fb3d472 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/quickfix/QuickFixTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/quickfix/QuickFixTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.quickfix; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInQuickfix() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("idea/testData/quickfix/abstract") @@ -127,7 +128,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInAbstract() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/abstract"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/abstract"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("makeEnumEntryAbstract.kt") @@ -215,7 +216,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInAddAnnotationTarget() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addAnnotationTarget"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addAnnotationTarget"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("basic1.kt") @@ -368,7 +369,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInAddConstructorParameterFromSuperTypeCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addConstructorParameterFromSuperTypeCall"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addConstructorParameterFromSuperTypeCall"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("backticks.kt") @@ -426,7 +427,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInAddCrossinline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addCrossinline"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addCrossinline"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("basic.kt") @@ -454,7 +455,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInAddDataModifier() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addDataModifier"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addDataModifier"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("inner.kt") @@ -542,7 +543,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInAddDefaultConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addDefaultConstructor"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addDefaultConstructor"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("expect.kt") @@ -585,7 +586,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInAddEqEqTrue() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addEqEqTrue"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addEqEqTrue"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("notBoolean.kt") @@ -618,7 +619,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInAddExclExclCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addExclExclCall"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addExclExclCall"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("array.kt") @@ -711,7 +712,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInAddGenericUpperBound() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addGenericUpperBound"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addGenericUpperBound"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("basic.kt") @@ -754,7 +755,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInAddInitializer() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addInitializer"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addInitializer"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("localVar.kt") @@ -852,7 +853,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInAddInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addInline"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addInline"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("basic.kt") @@ -875,7 +876,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInAddInlineToReifiedFunctionFix() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addInlineToReifiedFunctionFix"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addInlineToReifiedFunctionFix"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("basic.kt") @@ -893,7 +894,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInAddIsToWhenCondition() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addIsToWhenCondition"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addIsToWhenCondition"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("class.kt") @@ -911,7 +912,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInAddJvmDefault() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addJvmDefault"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addJvmDefault"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("functionOverride.kt") @@ -934,7 +935,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInAddJvmNameAnnotation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addJvmNameAnnotation"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addJvmNameAnnotation"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("basic.kt") @@ -982,7 +983,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInAddNewLineAfterAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addNewLineAfterAnnotations"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addNewLineAfterAnnotations"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("basic.kt") @@ -1015,7 +1016,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInAddNoinline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addNoinline"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addNoinline"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("basic.kt") @@ -1038,7 +1039,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInAddPropertyAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addPropertyAccessors"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addPropertyAccessors"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("val.kt") @@ -1076,7 +1077,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInAddPropertyToSupertype() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addPropertyToSupertype"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addPropertyToSupertype"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("interface.kt") @@ -1099,7 +1100,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInAddReifiedToTypeParameterOfFunctionFix() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addReifiedToTypeParameterOfFunctionFix"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addReifiedToTypeParameterOfFunctionFix"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("doubleColonClass.kt") @@ -1127,7 +1128,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInAddReturnToLastExpressionInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addReturnToLastExpressionInFunction"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addReturnToLastExpressionInFunction"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("notSubtype.kt") @@ -1170,7 +1171,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInAddReturnToUnusedLastExpressionInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addReturnToUnusedLastExpressionInFunction"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addReturnToUnusedLastExpressionInFunction"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("notSubtype.kt") @@ -1213,7 +1214,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInAddRunBeforeLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addRunBeforeLambda"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addRunBeforeLambda"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("basic.kt") @@ -1231,7 +1232,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInAddSemicolonBeforeLambdaExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addSemicolonBeforeLambdaExpression"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addSemicolonBeforeLambdaExpression"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("basic.kt") @@ -1309,7 +1310,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInAddSpreadOperatorForArrayAsVarargAfterSam() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addSpreadOperatorForArrayAsVarargAfterSam"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addSpreadOperatorForArrayAsVarargAfterSam"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } } @@ -1322,7 +1323,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInAddStarProjections() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addStarProjections"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addStarProjections"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("qualifiedArrayList.kt") @@ -1364,7 +1365,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInCast() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addStarProjections/cast"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addStarProjections/cast"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("changeFunctionalToStarProjection.kt") @@ -1487,7 +1488,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInCheckType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addStarProjections/checkType"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addStarProjections/checkType"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("changeToStarProjectionMultipleParameters.kt") @@ -1515,7 +1516,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInInner() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addStarProjections/inner"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addStarProjections/inner"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("inner1.kt") @@ -1568,7 +1569,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInWhen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addStarProjections/when"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addStarProjections/when"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("qualifiedArrayList.kt") @@ -1612,7 +1613,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInAddSuspend() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addSuspend"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addSuspend"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("fakeOverride.kt") @@ -1655,7 +1656,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInAddTypeAnnotationToValueParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addTypeAnnotationToValueParameter"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addTypeAnnotationToValueParameter"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("annotationWithArrayLiteralDouble.kt") @@ -1728,7 +1729,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInAddValVar() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addValVar"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addValVar"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } } @@ -1751,7 +1752,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInAddVarianceModifier() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addVarianceModifier"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/addVarianceModifier"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("emptyTest.kt") @@ -1769,7 +1770,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInAssignOperatorAmbiguity() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/assignOperatorAmbiguity"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/assignOperatorAmbiguity"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("idea/testData/quickfix/assignOperatorAmbiguity/changeToVal") @@ -1781,7 +1782,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInChangeToVal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/assignOperatorAmbiguity/changeToVal"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/assignOperatorAmbiguity/changeToVal"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("arrayList.kt") @@ -1829,7 +1830,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInReplaceWithAssignCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/assignOperatorAmbiguity/replaceWithAssignCall"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/assignOperatorAmbiguity/replaceWithAssignCall"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("arrayList.kt") @@ -1873,7 +1874,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInAssignToProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/assignToProperty"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/assignToProperty"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("differentNameProperty.kt") @@ -1946,7 +1947,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInAutoImports() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/autoImports"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/autoImports"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("checkNoStackOverflowInImportInnerClassInCurrentFile.kt") @@ -2123,7 +2124,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInKt21515() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/autoImports/kt21515"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/autoImports/kt21515"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("callableReferenceFromDeprecated.kt") @@ -2151,7 +2152,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInMismatchingArgs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/autoImports/mismatchingArgs"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/autoImports/mismatchingArgs"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } } } @@ -2165,7 +2166,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInCanBeParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/canBeParameter"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/canBeParameter"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("usedInDerivedClass.kt") @@ -2198,7 +2199,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInCanBePrimaryConstructorProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/canBePrimaryConstructorProperty"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/canBePrimaryConstructorProperty"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("commentAfter.kt") @@ -2236,7 +2237,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInChangeFeatureSupport() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/changeFeatureSupport"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/changeFeatureSupport"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("inlineClass.kt") @@ -2254,7 +2255,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInChangeObjectToClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/changeObjectToClass"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/changeObjectToClass"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("primaryConstructor.kt") @@ -2437,7 +2438,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInChangeSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/changeSignature"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/changeSignature"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("changeFunctionLiteralParameters1.kt") @@ -2624,7 +2625,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInJk() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/changeSignature/jk"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/changeSignature/jk"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } } @@ -2637,7 +2638,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInKj() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/changeSignature/kj"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/changeSignature/kj"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } } } @@ -2651,7 +2652,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInChangeSuperTypeListEntryTypeArgument() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/changeSuperTypeListEntryTypeArgument"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/changeSuperTypeListEntryTypeArgument"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("propertyTypeMismatchOnOverride.kt") @@ -2684,7 +2685,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInChangeToLabeledReturn() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/changeToLabeledReturn"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/changeToLabeledReturn"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("multipleInner.kt") @@ -2717,7 +2718,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInChangeToMutableCollection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/changeToMutableCollection"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/changeToMutableCollection"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("list.kt") @@ -2755,7 +2756,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInChangeToUseSpreadOperator() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/changeToUseSpreadOperator"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/changeToUseSpreadOperator"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("differentTypeParameter.kt") @@ -2808,7 +2809,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInCheckArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/checkArguments"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/checkArguments"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("nonVarargSpread.kt") @@ -2825,7 +2826,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInAddNameToArgument() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/checkArguments/addNameToArgument"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/checkArguments/addNameToArgument"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("invokeOnString.kt") @@ -2874,7 +2875,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInConflictingImports() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/conflictingImports"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/conflictingImports"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("removeConflictingImport.kt") @@ -2902,7 +2903,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInConvertJavaInterfaceToClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/convertJavaInterfaceToClass"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/convertJavaInterfaceToClass"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } } @@ -2915,7 +2916,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInConvertLateinitPropertyToNotNullDelegate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/convertLateinitPropertyToNotNullDelegate"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/convertLateinitPropertyToNotNullDelegate"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("basic.kt") @@ -2963,7 +2964,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInConvertPropertyInitializerToGetter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/convertPropertyInitializerToGetter"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/convertPropertyInitializerToGetter"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("val.kt") @@ -2991,7 +2992,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInConvertToAnonymousObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/convertToAnonymousObject"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/convertToAnonymousObject"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("hasConcreateMember.kt") @@ -3059,7 +3060,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInCreateFromUsage() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("idea/testData/quickfix/createFromUsage/createClass") @@ -3071,7 +3072,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInCreateClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createClass"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createClass"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("idea/testData/quickfix/createFromUsage/createClass/annotationEntry") @@ -3083,7 +3084,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInAnnotationEntry() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createClass/annotationEntry"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createClass/annotationEntry"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("annotationNoBrackets.kt") @@ -3136,7 +3137,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInCallExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createClass/callExpression"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createClass/callExpression"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("callInAnnotationEntry.kt") @@ -3353,7 +3354,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInTypeArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createClass/callExpression/typeArguments"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createClass/callExpression/typeArguments"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("callWithStarProjection.kt") @@ -3427,7 +3428,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInDelegationSpecifier() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createClass/delegationSpecifier"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createClass/delegationSpecifier"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("createSuperClassFromSuperTypeEntry.kt") @@ -3510,7 +3511,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInImportDirective() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createClass/importDirective"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createClass/importDirective"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("annotationInPackage.kt") @@ -3587,7 +3588,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInKt21515() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createClass/importDirective/kt21515"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("callableReferenceOnClass.kt") @@ -3626,7 +3627,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInReferenceExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createClass/referenceExpression"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createClass/referenceExpression"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("annotationByClassLiteral.kt") @@ -3874,7 +3875,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInTypeReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createClass/typeReference"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createClass/typeReference"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("annotationNotQualifierNoTypeArgs.kt") @@ -4038,7 +4039,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInCreateFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("idea/testData/quickfix/createFromUsage/createFunction/binaryOperations") @@ -4050,7 +4051,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInBinaryOperations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/binaryOperations"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/binaryOperations"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("customOperationOnUserType.kt") @@ -4143,7 +4144,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/call"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/call"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("approximateAnonymousObjectRuntime.kt") @@ -4490,7 +4491,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInAbstract() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/call/abstract"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/call/abstract"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("classNoExplicitReceiver.kt") @@ -4548,7 +4549,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInExtensionByExtensionReceiver() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/call/extensionByExtensionReceiver"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/call/extensionByExtensionReceiver"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("extensionFunction.kt") @@ -4586,7 +4587,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInTypeArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/call/typeArguments"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/call/typeArguments"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("callWithStarProjection.kt") @@ -4670,7 +4671,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInCallableReferences() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/callableReferences"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/callableReferences"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("extensionNoReceiverInCallableRef.kt") @@ -4713,7 +4714,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInComponent() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/component"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/component"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("createComponentFromUsage1.kt") @@ -4741,7 +4742,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInDelegateAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/delegateAccessors"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/delegateAccessors"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("localVal.kt") @@ -4784,7 +4785,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInFromJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/fromJava"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/fromJava"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } } @@ -4797,7 +4798,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInGet() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/get"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/get"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("createGetFromUsage1.kt") @@ -4875,7 +4876,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInHasNext() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/hasNext"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/hasNext"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("createHasNextFromUsage1.kt") @@ -4898,7 +4899,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInInvoke() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/invoke"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/invoke"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("invokeOnLibType.kt") @@ -4936,7 +4937,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInIterator() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/iterator"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/iterator"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("createIteratorFromUsage1.kt") @@ -4964,7 +4965,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInNext() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/next"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/next"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("createNextFromUsage1.kt") @@ -4987,7 +4988,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInSet() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/set"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/set"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("createSetFromUsage1.kt") @@ -5020,7 +5021,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInUnaryOperations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/unaryOperations"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createFunction/unaryOperations"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("incOnUserType.kt") @@ -5059,7 +5060,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInCreateSecondaryConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createSecondaryConstructor"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createSecondaryConstructor"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("argumentTypeMismatch.kt") @@ -5162,7 +5163,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInCreateTypeParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createTypeParameter"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createTypeParameter"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("idea/testData/quickfix/createFromUsage/createTypeParameter/inContainingDeclaration") @@ -5174,7 +5175,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInInContainingDeclaration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createTypeParameter/inContainingDeclaration"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createTypeParameter/inContainingDeclaration"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("backticks.kt") @@ -5302,7 +5303,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInInReferencedDeclaration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createTypeParameter/inReferencedDeclaration"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createTypeParameter/inReferencedDeclaration"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("missingArguments.kt") @@ -5331,7 +5332,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInCreateVariable() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createVariable"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createVariable"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("idea/testData/quickfix/createFromUsage/createVariable/localVariable") @@ -5343,7 +5344,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInLocalVariable() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createVariable/localVariable"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createVariable/localVariable"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("assignedInFun.kt") @@ -5466,7 +5467,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createVariable/parameter"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createVariable/parameter"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("assignedInFun.kt") @@ -5744,7 +5745,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInPrimaryParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createVariable/primaryParameter"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createVariable/primaryParameter"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("localValNoReceiver.kt") @@ -5822,7 +5823,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createVariable/property"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createVariable/property"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("callOnUserType.kt") @@ -6049,7 +6050,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInAbstract() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createVariable/property/abstract"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createVariable/property/abstract"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("classNoExplicitReceiver.kt") @@ -6087,7 +6088,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInFieldFromJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createVariable/property/fieldFromJava"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createFromUsage/createVariable/property/fieldFromJava"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } } } @@ -6103,7 +6104,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInCreateLabel() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createLabel"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/createLabel"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("breakInLoop.kt") @@ -6161,7 +6162,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInDeclarationCantBeInlined() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/declarationCantBeInlined"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/declarationCantBeInlined"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("inClass.kt") @@ -6184,7 +6185,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInDecreaseVisibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/decreaseVisibility"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/decreaseVisibility"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("exposedParameterType.kt") @@ -6252,7 +6253,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInDeprecatedJavaAnnotation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedJavaAnnotation"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedJavaAnnotation"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("withArgument.kt") @@ -6290,7 +6291,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInDeprecatedSymbolUsage() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("callChainBug.kt") @@ -6567,7 +6568,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInArgumentSideEffects() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/argumentSideEffects"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/argumentSideEffects"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("complexExpressionNotUsed1.kt") @@ -6680,7 +6681,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInClassUsages() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/classUsages"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/classUsages"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("annotation1.kt") @@ -6907,7 +6908,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInWholeProject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/classUsages/wholeProject"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/classUsages/wholeProject"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("inheritance.kt") @@ -6926,7 +6927,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInFunctionLiteralArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/functionLiteralArguments"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/functionLiteralArguments"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("cannotKeepOutside.kt") @@ -6959,7 +6960,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInImports() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/imports"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/imports"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } } @@ -6977,7 +6978,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInKeepComments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/keepComments"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/keepComments"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("commentBeforeArgument.kt") @@ -7025,7 +7026,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInKeepLineBreaks() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/keepLineBreaks"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/keepLineBreaks"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("lineBreakAfterReceiverRuntime.kt") @@ -7048,7 +7049,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInOperatorCalls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/operatorCalls"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/operatorCalls"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("get.kt") @@ -7081,7 +7082,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInOptionalParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/optionalParameters"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/optionalParameters"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("dropAll.kt") @@ -7159,7 +7160,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/properties"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/properties"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("callInAssignmentToProperty.kt") @@ -7197,7 +7198,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInPublishedApi() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/publishedApi"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/publishedApi"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("existingStub.kt") @@ -7260,7 +7261,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInSafeCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/safeCall"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/safeCall"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("changeThisSafeCall.kt") @@ -7313,7 +7314,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInTypeAliases() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/typeAliases"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/typeAliases"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("compoundWithDeprecatedArgumentsAndConstructor.kt") @@ -7385,7 +7386,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInWholeProject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/typeAliases/wholeProject"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/typeAliases/wholeProject"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } } } @@ -7399,7 +7400,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInTypeArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/typeArguments"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/typeArguments"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("classConstructor.kt") @@ -7476,7 +7477,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInWholeProject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/typeArguments/wholeProject"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/typeArguments/wholeProject"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("classConstructor.kt") @@ -7510,7 +7511,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInVararg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/vararg"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/vararg"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("booleanArrayRuntime.kt") @@ -7623,7 +7624,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInWholeProject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/wholeProject"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/deprecatedSymbolUsage/wholeProject"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } } } @@ -7637,7 +7638,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInExperimental() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/experimental"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/experimental"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("annotationInTopLevelProperty.kt") @@ -7740,7 +7741,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInExpressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/expressions"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/expressions"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("fixNullableBinaryWithExclExcl.kt") @@ -7923,7 +7924,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInFoldTryCatch() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/foldTryCatch"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/foldTryCatch"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("conditional.kt") @@ -7961,7 +7962,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInFunctionWithLambdaExpressionBody() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/functionWithLambdaExpressionBody"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/functionWithLambdaExpressionBody"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("idea/testData/quickfix/functionWithLambdaExpressionBody/removeBraces") @@ -7973,7 +7974,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInRemoveBraces() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/functionWithLambdaExpressionBody/removeBraces"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/functionWithLambdaExpressionBody/removeBraces"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("functionHasComment.kt") @@ -8026,7 +8027,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInWrapRun() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/functionWithLambdaExpressionBody/wrapRun"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/functionWithLambdaExpressionBody/wrapRun"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("funtionIsUsed.kt") @@ -8055,7 +8056,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInImplement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/implement"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/implement"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("annotation.kt") @@ -8243,7 +8244,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInIncreaseVisibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/increaseVisibility"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/increaseVisibility"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("exposedParameterType.kt") @@ -8355,7 +8356,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInInvisibleFake() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/increaseVisibility/invisibleFake"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/increaseVisibility/invisibleFake"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("methodToInternal.kt") @@ -8419,7 +8420,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInInitializeWithConstructorParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/initializeWithConstructorParameter"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/initializeWithConstructorParameter"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("constructorWithThisDelegation.kt") @@ -8512,7 +8513,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInInlineClassConstructorNotValParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/inlineClassConstructorNotValParameter"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/inlineClassConstructorNotValParameter"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("basic.kt") @@ -8535,7 +8536,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInInlineTypeParameterFix() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/inlineTypeParameterFix"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/inlineTypeParameterFix"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("basic.kt") @@ -8563,7 +8564,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInInsertDelegationCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/insertDelegationCall"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/insertDelegationCall"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("nonApplicableInsertSuper.kt") @@ -8616,7 +8617,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInKdocMissingDocumentation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/kdocMissingDocumentation"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/kdocMissingDocumentation"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("simple.kt") @@ -8639,7 +8640,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInLateinit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/lateinit"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/lateinit"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("nullable.kt") @@ -8697,7 +8698,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInLeakingThis() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/leakingThis"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/leakingThis"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("callOpenMethod.kt") @@ -8735,7 +8736,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInLibraries() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/libraries"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/libraries"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("junit.kt") @@ -8758,7 +8759,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInLocalVariableWithTypeParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/localVariableWithTypeParameters"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/localVariableWithTypeParameters"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("removeTypeParametersFromLocalVariable.kt") @@ -8776,7 +8777,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInMakeConstructorParameterProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/makeConstructorParameterProperty"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/makeConstructorParameterProperty"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("inner.kt") @@ -8814,7 +8815,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInMakePrivateAndOverrideMember() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/makePrivateAndOverrideMember"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/makePrivateAndOverrideMember"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } } @@ -8827,7 +8828,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInMakeTypeParameterReified() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/makeTypeParameterReified"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/makeTypeParameterReified"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("noTypeParameter.kt") @@ -8855,7 +8856,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInMemberVisibilityCanBePrivate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/memberVisibilityCanBePrivate"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/memberVisibilityCanBePrivate"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("constructorParam.kt") @@ -8893,7 +8894,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInMigration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/migration"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/migration"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("idea/testData/quickfix/migration/commasInWhenWithoutArgument") @@ -8905,7 +8906,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInCommasInWhenWithoutArgument() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/migration/commasInWhenWithoutArgument"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/migration/commasInWhenWithoutArgument"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("commasInConditionWithNoArguments.kt") @@ -8928,7 +8929,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInConflictingExtension() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/migration/conflictingExtension"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/migration/conflictingExtension"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("explicitThis.kt") @@ -9011,7 +9012,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInJavaAnnotationPositionedArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/migration/javaAnnotationPositionedArguments"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/migration/javaAnnotationPositionedArguments"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } } @@ -9024,7 +9025,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInJsExternal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/migration/jsExternal"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/migration/jsExternal"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("externalExtensionFunJsRuntime.kt") @@ -9092,7 +9093,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInMissingConstructorKeyword() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/migration/missingConstructorKeyword"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/migration/missingConstructorKeyword"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("basic.kt") @@ -9110,7 +9111,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInObsoleteLabelSyntax() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/migration/obsoleteLabelSyntax"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/migration/obsoleteLabelSyntax"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("lambda.kt") @@ -9133,7 +9134,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInRemoveNameFromFunctionExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/migration/removeNameFromFunctionExpression"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/migration/removeNameFromFunctionExpression"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("basic.kt") @@ -9151,7 +9152,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInTypeParameterList() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/migration/typeParameterList"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/migration/typeParameterList"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("basic.kt") @@ -9175,7 +9176,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInMissingConstructorBrackets() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/missingConstructorBrackets"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/missingConstructorBrackets"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("basic.kt") @@ -9203,7 +9204,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInModifiers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/modifiers"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/modifiers"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("cannotMakeClassAnnotation.kt") @@ -9510,7 +9511,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInAddOpenToClassDeclaration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/modifiers/addOpenToClassDeclaration"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/modifiers/addOpenToClassDeclaration"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("dataSuperType.kt") @@ -9598,7 +9599,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInSuspend() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/modifiers/suspend"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/modifiers/suspend"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("anonymousFunction.kt") @@ -9677,7 +9678,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInMoveMemberToCompanionObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/moveMemberToCompanionObject"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/moveMemberToCompanionObject"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("simple.kt") @@ -9695,7 +9696,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInMoveReceiverAnnotation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/moveReceiverAnnotation"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/moveReceiverAnnotation"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("fun.kt") @@ -9728,7 +9729,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInMoveToConstructorParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/moveToConstructorParameters"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/moveToConstructorParameters"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("localVar.kt") @@ -9801,7 +9802,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInMoveTypeAliasToTopLevel() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/moveTypeAliasToTopLevel"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/moveTypeAliasToTopLevel"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("inClass.kt") @@ -9834,7 +9835,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInNullables() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/nullables"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/nullables"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("removeRedundantNullable.kt") @@ -9866,7 +9867,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInUnsafeInfixCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/nullables/unsafeInfixCall"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/nullables/unsafeInfixCall"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("noComparison.kt") @@ -9940,7 +9941,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInObsoleteCoroutines() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/obsoleteCoroutines"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/obsoleteCoroutines"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("buildIteratorImport.kt") @@ -9993,7 +9994,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInObsoleteKotlinJsPackages() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/obsoleteKotlinJsPackages"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/obsoleteKotlinJsPackages"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("kotlinBrowserFullyQualifiedProperty.kt") @@ -10036,7 +10037,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInOptimizeImports() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/optimizeImports"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/optimizeImports"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("destructuringAtTop.kt") @@ -10074,7 +10075,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInOverride() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/override"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/override"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("changeToInvocation.kt") @@ -10271,7 +10272,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInNothingToOverride() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/override/nothingToOverride"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/override/nothingToOverride"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("changeFunctionReciever.kt") @@ -10389,7 +10390,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInTypeMismatchOnOverride() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/override/typeMismatchOnOverride"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/override/typeMismatchOnOverride"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("cantChangeMultipleOverriddenPropertiesTypes.kt") @@ -10503,7 +10504,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInPlatformClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/platformClasses"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/platformClasses"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("mapPlatformClassToKotlin1.kt") @@ -10536,7 +10537,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInPlatformTypesInspection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/platformTypesInspection"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/platformTypesInspection"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("nestedNoAssertRuntime.kt") @@ -10569,7 +10570,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInPrimitiveCastToConversion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/primitiveCastToConversion"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/primitiveCastToConversion"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("boolean.kt") @@ -10602,7 +10603,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/properties"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/properties"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("idea/testData/quickfix/properties/extensionPropertyInitializerToGetter") @@ -10614,7 +10615,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInExtensionPropertyInitializerToGetter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/properties/extensionPropertyInitializerToGetter"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/properties/extensionPropertyInitializerToGetter"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("baseCase.kt") @@ -10653,7 +10654,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInProtectedInFinal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/protectedInFinal"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/protectedInFinal"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("protected.kt") @@ -10676,7 +10677,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInRedundantConst() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/redundantConst"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/redundantConst"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("simple.kt") @@ -10694,7 +10695,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInRedundantFun() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/redundantFun"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/redundantFun"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("simple.kt") @@ -10712,7 +10713,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInRedundantIf() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/redundantIf"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/redundantIf"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("assignExpression.kt") @@ -10765,7 +10766,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInRedundantInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/redundantInline"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/redundantInline"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("function.kt") @@ -10783,7 +10784,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInRedundantLateinit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/redundantLateinit"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/redundantLateinit"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("simple.kt") @@ -10801,7 +10802,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInRedundantModalityModifier() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/redundantModalityModifier"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/redundantModalityModifier"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("redundantAbstract.kt") @@ -10834,7 +10835,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInRedundantSemicolon() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/redundantSemicolon"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/redundantSemicolon"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } } @@ -10847,7 +10848,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInRedundantSuspend() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/redundantSuspend"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/redundantSuspend"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("inline.kt") @@ -10865,7 +10866,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInRedundantVisibilityModifier() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/redundantVisibilityModifier"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/redundantVisibilityModifier"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("getter.kt") @@ -10888,7 +10889,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInRemoveAnnotation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeAnnotation"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeAnnotation"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("jvmOverloads.kt") @@ -10911,7 +10912,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInRemoveArgument() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeArgument"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeArgument"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("constructor.kt") @@ -10949,7 +10950,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInRemoveAtFromAnnotationArgument() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeAtFromAnnotationArgument"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeAtFromAnnotationArgument"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("arrayParam.kt") @@ -10982,7 +10983,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInRemoveDefaultParameterValue() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeDefaultParameterValue"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeDefaultParameterValue"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("defaultValueNotAllowedInOverride.kt") @@ -11005,7 +11006,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInRemoveFinalUpperBound() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeFinalUpperBound"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeFinalUpperBound"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("basic.kt") @@ -11028,7 +11029,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInRemoveNoConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeNoConstructor"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeNoConstructor"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("basic.kt") @@ -11046,7 +11047,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInRemoveRedundantAssignment() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeRedundantAssignment"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeRedundantAssignment"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("constant.kt") @@ -11079,7 +11080,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInRemoveRedundantInitializer() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeRedundantInitializer"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeRedundantInitializer"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("simple.kt") @@ -11097,7 +11098,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInRemoveRedundantLabel() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeRedundantLabel"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeRedundantLabel"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("simple.kt") @@ -11120,7 +11121,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInRemoveRedundantSpreadOperator() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeRedundantSpreadOperator"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeRedundantSpreadOperator"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("simple.kt") @@ -11138,7 +11139,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInRemoveSingleLambdaParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeSingleLambdaParameter"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeSingleLambdaParameter"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("inIf.kt") @@ -11191,7 +11192,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInRemoveSuspend() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeSuspend"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeSuspend"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("fakeOverride.kt") @@ -11234,7 +11235,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInRemoveToStringInStringTemplate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeToStringInStringTemplate"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeToStringInStringTemplate"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("call.kt") @@ -11277,7 +11278,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInRemoveTypeVariance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeTypeVariance"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeTypeVariance"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("in.kt") @@ -11300,7 +11301,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInRemoveUnused() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeUnused"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeUnused"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("companionViaImport3.kt") @@ -11453,7 +11454,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInRemoveUnusedReceiver() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeUnusedReceiver"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/removeUnusedReceiver"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("inFunction.kt") @@ -11476,7 +11477,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInRenameToRem() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/renameToRem"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/renameToRem"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("forbiddenModAsMember.kt") @@ -11509,7 +11510,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInRenameToUnderscore() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/renameToUnderscore"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/renameToUnderscore"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("commonDestructuring.kt") @@ -11562,7 +11563,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInRenameUnresolvedReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/renameUnresolvedReference"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/renameUnresolvedReference"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("qualifiedFunRef.kt") @@ -11605,7 +11606,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInReplaceInfixOrOperatorCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/replaceInfixOrOperatorCall"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/replaceInfixOrOperatorCall"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("array.kt") @@ -11668,7 +11669,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInReplaceJvmFieldWithConst() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/replaceJvmFieldWithConst"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/replaceJvmFieldWithConst"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("class.kt") @@ -11726,7 +11727,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInReplaceWithArrayCallInAnnotation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/replaceWithArrayCallInAnnotation"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/replaceWithArrayCallInAnnotation"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("emptyLiteral.kt") @@ -11759,7 +11760,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInReplaceWithDotCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/replaceWithDotCall"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/replaceWithDotCall"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("comment.kt") @@ -11792,7 +11793,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInReplaceWithSafeCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/replaceWithSafeCall"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/replaceWithSafeCall"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("apply.kt") @@ -11900,7 +11901,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInReplaceWithSafeCallForScopeFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/replaceWithSafeCallForScopeFunction"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/replaceWithSafeCallForScopeFunction"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("also.kt") @@ -11998,7 +11999,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInRestrictedRetentionForExpressionAnnotation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/restrictedRetentionForExpressionAnnotation"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/restrictedRetentionForExpressionAnnotation"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("idea/testData/quickfix/restrictedRetentionForExpressionAnnotation/addSourceRetention") @@ -12010,7 +12011,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInAddSourceRetention() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/restrictedRetentionForExpressionAnnotation/addSourceRetention"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/restrictedRetentionForExpressionAnnotation/addSourceRetention"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("binaryRetention.kt") @@ -12048,7 +12049,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInChangeRetentionToSource() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/restrictedRetentionForExpressionAnnotation/changeRetentionToSource"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/restrictedRetentionForExpressionAnnotation/changeRetentionToSource"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("binaryRetention.kt") @@ -12086,7 +12087,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInRemoveExpressionTarget() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/restrictedRetentionForExpressionAnnotation/removeExpressionTarget"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/restrictedRetentionForExpressionAnnotation/removeExpressionTarget"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("binaryRetention.kt") @@ -12130,7 +12131,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInSimplifyComparison() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/simplifyComparison"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/simplifyComparison"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("doubleNull.kt") @@ -12178,7 +12179,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInSmartCastImpossibleInIfThen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/smartCastImpossibleInIfThen"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/smartCastImpossibleInIfThen"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("ifThen.kt") @@ -12251,7 +12252,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInSpecifyOverrideExplicitly() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/specifyOverrideExplicitly"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/specifyOverrideExplicitly"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("base.kt") @@ -12299,7 +12300,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInSpecifySuperType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/specifySuperType"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/specifySuperType"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("fullyQualifiedSuperType.kt") @@ -12362,7 +12363,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInSpecifyVisibilityInExplicitApiMode() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/specifyVisibilityInExplicitApiMode"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/specifyVisibilityInExplicitApiMode"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("class.kt") @@ -12400,7 +12401,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInSuperTypeIsExtensionType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/superTypeIsExtensionType"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/superTypeIsExtensionType"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("typeWith1Argument.kt") @@ -12428,7 +12429,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInSupercalls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/supercalls"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/supercalls"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("typeArgumentsRedundantInSuperQualifier.kt") @@ -12501,7 +12502,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInSupertypeInitialization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/supertypeInitialization"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/supertypeInitialization"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("baseConstructorError.kt") @@ -12594,7 +12595,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInSuppress() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suppress"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suppress"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("idea/testData/quickfix/suppress/annotationPosition") @@ -12606,7 +12607,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInAnnotationPosition() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suppress/annotationPosition"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suppress/annotationPosition"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("paramWithModifier.kt") @@ -12699,7 +12700,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInAvailability() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suppress/availability"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suppress/availability"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("localFunSuppressForLocal.kt") @@ -12762,7 +12763,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInDeclarationKinds() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suppress/declarationKinds"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suppress/declarationKinds"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("class.kt") @@ -12835,7 +12836,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInErrorRecovery() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suppress/errorRecovery"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suppress/errorRecovery"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("nonStringInSuppress.kt") @@ -12858,7 +12859,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInExternal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suppress/external"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suppress/external"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("suppressActive.kt") @@ -12881,7 +12882,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInForStatement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suppress/forStatement"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suppress/forStatement"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("andAnd.kt") @@ -13083,7 +13084,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInUnavailable() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suppress/forStatement/unavailable"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suppress/forStatement/unavailable"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("inAnnotationArgument.kt") @@ -13152,7 +13153,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInInspections() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suppress/inspections"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suppress/inspections"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("constantConditionIf.kt") @@ -13176,7 +13177,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInSurroundWithArrayOfForNamedArgumentsToVarargs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/surroundWithArrayOfForNamedArgumentsToVarargs"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/surroundWithArrayOfForNamedArgumentsToVarargs"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("replaceForVarargOfAny.kt") @@ -13214,7 +13215,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInSurroundWithNullCheck() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/surroundWithNullCheck"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/surroundWithNullCheck"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("argumentNullable.kt") @@ -13332,7 +13333,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInSuspiciousCollectionReassignment() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suspiciousCollectionReassignment"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suspiciousCollectionReassignment"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("idea/testData/quickfix/suspiciousCollectionReassignment/changeTypeToMutable") @@ -13344,7 +13345,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInChangeTypeToMutable() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suspiciousCollectionReassignment/changeTypeToMutable"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suspiciousCollectionReassignment/changeTypeToMutable"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("hasType.kt") @@ -13412,7 +13413,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInJoinWithInitializer() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suspiciousCollectionReassignment/joinWithInitializer"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suspiciousCollectionReassignment/joinWithInitializer"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("noInitializer.kt") @@ -13445,7 +13446,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInReplaceWithAssignment() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suspiciousCollectionReassignment/replaceWithAssignment"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suspiciousCollectionReassignment/replaceWithAssignment"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("differentType.kt") @@ -13533,7 +13534,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInReplaceWithFilter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suspiciousCollectionReassignment/replaceWithFilter"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suspiciousCollectionReassignment/replaceWithFilter"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("map.kt") @@ -13566,7 +13567,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInReplaceWithOrdinaryAssignment() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suspiciousCollectionReassignment/replaceWithOrdinaryAssignment"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/suspiciousCollectionReassignment/replaceWithOrdinaryAssignment"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("simple.kt") @@ -13585,7 +13586,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInToString() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/toString"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/toString"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("notNullableExpectedNullable.kt") @@ -13618,7 +13619,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInTooLongCharLiteralToString() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/tooLongCharLiteralToString"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/tooLongCharLiteralToString"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("backslash.kt") @@ -13666,7 +13667,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInTypeAddition() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeAddition"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeAddition"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("ambiguousFunctionReturnType.kt") @@ -13774,7 +13775,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInTypeImports() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeImports"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeImports"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("hasThisImport.kt") @@ -13812,7 +13813,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInTypeInferenceExpectedTypeMismatch() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeInferenceExpectedTypeMismatch"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeInferenceExpectedTypeMismatch"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("convertClassToKClass1Runtime.kt") @@ -13880,7 +13881,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInTypeMismatch() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeMismatch"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeMismatch"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("anonymousObjectInCall.kt") @@ -14242,7 +14243,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInCasts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeMismatch/casts"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeMismatch/casts"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("castQualifiedArgument.kt") @@ -14315,7 +14316,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInComponentFunctionReturnTypeMismatch() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeMismatch/componentFunctionReturnTypeMismatch"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeMismatch/componentFunctionReturnTypeMismatch"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("componentFunctionReturnTypeMismatch1.kt") @@ -14358,7 +14359,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInConvertCollection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeMismatch/convertCollection"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeMismatch/convertCollection"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("arrayToCollection.kt") @@ -14426,7 +14427,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInFixOverloadedOperator() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeMismatch/fixOverloadedOperator"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeMismatch/fixOverloadedOperator"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("changeNotFunctionReturnType.kt") @@ -14454,7 +14455,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInGenericVarianceViolation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeMismatch/genericVarianceViolation"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeMismatch/genericVarianceViolation"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } } @@ -14467,7 +14468,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInNumberConversion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeMismatch/numberConversion"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeMismatch/numberConversion"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("convertBinaryExpression.kt") @@ -14500,7 +14501,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInParameterTypeMismatch() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeMismatch/parameterTypeMismatch"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeMismatch/parameterTypeMismatch"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("changeFunctionParameterType1.kt") @@ -14563,7 +14564,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInRoundNumber() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeMismatch/roundNumber"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeMismatch/roundNumber"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("notApplicable.kt") @@ -14606,7 +14607,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInTypeMismatchOnReturnedExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeMismatch/typeMismatchOnReturnedExpression"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("assignmentTypeMismatch.kt") @@ -14699,7 +14700,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInWrapWithCollectionLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeMismatch/wrapWithCollectionLiteral"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeMismatch/wrapWithCollectionLiteral"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("inAnnotation.kt") @@ -14782,7 +14783,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInWrongPrimitive() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeMismatch/wrongPrimitive"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeMismatch/wrongPrimitive"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("doubleToIntDecimalPlaces.kt") @@ -14866,7 +14867,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInTypeOfAnnotationMember() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeOfAnnotationMember"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeOfAnnotationMember"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("boolean.kt") @@ -14924,7 +14925,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInTypeParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeParameters"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeParameters"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("misplacedClassTypeParameter.kt") @@ -14947,7 +14948,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInTypeProjection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeProjection"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/typeProjection"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("conflictingProjection.kt") @@ -14995,7 +14996,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInUnnecessaryLateinit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/unnecessaryLateinit"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/unnecessaryLateinit"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("lateinitWithConstructor.kt") @@ -15038,7 +15039,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInUnusedSuppressAnnotation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/unusedSuppressAnnotation"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/unusedSuppressAnnotation"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("notForDeprecated.kt") @@ -15071,7 +15072,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInVariables() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/variables"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/variables"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("unusedVariableWithAnonymousFunctionInitialize1.kt") @@ -15128,7 +15129,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInChangeMutability() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/variables/changeMutability"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/variables/changeMutability"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("capturedMemberValInitialization.kt") @@ -15200,7 +15201,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInCanBeVal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/variables/changeMutability/canBeVal"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/variables/changeMutability/canBeVal"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("const.kt") @@ -15259,7 +15260,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInChangeToFunctionInvocation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/variables/changeToFunctionInvocation"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/variables/changeToFunctionInvocation"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("funInvWithoutParentheses.kt") @@ -15302,7 +15303,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInChangeToPropertyAccess() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/variables/changeToPropertyAccess"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/variables/changeToPropertyAccess"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("enumEntryCall.kt") @@ -15340,7 +15341,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInRemoveValVarFromParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/variables/removeValVarFromParameter"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/variables/removeValVarFromParameter"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("catchParameter.kt") @@ -15464,7 +15465,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInWhen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/when"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/when"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("breakInWhen.kt") @@ -15542,7 +15543,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInWrapWithSafeLetCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/wrapWithSafeLetCall"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/wrapWithSafeLetCall"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("argumentNullable.kt") @@ -15640,7 +15641,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInWrongLongSuffix() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/wrongLongSuffix"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/wrongLongSuffix"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("simple.kt") @@ -15658,7 +15659,7 @@ public class QuickFixTestGenerated extends AbstractQuickFixTest { } public void testAllFilesPresentInYieldUnsupported() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/yieldUnsupported"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/quickfix/yieldUnsupported"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("yieldAsSimpleName.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/refactoring/NameSuggestionProviderTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/refactoring/NameSuggestionProviderTestGenerated.java index c600b32e299..cddd693d43b 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/refactoring/NameSuggestionProviderTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/refactoring/NameSuggestionProviderTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.refactoring; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class NameSuggestionProviderTestGenerated extends AbstractNameSuggestionP } public void testAllFilesPresentInNameSuggestionProvider() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/nameSuggestionProvider"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/nameSuggestionProvider"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("localVarAsCallArgument.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/refactoring/copy/CopyTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/refactoring/copy/CopyTestGenerated.java index 2f0fa9490e1..286426d3358 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/refactoring/copy/CopyTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/refactoring/copy/CopyTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.refactoring.copy; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class CopyTestGenerated extends AbstractCopyTest { } public void testAllFilesPresentInCopy() throws Exception { - KotlinTestUtils.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File("idea/testData/refactoring/copy"), Pattern.compile("^(.+)\\.test$"), null); + KtTestUtil.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File("idea/testData/refactoring/copy"), Pattern.compile("^(.+)\\.test$"), null); } @TestMetadata("copyClassCaretInside/copyClassCaretInside.test") diff --git a/idea/tests/org/jetbrains/kotlin/idea/refactoring/copy/MultiModuleCopyTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/refactoring/copy/MultiModuleCopyTestGenerated.java index bee4b6c3b4b..b950cf29921 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/refactoring/copy/MultiModuleCopyTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/refactoring/copy/MultiModuleCopyTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.refactoring.copy; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class MultiModuleCopyTestGenerated extends AbstractMultiModuleCopyTest { } public void testAllFilesPresentInCopyMultiModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File("idea/testData/refactoring/copyMultiModule"), Pattern.compile("^(.+)\\.test$"), null); + KtTestUtil.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File("idea/testData/refactoring/copyMultiModule"), Pattern.compile("^(.+)\\.test$"), null); } @TestMetadata("fileNotUnderSourceRoot/fileNotUnderSourceRoot.test") diff --git a/idea/tests/org/jetbrains/kotlin/idea/refactoring/inline/InlineTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/refactoring/inline/InlineTestGenerated.java index 1c8cfd0e378..850367d12e3 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/refactoring/inline/InlineTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/refactoring/inline/InlineTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.refactoring.inline; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class InlineTestGenerated extends AbstractInlineTest { } public void testAllFilesPresentInInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/inline"), Pattern.compile("^(\\w+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/inline"), Pattern.compile("^(\\w+)\\.kt$"), null, true); } @TestMetadata("idea/testData/refactoring/inline/function") @@ -37,7 +38,7 @@ public class InlineTestGenerated extends AbstractInlineTest { } public void testAllFilesPresentInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/inline/function"), Pattern.compile("^(\\w+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/inline/function"), Pattern.compile("^(\\w+)\\.kt$"), null, true); } @TestMetadata("EmptyFunction.kt") @@ -189,7 +190,7 @@ public class InlineTestGenerated extends AbstractInlineTest { } public void testAllFilesPresentInExpressionBody() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/inline/function/expressionBody"), Pattern.compile("^(\\w+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/inline/function/expressionBody"), Pattern.compile("^(\\w+)\\.kt$"), null, true); } @TestMetadata("ComplexArgumentNotUsed.kt") @@ -322,7 +323,7 @@ public class InlineTestGenerated extends AbstractInlineTest { } public void testAllFilesPresentInFromIntellij() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/inline/function/fromIntellij"), Pattern.compile("^(\\w+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/inline/function/fromIntellij"), Pattern.compile("^(\\w+)\\.kt$"), null, true); } @TestMetadata("ArrayAccess.kt") @@ -435,7 +436,7 @@ public class InlineTestGenerated extends AbstractInlineTest { } public void testAllFilesPresentInReturnAtEnd() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/inline/function/returnAtEnd"), Pattern.compile("^(\\w+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/inline/function/returnAtEnd"), Pattern.compile("^(\\w+)\\.kt$"), null, true); } @TestMetadata("Bug1.kt") @@ -584,7 +585,7 @@ public class InlineTestGenerated extends AbstractInlineTest { } public void testAllFilesPresentInInlineTypeAlias() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/inline/inlineTypeAlias"), Pattern.compile("^(\\w+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/inline/inlineTypeAlias"), Pattern.compile("^(\\w+)\\.kt$"), null, true); } @TestMetadata("extensionFunctionTypeToFunctionType.kt") @@ -627,7 +628,7 @@ public class InlineTestGenerated extends AbstractInlineTest { } public void testAllFilesPresentInInlineVariableOrProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/inline/inlineVariableOrProperty"), Pattern.compile("^(\\w+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/inline/inlineVariableOrProperty"), Pattern.compile("^(\\w+)\\.kt$"), null, true); } @TestMetadata("AppendToCollection.kt") @@ -749,7 +750,7 @@ public class InlineTestGenerated extends AbstractInlineTest { } public void testAllFilesPresentInAddParenthesis() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/inline/inlineVariableOrProperty/addParenthesis"), Pattern.compile("^(\\w+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/inline/inlineVariableOrProperty/addParenthesis"), Pattern.compile("^(\\w+)\\.kt$"), null, true); } @TestMetadata("ArrayAccess.kt") @@ -922,7 +923,7 @@ public class InlineTestGenerated extends AbstractInlineTest { } public void testAllFilesPresentInExplicateParameterTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/inline/inlineVariableOrProperty/explicateParameterTypes"), Pattern.compile("^(\\w+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/inline/inlineVariableOrProperty/explicateParameterTypes"), Pattern.compile("^(\\w+)\\.kt$"), null, true); } @TestMetadata("EnoughDontExplicate.kt") @@ -970,7 +971,7 @@ public class InlineTestGenerated extends AbstractInlineTest { } public void testAllFilesPresentInExplicateTypeArgument() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/inline/inlineVariableOrProperty/explicateTypeArgument"), Pattern.compile("^(\\w+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/inline/inlineVariableOrProperty/explicateTypeArgument"), Pattern.compile("^(\\w+)\\.kt$"), null, true); } @TestMetadata("DeeperNestedCall.kt") @@ -1033,7 +1034,7 @@ public class InlineTestGenerated extends AbstractInlineTest { } public void testAllFilesPresentInProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/inline/inlineVariableOrProperty/property"), Pattern.compile("^(\\w+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/inline/inlineVariableOrProperty/property"), Pattern.compile("^(\\w+)\\.kt$"), null, true); } @TestMetadata("Basic.kt") @@ -1100,7 +1101,7 @@ public class InlineTestGenerated extends AbstractInlineTest { } public void testAllFilesPresentInAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/inline/inlineVariableOrProperty/property/accessors"), Pattern.compile("^(\\w+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/inline/inlineVariableOrProperty/property/accessors"), Pattern.compile("^(\\w+)\\.kt$"), null, true); } @TestMetadata("BlockBody.kt") @@ -1149,7 +1150,7 @@ public class InlineTestGenerated extends AbstractInlineTest { } public void testAllFilesPresentInStringTemplates() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/inline/inlineVariableOrProperty/stringTemplates"), Pattern.compile("^(\\w+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/inline/inlineVariableOrProperty/stringTemplates"), Pattern.compile("^(\\w+)\\.kt$"), null, true); } @TestMetadata("blockEntry.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/refactoring/introduce/ExtractionTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/refactoring/introduce/ExtractionTestGenerated.java index 8c0b02dd72b..eabd044dc30 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/refactoring/introduce/ExtractionTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/refactoring/introduce/ExtractionTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.refactoring.introduce; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -27,7 +28,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInIntroduceVariable() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/introduceVariable"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/introduceVariable"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("AnonymousType.kt") @@ -469,7 +470,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInExplicateTypeArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/introduceVariable/explicateTypeArguments"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/introduceVariable/explicateTypeArguments"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("DeeperNestedCall.kt") @@ -512,7 +513,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInExtractToScope() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/introduceVariable/extractToScope"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/introduceVariable/extractToScope"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("implicitOuterThisInsideNestedLamba.kt") @@ -580,7 +581,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInMultiDeclarations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/introduceVariable/multiDeclarations"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/introduceVariable/multiDeclarations"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("array.kt") @@ -638,7 +639,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInScript() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/introduceVariable/script"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/introduceVariable/script"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("ExpressionPart.kts") @@ -666,7 +667,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInStringTemplates() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/introduceVariable/stringTemplates"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/introduceVariable/stringTemplates"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("brokenEntryWithBlockExpr.kt") @@ -765,7 +766,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInExtractFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("idea/testData/refactoring/extractFunction/basic") @@ -777,7 +778,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInBasic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/basic"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/basic"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("callWithPlatformTypeReceiver.kt") @@ -1060,7 +1061,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInControlFlow() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/controlFlow"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/controlFlow"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("idea/testData/refactoring/extractFunction/controlFlow/conditionalJumps") @@ -1072,7 +1073,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInConditionalJumps() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/controlFlow/conditionalJumps"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/controlFlow/conditionalJumps"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("conditionalBreakWithIf.kt") @@ -1135,7 +1136,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInDefault() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/controlFlow/default"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/controlFlow/default"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("defaultCF.kt") @@ -1183,7 +1184,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInDefiniteReturns() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/controlFlow/definiteReturns"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/controlFlow/definiteReturns"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("definiteReturnWithIf.kt") @@ -1236,7 +1237,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInEvaluateExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/controlFlow/evaluateExpression"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/controlFlow/evaluateExpression"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("evalExprInIfCondition.kt") @@ -1319,7 +1320,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInExitPointEquivalence() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/controlFlow/exitPointEquivalence"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/controlFlow/exitPointEquivalence"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("breakAndReturn.kt") @@ -1372,7 +1373,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInInitializer() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/controlFlow/initializer"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/controlFlow/initializer"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("propertyWithInitializer.kt") @@ -1420,7 +1421,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInOutputValues() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/controlFlow/outputValues"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/controlFlow/outputValues"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("genericPair.kt") @@ -1558,7 +1559,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInReturnTypeCandidates() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/controlFlow/returnTypeCandidates"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/controlFlow/returnTypeCandidates"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("javaAnnotatedNotNull.kt") @@ -1586,7 +1587,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInThrows() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/controlFlow/throws"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/controlFlow/throws"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("breakWithThrow.kt") @@ -1634,7 +1635,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInUnextractable() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/controlFlow/unextractable"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/controlFlow/unextractable"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("anonymousObject.kt") @@ -1683,7 +1684,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInDefaultContainer() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/defaultContainer"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/defaultContainer"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("anonymousObject.kt") @@ -1731,7 +1732,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInDelegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/delegation"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/delegation"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("delegationByExpression.kt") @@ -1759,7 +1760,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInDuplicates() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/duplicates"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/duplicates"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("branchingMatch1.kt") @@ -1827,7 +1828,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInInitializers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/initializers"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/initializers"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("idea/testData/refactoring/extractFunction/initializers/accessors") @@ -1839,7 +1840,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/initializers/accessors"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/initializers/accessors"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("memberProperty.kt") @@ -1872,7 +1873,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/initializers/classes"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/initializers/classes"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("classInitializer.kt") @@ -1905,7 +1906,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/initializers/functions"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/initializers/functions"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("localFunction.kt") @@ -1978,7 +1979,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/initializers/properties"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/initializers/properties"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("localProperty.kt") @@ -2032,7 +2033,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInMultiline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/multiline"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/multiline"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("multilineBinaryExpression.kt") @@ -2065,7 +2066,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/parameters"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/parameters"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("idea/testData/refactoring/extractFunction/parameters/candidateTypes") @@ -2077,7 +2078,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInCandidateTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/parameters/candidateTypes"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/parameters/candidateTypes"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("cantLiftAnonymousToSupertype.kt") @@ -2175,7 +2176,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInCapturedFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/parameters/capturedFunctions"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/parameters/capturedFunctions"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("deeplyLocalFun.kt") @@ -2213,7 +2214,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInExtractSuper() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/parameters/extractSuper"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/parameters/extractSuper"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("labeledSuperPropertyCall.kt") @@ -2246,7 +2247,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInExtractThis() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/parameters/extractThis"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/parameters/extractThis"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("explicitLabeledThisInMember.kt") @@ -2354,7 +2355,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInIt() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/parameters/it"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/parameters/it"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("innerIt.kt") @@ -2392,7 +2393,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInMisc() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/parameters/misc"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/parameters/misc"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("classObject.kt") @@ -2530,7 +2531,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInNonDenotableTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/parameters/nonDenotableTypes"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/parameters/nonDenotableTypes"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("anonymousObject.kt") @@ -2579,7 +2580,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInScript() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/script"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/script"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("NotExpression.kts") @@ -2602,7 +2603,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInStringTemplates() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/stringTemplates"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/stringTemplates"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("brokenEntryWithBlockExpr.kt") @@ -2695,7 +2696,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInTypeParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/typeParameters"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractFunction/typeParameters"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("localClassInBound.kt") @@ -2794,7 +2795,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInIntroduceProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/introduceProperty"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/introduceProperty"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("conflictWithParentClass.kt") @@ -2981,7 +2982,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInScript() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/introduceProperty/script"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/introduceProperty/script"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("ClassInScript.kts") @@ -3009,7 +3010,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInStringTemplates() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/introduceProperty/stringTemplates"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/introduceProperty/stringTemplates"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("brokenEntryWithBlockExpr.kt") @@ -3103,7 +3104,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInIntroduceParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/introduceParameter"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/introduceParameter"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("annotationArgument.kt") @@ -3380,7 +3381,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInMultiline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/introduceParameter/multiline"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/introduceParameter/multiline"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("multilineBinaryExpression.kt") @@ -3413,7 +3414,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInScript() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/introduceParameter/script"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/introduceParameter/script"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("ExpressionPart.kts") @@ -3441,7 +3442,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInStringTemplates() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/introduceParameter/stringTemplates"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/introduceParameter/stringTemplates"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("brokenEntryWithBlockExpr.kt") @@ -3534,7 +3535,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInVariableConversion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/introduceParameter/variableConversion"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/introduceParameter/variableConversion"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("caretAtIdentifier.kt") @@ -3558,7 +3559,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInIntroduceLambdaParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/introduceLambdaParameter"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/introduceLambdaParameter"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("lambdaArgument.kt") @@ -3620,7 +3621,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInMultiline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/introduceLambdaParameter/multiline"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/introduceLambdaParameter/multiline"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("multilineBinaryExpression.kt") @@ -3653,7 +3654,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInStringTemplates() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/introduceLambdaParameter/stringTemplates"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/introduceLambdaParameter/stringTemplates"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("brokenEntryWithBlockExpr.kt") @@ -3747,7 +3748,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInIntroduceJavaParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/introduceJavaParameter"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/introduceJavaParameter"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("javaMethod.java") @@ -3770,7 +3771,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInIntroduceTypeParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/introduceTypeParameter"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/introduceTypeParameter"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("duplicates.kt") @@ -3813,7 +3814,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInIntroduceTypeAlias() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/introduceTypeAlias"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/introduceTypeAlias"), Pattern.compile("^(.+)\\.(kt|kts)$"), null, true); } @TestMetadata("callableReference.kt") @@ -4001,7 +4002,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInExtractSuperclass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractSuperclass"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractSuperclass"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); } @TestMetadata("annotation.kt") @@ -4104,7 +4105,7 @@ public class ExtractionTestGenerated extends AbstractExtractionTest { } public void testAllFilesPresentInExtractInterface() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractInterface"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/extractInterface"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), null, true); } @TestMetadata("annotation.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/refactoring/move/MoveTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/refactoring/move/MoveTestGenerated.java index 2c7c841155a..9bde6d812a6 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/refactoring/move/MoveTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/refactoring/move/MoveTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.refactoring.move; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class MoveTestGenerated extends AbstractMoveTest { } public void testAllFilesPresentInMove() throws Exception { - KotlinTestUtils.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File("idea/testData/refactoring/move"), Pattern.compile("^(.+)\\.test$"), null); + KtTestUtil.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File("idea/testData/refactoring/move"), Pattern.compile("^(.+)\\.test$"), null); } @TestMetadata("java/moveClass/callableReferences/nestedToAnotherClass/nestedToAnotherClass.test") diff --git a/idea/tests/org/jetbrains/kotlin/idea/refactoring/move/MultiModuleMoveTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/refactoring/move/MultiModuleMoveTestGenerated.java index a73cd98e1ea..c552cf22358 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/refactoring/move/MultiModuleMoveTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/refactoring/move/MultiModuleMoveTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.refactoring.move; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class MultiModuleMoveTestGenerated extends AbstractMultiModuleMoveTest { } public void testAllFilesPresentInMoveMultiModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File("idea/testData/refactoring/moveMultiModule"), Pattern.compile("^(.+)\\.test$"), null); + KtTestUtil.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File("idea/testData/refactoring/moveMultiModule"), Pattern.compile("^(.+)\\.test$"), null); } @TestMetadata("moveClassWithInternalMemberFromJvmToCommon/moveClassWithInternalMemberFromJvmToCommon.test") diff --git a/idea/tests/org/jetbrains/kotlin/idea/refactoring/pullUp/PullUpTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/refactoring/pullUp/PullUpTestGenerated.java index 33ff31ceaac..1903e9df72c 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/refactoring/pullUp/PullUpTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/refactoring/pullUp/PullUpTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.refactoring.pullUp; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -37,7 +38,7 @@ public class PullUpTestGenerated extends AbstractPullUpTest { } public void testAllFilesPresentInK2K() throws Exception { - KotlinTestUtils.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File("idea/testData/refactoring/pullUp/k2k"), Pattern.compile("^(.+)\\.kt$"), null); + KtTestUtil.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File("idea/testData/refactoring/pullUp/k2k"), Pattern.compile("^(.+)\\.kt$"), null); } @TestMetadata("clashWithSuper.kt") @@ -325,7 +326,7 @@ public class PullUpTestGenerated extends AbstractPullUpTest { } public void testAllFilesPresentInK2J() throws Exception { - KotlinTestUtils.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File("idea/testData/refactoring/pullUp/k2j"), Pattern.compile("^(.+)\\.kt$"), null); + KtTestUtil.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File("idea/testData/refactoring/pullUp/k2j"), Pattern.compile("^(.+)\\.kt$"), null); } @TestMetadata("constructorParameterToClass.kt") @@ -398,7 +399,7 @@ public class PullUpTestGenerated extends AbstractPullUpTest { } public void testAllFilesPresentInJ2K() throws Exception { - KotlinTestUtils.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File("idea/testData/refactoring/pullUp/j2k"), Pattern.compile("^(.+)\\.java$"), null); + KtTestUtil.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File("idea/testData/refactoring/pullUp/j2k"), Pattern.compile("^(.+)\\.java$"), null); } @TestMetadata("fromClassToClass.java") diff --git a/idea/tests/org/jetbrains/kotlin/idea/refactoring/pushDown/PushDownTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/refactoring/pushDown/PushDownTestGenerated.java index d5ef043da0f..4a10c8efe5e 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/refactoring/pushDown/PushDownTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/refactoring/pushDown/PushDownTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.refactoring.pushDown; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -32,7 +33,7 @@ public class PushDownTestGenerated extends AbstractPushDownTest { } public void testAllFilesPresentInK2K() throws Exception { - KotlinTestUtils.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File("idea/testData/refactoring/pushDown/k2k"), Pattern.compile("^(.+)\\.kt$"), null); + KtTestUtil.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File("idea/testData/refactoring/pushDown/k2k"), Pattern.compile("^(.+)\\.kt$"), null); } @TestMetadata("clashingMembers.kt") @@ -140,7 +141,7 @@ public class PushDownTestGenerated extends AbstractPushDownTest { } public void testAllFilesPresentInK2J() throws Exception { - KotlinTestUtils.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File("idea/testData/refactoring/pushDown/k2j"), Pattern.compile("^(.+)\\.kt$"), null); + KtTestUtil.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File("idea/testData/refactoring/pushDown/k2j"), Pattern.compile("^(.+)\\.kt$"), null); } @TestMetadata("kotlinToJava.kt") @@ -158,7 +159,7 @@ public class PushDownTestGenerated extends AbstractPushDownTest { } public void testAllFilesPresentInJ2K() throws Exception { - KotlinTestUtils.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File("idea/testData/refactoring/pushDown/j2k"), Pattern.compile("^(.+)\\.java$"), null); + KtTestUtil.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File("idea/testData/refactoring/pushDown/j2k"), Pattern.compile("^(.+)\\.java$"), null); } @TestMetadata("fromClass.java") diff --git a/idea/tests/org/jetbrains/kotlin/idea/refactoring/rename/MultiModuleRenameTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/refactoring/rename/MultiModuleRenameTestGenerated.java index 3edfb45236d..ecdd3e19c9a 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/refactoring/rename/MultiModuleRenameTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/refactoring/rename/MultiModuleRenameTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.refactoring.rename; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class MultiModuleRenameTestGenerated extends AbstractMultiModuleRenameTes } public void testAllFilesPresentInRenameMultiModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File("idea/testData/refactoring/renameMultiModule"), Pattern.compile("^(.+)\\.test$"), null); + KtTestUtil.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File("idea/testData/refactoring/renameMultiModule"), Pattern.compile("^(.+)\\.test$"), null); } @TestMetadata("fileNotUnderSourceRootWithNamesakeUnderSourceRoot/fileNotUnderSourceRootWithNamesakeUnderSourceRoot.test") diff --git a/idea/tests/org/jetbrains/kotlin/idea/refactoring/rename/RenameTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/refactoring/rename/RenameTestGenerated.java index bdf08b5e480..0a6a062b31f 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/refactoring/rename/RenameTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/refactoring/rename/RenameTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.refactoring.rename; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class RenameTestGenerated extends AbstractRenameTest { } public void testAllFilesPresentInRename() throws Exception { - KotlinTestUtils.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File("idea/testData/refactoring/rename"), Pattern.compile("^(.+)\\.test$"), null); + KtTestUtil.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File("idea/testData/refactoring/rename"), Pattern.compile("^(.+)\\.test$"), null); } @TestMetadata("ambiguousClassFunImportRenameClass/ambiguousClassFunImportRenameClass.test") diff --git a/idea/tests/org/jetbrains/kotlin/idea/refactoring/safeDelete/MultiModuleSafeDeleteTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/refactoring/safeDelete/MultiModuleSafeDeleteTestGenerated.java index 7d4c3849633..206c13b6806 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/refactoring/safeDelete/MultiModuleSafeDeleteTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/refactoring/safeDelete/MultiModuleSafeDeleteTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.refactoring.safeDelete; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class MultiModuleSafeDeleteTestGenerated extends AbstractMultiModuleSafeD } public void testAllFilesPresentInSafeDeleteMultiModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File("idea/testData/refactoring/safeDeleteMultiModule"), Pattern.compile("^(.+)\\.test$"), null); + KtTestUtil.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File("idea/testData/refactoring/safeDeleteMultiModule"), Pattern.compile("^(.+)\\.test$"), null); } @TestMetadata("byActualClass/byActualClass.test") diff --git a/idea/tests/org/jetbrains/kotlin/idea/refactoring/safeDelete/SafeDeleteTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/refactoring/safeDelete/SafeDeleteTestGenerated.java index 30b5be408a2..c8108880c47 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/refactoring/safeDelete/SafeDeleteTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/refactoring/safeDelete/SafeDeleteTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.refactoring.safeDelete; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -27,7 +28,7 @@ public class SafeDeleteTestGenerated extends AbstractSafeDeleteTest { } public void testAllFilesPresentInKotlinClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/safeDelete/deleteClass/kotlinClass"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/safeDelete/deleteClass/kotlinClass"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("class1.kt") @@ -110,7 +111,7 @@ public class SafeDeleteTestGenerated extends AbstractSafeDeleteTest { } public void testAllFilesPresentInKotlinClassWithJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/safeDelete/deleteClass/kotlinClassWithJava"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/safeDelete/deleteClass/kotlinClassWithJava"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("classWithDelegationCalls.kt") @@ -128,7 +129,7 @@ public class SafeDeleteTestGenerated extends AbstractSafeDeleteTest { } public void testAllFilesPresentInJavaClassWithKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/safeDelete/deleteClass/javaClassWithKotlin"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/safeDelete/deleteClass/javaClassWithKotlin"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("ImportJavaClassToKotlin.java") @@ -156,7 +157,7 @@ public class SafeDeleteTestGenerated extends AbstractSafeDeleteTest { } public void testAllFilesPresentInKotlinObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/safeDelete/deleteObject/kotlinObject"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/safeDelete/deleteObject/kotlinObject"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("anonymousObject.kt") @@ -224,7 +225,7 @@ public class SafeDeleteTestGenerated extends AbstractSafeDeleteTest { } public void testAllFilesPresentInKotlinFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/safeDelete/deleteFunction/kotlinFunction"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/safeDelete/deleteFunction/kotlinFunction"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("fun1.kt") @@ -322,7 +323,7 @@ public class SafeDeleteTestGenerated extends AbstractSafeDeleteTest { } public void testAllFilesPresentInKotlinFunctionWithJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/safeDelete/deleteFunction/kotlinFunctionWithJava"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/safeDelete/deleteFunction/kotlinFunctionWithJava"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("funExt.kt") @@ -395,7 +396,7 @@ public class SafeDeleteTestGenerated extends AbstractSafeDeleteTest { } public void testAllFilesPresentInJavaFunctionWithKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/safeDelete/deleteFunction/javaFunctionWithKotlin"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/safeDelete/deleteFunction/javaFunctionWithKotlin"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("mixedHierarchy1.kt") @@ -418,7 +419,7 @@ public class SafeDeleteTestGenerated extends AbstractSafeDeleteTest { } public void testAllFilesPresentInKotlinProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/safeDelete/deleteProperty/kotlinProperty"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/safeDelete/deleteProperty/kotlinProperty"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("implement1.kt") @@ -551,7 +552,7 @@ public class SafeDeleteTestGenerated extends AbstractSafeDeleteTest { } public void testAllFilesPresentInKotlinPropertyWithJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/safeDelete/deleteProperty/kotlinPropertyWithJava"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/safeDelete/deleteProperty/kotlinPropertyWithJava"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("implement1.kt") @@ -624,7 +625,7 @@ public class SafeDeleteTestGenerated extends AbstractSafeDeleteTest { } public void testAllFilesPresentInJavaPropertyWithKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/safeDelete/deleteProperty/javaPropertyWithKotlin"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/safeDelete/deleteProperty/javaPropertyWithKotlin"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("middleJava1.kt") @@ -667,7 +668,7 @@ public class SafeDeleteTestGenerated extends AbstractSafeDeleteTest { } public void testAllFilesPresentInKotlinTypeAlias() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/safeDelete/deleteTypeAlias/kotlinTypeAlias"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/safeDelete/deleteTypeAlias/kotlinTypeAlias"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("simple.kt") @@ -690,7 +691,7 @@ public class SafeDeleteTestGenerated extends AbstractSafeDeleteTest { } public void testAllFilesPresentInKotlinTypeParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/safeDelete/deleteTypeParameter/kotlinTypeParameter"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/safeDelete/deleteTypeParameter/kotlinTypeParameter"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("internalUsages1.kt") @@ -783,7 +784,7 @@ public class SafeDeleteTestGenerated extends AbstractSafeDeleteTest { } public void testAllFilesPresentInKotlinTypeParameterWithJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/safeDelete/deleteTypeParameter/kotlinTypeParameterWithJava"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/safeDelete/deleteTypeParameter/kotlinTypeParameterWithJava"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("internalUsages1.kt") @@ -881,7 +882,7 @@ public class SafeDeleteTestGenerated extends AbstractSafeDeleteTest { } public void testAllFilesPresentInKotlinValueParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameter"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("dataClassComponent.kt") @@ -1054,7 +1055,7 @@ public class SafeDeleteTestGenerated extends AbstractSafeDeleteTest { } public void testAllFilesPresentInKotlinValueParameterWithJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameterWithJava"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/refactoring/safeDelete/deleteValueParameter/kotlinValueParameterWithJava"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("dataClassComponent.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/repl/IdeReplCompletionTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/repl/IdeReplCompletionTestGenerated.java index 420e5f6e8b0..1a9ae136f60 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/repl/IdeReplCompletionTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/repl/IdeReplCompletionTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.repl; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class IdeReplCompletionTestGenerated extends AbstractIdeReplCompletionTes } public void testAllFilesPresentInCompletion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/repl/completion"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/repl/completion"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("builtInMember.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/resolve/AdditionalResolveDescriptorRendererTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/resolve/AdditionalResolveDescriptorRendererTestGenerated.java index 6e724bbb3b8..8fe4f5f5d4e 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/resolve/AdditionalResolveDescriptorRendererTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/resolve/AdditionalResolveDescriptorRendererTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.resolve; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class AdditionalResolveDescriptorRendererTestGenerated extends AbstractAd } public void testAllFilesPresentInAdditionalLazyResolve() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/additionalLazyResolve"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/additionalLazyResolve"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("anonymousObjectInBaseConstructor.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/resolve/PartialBodyResolveTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/resolve/PartialBodyResolveTestGenerated.java index 278224954f9..fb126e8b0b3 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/resolve/PartialBodyResolveTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/resolve/PartialBodyResolveTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.resolve; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class PartialBodyResolveTestGenerated extends AbstractPartialBodyResolveT } public void testAllFilesPresentInPartialBodyResolve() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/partialBodyResolve"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/partialBodyResolve"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("AnonymousObjects.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/resolve/ReferenceResolveInJavaTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/resolve/ReferenceResolveInJavaTestGenerated.java index f04e8ef02b1..aa34057a583 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/resolve/ReferenceResolveInJavaTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/resolve/ReferenceResolveInJavaTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.resolve; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -27,7 +28,7 @@ public class ReferenceResolveInJavaTestGenerated extends AbstractReferenceResolv } public void testAllFilesPresentInBinaryAndSource() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/referenceInJava/binaryAndSource"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/referenceInJava/binaryAndSource"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("Class.java") @@ -100,7 +101,7 @@ public class ReferenceResolveInJavaTestGenerated extends AbstractReferenceResolv } public void testAllFilesPresentInSourceOnly() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/referenceInJava/sourceOnly"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/referenceInJava/sourceOnly"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("AnnotationParameterReference.java") diff --git a/idea/tests/org/jetbrains/kotlin/idea/resolve/ReferenceResolveInLibrarySourcesTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/resolve/ReferenceResolveInLibrarySourcesTestGenerated.java index 7af6931f5f2..d4269a9f24e 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/resolve/ReferenceResolveInLibrarySourcesTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/resolve/ReferenceResolveInLibrarySourcesTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.resolve; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class ReferenceResolveInLibrarySourcesTestGenerated extends AbstractRefer } public void testAllFilesPresentInReferenceInLib() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/referenceInLib"), Pattern.compile("^(.+)\\.kt$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/referenceInLib"), Pattern.compile("^(.+)\\.kt$"), null, false); } @TestMetadata("builtInNumber.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/resolve/ReferenceResolveTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/resolve/ReferenceResolveTestGenerated.java index a9ca663b714..8ee4a6f234c 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/resolve/ReferenceResolveTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/resolve/ReferenceResolveTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.resolve; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class ReferenceResolveTestGenerated extends AbstractReferenceResolveTest } public void testAllFilesPresentInReferences() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/references"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/references"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("AnnotationForClass.kt") @@ -427,7 +428,7 @@ public class ReferenceResolveTestGenerated extends AbstractReferenceResolveTest } public void testAllFilesPresentInArrayAccess() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/references/arrayAccess"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/references/arrayAccess"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("get.kt") @@ -450,7 +451,7 @@ public class ReferenceResolveTestGenerated extends AbstractReferenceResolveTest } public void testAllFilesPresentInConstructorDelegatingReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/references/constructorDelegatingReference"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/references/constructorDelegatingReference"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("toPrimary.kt") @@ -473,7 +474,7 @@ public class ReferenceResolveTestGenerated extends AbstractReferenceResolveTest } public void testAllFilesPresentInDelegatedPropertyAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/references/delegatedPropertyAccessors"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/references/delegatedPropertyAccessors"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("unresolved.kt") @@ -490,7 +491,7 @@ public class ReferenceResolveTestGenerated extends AbstractReferenceResolveTest } public void testAllFilesPresentInInSource() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/references/delegatedPropertyAccessors/inSource"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/references/delegatedPropertyAccessors/inSource"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("getExtension.kt") @@ -523,7 +524,7 @@ public class ReferenceResolveTestGenerated extends AbstractReferenceResolveTest } public void testAllFilesPresentInInStandardLibrary() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/references/delegatedPropertyAccessors/inStandardLibrary"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/references/delegatedPropertyAccessors/inStandardLibrary"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("lazy.kt") @@ -547,7 +548,7 @@ public class ReferenceResolveTestGenerated extends AbstractReferenceResolveTest } public void testAllFilesPresentInForLoopIn() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/references/forLoopIn"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/references/forLoopIn"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("unresolvedIterator.kt") @@ -564,7 +565,7 @@ public class ReferenceResolveTestGenerated extends AbstractReferenceResolveTest } public void testAllFilesPresentInInBuiltIns() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/references/forLoopIn/inBuiltIns"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/references/forLoopIn/inBuiltIns"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("extension.kt") @@ -587,7 +588,7 @@ public class ReferenceResolveTestGenerated extends AbstractReferenceResolveTest } public void testAllFilesPresentInInLibrary() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/references/forLoopIn/inLibrary"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/references/forLoopIn/inLibrary"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("extension.kt") @@ -610,7 +611,7 @@ public class ReferenceResolveTestGenerated extends AbstractReferenceResolveTest } public void testAllFilesPresentInInSource() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/references/forLoopIn/inSource"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/references/forLoopIn/inSource"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("allMembers.kt") @@ -634,7 +635,7 @@ public class ReferenceResolveTestGenerated extends AbstractReferenceResolveTest } public void testAllFilesPresentInInvoke() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/references/invoke"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/references/invoke"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("lambdaAndParens.kt") @@ -717,7 +718,7 @@ public class ReferenceResolveTestGenerated extends AbstractReferenceResolveTest } public void testAllFilesPresentInNestedTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/references/nestedTypes"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/references/nestedTypes"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("ResolveCompanionInCompanionType.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/resolve/ReferenceResolveWithLibTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/resolve/ReferenceResolveWithLibTestGenerated.java index 32b8e4296a9..9d406613060 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/resolve/ReferenceResolveWithLibTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/resolve/ReferenceResolveWithLibTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.resolve; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class ReferenceResolveWithLibTestGenerated extends AbstractReferenceResol } public void testAllFilesPresentInReferenceWithLib() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/referenceWithLib"), Pattern.compile("^(.+)\\.kt$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/referenceWithLib"), Pattern.compile("^(.+)\\.kt$"), null, false); } @TestMetadata("delegatedPropertyWithTypeParameters.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/resolve/ReferenceToCompiledKotlinResolveInJavaTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/resolve/ReferenceToCompiledKotlinResolveInJavaTestGenerated.java index 76b7ad0ae1d..58fb2c31598 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/resolve/ReferenceToCompiledKotlinResolveInJavaTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/resolve/ReferenceToCompiledKotlinResolveInJavaTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.resolve; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class ReferenceToCompiledKotlinResolveInJavaTestGenerated extends Abstrac } public void testAllFilesPresentInBinaryAndSource() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/referenceInJava/binaryAndSource"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/referenceInJava/binaryAndSource"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("Class.java") diff --git a/idea/tests/org/jetbrains/kotlin/idea/resolve/ReferenceToJavaWithWrongFileStructureTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/resolve/ReferenceToJavaWithWrongFileStructureTestGenerated.java index 8c5277d44d8..743967149be 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/resolve/ReferenceToJavaWithWrongFileStructureTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/resolve/ReferenceToJavaWithWrongFileStructureTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.resolve; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class ReferenceToJavaWithWrongFileStructureTestGenerated extends Abstract } public void testAllFilesPresentInReferenceToJavaWithWrongFileStructure() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/referenceToJavaWithWrongFileStructure"), Pattern.compile("^(.+)\\.kt$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/referenceToJavaWithWrongFileStructure"), Pattern.compile("^(.+)\\.kt$"), null, false); } @TestMetadata("ClassStatics.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/resolve/ResolveModeComparisonTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/resolve/ResolveModeComparisonTestGenerated.java index ebee6138f84..a6232481b2c 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/resolve/ResolveModeComparisonTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/resolve/ResolveModeComparisonTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.resolve; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class ResolveModeComparisonTestGenerated extends AbstractResolveModeCompa } public void testAllFilesPresentInResolveModeComparison() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/resolveModeComparison"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/resolve/resolveModeComparison"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Classes.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/script/ScriptConfigurationCompletionTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/script/ScriptConfigurationCompletionTestGenerated.java index 549c852bc1f..3dbbbcb2f2b 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/script/ScriptConfigurationCompletionTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/script/ScriptConfigurationCompletionTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.script; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class ScriptConfigurationCompletionTestGenerated extends AbstractScriptCo } public void testAllFilesPresentInCompletion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/script/definition/completion"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/script/definition/completion"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("conflictingModule") diff --git a/idea/tests/org/jetbrains/kotlin/idea/script/ScriptConfigurationHighlightingTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/script/ScriptConfigurationHighlightingTestGenerated.java index 2953e4c5bdd..0277111fbc0 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/script/ScriptConfigurationHighlightingTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/script/ScriptConfigurationHighlightingTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.script; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -37,7 +38,7 @@ public class ScriptConfigurationHighlightingTestGenerated extends AbstractScript } public void testAllFilesPresentInHighlighting() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/script/definition/highlighting"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/script/definition/highlighting"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("asyncResolver") @@ -150,7 +151,7 @@ public class ScriptConfigurationHighlightingTestGenerated extends AbstractScript } public void testAllFilesPresentInComplex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/script/definition/complex"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/script/definition/complex"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("errorResolver") diff --git a/idea/tests/org/jetbrains/kotlin/idea/script/ScriptConfigurationInsertImportOnPasteTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/script/ScriptConfigurationInsertImportOnPasteTestGenerated.java index eb7d608717f..6dfd9fa84a2 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/script/ScriptConfigurationInsertImportOnPasteTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/script/ScriptConfigurationInsertImportOnPasteTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.script; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -27,7 +28,7 @@ public class ScriptConfigurationInsertImportOnPasteTestGenerated extends Abstrac } public void testAllFilesPresentInCopy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/script/definition/imports"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/script/definition/imports"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("implicitImport") @@ -45,7 +46,7 @@ public class ScriptConfigurationInsertImportOnPasteTestGenerated extends Abstrac } public void testAllFilesPresentInCut() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/script/definition/imports"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/script/definition/imports"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("implicitImport") diff --git a/idea/tests/org/jetbrains/kotlin/idea/script/ScriptConfigurationNavigationTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/script/ScriptConfigurationNavigationTestGenerated.java index 90a7d653209..51e4eb619de 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/script/ScriptConfigurationNavigationTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/script/ScriptConfigurationNavigationTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.script; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class ScriptConfigurationNavigationTestGenerated extends AbstractScriptCo } public void testAllFilesPresentInNavigation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/script/definition/navigation"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/script/definition/navigation"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("buildSrcProblem") diff --git a/idea/tests/org/jetbrains/kotlin/idea/script/ScriptDefinitionsOrderTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/script/ScriptDefinitionsOrderTestGenerated.java index 1a1bc73af36..4232d32aed3 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/script/ScriptDefinitionsOrderTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/script/ScriptDefinitionsOrderTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.script; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class ScriptDefinitionsOrderTestGenerated extends AbstractScriptDefinitio } public void testAllFilesPresentInOrder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/script/definition/order"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/script/definition/order"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("reorder") diff --git a/idea/tests/org/jetbrains/kotlin/idea/slicer/SlicerLeafGroupingTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/slicer/SlicerLeafGroupingTestGenerated.java index 4bcad099ef8..e03dd7a2622 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/slicer/SlicerLeafGroupingTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/slicer/SlicerLeafGroupingTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.slicer; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -30,7 +31,7 @@ public class SlicerLeafGroupingTestGenerated extends AbstractSlicerLeafGroupingT } public void testAllFilesPresentInInflow() throws Exception { - KotlinTestUtils.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File("idea/testData/slicer/inflow"), Pattern.compile("^(.+)\\.kt$"), null); + KtTestUtil.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File("idea/testData/slicer/inflow"), Pattern.compile("^(.+)\\.kt$"), null); } @TestMetadata("anonymousFunBodyExpression.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/slicer/SlicerMultiplatformTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/slicer/SlicerMultiplatformTestGenerated.java index b483948a483..5de24f22f00 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/slicer/SlicerMultiplatformTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/slicer/SlicerMultiplatformTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.slicer; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -35,7 +36,7 @@ public class SlicerMultiplatformTestGenerated extends AbstractSlicerMultiplatfor } public void testAllFilesPresentInMpp() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/slicer/mpp"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/slicer/mpp"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("expectClassFunctionParameter") diff --git a/idea/tests/org/jetbrains/kotlin/idea/slicer/SlicerNullnessGroupingTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/slicer/SlicerNullnessGroupingTestGenerated.java index eac7d0405a5..9a302b4c00b 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/slicer/SlicerNullnessGroupingTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/slicer/SlicerNullnessGroupingTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.slicer; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -30,7 +31,7 @@ public class SlicerNullnessGroupingTestGenerated extends AbstractSlicerNullnessG } public void testAllFilesPresentInInflow() throws Exception { - KotlinTestUtils.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File("idea/testData/slicer/inflow"), Pattern.compile("^(.+)\\.kt$"), null); + KtTestUtil.assertAllTestsPresentInSingleGeneratedClassWithExcluded(this.getClass(), new File("idea/testData/slicer/inflow"), Pattern.compile("^(.+)\\.kt$"), null); } @TestMetadata("anonymousFunBodyExpression.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/slicer/SlicerTreeTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/slicer/SlicerTreeTestGenerated.java index e27e1f28ac9..d362101e910 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/slicer/SlicerTreeTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/slicer/SlicerTreeTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.slicer; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class SlicerTreeTestGenerated extends AbstractSlicerTreeTest { } public void testAllFilesPresentInSlicer() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/slicer"), Pattern.compile("^(.+)\\.kt$"), null, true, "mpp"); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/slicer"), Pattern.compile("^(.+)\\.kt$"), null, true, "mpp"); } @TestMetadata("idea/testData/slicer/inflow") @@ -42,7 +43,7 @@ public class SlicerTreeTestGenerated extends AbstractSlicerTreeTest { } public void testAllFilesPresentInInflow() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/slicer/inflow"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/slicer/inflow"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("anonymousFunBodyExpression.kt") @@ -460,7 +461,7 @@ public class SlicerTreeTestGenerated extends AbstractSlicerTreeTest { } public void testAllFilesPresentInOutflow() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/slicer/outflow"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/slicer/outflow"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("anonymousFunBodyExpression.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/structureView/KotlinFileStructureTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/structureView/KotlinFileStructureTestGenerated.java index b42bc5bebd3..e7573bf6108 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/structureView/KotlinFileStructureTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/structureView/KotlinFileStructureTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.structureView; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class KotlinFileStructureTestGenerated extends AbstractKotlinFileStructur } public void testAllFilesPresentInFileStructure() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/structureView/fileStructure"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/structureView/fileStructure"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("AnonymousObjectMembers.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/stubs/MultiFileHighlightingTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/stubs/MultiFileHighlightingTestGenerated.java index c24e6cfd280..daeac78e713 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/stubs/MultiFileHighlightingTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/stubs/MultiFileHighlightingTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.stubs; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class MultiFileHighlightingTestGenerated extends AbstractMultiFileHighlig } public void testAllFilesPresentInMultiFileHighlighting() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/multiFileHighlighting"), Pattern.compile("^(.+)\\.kt$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/multiFileHighlighting"), Pattern.compile("^(.+)\\.kt$"), null, false); } @TestMetadata("annotatedParameter.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/stubs/ResolveByStubTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/stubs/ResolveByStubTestGenerated.java index 925e4f8ec45..3701f7375e5 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/stubs/ResolveByStubTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/stubs/ResolveByStubTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.stubs; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class ResolveByStubTestGenerated extends AbstractResolveByStubTest { } public void testAllFilesPresentInCompiledKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("compiler/testData/loadJava/compiledKotlin/annotations") @@ -37,7 +38,7 @@ public class ResolveByStubTestGenerated extends AbstractResolveByStubTest { } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("AnnotatedAnnotation.kt") @@ -94,7 +95,7 @@ public class ResolveByStubTestGenerated extends AbstractResolveByStubTest { } public void testAllFilesPresentInClassMembers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/classMembers"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/classMembers"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassObjectPropertyField.kt") @@ -162,7 +163,7 @@ public class ResolveByStubTestGenerated extends AbstractResolveByStubTest { } public void testAllFilesPresentInClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/classes"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/classes"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("AnnotationInClassObject.kt") @@ -250,7 +251,7 @@ public class ResolveByStubTestGenerated extends AbstractResolveByStubTest { } public void testAllFilesPresentInPackageMembers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/packageMembers"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/packageMembers"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("DelegatedProperty.kt") @@ -303,7 +304,7 @@ public class ResolveByStubTestGenerated extends AbstractResolveByStubTest { } public void testAllFilesPresentInParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/parameters"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/parameters"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Constructor.kt") @@ -376,7 +377,7 @@ public class ResolveByStubTestGenerated extends AbstractResolveByStubTest { } public void testAllFilesPresentInPropertiesWithoutBackingFields() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Class.kt") @@ -429,7 +430,7 @@ public class ResolveByStubTestGenerated extends AbstractResolveByStubTest { } public void testAllFilesPresentInTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/types"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/types"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassLiteralArgument.kt") @@ -487,7 +488,7 @@ public class ResolveByStubTestGenerated extends AbstractResolveByStubTest { } public void testAllFilesPresentInWithUseSiteTarget() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/withUseSiteTarget"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/annotations/withUseSiteTarget"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("DelegateTarget.kt") @@ -521,7 +522,7 @@ public class ResolveByStubTestGenerated extends AbstractResolveByStubTest { } public void testAllFilesPresentInClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/class"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/class"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Class.kt") @@ -718,7 +719,7 @@ public class ResolveByStubTestGenerated extends AbstractResolveByStubTest { } public void testAllFilesPresentInJavaBean() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/class/javaBean"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/class/javaBean"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("DifferentGetterAndSetter.kt") @@ -762,7 +763,7 @@ public class ResolveByStubTestGenerated extends AbstractResolveByStubTest { } public void testAllFilesPresentInClassFun() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/classFun"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/classFun"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassInParamUsedInFun.kt") @@ -800,7 +801,7 @@ public class ResolveByStubTestGenerated extends AbstractResolveByStubTest { } public void testAllFilesPresentInClassObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/classObject"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/classObject"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassObjectDeclaresVal.kt") @@ -878,7 +879,7 @@ public class ResolveByStubTestGenerated extends AbstractResolveByStubTest { } public void testAllFilesPresentInConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/constructor"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/constructor"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Constructor0.kt") @@ -970,7 +971,7 @@ public class ResolveByStubTestGenerated extends AbstractResolveByStubTest { } public void testAllFilesPresentInVararg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/constructor/vararg"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/constructor/vararg"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ConstructorNonLastVararg.kt") @@ -994,7 +995,7 @@ public class ResolveByStubTestGenerated extends AbstractResolveByStubTest { } public void testAllFilesPresentInCoroutines() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Basic.kt") @@ -1012,7 +1013,7 @@ public class ResolveByStubTestGenerated extends AbstractResolveByStubTest { } public void testAllFilesPresentInDataClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/dataClass"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/dataClass"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("MixedComponents.kt") @@ -1045,7 +1046,7 @@ public class ResolveByStubTestGenerated extends AbstractResolveByStubTest { } public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/enum"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/enum"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("enumVisibility.kt") @@ -1088,7 +1089,7 @@ public class ResolveByStubTestGenerated extends AbstractResolveByStubTest { } public void testAllFilesPresentInFromLoadJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ArrayTypeVariance.kt") @@ -1275,7 +1276,7 @@ public class ResolveByStubTestGenerated extends AbstractResolveByStubTest { } public void testAllFilesPresentInKotlinSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ArrayType.kt") @@ -1367,7 +1368,7 @@ public class ResolveByStubTestGenerated extends AbstractResolveByStubTest { } public void testAllFilesPresentInError() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/error"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ConflictingProjectionKind.kt") @@ -1510,7 +1511,7 @@ public class ResolveByStubTestGenerated extends AbstractResolveByStubTest { } public void testAllFilesPresentInPropagation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("PropagateTypeArgumentNullable.kt") @@ -1527,7 +1528,7 @@ public class ResolveByStubTestGenerated extends AbstractResolveByStubTest { } public void testAllFilesPresentInParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/parameter"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ChangeProjectionKind1.kt") @@ -1700,7 +1701,7 @@ public class ResolveByStubTestGenerated extends AbstractResolveByStubTest { } public void testAllFilesPresentInReturn() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/return"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("CantMakeImmutableInSubclass.kt") @@ -1853,7 +1854,7 @@ public class ResolveByStubTestGenerated extends AbstractResolveByStubTest { } public void testAllFilesPresentInTypeParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/typeParameter"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/kotlinSignature/propagation/typeParameter"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("InheritMutability.kt") @@ -1913,7 +1914,7 @@ public class ResolveByStubTestGenerated extends AbstractResolveByStubTest { } public void testAllFilesPresentInLibrary() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/library"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/library"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("LoadIterable.kt") @@ -1941,7 +1942,7 @@ public class ResolveByStubTestGenerated extends AbstractResolveByStubTest { } public void testAllFilesPresentInModality() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/modality"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/modality"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ModalityOfFakeOverrides.kt") @@ -1959,7 +1960,7 @@ public class ResolveByStubTestGenerated extends AbstractResolveByStubTest { } public void testAllFilesPresentInNotNull() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/notNull"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fromLoadJava/notNull"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("NotNullField.kt") @@ -1998,7 +1999,7 @@ public class ResolveByStubTestGenerated extends AbstractResolveByStubTest { } public void testAllFilesPresentInFun() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Assert.kt") @@ -2065,7 +2066,7 @@ public class ResolveByStubTestGenerated extends AbstractResolveByStubTest { } public void testAllFilesPresentInGenericWithTypeVariables() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/genericWithTypeVariables"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/genericWithTypeVariables"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("FunGenericParam.kt") @@ -2128,7 +2129,7 @@ public class ResolveByStubTestGenerated extends AbstractResolveByStubTest { } public void testAllFilesPresentInGenericWithoutTypeVariables() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/genericWithoutTypeVariables"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/genericWithoutTypeVariables"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("FunClassParamNotNull.kt") @@ -2166,7 +2167,7 @@ public class ResolveByStubTestGenerated extends AbstractResolveByStubTest { } public void testAllFilesPresentInNonGeneric() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/nonGeneric"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassFun.kt") @@ -2259,7 +2260,7 @@ public class ResolveByStubTestGenerated extends AbstractResolveByStubTest { } public void testAllFilesPresentInVararg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/vararg"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/fun/vararg"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("nonLastVararg.kt") @@ -2288,7 +2289,7 @@ public class ResolveByStubTestGenerated extends AbstractResolveByStubTest { } public void testAllFilesPresentInInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/inline"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/inline"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("inlineFunction.kt") @@ -2306,7 +2307,7 @@ public class ResolveByStubTestGenerated extends AbstractResolveByStubTest { } public void testAllFilesPresentInMemberOrder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/memberOrder"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/memberOrder"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("callablesNameClash.kt") @@ -2349,7 +2350,7 @@ public class ResolveByStubTestGenerated extends AbstractResolveByStubTest { } public void testAllFilesPresentInNested() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/nested"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/nested"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("deepInnerGeneric.kt") @@ -2377,7 +2378,7 @@ public class ResolveByStubTestGenerated extends AbstractResolveByStubTest { } public void testAllFilesPresentInPlatformTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/platformTypes"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/platformTypes"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("notnullTypeArgument.kt") @@ -2400,7 +2401,7 @@ public class ResolveByStubTestGenerated extends AbstractResolveByStubTest { } public void testAllFilesPresentInProp() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/prop"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/prop"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassVal.kt") @@ -2582,7 +2583,7 @@ public class ResolveByStubTestGenerated extends AbstractResolveByStubTest { } public void testAllFilesPresentInDefaultAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/prop/defaultAccessors"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/prop/defaultAccessors"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassVal.kt") @@ -2646,7 +2647,7 @@ public class ResolveByStubTestGenerated extends AbstractResolveByStubTest { } public void testAllFilesPresentInType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/type"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/type"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Any.kt") @@ -2814,7 +2815,7 @@ public class ResolveByStubTestGenerated extends AbstractResolveByStubTest { } public void testAllFilesPresentInTypealias() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/typealias"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/typealias"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Annotations.kt") @@ -2847,7 +2848,7 @@ public class ResolveByStubTestGenerated extends AbstractResolveByStubTest { } public void testAllFilesPresentInVisibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/visibility"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava/compiledKotlin/visibility"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("InternalClass.kt") diff --git a/idea/tests/org/jetbrains/kotlin/idea/stubs/StubBuilderTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/stubs/StubBuilderTestGenerated.java index 1e6024edc7f..28e756c5d91 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/stubs/StubBuilderTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/stubs/StubBuilderTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.idea.stubs; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class StubBuilderTestGenerated extends AbstractStubBuilderTest { } public void testAllFilesPresentInStubs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/stubs"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/stubs"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("AnnotationClass.kt") diff --git a/idea/tests/org/jetbrains/kotlin/psi/patternMatching/PsiUnifierTestGenerated.java b/idea/tests/org/jetbrains/kotlin/psi/patternMatching/PsiUnifierTestGenerated.java index baa302af380..7d6b6077081 100644 --- a/idea/tests/org/jetbrains/kotlin/psi/patternMatching/PsiUnifierTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/psi/patternMatching/PsiUnifierTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.psi.patternMatching; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class PsiUnifierTestGenerated extends AbstractPsiUnifierTest { } public void testAllFilesPresentInUnifier() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/unifier"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/unifier"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("idea/testData/unifier/equivalence") @@ -37,7 +38,7 @@ public class PsiUnifierTestGenerated extends AbstractPsiUnifierTest { } public void testAllFilesPresentInEquivalence() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/unifier/equivalence"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/unifier/equivalence"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("idea/testData/unifier/equivalence/controlStructures") @@ -49,7 +50,7 @@ public class PsiUnifierTestGenerated extends AbstractPsiUnifierTest { } public void testAllFilesPresentInControlStructures() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/unifier/equivalence/controlStructures"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/unifier/equivalence/controlStructures"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("break.kt") @@ -126,7 +127,7 @@ public class PsiUnifierTestGenerated extends AbstractPsiUnifierTest { } public void testAllFilesPresentInBlocks() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/unifier/equivalence/controlStructures/blocks"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/unifier/equivalence/controlStructures/blocks"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("anonymousObjectsRuntime.kt") @@ -155,7 +156,7 @@ public class PsiUnifierTestGenerated extends AbstractPsiUnifierTest { } public void testAllFilesPresentInDeclarations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/unifier/equivalence/declarations"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/unifier/equivalence/declarations"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("idea/testData/unifier/equivalence/declarations/classesAndObjects") @@ -167,7 +168,7 @@ public class PsiUnifierTestGenerated extends AbstractPsiUnifierTest { } public void testAllFilesPresentInClassesAndObjects() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/unifier/equivalence/declarations/classesAndObjects"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/unifier/equivalence/declarations/classesAndObjects"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("anonymousObjectBody.kt") @@ -210,7 +211,7 @@ public class PsiUnifierTestGenerated extends AbstractPsiUnifierTest { } public void testAllFilesPresentInLocalCallables() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/unifier/equivalence/declarations/localCallables"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/unifier/equivalence/declarations/localCallables"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("localExtensionFunctions.kt") @@ -242,7 +243,7 @@ public class PsiUnifierTestGenerated extends AbstractPsiUnifierTest { } public void testAllFilesPresentInLambdas() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/unifier/equivalence/declarations/localCallables/lambdas"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/unifier/equivalence/declarations/localCallables/lambdas"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("multipleParamsRuntime.kt") @@ -281,7 +282,7 @@ public class PsiUnifierTestGenerated extends AbstractPsiUnifierTest { } public void testAllFilesPresentInTypeParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/unifier/equivalence/declarations/typeParameters"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/unifier/equivalence/declarations/typeParameters"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("boundsAndConstraints.kt") @@ -300,7 +301,7 @@ public class PsiUnifierTestGenerated extends AbstractPsiUnifierTest { } public void testAllFilesPresentInExpressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/unifier/equivalence/expressions"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/unifier/equivalence/expressions"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("arrayAccess.kt") @@ -337,7 +338,7 @@ public class PsiUnifierTestGenerated extends AbstractPsiUnifierTest { } public void testAllFilesPresentInCallableReferences() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/unifier/equivalence/expressions/callableReferences"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/unifier/equivalence/expressions/callableReferences"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("classRefRuntime.kt") @@ -365,7 +366,7 @@ public class PsiUnifierTestGenerated extends AbstractPsiUnifierTest { } public void testAllFilesPresentInCalls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/unifier/equivalence/expressions/calls"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/unifier/equivalence/expressions/calls"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("callAndCalleeRuntime.kt") @@ -428,7 +429,7 @@ public class PsiUnifierTestGenerated extends AbstractPsiUnifierTest { } public void testAllFilesPresentInCasts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/unifier/equivalence/expressions/casts"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/unifier/equivalence/expressions/casts"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("as.kt") @@ -456,7 +457,7 @@ public class PsiUnifierTestGenerated extends AbstractPsiUnifierTest { } public void testAllFilesPresentInConventions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/unifier/equivalence/expressions/conventions"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/unifier/equivalence/expressions/conventions"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("containsRuntime.kt") @@ -518,7 +519,7 @@ public class PsiUnifierTestGenerated extends AbstractPsiUnifierTest { } public void testAllFilesPresentInAssignments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/unifier/equivalence/expressions/conventions/assignments"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/unifier/equivalence/expressions/conventions/assignments"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("indexedPlusAssignRuntime.kt") @@ -556,7 +557,7 @@ public class PsiUnifierTestGenerated extends AbstractPsiUnifierTest { } public void testAllFilesPresentInInvoke() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/unifier/equivalence/expressions/conventions/invoke"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/unifier/equivalence/expressions/conventions/invoke"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("invokeOnCall.kt") @@ -590,7 +591,7 @@ public class PsiUnifierTestGenerated extends AbstractPsiUnifierTest { } public void testAllFilesPresentInMisc() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/unifier/equivalence/expressions/misc"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/unifier/equivalence/expressions/misc"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("misc1.kt") @@ -618,7 +619,7 @@ public class PsiUnifierTestGenerated extends AbstractPsiUnifierTest { } public void testAllFilesPresentInSuper() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/unifier/equivalence/expressions/super"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/unifier/equivalence/expressions/super"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("multipleSuperTypes.kt") @@ -651,7 +652,7 @@ public class PsiUnifierTestGenerated extends AbstractPsiUnifierTest { } public void testAllFilesPresentInThis() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/unifier/equivalence/expressions/this"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/unifier/equivalence/expressions/this"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("anonymousObjects.kt") @@ -715,7 +716,7 @@ public class PsiUnifierTestGenerated extends AbstractPsiUnifierTest { } public void testAllFilesPresentInTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/unifier/equivalence/types"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/unifier/equivalence/types"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("function0.kt") diff --git a/idea/tests/org/jetbrains/kotlin/search/AnnotatedMembersSearchTestGenerated.java b/idea/tests/org/jetbrains/kotlin/search/AnnotatedMembersSearchTestGenerated.java index 8ebf448a808..1960b0afa9e 100644 --- a/idea/tests/org/jetbrains/kotlin/search/AnnotatedMembersSearchTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/search/AnnotatedMembersSearchTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.search; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class AnnotatedMembersSearchTestGenerated extends AbstractAnnotatedMember } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/search/annotations"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/search/annotations"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("annotationAliased.kt") diff --git a/idea/tests/org/jetbrains/kotlin/search/InheritorsSearchTestGenerated.java b/idea/tests/org/jetbrains/kotlin/search/InheritorsSearchTestGenerated.java index ceff1292166..72a4be45350 100644 --- a/idea/tests/org/jetbrains/kotlin/search/InheritorsSearchTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/search/InheritorsSearchTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.search; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class InheritorsSearchTestGenerated extends AbstractInheritorsSearchTest } public void testAllFilesPresentInInheritance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/search/inheritance"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/search/inheritance"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("annotationClass.kt") diff --git a/idea/tests/org/jetbrains/kotlin/shortenRefs/ShortenRefsTestGenerated.java b/idea/tests/org/jetbrains/kotlin/shortenRefs/ShortenRefsTestGenerated.java index d4d66526fab..4a526095a1b 100644 --- a/idea/tests/org/jetbrains/kotlin/shortenRefs/ShortenRefsTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/shortenRefs/ShortenRefsTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.shortenRefs; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class ShortenRefsTestGenerated extends AbstractShortenRefsTest { } public void testAllFilesPresentInShortenRefs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/shortenRefs"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/shortenRefs"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("annotation.kt") @@ -162,7 +163,7 @@ public class ShortenRefsTestGenerated extends AbstractShortenRefsTest { } public void testAllFilesPresentInConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/shortenRefs/constructor"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/shortenRefs/constructor"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("Ambiguous.kt") @@ -255,7 +256,7 @@ public class ShortenRefsTestGenerated extends AbstractShortenRefsTest { } public void testAllFilesPresentInImports() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/shortenRefs/imports"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/shortenRefs/imports"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("importGlobalCallables.kt") @@ -283,7 +284,7 @@ public class ShortenRefsTestGenerated extends AbstractShortenRefsTest { } public void testAllFilesPresentInJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/shortenRefs/java"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/shortenRefs/java"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("innerClassImport.kt") @@ -351,7 +352,7 @@ public class ShortenRefsTestGenerated extends AbstractShortenRefsTest { } public void testAllFilesPresentInKt21515() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/shortenRefs/kt21515"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/shortenRefs/kt21515"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("callableReferenceOnClass.kt") @@ -394,7 +395,7 @@ public class ShortenRefsTestGenerated extends AbstractShortenRefsTest { } public void testAllFilesPresentInThis() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/shortenRefs/this"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/shortenRefs/this"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("cantShortenThis.kt") @@ -447,7 +448,7 @@ public class ShortenRefsTestGenerated extends AbstractShortenRefsTest { } public void testAllFilesPresentInType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/shortenRefs/type"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/shortenRefs/type"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("ClassNameInsideArguments.kt") @@ -550,7 +551,7 @@ public class ShortenRefsTestGenerated extends AbstractShortenRefsTest { } public void testAllFilesPresentInTypealias() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/shortenRefs/typealias"), Pattern.compile("^([^.]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/shortenRefs/typealias"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } @TestMetadata("TypeAliasAsCtor.kt") diff --git a/j2k/tests/org/jetbrains/kotlin/j2k/JavaToKotlinConverterForWebDemoTestGenerated.java b/j2k/tests/org/jetbrains/kotlin/j2k/JavaToKotlinConverterForWebDemoTestGenerated.java index 0682087b251..e2bb3d797ae 100644 --- a/j2k/tests/org/jetbrains/kotlin/j2k/JavaToKotlinConverterForWebDemoTestGenerated.java +++ b/j2k/tests/org/jetbrains/kotlin/j2k/JavaToKotlinConverterForWebDemoTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.j2k; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInFileOrElement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("j2k/testData/fileOrElement/annotations") @@ -37,7 +38,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/annotations"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/annotations"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("annotationArrayArgument.java") @@ -140,7 +141,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInAnonymousBlock() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/anonymousBlock"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/anonymousBlock"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("oneAnonBlock.java") @@ -163,7 +164,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInAnonymousClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/anonymousClass"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/anonymousClass"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("kt-13146.java") @@ -186,7 +187,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInArrayAccessExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/arrayAccessExpression"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/arrayAccessExpression"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("expressionIndex.java") @@ -214,7 +215,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInArrayInitializerExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/arrayInitializerExpression"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/arrayInitializerExpression"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("doubleArray.java") @@ -287,7 +288,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInArrayType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/arrayType"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/arrayType"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("arrayInitializationStatement.java") @@ -350,7 +351,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInAssertStatement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/assertStatement"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/assertStatement"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("assertNotNull.java") @@ -388,7 +389,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInAssignmentExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/assignmentExpression"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/assignmentExpression"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("and.java") @@ -491,7 +492,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInBinaryExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/binaryExpression"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/binaryExpression"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("and.java") @@ -604,7 +605,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInBlocks() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/blocks"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/blocks"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("Blocks.java") @@ -622,7 +623,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInBoxedType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/boxedType"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/boxedType"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("boolean.java") @@ -690,7 +691,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInBreakStatement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/breakStatement"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/breakStatement"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("breakWithLabel.java") @@ -713,7 +714,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInCallChainExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/callChainExpression"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/callChainExpression"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("libraryFieldCall.java") @@ -766,7 +767,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/class"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/class"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("anonymousClass.java") @@ -944,7 +945,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInClassExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/classExpression"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/classExpression"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("complexExample.java") @@ -977,7 +978,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInComments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/comments"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/comments"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("commentInsideCall.java") @@ -1025,7 +1026,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInConditionalExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/conditionalExpression"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/conditionalExpression"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("multiline.java") @@ -1058,7 +1059,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/constructors"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/constructors"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("artificialPrimary.java") @@ -1266,7 +1267,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInContinueStatement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/continueStatement"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/continueStatement"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("continueWithLabel.java") @@ -1289,7 +1290,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInDeclarationStatement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/declarationStatement"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/declarationStatement"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("multiplyFinalIntDeclaration.java") @@ -1347,7 +1348,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInDetectProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/detectProperties"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/detectProperties"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("AnonymousClass.java") @@ -1575,7 +1576,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInDoWhileStatement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/doWhileStatement"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/doWhileStatement"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("whileWithAssignmentAsExpression.java") @@ -1618,7 +1619,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInDocComments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/docComments"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/docComments"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("deprecatedDocTag.java") @@ -1701,7 +1702,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/enum"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/enum"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("colorEnum.java") @@ -1804,7 +1805,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInEquals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/equals"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/equals"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("EqOperator.java") @@ -1847,7 +1848,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInField() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/field"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/field"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("classChildExtendsBase.java") @@ -1925,7 +1926,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInFor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/for"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/for"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("arrayIndicesReversed.java") @@ -2158,7 +2159,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInForeachStatement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/foreachStatement"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/foreachStatement"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("enhancedForWithBlock.java") @@ -2201,7 +2202,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInFormatting() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/formatting"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/formatting"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("chainedCall.java") @@ -2254,7 +2255,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/function"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/function"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("classGenericParam.java") @@ -2437,7 +2438,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInIdentifier() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/identifier"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/identifier"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("finalFieldReference.java") @@ -2465,7 +2466,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInIfStatement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/ifStatement"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/ifStatement"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("assignmentAsExpressionInIf.java") @@ -2518,7 +2519,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInImportStatement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/importStatement"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/importStatement"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("importWithKeywords.java") @@ -2556,7 +2557,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInInheritance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/inheritance"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/inheritance"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("classOneExtendsBaseGeneric.java") @@ -2594,7 +2595,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInIsOperator() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/isOperator"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/isOperator"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("complicatedExpression.java") @@ -2622,7 +2623,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInIssues() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/issues"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/issues"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("arrayLength.java") @@ -2860,7 +2861,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInKotlinApiAccess() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/kotlinApiAccess"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/kotlinApiAccess"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("ClassObjectMembers.java") @@ -2968,7 +2969,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInLabelStatement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/labelStatement"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/labelStatement"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("complicatedExampleFromJavaTutorial.java") @@ -2986,7 +2987,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInList() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/list"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/list"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("ForEach.java") @@ -3009,7 +3010,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInLiteralExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/literalExpression"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/literalExpression"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("char.java") @@ -3097,7 +3098,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInLocalVariable() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/localVariable"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/localVariable"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("autoBangBang.java") @@ -3155,7 +3156,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInMethodCallExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/methodCallExpression"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/methodCallExpression"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("callWithKeywords.java") @@ -3233,7 +3234,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInMisc() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/misc"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/misc"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("packageWithClass.java") @@ -3276,7 +3277,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInMutableCollections() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/mutableCollections"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/mutableCollections"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("FunctionParameters.java") @@ -3329,7 +3330,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInNewClassExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/newClassExpression"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/newClassExpression"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("classWithParam.java") @@ -3417,7 +3418,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInNullability() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/nullability"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/nullability"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("autoNotNull.java") @@ -3615,7 +3616,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInObjectLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/objectLiteral"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/objectLiteral"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("MyFrame.java") @@ -3643,7 +3644,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInOverloads() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/overloads"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/overloads"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("Annotations.java") @@ -3681,7 +3682,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInPackageStatement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/packageStatement"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/packageStatement"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("keywordInPackageName.java") @@ -3699,7 +3700,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInParenthesizedExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/parenthesizedExpression"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/parenthesizedExpression"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("parenthesized.java") @@ -3722,7 +3723,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInPolyadicExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/polyadicExpression"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/polyadicExpression"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("divide.java") @@ -3765,7 +3766,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInPostProcessing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/postProcessing"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/postProcessing"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("AnonymousObject.java") @@ -3838,7 +3839,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInPostfixOperator() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/postfixOperator"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/postfixOperator"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("decrement.java") @@ -3861,7 +3862,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInPrefixOperator() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/prefixOperator"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/prefixOperator"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("decrement.java") @@ -3904,7 +3905,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInProjections() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/projections"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/projections"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("projections.java") @@ -3922,7 +3923,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInProtected() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/protected"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/protected"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("constructorProperty.java") @@ -3970,7 +3971,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInRawGenerics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/rawGenerics"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/rawGenerics"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("kt-540.java") @@ -4003,7 +4004,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInReturnStatement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/returnStatement"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/returnStatement"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("currentMethodBug.java") @@ -4041,7 +4042,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInSettings() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/settings"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/settings"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("openByDefault.java") @@ -4074,7 +4075,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInStaticMembers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/staticMembers"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/staticMembers"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("PrivateStaticMembers.java") @@ -4112,7 +4113,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInStrings() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/strings"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/strings"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("escapedBackslash.java") @@ -4140,7 +4141,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInSuperExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/superExpression"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/superExpression"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("classAdotSuperFoo.java") @@ -4168,7 +4169,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInSwitch() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/switch"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/switch"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("caseWithBlock.java") @@ -4261,7 +4262,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInSynchronizedStatement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/synchronizedStatement"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/synchronizedStatement"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("singleLineExample.java") @@ -4279,7 +4280,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInThisExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/thisExpression"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/thisExpression"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("classAdotThisFoo.java") @@ -4302,7 +4303,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInThrowStatement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/throwStatement"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/throwStatement"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("simpleThrowStatement.java") @@ -4320,7 +4321,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInToArray() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/toArray"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/toArray"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("toArray.java") @@ -4338,7 +4339,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInToKotlinClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/toKotlinClasses"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/toKotlinClasses"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("iterableAndIterator.java") @@ -4381,7 +4382,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInTrait() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/trait"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/trait"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("emptyInterface.java") @@ -4444,7 +4445,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInTryStatement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/tryStatement"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/tryStatement"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("commonCaseForTryStatement.java") @@ -4482,7 +4483,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInTryWithResource() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/tryWithResource"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/tryWithResource"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("Multiline.java") @@ -4545,7 +4546,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInTypeCastExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/typeCastExpression"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/typeCastExpression"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("beforeDot.java") @@ -4613,7 +4614,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInTypeParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/typeParameters"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/typeParameters"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("classDoubleParametrizationWithTwoBoundsWithExtending.java") @@ -4701,7 +4702,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInVarArg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/varArg"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/varArg"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("ellipsisTypeSeveralParams.java") @@ -4724,7 +4725,7 @@ public class JavaToKotlinConverterForWebDemoTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInWhileStatement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/whileStatement"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/whileStatement"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("whileWithAssignmentAsExpression.java") diff --git a/j2k/tests/org/jetbrains/kotlin/j2k/JavaToKotlinConverterMultiFileTestGenerated.java b/j2k/tests/org/jetbrains/kotlin/j2k/JavaToKotlinConverterMultiFileTestGenerated.java index 5bfcd1caa12..c0c8fa6d8aa 100644 --- a/j2k/tests/org/jetbrains/kotlin/j2k/JavaToKotlinConverterMultiFileTestGenerated.java +++ b/j2k/tests/org/jetbrains/kotlin/j2k/JavaToKotlinConverterMultiFileTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.j2k; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class JavaToKotlinConverterMultiFileTestGenerated extends AbstractJavaToK } public void testAllFilesPresentInMultiFile() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/multiFile"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/multiFile"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("AnnotationWithArrayParameter") diff --git a/j2k/tests/org/jetbrains/kotlin/j2k/JavaToKotlinConverterSingleFileTestGenerated.java b/j2k/tests/org/jetbrains/kotlin/j2k/JavaToKotlinConverterSingleFileTestGenerated.java index c7bbad32c8e..d5c168286fc 100644 --- a/j2k/tests/org/jetbrains/kotlin/j2k/JavaToKotlinConverterSingleFileTestGenerated.java +++ b/j2k/tests/org/jetbrains/kotlin/j2k/JavaToKotlinConverterSingleFileTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.j2k; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInFileOrElement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("j2k/testData/fileOrElement/annotations") @@ -37,7 +38,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/annotations"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/annotations"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("annotationArrayArgument.java") @@ -140,7 +141,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInAnonymousBlock() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/anonymousBlock"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/anonymousBlock"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("oneAnonBlock.java") @@ -163,7 +164,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInAnonymousClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/anonymousClass"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/anonymousClass"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("kt-13146.java") @@ -186,7 +187,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInArrayAccessExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/arrayAccessExpression"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/arrayAccessExpression"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("expressionIndex.java") @@ -214,7 +215,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInArrayInitializerExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/arrayInitializerExpression"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/arrayInitializerExpression"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("doubleArray.java") @@ -287,7 +288,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInArrayType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/arrayType"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/arrayType"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("arrayInitializationStatement.java") @@ -350,7 +351,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInAssertStatement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/assertStatement"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/assertStatement"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("assertNotNull.java") @@ -388,7 +389,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInAssignmentExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/assignmentExpression"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/assignmentExpression"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("and.java") @@ -491,7 +492,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInBinaryExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/binaryExpression"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/binaryExpression"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("and.java") @@ -604,7 +605,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInBlocks() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/blocks"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/blocks"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("Blocks.java") @@ -622,7 +623,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInBoxedType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/boxedType"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/boxedType"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("boolean.java") @@ -690,7 +691,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInBreakStatement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/breakStatement"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/breakStatement"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("breakWithLabel.java") @@ -713,7 +714,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInCallChainExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/callChainExpression"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/callChainExpression"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("libraryFieldCall.java") @@ -766,7 +767,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/class"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/class"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("anonymousClass.java") @@ -944,7 +945,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInClassExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/classExpression"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/classExpression"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("complexExample.java") @@ -977,7 +978,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInComments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/comments"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/comments"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("commentInsideCall.java") @@ -1025,7 +1026,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInConditionalExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/conditionalExpression"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/conditionalExpression"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("multiline.java") @@ -1058,7 +1059,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/constructors"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/constructors"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("artificialPrimary.java") @@ -1266,7 +1267,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInContinueStatement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/continueStatement"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/continueStatement"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("continueWithLabel.java") @@ -1289,7 +1290,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInDeclarationStatement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/declarationStatement"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/declarationStatement"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("multiplyFinalIntDeclaration.java") @@ -1347,7 +1348,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInDetectProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/detectProperties"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/detectProperties"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("AnonymousClass.java") @@ -1575,7 +1576,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInDoWhileStatement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/doWhileStatement"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/doWhileStatement"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("whileWithAssignmentAsExpression.java") @@ -1618,7 +1619,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInDocComments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/docComments"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/docComments"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("deprecatedDocTag.java") @@ -1701,7 +1702,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/enum"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/enum"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("colorEnum.java") @@ -1804,7 +1805,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInEquals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/equals"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/equals"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("EqOperator.java") @@ -1847,7 +1848,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInField() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/field"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/field"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("classChildExtendsBase.java") @@ -1925,7 +1926,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInFor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/for"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/for"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("arrayIndicesReversed.java") @@ -2158,7 +2159,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInForeachStatement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/foreachStatement"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/foreachStatement"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("enhancedForWithBlock.java") @@ -2201,7 +2202,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInFormatting() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/formatting"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/formatting"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("chainedCall.java") @@ -2254,7 +2255,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/function"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/function"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("classGenericParam.java") @@ -2437,7 +2438,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInIdentifier() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/identifier"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/identifier"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("finalFieldReference.java") @@ -2465,7 +2466,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInIfStatement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/ifStatement"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/ifStatement"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("assignmentAsExpressionInIf.java") @@ -2518,7 +2519,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInImportStatement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/importStatement"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/importStatement"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("importWithKeywords.java") @@ -2556,7 +2557,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInInheritance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/inheritance"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/inheritance"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("classOneExtendsBaseGeneric.java") @@ -2594,7 +2595,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInIsOperator() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/isOperator"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/isOperator"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("complicatedExpression.java") @@ -2622,7 +2623,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInIssues() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/issues"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/issues"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("arrayLength.java") @@ -2860,7 +2861,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInKotlinApiAccess() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/kotlinApiAccess"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/kotlinApiAccess"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("ClassObjectMembers.java") @@ -2968,7 +2969,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInLabelStatement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/labelStatement"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/labelStatement"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("complicatedExampleFromJavaTutorial.java") @@ -2986,7 +2987,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInList() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/list"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/list"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("ForEach.java") @@ -3009,7 +3010,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInLiteralExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/literalExpression"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/literalExpression"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("char.java") @@ -3097,7 +3098,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInLocalVariable() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/localVariable"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/localVariable"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("autoBangBang.java") @@ -3155,7 +3156,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInMethodCallExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/methodCallExpression"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/methodCallExpression"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("callWithKeywords.java") @@ -3233,7 +3234,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInMisc() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/misc"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/misc"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("packageWithClass.java") @@ -3276,7 +3277,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInMutableCollections() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/mutableCollections"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/mutableCollections"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("FunctionParameters.java") @@ -3329,7 +3330,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInNewClassExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/newClassExpression"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/newClassExpression"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("classWithParam.java") @@ -3417,7 +3418,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInNullability() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/nullability"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/nullability"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("autoNotNull.java") @@ -3615,7 +3616,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInObjectLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/objectLiteral"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/objectLiteral"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("MyFrame.java") @@ -3643,7 +3644,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInOverloads() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/overloads"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/overloads"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("Annotations.java") @@ -3681,7 +3682,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInPackageStatement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/packageStatement"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/packageStatement"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("keywordInPackageName.java") @@ -3699,7 +3700,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInParenthesizedExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/parenthesizedExpression"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/parenthesizedExpression"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("parenthesized.java") @@ -3722,7 +3723,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInPolyadicExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/polyadicExpression"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/polyadicExpression"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("divide.java") @@ -3765,7 +3766,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInPostProcessing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/postProcessing"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/postProcessing"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("AnonymousObject.java") @@ -3838,7 +3839,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInPostfixOperator() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/postfixOperator"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/postfixOperator"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("decrement.java") @@ -3861,7 +3862,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInPrefixOperator() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/prefixOperator"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/prefixOperator"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("decrement.java") @@ -3904,7 +3905,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInProjections() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/projections"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/projections"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("projections.java") @@ -3922,7 +3923,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInProtected() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/protected"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/protected"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("constructorProperty.java") @@ -3970,7 +3971,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInRawGenerics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/rawGenerics"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/rawGenerics"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("kt-540.java") @@ -4003,7 +4004,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInReturnStatement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/returnStatement"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/returnStatement"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("currentMethodBug.java") @@ -4041,7 +4042,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInSettings() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/settings"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/settings"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("openByDefault.java") @@ -4074,7 +4075,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInStaticMembers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/staticMembers"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/staticMembers"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("PrivateStaticMembers.java") @@ -4112,7 +4113,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInStrings() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/strings"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/strings"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("escapedBackslash.java") @@ -4140,7 +4141,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInSuperExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/superExpression"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/superExpression"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("classAdotSuperFoo.java") @@ -4168,7 +4169,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInSwitch() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/switch"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/switch"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("caseWithBlock.java") @@ -4261,7 +4262,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInSynchronizedStatement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/synchronizedStatement"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/synchronizedStatement"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("singleLineExample.java") @@ -4279,7 +4280,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInThisExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/thisExpression"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/thisExpression"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("classAdotThisFoo.java") @@ -4302,7 +4303,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInThrowStatement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/throwStatement"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/throwStatement"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("simpleThrowStatement.java") @@ -4320,7 +4321,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInToArray() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/toArray"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/toArray"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("toArray.java") @@ -4338,7 +4339,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInToKotlinClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/toKotlinClasses"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/toKotlinClasses"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("iterableAndIterator.java") @@ -4381,7 +4382,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInTrait() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/trait"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/trait"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("emptyInterface.java") @@ -4444,7 +4445,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInTryStatement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/tryStatement"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/tryStatement"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("commonCaseForTryStatement.java") @@ -4482,7 +4483,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInTryWithResource() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/tryWithResource"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/tryWithResource"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("Multiline.java") @@ -4545,7 +4546,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInTypeCastExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/typeCastExpression"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/typeCastExpression"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("beforeDot.java") @@ -4613,7 +4614,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInTypeParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/typeParameters"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/typeParameters"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("classDoubleParametrizationWithTwoBoundsWithExtending.java") @@ -4701,7 +4702,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInVarArg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/varArg"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/varArg"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("ellipsisTypeSeveralParams.java") @@ -4724,7 +4725,7 @@ public class JavaToKotlinConverterSingleFileTestGenerated extends AbstractJavaTo } public void testAllFilesPresentInWhileStatement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/whileStatement"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("j2k/testData/fileOrElement/whileStatement"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("whileWithAssignmentAsExpression.java") diff --git a/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/DataContainerVersionChangedTestGenerated.java b/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/DataContainerVersionChangedTestGenerated.java index d6b3b3a2f72..79b5c1e45c2 100644 --- a/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/DataContainerVersionChangedTestGenerated.java +++ b/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/DataContainerVersionChangedTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.jps.build; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class DataContainerVersionChangedTestGenerated extends AbstractDataContai } public void testAllFilesPresentInCacheVersionChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/cacheVersionChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/cacheVersionChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("clearedHasKotlin") @@ -92,7 +93,7 @@ public class DataContainerVersionChangedTestGenerated extends AbstractDataContai } public void testAllFilesPresentInClearedHasKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/cacheVersionChanged/clearedHasKotlin"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/cacheVersionChanged/clearedHasKotlin"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -105,7 +106,7 @@ public class DataContainerVersionChangedTestGenerated extends AbstractDataContai } public void testAllFilesPresentInExportedModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/cacheVersionChanged/exportedModule"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/cacheVersionChanged/exportedModule"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -118,7 +119,7 @@ public class DataContainerVersionChangedTestGenerated extends AbstractDataContai } public void testAllFilesPresentInJavaOnlyModulesAreNotAffected() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/cacheVersionChanged/javaOnlyModulesAreNotAffected"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/cacheVersionChanged/javaOnlyModulesAreNotAffected"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -131,7 +132,7 @@ public class DataContainerVersionChangedTestGenerated extends AbstractDataContai } public void testAllFilesPresentInModule1Modified() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/cacheVersionChanged/module1Modified"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/cacheVersionChanged/module1Modified"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -144,7 +145,7 @@ public class DataContainerVersionChangedTestGenerated extends AbstractDataContai } public void testAllFilesPresentInModule2Modified() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/cacheVersionChanged/module2Modified"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/cacheVersionChanged/module2Modified"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -157,7 +158,7 @@ public class DataContainerVersionChangedTestGenerated extends AbstractDataContai } public void testAllFilesPresentInModuleWithConstantModified() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/cacheVersionChanged/moduleWithConstantModified"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/cacheVersionChanged/moduleWithConstantModified"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -170,7 +171,7 @@ public class DataContainerVersionChangedTestGenerated extends AbstractDataContai } public void testAllFilesPresentInModuleWithInlineModified() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/cacheVersionChanged/moduleWithInlineModified"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/cacheVersionChanged/moduleWithInlineModified"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -183,7 +184,7 @@ public class DataContainerVersionChangedTestGenerated extends AbstractDataContai } public void testAllFilesPresentInTouchedFile() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/cacheVersionChanged/touchedFile"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/cacheVersionChanged/touchedFile"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -196,7 +197,7 @@ public class DataContainerVersionChangedTestGenerated extends AbstractDataContai } public void testAllFilesPresentInTouchedOnlyJavaFile() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/cacheVersionChanged/touchedOnlyJavaFile"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/cacheVersionChanged/touchedOnlyJavaFile"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -209,7 +210,7 @@ public class DataContainerVersionChangedTestGenerated extends AbstractDataContai } public void testAllFilesPresentInUntouchedFiles() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/cacheVersionChanged/untouchedFiles"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/cacheVersionChanged/untouchedFiles"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -222,7 +223,7 @@ public class DataContainerVersionChangedTestGenerated extends AbstractDataContai } public void testAllFilesPresentInWithError() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/cacheVersionChanged/withError"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/cacheVersionChanged/withError"), Pattern.compile("^([^\\.]+)$"), null, true); } } } diff --git a/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/IncrementalCacheVersionChangedTestGenerated.java b/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/IncrementalCacheVersionChangedTestGenerated.java index d61b539b7df..dba3c2db6f2 100644 --- a/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/IncrementalCacheVersionChangedTestGenerated.java +++ b/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/IncrementalCacheVersionChangedTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.jps.build; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class IncrementalCacheVersionChangedTestGenerated extends AbstractIncreme } public void testAllFilesPresentInCacheVersionChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/cacheVersionChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/cacheVersionChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("clearedHasKotlin") @@ -92,7 +93,7 @@ public class IncrementalCacheVersionChangedTestGenerated extends AbstractIncreme } public void testAllFilesPresentInClearedHasKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/cacheVersionChanged/clearedHasKotlin"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/cacheVersionChanged/clearedHasKotlin"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -105,7 +106,7 @@ public class IncrementalCacheVersionChangedTestGenerated extends AbstractIncreme } public void testAllFilesPresentInExportedModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/cacheVersionChanged/exportedModule"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/cacheVersionChanged/exportedModule"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -118,7 +119,7 @@ public class IncrementalCacheVersionChangedTestGenerated extends AbstractIncreme } public void testAllFilesPresentInJavaOnlyModulesAreNotAffected() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/cacheVersionChanged/javaOnlyModulesAreNotAffected"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/cacheVersionChanged/javaOnlyModulesAreNotAffected"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -131,7 +132,7 @@ public class IncrementalCacheVersionChangedTestGenerated extends AbstractIncreme } public void testAllFilesPresentInModule1Modified() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/cacheVersionChanged/module1Modified"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/cacheVersionChanged/module1Modified"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -144,7 +145,7 @@ public class IncrementalCacheVersionChangedTestGenerated extends AbstractIncreme } public void testAllFilesPresentInModule2Modified() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/cacheVersionChanged/module2Modified"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/cacheVersionChanged/module2Modified"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -157,7 +158,7 @@ public class IncrementalCacheVersionChangedTestGenerated extends AbstractIncreme } public void testAllFilesPresentInModuleWithConstantModified() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/cacheVersionChanged/moduleWithConstantModified"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/cacheVersionChanged/moduleWithConstantModified"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -170,7 +171,7 @@ public class IncrementalCacheVersionChangedTestGenerated extends AbstractIncreme } public void testAllFilesPresentInModuleWithInlineModified() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/cacheVersionChanged/moduleWithInlineModified"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/cacheVersionChanged/moduleWithInlineModified"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -183,7 +184,7 @@ public class IncrementalCacheVersionChangedTestGenerated extends AbstractIncreme } public void testAllFilesPresentInTouchedFile() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/cacheVersionChanged/touchedFile"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/cacheVersionChanged/touchedFile"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -196,7 +197,7 @@ public class IncrementalCacheVersionChangedTestGenerated extends AbstractIncreme } public void testAllFilesPresentInTouchedOnlyJavaFile() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/cacheVersionChanged/touchedOnlyJavaFile"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/cacheVersionChanged/touchedOnlyJavaFile"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -209,7 +210,7 @@ public class IncrementalCacheVersionChangedTestGenerated extends AbstractIncreme } public void testAllFilesPresentInUntouchedFiles() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/cacheVersionChanged/untouchedFiles"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/cacheVersionChanged/untouchedFiles"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -222,7 +223,7 @@ public class IncrementalCacheVersionChangedTestGenerated extends AbstractIncreme } public void testAllFilesPresentInWithError() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/cacheVersionChanged/withError"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/cacheVersionChanged/withError"), Pattern.compile("^([^\\.]+)$"), null, true); } } } diff --git a/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/IncrementalJsJpsTestGenerated.java b/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/IncrementalJsJpsTestGenerated.java index 6f9c4fcddcd..e181fc85bed 100644 --- a/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/IncrementalJsJpsTestGenerated.java +++ b/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/IncrementalJsJpsTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.jps.build; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class IncrementalJsJpsTestGenerated extends AbstractIncrementalJsJpsTest } public void testAllFilesPresentInCommon() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("classAdded") @@ -157,7 +158,7 @@ public class IncrementalJsJpsTestGenerated extends AbstractIncrementalJsJpsTest } public void testAllFilesPresentInClassAdded() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/classAdded"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/classAdded"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -170,7 +171,7 @@ public class IncrementalJsJpsTestGenerated extends AbstractIncrementalJsJpsTest } public void testAllFilesPresentInClassRemoved() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/classRemoved"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/classRemoved"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -183,7 +184,7 @@ public class IncrementalJsJpsTestGenerated extends AbstractIncrementalJsJpsTest } public void testAllFilesPresentInConstantValueChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/constantValueChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/constantValueChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -196,7 +197,7 @@ public class IncrementalJsJpsTestGenerated extends AbstractIncrementalJsJpsTest } public void testAllFilesPresentInCopyFileToAnotherModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/copyFileToAnotherModule"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/copyFileToAnotherModule"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -209,7 +210,7 @@ public class IncrementalJsJpsTestGenerated extends AbstractIncrementalJsJpsTest } public void testAllFilesPresentInDefaultArgumentInConstructorRemoved() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/defaultArgumentInConstructorRemoved"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/defaultArgumentInConstructorRemoved"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -222,7 +223,7 @@ public class IncrementalJsJpsTestGenerated extends AbstractIncrementalJsJpsTest } public void testAllFilesPresentInDefaultParameterAdded() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/defaultParameterAdded"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/defaultParameterAdded"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -235,7 +236,7 @@ public class IncrementalJsJpsTestGenerated extends AbstractIncrementalJsJpsTest } public void testAllFilesPresentInDefaultParameterAddedForTopLevelFun() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/defaultParameterAddedForTopLevelFun"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/defaultParameterAddedForTopLevelFun"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -248,7 +249,7 @@ public class IncrementalJsJpsTestGenerated extends AbstractIncrementalJsJpsTest } public void testAllFilesPresentInDefaultParameterRemoved() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/defaultParameterRemoved"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/defaultParameterRemoved"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -261,7 +262,7 @@ public class IncrementalJsJpsTestGenerated extends AbstractIncrementalJsJpsTest } public void testAllFilesPresentInDefaultParameterRemovedForTopLevelFun() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/defaultParameterRemovedForTopLevelFun"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/defaultParameterRemovedForTopLevelFun"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -274,7 +275,7 @@ public class IncrementalJsJpsTestGenerated extends AbstractIncrementalJsJpsTest } public void testAllFilesPresentInDefaultValueInConstructorRemoved() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/defaultValueInConstructorRemoved"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/defaultValueInConstructorRemoved"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -287,7 +288,7 @@ public class IncrementalJsJpsTestGenerated extends AbstractIncrementalJsJpsTest } public void testAllFilesPresentInDuplicatedClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/duplicatedClass"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/duplicatedClass"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -300,7 +301,7 @@ public class IncrementalJsJpsTestGenerated extends AbstractIncrementalJsJpsTest } public void testAllFilesPresentInExportedDependency() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/exportedDependency"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/exportedDependency"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -313,7 +314,7 @@ public class IncrementalJsJpsTestGenerated extends AbstractIncrementalJsJpsTest } public void testAllFilesPresentInFunctionFromDifferentPackageChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/functionFromDifferentPackageChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/functionFromDifferentPackageChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -326,7 +327,7 @@ public class IncrementalJsJpsTestGenerated extends AbstractIncrementalJsJpsTest } public void testAllFilesPresentInInlineFunctionInlined() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/inlineFunctionInlined"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/inlineFunctionInlined"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -339,7 +340,7 @@ public class IncrementalJsJpsTestGenerated extends AbstractIncrementalJsJpsTest } public void testAllFilesPresentInInlineFunctionTwoPackageParts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/inlineFunctionTwoPackageParts"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/inlineFunctionTwoPackageParts"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -352,7 +353,7 @@ public class IncrementalJsJpsTestGenerated extends AbstractIncrementalJsJpsTest } public void testAllFilesPresentInMoveFileToAnotherModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/moveFileToAnotherModule"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/moveFileToAnotherModule"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -365,7 +366,7 @@ public class IncrementalJsJpsTestGenerated extends AbstractIncrementalJsJpsTest } public void testAllFilesPresentInSimple() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/simple"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/simple"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -378,7 +379,7 @@ public class IncrementalJsJpsTestGenerated extends AbstractIncrementalJsJpsTest } public void testAllFilesPresentInSimpleDependency() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/simpleDependency"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/simpleDependency"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -391,7 +392,7 @@ public class IncrementalJsJpsTestGenerated extends AbstractIncrementalJsJpsTest } public void testAllFilesPresentInSimpleDependencyErrorOnAccessToInternal1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/simpleDependencyErrorOnAccessToInternal1"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/simpleDependencyErrorOnAccessToInternal1"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -404,7 +405,7 @@ public class IncrementalJsJpsTestGenerated extends AbstractIncrementalJsJpsTest } public void testAllFilesPresentInSimpleDependencyErrorOnAccessToInternal2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/simpleDependencyErrorOnAccessToInternal2"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/simpleDependencyErrorOnAccessToInternal2"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -417,7 +418,7 @@ public class IncrementalJsJpsTestGenerated extends AbstractIncrementalJsJpsTest } public void testAllFilesPresentInSimpleDependencyUnchanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/simpleDependencyUnchanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/simpleDependencyUnchanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -430,7 +431,7 @@ public class IncrementalJsJpsTestGenerated extends AbstractIncrementalJsJpsTest } public void testAllFilesPresentInTransitiveDependency() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/transitiveDependency"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/transitiveDependency"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -443,7 +444,7 @@ public class IncrementalJsJpsTestGenerated extends AbstractIncrementalJsJpsTest } public void testAllFilesPresentInTransitiveInlining() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/transitiveInlining"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/transitiveInlining"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -456,7 +457,7 @@ public class IncrementalJsJpsTestGenerated extends AbstractIncrementalJsJpsTest } public void testAllFilesPresentInTwoDependants() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/twoDependants"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/twoDependants"), Pattern.compile("^([^\\.]+)$"), null, true); } } } diff --git a/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/IncrementalJvmJpsTestGenerated.java b/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/IncrementalJvmJpsTestGenerated.java index d0ce519c09c..99f1a17016e 100644 --- a/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/IncrementalJvmJpsTestGenerated.java +++ b/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/IncrementalJvmJpsTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.jps.build; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -27,7 +28,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInCommon() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("classAdded") @@ -159,7 +160,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInClassAdded() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/classAdded"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/classAdded"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -172,7 +173,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInClassRemoved() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/classRemoved"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/classRemoved"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -185,7 +186,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInConstantValueChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/constantValueChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/constantValueChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -198,7 +199,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInCopyFileToAnotherModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/copyFileToAnotherModule"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/copyFileToAnotherModule"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -211,7 +212,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInDefaultArgumentInConstructorRemoved() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/defaultArgumentInConstructorRemoved"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/defaultArgumentInConstructorRemoved"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -224,7 +225,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInDefaultParameterAdded() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/defaultParameterAdded"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/defaultParameterAdded"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -237,7 +238,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInDefaultParameterAddedForTopLevelFun() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/defaultParameterAddedForTopLevelFun"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/defaultParameterAddedForTopLevelFun"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -250,7 +251,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInDefaultParameterRemoved() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/defaultParameterRemoved"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/defaultParameterRemoved"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -263,7 +264,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInDefaultParameterRemovedForTopLevelFun() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/defaultParameterRemovedForTopLevelFun"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/defaultParameterRemovedForTopLevelFun"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -276,7 +277,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInDefaultValueInConstructorRemoved() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/defaultValueInConstructorRemoved"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/defaultValueInConstructorRemoved"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -289,7 +290,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInDuplicatedClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/duplicatedClass"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/duplicatedClass"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -302,7 +303,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInExportedDependency() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/exportedDependency"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/exportedDependency"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -315,7 +316,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInFunctionFromDifferentPackageChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/functionFromDifferentPackageChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/functionFromDifferentPackageChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -328,7 +329,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInInlineFunctionInlined() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/inlineFunctionInlined"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/inlineFunctionInlined"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -341,7 +342,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInInlineFunctionTwoPackageParts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/inlineFunctionTwoPackageParts"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/inlineFunctionTwoPackageParts"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -354,7 +355,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInMoveFileToAnotherModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/moveFileToAnotherModule"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/moveFileToAnotherModule"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -367,7 +368,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInSimple() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/simple"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/simple"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -380,7 +381,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInSimpleDependency() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/simpleDependency"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/simpleDependency"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -393,7 +394,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInSimpleDependencyErrorOnAccessToInternal1() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/simpleDependencyErrorOnAccessToInternal1"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/simpleDependencyErrorOnAccessToInternal1"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -406,7 +407,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInSimpleDependencyErrorOnAccessToInternal2() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/simpleDependencyErrorOnAccessToInternal2"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/simpleDependencyErrorOnAccessToInternal2"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -419,7 +420,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInSimpleDependencyUnchanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/simpleDependencyUnchanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/simpleDependencyUnchanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -432,7 +433,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInTransitiveDependency() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/transitiveDependency"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/transitiveDependency"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -445,7 +446,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInTransitiveInlining() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/transitiveInlining"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/transitiveInlining"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -458,7 +459,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInTwoDependants() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/twoDependants"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/common/twoDependants"), Pattern.compile("^([^\\.]+)$"), null, true); } } } @@ -472,7 +473,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInJvm() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/jvm"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/jvm"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("circular") @@ -509,7 +510,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInCircular() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/jvm/circular"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/jvm/circular"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -522,7 +523,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInCircularDependencyClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/jvm/circularDependencyClasses"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/jvm/circularDependencyClasses"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -535,7 +536,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInCircularDependencySamePackageUnchanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/jvm/circularDependencySamePackageUnchanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/jvm/circularDependencySamePackageUnchanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -548,7 +549,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInCircularDependencyTopLevelFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/jvm/circularDependencyTopLevelFunctions"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/jvm/circularDependencyTopLevelFunctions"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -561,7 +562,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInCircularDependencyWithAccessToInternal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/jvm/circularDependencyWithAccessToInternal"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/jvm/circularDependencyWithAccessToInternal"), Pattern.compile("^([^\\.]+)$"), null, true); } } } @@ -575,7 +576,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInCustom() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/custom"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/custom"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("buildError") @@ -617,7 +618,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInBuildError() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/custom/buildError"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/custom/buildError"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -630,7 +631,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInBuildError2Levels() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/custom/buildError2Levels"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/custom/buildError2Levels"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -643,7 +644,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInCommonSourcesCompilerArg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/custom/commonSourcesCompilerArg"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/custom/commonSourcesCompilerArg"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -656,7 +657,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInComplementaryFiles() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/custom/complementaryFiles"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/custom/complementaryFiles"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -669,7 +670,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInModifyOptionalAnnotationUsage() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/custom/modifyOptionalAnnotationUsage"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/custom/modifyOptionalAnnotationUsage"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -682,7 +683,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInNotSameCompiler() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/custom/notSameCompiler"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/custom/notSameCompiler"), Pattern.compile("^([^\\.]+)$"), null, true); } } } @@ -731,7 +732,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInPureKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/pureKotlin"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/pureKotlin"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("annotations") @@ -1329,7 +1330,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInWithJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin") @@ -1341,7 +1342,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInConvertBetweenJavaAndKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("javaToKotlin") @@ -1373,7 +1374,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInJavaToKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlin"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlin"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -1386,7 +1387,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInJavaToKotlinAndBack() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlinAndBack"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlinAndBack"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -1399,7 +1400,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInJavaToKotlinAndRemove() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlinAndRemove"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/javaToKotlinAndRemove"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -1412,7 +1413,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInKotlinToJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/kotlinToJava"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/convertBetweenJavaAndKotlin/kotlinToJava"), Pattern.compile("^([^\\.]+)$"), null, true); } } } @@ -1426,7 +1427,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInJavaUsedInKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("changeFieldType") @@ -1533,7 +1534,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInChangeFieldType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeFieldType"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeFieldType"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -1546,7 +1547,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInChangeNotUsedSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeNotUsedSignature"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeNotUsedSignature"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -1559,7 +1560,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInChangePropertyOverrideType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changePropertyOverrideType"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changePropertyOverrideType"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -1572,7 +1573,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInChangeSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignature"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignature"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -1585,7 +1586,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInChangeSignaturePackagePrivate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivate"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivate"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -1598,7 +1599,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInChangeSignaturePackagePrivateNonRoot() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivateNonRoot"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignaturePackagePrivateNonRoot"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -1611,7 +1612,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInChangeSignatureStatic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignatureStatic"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/changeSignatureStatic"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -1624,7 +1625,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInConstantChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -1637,7 +1638,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInConstantUnchanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantUnchanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/constantUnchanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -1650,7 +1651,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInEnumEntryAdded() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/enumEntryAdded"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/enumEntryAdded"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -1663,7 +1664,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInEnumEntryRemoved() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/enumEntryRemoved"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/enumEntryRemoved"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -1676,7 +1677,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInJavaAndKotlinChangedSimultaneously() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaAndKotlinChangedSimultaneously"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaAndKotlinChangedSimultaneously"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -1689,7 +1690,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInJavaFieldNullabilityChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaFieldNullabilityChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaFieldNullabilityChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -1702,7 +1703,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInJavaMethodParamNullabilityChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaMethodParamNullabilityChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaMethodParamNullabilityChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -1715,7 +1716,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInJavaMethodReturnTypeNullabilityChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaMethodReturnTypeNullabilityChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/javaMethodReturnTypeNullabilityChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -1728,7 +1729,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInMethodAddedInSuper() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/methodAddedInSuper"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/methodAddedInSuper"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -1741,7 +1742,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInMethodRenamed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/methodRenamed"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/methodRenamed"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -1754,7 +1755,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInMixedInheritance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/mixedInheritance"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/mixedInheritance"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -1767,7 +1768,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInNotChangeSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/notChangeSignature"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/notChangeSignature"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -1780,7 +1781,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInSamConversions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("methodAdded") @@ -1812,7 +1813,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInMethodAdded() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodAdded"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodAdded"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -1825,7 +1826,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInMethodAddedSamAdapter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodAddedSamAdapter"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodAddedSamAdapter"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -1838,7 +1839,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInMethodSignatureChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodSignatureChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodSignatureChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -1851,7 +1852,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInMethodSignatureChangedSamAdapter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodSignatureChangedSamAdapter"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodSignatureChangedSamAdapter"), Pattern.compile("^([^\\.]+)$"), null, true); } } } @@ -1871,7 +1872,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInKotlinUsedInJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("changeNotUsedSignature") @@ -1948,7 +1949,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInAddOptionalParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/addOptionalParameter"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/addOptionalParameter"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -1961,7 +1962,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInChangeNotUsedSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/changeNotUsedSignature"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/changeNotUsedSignature"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -1974,7 +1975,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInChangeSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/changeSignature"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/changeSignature"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -1987,7 +1988,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInConstantChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/constantChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/constantChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2000,7 +2001,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInConstantUnchanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/constantUnchanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/constantUnchanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2013,7 +2014,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInFunRenamed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/funRenamed"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/funRenamed"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2026,7 +2027,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInJvmFieldChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/jvmFieldChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/jvmFieldChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2039,7 +2040,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInJvmFieldUnchanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/jvmFieldUnchanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/jvmFieldUnchanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2052,7 +2053,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInMethodAddedInSuper() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/methodAddedInSuper"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/methodAddedInSuper"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2065,7 +2066,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInNotChangeSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/notChangeSignature"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/notChangeSignature"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2078,7 +2079,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInOnlyTopLevelFunctionInFileRemoved() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/onlyTopLevelFunctionInFileRemoved"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/onlyTopLevelFunctionInFileRemoved"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2091,7 +2092,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInPackageFileAdded() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/packageFileAdded"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/packageFileAdded"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2104,7 +2105,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInPrivateChanges() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/privateChanges"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/privateChanges"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2117,7 +2118,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInPropertyRenamed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/propertyRenamed"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/kotlinUsedInJava/propertyRenamed"), Pattern.compile("^([^\\.]+)$"), null, true); } } } @@ -2136,7 +2137,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInOther() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("allKotlinFilesRemovedThenNewAdded") @@ -2293,7 +2294,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInAccessingFunctionsViaRenamedFileClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/accessingFunctionsViaRenamedFileClass"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/accessingFunctionsViaRenamedFileClass"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2306,7 +2307,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInAllKotlinFilesRemovedThenNewAdded() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/allKotlinFilesRemovedThenNewAdded"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/allKotlinFilesRemovedThenNewAdded"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2319,7 +2320,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInClassRedeclaration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/classRedeclaration"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/classRedeclaration"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2332,7 +2333,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInClassToPackageFacade() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/classToPackageFacade"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/classToPackageFacade"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2345,7 +2346,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInConflictingPlatformDeclarations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/conflictingPlatformDeclarations"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/conflictingPlatformDeclarations"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2358,7 +2359,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInDefaultValueInConstructorAdded() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/defaultValueInConstructorAdded"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/defaultValueInConstructorAdded"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2371,7 +2372,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInInlineFunctionWithJvmNameInClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/inlineFunctionWithJvmNameInClass"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/inlineFunctionWithJvmNameInClass"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2384,7 +2385,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInInlineTopLevelFunctionWithJvmName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/inlineTopLevelFunctionWithJvmName"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/inlineTopLevelFunctionWithJvmName"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2397,7 +2398,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInInlineTopLevelValPropertyWithJvmName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/inlineTopLevelValPropertyWithJvmName"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/inlineTopLevelValPropertyWithJvmName"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2410,7 +2411,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInInnerClassNotGeneratedWhenRebuilding() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/innerClassNotGeneratedWhenRebuilding"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/innerClassNotGeneratedWhenRebuilding"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2423,7 +2424,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInJvmNameChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/jvmNameChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/jvmNameChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2436,7 +2437,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInMainRedeclaration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/mainRedeclaration"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/mainRedeclaration"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2449,7 +2450,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInMultifileClassAddTopLevelFunWithDefault() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassAddTopLevelFunWithDefault"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassAddTopLevelFunWithDefault"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2462,7 +2463,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInMultifileClassFileAdded() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassFileAdded"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassFileAdded"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2475,7 +2476,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInMultifileClassFileChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassFileChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassFileChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2488,7 +2489,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInMultifileClassFileMovedToAnotherMultifileClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassFileMovedToAnotherMultifileClass"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassFileMovedToAnotherMultifileClass"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2501,7 +2502,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInMultifileClassInlineFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassInlineFunction"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassInlineFunction"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2514,7 +2515,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInMultifileClassInlineFunctionAccessingField() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassInlineFunctionAccessingField"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassInlineFunctionAccessingField"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2527,7 +2528,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInMultifileClassRecreated() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassRecreated"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassRecreated"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2540,7 +2541,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInMultifileClassRecreatedAfterRenaming() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassRecreatedAfterRenaming"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassRecreatedAfterRenaming"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2553,7 +2554,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInMultifileClassRemoved() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassRemoved"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifileClassRemoved"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2566,7 +2567,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInMultifilePackagePartMethodAdded() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifilePackagePartMethodAdded"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifilePackagePartMethodAdded"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2579,7 +2580,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInMultifilePartsWithProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifilePartsWithProperties"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/multifilePartsWithProperties"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2592,7 +2593,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInOptionalParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/optionalParameter"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/optionalParameter"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2605,7 +2606,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInPackageFacadeToClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/packageFacadeToClass"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/packageFacadeToClass"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2618,7 +2619,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInPackageMultifileClassOneFileWithPublicChanges() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/packageMultifileClassOneFileWithPublicChanges"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/packageMultifileClassOneFileWithPublicChanges"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2631,7 +2632,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInPackageMultifileClassPrivateOnlyChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/packageMultifileClassPrivateOnlyChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/packageMultifileClassPrivateOnlyChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2644,7 +2645,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInPublicPropertyWithPrivateSetterMultiFileFacade() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/publicPropertyWithPrivateSetterMultiFileFacade"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/publicPropertyWithPrivateSetterMultiFileFacade"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2657,7 +2658,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInTopLevelFunctionWithJvmName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/topLevelFunctionWithJvmName"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/topLevelFunctionWithJvmName"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2670,7 +2671,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInTopLevelPropertyWithJvmName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/topLevelPropertyWithJvmName"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/withJava/other/topLevelPropertyWithJvmName"), Pattern.compile("^([^\\.]+)$"), null, true); } } } @@ -2685,7 +2686,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInInlineFunCallSite() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("classProperty") @@ -2767,7 +2768,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInClassProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/classProperty"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/classProperty"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2780,7 +2781,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInCompanionObjectProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/companionObjectProperty"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/companionObjectProperty"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2793,7 +2794,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInCoroutine() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/coroutine"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/coroutine"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2806,7 +2807,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/function"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/function"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2819,7 +2820,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInGetter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/getter"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/getter"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2832,7 +2833,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/lambda"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/lambda"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2845,7 +2846,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInLocalFun() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/localFun"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/localFun"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2858,7 +2859,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInMethod() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/method"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/method"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2871,7 +2872,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInParameterDefaultValue() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/parameterDefaultValue"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/parameterDefaultValue"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2884,7 +2885,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInPrimaryConstructorParameterDefaultValue() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/primaryConstructorParameterDefaultValue"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/primaryConstructorParameterDefaultValue"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2897,7 +2898,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInSuperCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/superCall"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/superCall"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2910,7 +2911,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInThisCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/thisCall"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/thisCall"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2923,7 +2924,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInTopLevelObjectProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/topLevelObjectProperty"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/topLevelObjectProperty"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -2936,7 +2937,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInTopLevelProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/topLevelProperty"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/inlineFunCallSite/topLevelProperty"), Pattern.compile("^([^\\.]+)$"), null, true); } } } @@ -2950,7 +2951,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInClassHierarchyAffected() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("annotationFlagRemoved") @@ -3162,7 +3163,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInAnnotationFlagRemoved() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/annotationFlagRemoved"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/annotationFlagRemoved"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -3175,7 +3176,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInAnnotationListChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/annotationListChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/annotationListChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -3188,7 +3189,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInBridgeGenerated() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/bridgeGenerated"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/bridgeGenerated"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -3201,7 +3202,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInClassBecameFinal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/classBecameFinal"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/classBecameFinal"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -3214,7 +3215,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInClassBecameInterface() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/classBecameInterface"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/classBecameInterface"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -3227,7 +3228,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInClassBecamePrivate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/classBecamePrivate"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/classBecamePrivate"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -3240,7 +3241,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInClassMovedIntoOtherClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/classMovedIntoOtherClass"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/classMovedIntoOtherClass"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -3253,7 +3254,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInClassRemoved() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/classRemoved"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/classRemoved"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -3266,7 +3267,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInClassRemovedAndRestored() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/classRemovedAndRestored"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/classRemovedAndRestored"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -3279,7 +3280,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInCompanionObjectInheritedMemberChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/companionObjectInheritedMemberChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/companionObjectInheritedMemberChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -3292,7 +3293,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInCompanionObjectMemberChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/companionObjectMemberChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/companionObjectMemberChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -3305,7 +3306,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInCompanionObjectNameChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/companionObjectNameChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/companionObjectNameChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -3318,7 +3319,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInCompanionObjectToSimpleObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/companionObjectToSimpleObject"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/companionObjectToSimpleObject"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -3331,7 +3332,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInConstructorVisibilityChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/constructorVisibilityChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/constructorVisibilityChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -3344,7 +3345,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInEnumEntryAdded() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/enumEntryAdded"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/enumEntryAdded"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -3357,7 +3358,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInEnumEntryRemoved() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/enumEntryRemoved"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/enumEntryRemoved"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -3370,7 +3371,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInEnumMemberChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/enumMemberChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/enumMemberChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -3383,7 +3384,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInFlagsAndMemberInDifferentClassesChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/flagsAndMemberInDifferentClassesChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/flagsAndMemberInDifferentClassesChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -3396,7 +3397,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInFlagsAndMemberInSameClassChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/flagsAndMemberInSameClassChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/flagsAndMemberInSameClassChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -3409,7 +3410,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInImplcitUpcast() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/implcitUpcast"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/implcitUpcast"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -3422,7 +3423,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInInferredTypeArgumentChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/inferredTypeArgumentChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/inferredTypeArgumentChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -3435,7 +3436,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInInferredTypeChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/inferredTypeChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/inferredTypeChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -3448,7 +3449,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInInterfaceAnyMethods() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/interfaceAnyMethods"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/interfaceAnyMethods"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -3461,7 +3462,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInLambdaParameterAffected() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/lambdaParameterAffected"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/lambdaParameterAffected"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -3474,7 +3475,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInMethodAdded() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/methodAdded"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/methodAdded"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -3487,7 +3488,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInMethodAnnotationAdded() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/methodAnnotationAdded"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/methodAnnotationAdded"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -3500,7 +3501,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInMethodNullabilityChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/methodNullabilityChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/methodNullabilityChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -3513,7 +3514,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInMethodParameterWithDefaultValueAdded() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/methodParameterWithDefaultValueAdded"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/methodParameterWithDefaultValueAdded"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -3526,7 +3527,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInMethodRemoved() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/methodRemoved"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/methodRemoved"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -3539,7 +3540,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInOverrideExplicit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/overrideExplicit"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/overrideExplicit"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -3552,7 +3553,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInOverrideImplicit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/overrideImplicit"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/overrideImplicit"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -3565,7 +3566,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInPropertyNullabilityChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/propertyNullabilityChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/propertyNullabilityChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -3578,7 +3579,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInSealedClassImplAdded() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/sealedClassImplAdded"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/sealedClassImplAdded"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -3591,7 +3592,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInSealedClassIndirectImplAdded() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/sealedClassIndirectImplAdded"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/sealedClassIndirectImplAdded"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -3604,7 +3605,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInSealedClassNestedImplAdded() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/sealedClassNestedImplAdded"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/sealedClassNestedImplAdded"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -3617,7 +3618,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInSecondaryConstructorAdded() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/secondaryConstructorAdded"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/secondaryConstructorAdded"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -3630,7 +3631,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInStarProjectionUpperBoundChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/starProjectionUpperBoundChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/starProjectionUpperBoundChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -3643,7 +3644,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInSupertypesListChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/supertypesListChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/supertypesListChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -3656,7 +3657,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInTypeParameterListChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/typeParameterListChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/typeParameterListChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -3669,7 +3670,7 @@ public class IncrementalJvmJpsTestGenerated extends AbstractIncrementalJvmJpsTes } public void testAllFilesPresentInVarianceChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/varianceChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/classHierarchyAffected/varianceChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } } diff --git a/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/IncrementalLazyCachesTestGenerated.java b/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/IncrementalLazyCachesTestGenerated.java index 45c412b7c16..3f67e15c7bb 100644 --- a/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/IncrementalLazyCachesTestGenerated.java +++ b/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/IncrementalLazyCachesTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.jps.build; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -27,7 +28,7 @@ public class IncrementalLazyCachesTestGenerated extends AbstractIncrementalLazyC } public void testAllFilesPresentInLazyKotlinCaches() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/lazyKotlinCaches"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/lazyKotlinCaches"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("class") @@ -79,7 +80,7 @@ public class IncrementalLazyCachesTestGenerated extends AbstractIncrementalLazyC } public void testAllFilesPresentInClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/lazyKotlinCaches/class"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/lazyKotlinCaches/class"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -92,7 +93,7 @@ public class IncrementalLazyCachesTestGenerated extends AbstractIncrementalLazyC } public void testAllFilesPresentInClassInheritance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/lazyKotlinCaches/classInheritance"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/lazyKotlinCaches/classInheritance"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -105,7 +106,7 @@ public class IncrementalLazyCachesTestGenerated extends AbstractIncrementalLazyC } public void testAllFilesPresentInConstant() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/lazyKotlinCaches/constant"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/lazyKotlinCaches/constant"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -118,7 +119,7 @@ public class IncrementalLazyCachesTestGenerated extends AbstractIncrementalLazyC } public void testAllFilesPresentInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/lazyKotlinCaches/function"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/lazyKotlinCaches/function"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -131,7 +132,7 @@ public class IncrementalLazyCachesTestGenerated extends AbstractIncrementalLazyC } public void testAllFilesPresentInInlineFunctionWithUsage() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/lazyKotlinCaches/inlineFunctionWithUsage"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/lazyKotlinCaches/inlineFunctionWithUsage"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -144,7 +145,7 @@ public class IncrementalLazyCachesTestGenerated extends AbstractIncrementalLazyC } public void testAllFilesPresentInInlineFunctionWithoutUsage() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/lazyKotlinCaches/inlineFunctionWithoutUsage"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/lazyKotlinCaches/inlineFunctionWithoutUsage"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -157,7 +158,7 @@ public class IncrementalLazyCachesTestGenerated extends AbstractIncrementalLazyC } public void testAllFilesPresentInNoKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/lazyKotlinCaches/noKotlin"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/lazyKotlinCaches/noKotlin"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -170,7 +171,7 @@ public class IncrementalLazyCachesTestGenerated extends AbstractIncrementalLazyC } public void testAllFilesPresentInTopLevelPropertyAccess() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/lazyKotlinCaches/topLevelPropertyAccess"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/lazyKotlinCaches/topLevelPropertyAccess"), Pattern.compile("^([^\\.]+)$"), null, true); } } } @@ -184,7 +185,7 @@ public class IncrementalLazyCachesTestGenerated extends AbstractIncrementalLazyC } public void testAllFilesPresentInChangeIncrementalOption() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/changeIncrementalOption"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/changeIncrementalOption"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("incrementalOff") @@ -216,7 +217,7 @@ public class IncrementalLazyCachesTestGenerated extends AbstractIncrementalLazyC } public void testAllFilesPresentInIncrementalOff() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/changeIncrementalOption/incrementalOff"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/changeIncrementalOption/incrementalOff"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -229,7 +230,7 @@ public class IncrementalLazyCachesTestGenerated extends AbstractIncrementalLazyC } public void testAllFilesPresentInIncrementalOffOn() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/changeIncrementalOption/incrementalOffOn"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/changeIncrementalOption/incrementalOffOn"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -242,7 +243,7 @@ public class IncrementalLazyCachesTestGenerated extends AbstractIncrementalLazyC } public void testAllFilesPresentInIncrementalOffOnJavaChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/changeIncrementalOption/incrementalOffOnJavaChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/changeIncrementalOption/incrementalOffOnJavaChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -255,7 +256,7 @@ public class IncrementalLazyCachesTestGenerated extends AbstractIncrementalLazyC } public void testAllFilesPresentInIncrementalOffOnJavaOnly() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/changeIncrementalOption/incrementalOffOnJavaOnly"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/changeIncrementalOption/incrementalOffOnJavaOnly"), Pattern.compile("^([^\\.]+)$"), null, true); } } } diff --git a/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/JsKlibLookupTrackerTestGenerated.java b/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/JsKlibLookupTrackerTestGenerated.java index 7ad7897706c..8b59e851b06 100644 --- a/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/JsKlibLookupTrackerTestGenerated.java +++ b/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/JsKlibLookupTrackerTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.jps.build; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class JsKlibLookupTrackerTestGenerated extends AbstractJsKlibLookupTracke } public void testAllFilesPresentInJsKlib() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/lookupTracker/jsKlib"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/lookupTracker/jsKlib"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("classifierMembers") diff --git a/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/JsLookupTrackerTestGenerated.java b/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/JsLookupTrackerTestGenerated.java index 1a4462e6cb6..89e80da5ae6 100644 --- a/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/JsLookupTrackerTestGenerated.java +++ b/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/JsLookupTrackerTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.jps.build; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class JsLookupTrackerTestGenerated extends AbstractJsLookupTrackerTest { } public void testAllFilesPresentInJs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/lookupTracker/js"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/lookupTracker/js"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("classifierMembers") diff --git a/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/JvmLookupTrackerTestGenerated.java b/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/JvmLookupTrackerTestGenerated.java index 204bef71086..3403a74d25d 100644 --- a/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/JvmLookupTrackerTestGenerated.java +++ b/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/JvmLookupTrackerTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.jps.build; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class JvmLookupTrackerTestGenerated extends AbstractJvmLookupTrackerTest } public void testAllFilesPresentInJvm() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/lookupTracker/jvm"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/lookupTracker/jvm"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("classifierMembers") diff --git a/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/MultiplatformJpsTestWithGeneratedContentGenerated.java b/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/MultiplatformJpsTestWithGeneratedContentGenerated.java index 9c7d95d8d53..27653a6270b 100644 --- a/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/MultiplatformJpsTestWithGeneratedContentGenerated.java +++ b/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/MultiplatformJpsTestWithGeneratedContentGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.jps.build; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class MultiplatformJpsTestWithGeneratedContentGenerated extends AbstractM } public void testAllFilesPresentInMultiplatformMultiModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ignoreAndWarnAboutNative") @@ -37,7 +38,7 @@ public class MultiplatformJpsTestWithGeneratedContentGenerated extends AbstractM } public void testAllFilesPresentInIgnoreAndWarnAboutNative() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ignoreAndWarnAboutNative"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ignoreAndWarnAboutNative"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("editingCKotlin") @@ -54,7 +55,7 @@ public class MultiplatformJpsTestWithGeneratedContentGenerated extends AbstractM } public void testAllFilesPresentInEditingCKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ignoreAndWarnAboutNative/editingCKotlin"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ignoreAndWarnAboutNative/editingCKotlin"), Pattern.compile("^([^\\.]+)$"), null, true); } } } @@ -68,7 +69,7 @@ public class MultiplatformJpsTestWithGeneratedContentGenerated extends AbstractM } public void testAllFilesPresentInSimple() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simple"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simple"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("editingCKotlin") @@ -100,7 +101,7 @@ public class MultiplatformJpsTestWithGeneratedContentGenerated extends AbstractM } public void testAllFilesPresentInEditingCKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simple/editingCKotlin"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simple/editingCKotlin"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -113,7 +114,7 @@ public class MultiplatformJpsTestWithGeneratedContentGenerated extends AbstractM } public void testAllFilesPresentInEditingPJsKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simple/editingPJsKotlin"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simple/editingPJsKotlin"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -126,7 +127,7 @@ public class MultiplatformJpsTestWithGeneratedContentGenerated extends AbstractM } public void testAllFilesPresentInEditingPJvmJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simple/editingPJvmJava"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simple/editingPJvmJava"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -139,7 +140,7 @@ public class MultiplatformJpsTestWithGeneratedContentGenerated extends AbstractM } public void testAllFilesPresentInEditingPJvmKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simple/editingPJvmKotlin"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simple/editingPJvmKotlin"), Pattern.compile("^([^\\.]+)$"), null, true); } } } @@ -153,7 +154,7 @@ public class MultiplatformJpsTestWithGeneratedContentGenerated extends AbstractM } public void testAllFilesPresentInSimpleJsJvmProjectWithTests() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simpleJsJvmProjectWithTests"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simpleJsJvmProjectWithTests"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("editingCMainExpectActual") @@ -175,7 +176,7 @@ public class MultiplatformJpsTestWithGeneratedContentGenerated extends AbstractM } public void testAllFilesPresentInEditingCMainExpectActual() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simpleJsJvmProjectWithTests/editingCMainExpectActual"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simpleJsJvmProjectWithTests/editingCMainExpectActual"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -188,7 +189,7 @@ public class MultiplatformJpsTestWithGeneratedContentGenerated extends AbstractM } public void testAllFilesPresentInEditingCTestsExpectActual() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simpleJsJvmProjectWithTests/editingCTestsExpectActual"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simpleJsJvmProjectWithTests/editingCTestsExpectActual"), Pattern.compile("^([^\\.]+)$"), null, true); } } } @@ -202,7 +203,7 @@ public class MultiplatformJpsTestWithGeneratedContentGenerated extends AbstractM } public void testAllFilesPresentInSimpleNewMpp() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simpleNewMpp"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simpleNewMpp"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("editingCKotlin") @@ -234,7 +235,7 @@ public class MultiplatformJpsTestWithGeneratedContentGenerated extends AbstractM } public void testAllFilesPresentInEditingCKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simpleNewMpp/editingCKotlin"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simpleNewMpp/editingCKotlin"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -247,7 +248,7 @@ public class MultiplatformJpsTestWithGeneratedContentGenerated extends AbstractM } public void testAllFilesPresentInEditingPJsKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simpleNewMpp/editingPJsKotlin"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simpleNewMpp/editingPJsKotlin"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -260,7 +261,7 @@ public class MultiplatformJpsTestWithGeneratedContentGenerated extends AbstractM } public void testAllFilesPresentInEditingPJvmJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simpleNewMpp/editingPJvmJava"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simpleNewMpp/editingPJvmJava"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -273,7 +274,7 @@ public class MultiplatformJpsTestWithGeneratedContentGenerated extends AbstractM } public void testAllFilesPresentInEditingPJvmKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simpleNewMpp/editingPJvmKotlin"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/simpleNewMpp/editingPJvmKotlin"), Pattern.compile("^([^\\.]+)$"), null, true); } } } @@ -287,7 +288,7 @@ public class MultiplatformJpsTestWithGeneratedContentGenerated extends AbstractM } public void testAllFilesPresentInUltimate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ultimate"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ultimate"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("editingACommonExpectActual") @@ -344,7 +345,7 @@ public class MultiplatformJpsTestWithGeneratedContentGenerated extends AbstractM } public void testAllFilesPresentInEditingACommonExpectActual() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ultimate/editingACommonExpectActual"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ultimate/editingACommonExpectActual"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -357,7 +358,7 @@ public class MultiplatformJpsTestWithGeneratedContentGenerated extends AbstractM } public void testAllFilesPresentInEditingAJsClientKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ultimate/editingAJsClientKotlin"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ultimate/editingAJsClientKotlin"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -370,7 +371,7 @@ public class MultiplatformJpsTestWithGeneratedContentGenerated extends AbstractM } public void testAllFilesPresentInEditingAJvmClientJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ultimate/editingAJvmClientJava"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ultimate/editingAJvmClientJava"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -383,7 +384,7 @@ public class MultiplatformJpsTestWithGeneratedContentGenerated extends AbstractM } public void testAllFilesPresentInEditingAJvmClientKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ultimate/editingAJvmClientKotlin"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ultimate/editingAJvmClientKotlin"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -396,7 +397,7 @@ public class MultiplatformJpsTestWithGeneratedContentGenerated extends AbstractM } public void testAllFilesPresentInEditingBCommonExpectActual() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ultimate/editingBCommonExpectActual"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ultimate/editingBCommonExpectActual"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -409,7 +410,7 @@ public class MultiplatformJpsTestWithGeneratedContentGenerated extends AbstractM } public void testAllFilesPresentInEditingRJsKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ultimate/editingRJsKotlin"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ultimate/editingRJsKotlin"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -422,7 +423,7 @@ public class MultiplatformJpsTestWithGeneratedContentGenerated extends AbstractM } public void testAllFilesPresentInEditingRJvmKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ultimate/editingRJvmKotlin"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ultimate/editingRJvmKotlin"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -435,7 +436,7 @@ public class MultiplatformJpsTestWithGeneratedContentGenerated extends AbstractM } public void testAllFilesPresentInEditingRaJsKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ultimate/editingRaJsKotlin"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ultimate/editingRaJsKotlin"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -448,7 +449,7 @@ public class MultiplatformJpsTestWithGeneratedContentGenerated extends AbstractM } public void testAllFilesPresentInEditingRaJvmKotlin() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ultimate/editingRaJvmKotlin"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/incremental/multiModule/multiplatform/withGeneratedContent/ultimate/editingRaJvmKotlin"), Pattern.compile("^([^\\.]+)$"), null, true); } } } diff --git a/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/incremental/JsProtoComparisonTestGenerated.java b/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/incremental/JsProtoComparisonTestGenerated.java index 35fbf182b18..e0ade944522 100644 --- a/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/incremental/JsProtoComparisonTestGenerated.java +++ b/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/incremental/JsProtoComparisonTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.jps.incremental; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -27,7 +28,7 @@ public class JsProtoComparisonTestGenerated extends AbstractJsProtoComparisonTes } public void testAllFilesPresentInClassSignatureChange() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classSignatureChange"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classSignatureChange"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("classAnnotationListChanged") @@ -94,7 +95,7 @@ public class JsProtoComparisonTestGenerated extends AbstractJsProtoComparisonTes } public void testAllFilesPresentInClassAnnotationListChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classSignatureChange/classAnnotationListChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classSignatureChange/classAnnotationListChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -107,7 +108,7 @@ public class JsProtoComparisonTestGenerated extends AbstractJsProtoComparisonTes } public void testAllFilesPresentInClassFlagsAndMembersChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classSignatureChange/classFlagsAndMembersChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classSignatureChange/classFlagsAndMembersChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -120,7 +121,7 @@ public class JsProtoComparisonTestGenerated extends AbstractJsProtoComparisonTes } public void testAllFilesPresentInClassFlagsChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classSignatureChange/classFlagsChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classSignatureChange/classFlagsChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -133,7 +134,7 @@ public class JsProtoComparisonTestGenerated extends AbstractJsProtoComparisonTes } public void testAllFilesPresentInClassTypeParameterListChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classSignatureChange/classTypeParameterListChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classSignatureChange/classTypeParameterListChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -146,7 +147,7 @@ public class JsProtoComparisonTestGenerated extends AbstractJsProtoComparisonTes } public void testAllFilesPresentInClassWithSuperTypeListChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classSignatureChange/classWithSuperTypeListChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classSignatureChange/classWithSuperTypeListChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -159,7 +160,7 @@ public class JsProtoComparisonTestGenerated extends AbstractJsProtoComparisonTes } public void testAllFilesPresentInNestedClassSignatureChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classSignatureChange/nestedClassSignatureChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classSignatureChange/nestedClassSignatureChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -172,7 +173,7 @@ public class JsProtoComparisonTestGenerated extends AbstractJsProtoComparisonTes } public void testAllFilesPresentInSealedClassImplAdded() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classSignatureChange/sealedClassImplAdded"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classSignatureChange/sealedClassImplAdded"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -185,7 +186,7 @@ public class JsProtoComparisonTestGenerated extends AbstractJsProtoComparisonTes } public void testAllFilesPresentInSealedClassImplRemoved() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classSignatureChange/sealedClassImplRemoved"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classSignatureChange/sealedClassImplRemoved"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -198,7 +199,7 @@ public class JsProtoComparisonTestGenerated extends AbstractJsProtoComparisonTes } public void testAllFilesPresentInSealedClassNestedImplAdded() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classSignatureChange/sealedClassNestedImplAdded"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classSignatureChange/sealedClassNestedImplAdded"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -211,7 +212,7 @@ public class JsProtoComparisonTestGenerated extends AbstractJsProtoComparisonTes } public void testAllFilesPresentInSealedClassNestedImplAddedDeep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classSignatureChange/sealedClassNestedImplAddedDeep"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classSignatureChange/sealedClassNestedImplAddedDeep"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -224,7 +225,7 @@ public class JsProtoComparisonTestGenerated extends AbstractJsProtoComparisonTes } public void testAllFilesPresentInSealedClassNestedImplRemoved() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classSignatureChange/sealedClassNestedImplRemoved"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classSignatureChange/sealedClassNestedImplRemoved"), Pattern.compile("^([^\\.]+)$"), null, true); } } } @@ -238,7 +239,7 @@ public class JsProtoComparisonTestGenerated extends AbstractJsProtoComparisonTes } public void testAllFilesPresentInClassPrivateOnlyChange() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classPrivateOnlyChange"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classPrivateOnlyChange"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("classWithPrivateFunChanged") @@ -275,7 +276,7 @@ public class JsProtoComparisonTestGenerated extends AbstractJsProtoComparisonTes } public void testAllFilesPresentInClassWithPrivateFunChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classPrivateOnlyChange/classWithPrivateFunChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classPrivateOnlyChange/classWithPrivateFunChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -288,7 +289,7 @@ public class JsProtoComparisonTestGenerated extends AbstractJsProtoComparisonTes } public void testAllFilesPresentInClassWithPrivatePrimaryConstructorChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classPrivateOnlyChange/classWithPrivatePrimaryConstructorChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classPrivateOnlyChange/classWithPrivatePrimaryConstructorChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -301,7 +302,7 @@ public class JsProtoComparisonTestGenerated extends AbstractJsProtoComparisonTes } public void testAllFilesPresentInClassWithPrivateSecondaryConstructorChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classPrivateOnlyChange/classWithPrivateSecondaryConstructorChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classPrivateOnlyChange/classWithPrivateSecondaryConstructorChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -314,7 +315,7 @@ public class JsProtoComparisonTestGenerated extends AbstractJsProtoComparisonTes } public void testAllFilesPresentInClassWithPrivateValChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classPrivateOnlyChange/classWithPrivateValChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classPrivateOnlyChange/classWithPrivateValChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -327,7 +328,7 @@ public class JsProtoComparisonTestGenerated extends AbstractJsProtoComparisonTes } public void testAllFilesPresentInClassWithPrivateVarChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classPrivateOnlyChange/classWithPrivateVarChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classPrivateOnlyChange/classWithPrivateVarChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } } @@ -341,7 +342,7 @@ public class JsProtoComparisonTestGenerated extends AbstractJsProtoComparisonTes } public void testAllFilesPresentInClassMembersOnlyChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classMembersOnlyChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classMembersOnlyChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("classWithCompanionObjectChanged") @@ -403,7 +404,7 @@ public class JsProtoComparisonTestGenerated extends AbstractJsProtoComparisonTes } public void testAllFilesPresentInClassWithCompanionObjectChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classMembersOnlyChanged/classWithCompanionObjectChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classMembersOnlyChanged/classWithCompanionObjectChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -416,7 +417,7 @@ public class JsProtoComparisonTestGenerated extends AbstractJsProtoComparisonTes } public void testAllFilesPresentInClassWithConstructorChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classMembersOnlyChanged/classWithConstructorChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classMembersOnlyChanged/classWithConstructorChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -429,7 +430,7 @@ public class JsProtoComparisonTestGenerated extends AbstractJsProtoComparisonTes } public void testAllFilesPresentInClassWithFunAndValChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classMembersOnlyChanged/classWithFunAndValChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classMembersOnlyChanged/classWithFunAndValChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -442,7 +443,7 @@ public class JsProtoComparisonTestGenerated extends AbstractJsProtoComparisonTes } public void testAllFilesPresentInClassWithNestedClassesChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classMembersOnlyChanged/classWithNestedClassesChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classMembersOnlyChanged/classWithNestedClassesChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -455,7 +456,7 @@ public class JsProtoComparisonTestGenerated extends AbstractJsProtoComparisonTes } public void testAllFilesPresentInClassWitnEnumChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classMembersOnlyChanged/classWitnEnumChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classMembersOnlyChanged/classWitnEnumChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -468,7 +469,7 @@ public class JsProtoComparisonTestGenerated extends AbstractJsProtoComparisonTes } public void testAllFilesPresentInDefaultValues() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classMembersOnlyChanged/defaultValues"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classMembersOnlyChanged/defaultValues"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -481,7 +482,7 @@ public class JsProtoComparisonTestGenerated extends AbstractJsProtoComparisonTes } public void testAllFilesPresentInMembersAnnotationListChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classMembersOnlyChanged/membersAnnotationListChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classMembersOnlyChanged/membersAnnotationListChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -494,7 +495,7 @@ public class JsProtoComparisonTestGenerated extends AbstractJsProtoComparisonTes } public void testAllFilesPresentInMembersFlagsChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classMembersOnlyChanged/membersFlagsChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classMembersOnlyChanged/membersFlagsChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -507,7 +508,7 @@ public class JsProtoComparisonTestGenerated extends AbstractJsProtoComparisonTes } public void testAllFilesPresentInNestedClassMembersChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classMembersOnlyChanged/nestedClassMembersChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classMembersOnlyChanged/nestedClassMembersChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -520,7 +521,7 @@ public class JsProtoComparisonTestGenerated extends AbstractJsProtoComparisonTes } public void testAllFilesPresentInSealedClassImplAdded() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classMembersOnlyChanged/sealedClassImplAdded"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classMembersOnlyChanged/sealedClassImplAdded"), Pattern.compile("^([^\\.]+)$"), null, true); } } } @@ -534,7 +535,7 @@ public class JsProtoComparisonTestGenerated extends AbstractJsProtoComparisonTes } public void testAllFilesPresentInPackageMembers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/packageMembers"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/packageMembers"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("defaultValues") @@ -571,7 +572,7 @@ public class JsProtoComparisonTestGenerated extends AbstractJsProtoComparisonTes } public void testAllFilesPresentInDefaultValues() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/packageMembers/defaultValues"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/packageMembers/defaultValues"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -584,7 +585,7 @@ public class JsProtoComparisonTestGenerated extends AbstractJsProtoComparisonTes } public void testAllFilesPresentInMembersAnnotationListChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/packageMembers/membersAnnotationListChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/packageMembers/membersAnnotationListChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -597,7 +598,7 @@ public class JsProtoComparisonTestGenerated extends AbstractJsProtoComparisonTes } public void testAllFilesPresentInMembersFlagsChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/packageMembers/membersFlagsChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/packageMembers/membersFlagsChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -610,7 +611,7 @@ public class JsProtoComparisonTestGenerated extends AbstractJsProtoComparisonTes } public void testAllFilesPresentInPackageFacadePrivateOnlyChanges() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/packageMembers/packageFacadePrivateOnlyChanges"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/packageMembers/packageFacadePrivateOnlyChanges"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -623,7 +624,7 @@ public class JsProtoComparisonTestGenerated extends AbstractJsProtoComparisonTes } public void testAllFilesPresentInPackageFacadePublicChanges() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/packageMembers/packageFacadePublicChanges"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/packageMembers/packageFacadePublicChanges"), Pattern.compile("^([^\\.]+)$"), null, true); } } } @@ -637,7 +638,7 @@ public class JsProtoComparisonTestGenerated extends AbstractJsProtoComparisonTes } public void testAllFilesPresentInUnchanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/unchanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/unchanged"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("unchangedClass") @@ -659,7 +660,7 @@ public class JsProtoComparisonTestGenerated extends AbstractJsProtoComparisonTes } public void testAllFilesPresentInUnchangedClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/unchanged/unchangedClass"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/unchanged/unchangedClass"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -672,7 +673,7 @@ public class JsProtoComparisonTestGenerated extends AbstractJsProtoComparisonTes } public void testAllFilesPresentInUnchangedPackageFacade() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/unchanged/unchangedPackageFacade"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/unchanged/unchangedPackageFacade"), Pattern.compile("^([^\\.]+)$"), null, true); } } } @@ -686,7 +687,7 @@ public class JsProtoComparisonTestGenerated extends AbstractJsProtoComparisonTes } public void testAllFilesPresentInJsOnly() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/jsOnly"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/jsOnly"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("externals") @@ -703,7 +704,7 @@ public class JsProtoComparisonTestGenerated extends AbstractJsProtoComparisonTes } public void testAllFilesPresentInExternals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/jsOnly/externals"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/jsOnly/externals"), Pattern.compile("^([^\\.]+)$"), null, true); } } } diff --git a/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/incremental/JvmProtoComparisonTestGenerated.java b/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/incremental/JvmProtoComparisonTestGenerated.java index a9272c01309..39e16c795f2 100644 --- a/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/incremental/JvmProtoComparisonTestGenerated.java +++ b/jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/incremental/JvmProtoComparisonTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.jps.incremental; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -27,7 +28,7 @@ public class JvmProtoComparisonTestGenerated extends AbstractJvmProtoComparisonT } public void testAllFilesPresentInClassSignatureChange() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classSignatureChange"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classSignatureChange"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("classAnnotationListChanged") @@ -94,7 +95,7 @@ public class JvmProtoComparisonTestGenerated extends AbstractJvmProtoComparisonT } public void testAllFilesPresentInClassAnnotationListChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classSignatureChange/classAnnotationListChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classSignatureChange/classAnnotationListChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -107,7 +108,7 @@ public class JvmProtoComparisonTestGenerated extends AbstractJvmProtoComparisonT } public void testAllFilesPresentInClassFlagsAndMembersChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classSignatureChange/classFlagsAndMembersChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classSignatureChange/classFlagsAndMembersChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -120,7 +121,7 @@ public class JvmProtoComparisonTestGenerated extends AbstractJvmProtoComparisonT } public void testAllFilesPresentInClassFlagsChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classSignatureChange/classFlagsChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classSignatureChange/classFlagsChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -133,7 +134,7 @@ public class JvmProtoComparisonTestGenerated extends AbstractJvmProtoComparisonT } public void testAllFilesPresentInClassTypeParameterListChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classSignatureChange/classTypeParameterListChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classSignatureChange/classTypeParameterListChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -146,7 +147,7 @@ public class JvmProtoComparisonTestGenerated extends AbstractJvmProtoComparisonT } public void testAllFilesPresentInClassWithSuperTypeListChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classSignatureChange/classWithSuperTypeListChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classSignatureChange/classWithSuperTypeListChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -159,7 +160,7 @@ public class JvmProtoComparisonTestGenerated extends AbstractJvmProtoComparisonT } public void testAllFilesPresentInNestedClassSignatureChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classSignatureChange/nestedClassSignatureChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classSignatureChange/nestedClassSignatureChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -172,7 +173,7 @@ public class JvmProtoComparisonTestGenerated extends AbstractJvmProtoComparisonT } public void testAllFilesPresentInSealedClassImplAdded() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classSignatureChange/sealedClassImplAdded"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classSignatureChange/sealedClassImplAdded"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -185,7 +186,7 @@ public class JvmProtoComparisonTestGenerated extends AbstractJvmProtoComparisonT } public void testAllFilesPresentInSealedClassImplRemoved() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classSignatureChange/sealedClassImplRemoved"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classSignatureChange/sealedClassImplRemoved"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -198,7 +199,7 @@ public class JvmProtoComparisonTestGenerated extends AbstractJvmProtoComparisonT } public void testAllFilesPresentInSealedClassNestedImplAdded() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classSignatureChange/sealedClassNestedImplAdded"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classSignatureChange/sealedClassNestedImplAdded"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -211,7 +212,7 @@ public class JvmProtoComparisonTestGenerated extends AbstractJvmProtoComparisonT } public void testAllFilesPresentInSealedClassNestedImplAddedDeep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classSignatureChange/sealedClassNestedImplAddedDeep"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classSignatureChange/sealedClassNestedImplAddedDeep"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -224,7 +225,7 @@ public class JvmProtoComparisonTestGenerated extends AbstractJvmProtoComparisonT } public void testAllFilesPresentInSealedClassNestedImplRemoved() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classSignatureChange/sealedClassNestedImplRemoved"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classSignatureChange/sealedClassNestedImplRemoved"), Pattern.compile("^([^\\.]+)$"), null, true); } } } @@ -238,7 +239,7 @@ public class JvmProtoComparisonTestGenerated extends AbstractJvmProtoComparisonT } public void testAllFilesPresentInClassPrivateOnlyChange() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classPrivateOnlyChange"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classPrivateOnlyChange"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("classWithPrivateFunChanged") @@ -275,7 +276,7 @@ public class JvmProtoComparisonTestGenerated extends AbstractJvmProtoComparisonT } public void testAllFilesPresentInClassWithPrivateFunChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classPrivateOnlyChange/classWithPrivateFunChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classPrivateOnlyChange/classWithPrivateFunChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -288,7 +289,7 @@ public class JvmProtoComparisonTestGenerated extends AbstractJvmProtoComparisonT } public void testAllFilesPresentInClassWithPrivatePrimaryConstructorChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classPrivateOnlyChange/classWithPrivatePrimaryConstructorChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classPrivateOnlyChange/classWithPrivatePrimaryConstructorChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -301,7 +302,7 @@ public class JvmProtoComparisonTestGenerated extends AbstractJvmProtoComparisonT } public void testAllFilesPresentInClassWithPrivateSecondaryConstructorChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classPrivateOnlyChange/classWithPrivateSecondaryConstructorChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classPrivateOnlyChange/classWithPrivateSecondaryConstructorChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -314,7 +315,7 @@ public class JvmProtoComparisonTestGenerated extends AbstractJvmProtoComparisonT } public void testAllFilesPresentInClassWithPrivateValChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classPrivateOnlyChange/classWithPrivateValChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classPrivateOnlyChange/classWithPrivateValChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -327,7 +328,7 @@ public class JvmProtoComparisonTestGenerated extends AbstractJvmProtoComparisonT } public void testAllFilesPresentInClassWithPrivateVarChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classPrivateOnlyChange/classWithPrivateVarChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classPrivateOnlyChange/classWithPrivateVarChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } } @@ -341,7 +342,7 @@ public class JvmProtoComparisonTestGenerated extends AbstractJvmProtoComparisonT } public void testAllFilesPresentInClassMembersOnlyChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classMembersOnlyChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classMembersOnlyChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("classWithCompanionObjectChanged") @@ -403,7 +404,7 @@ public class JvmProtoComparisonTestGenerated extends AbstractJvmProtoComparisonT } public void testAllFilesPresentInClassWithCompanionObjectChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classMembersOnlyChanged/classWithCompanionObjectChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classMembersOnlyChanged/classWithCompanionObjectChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -416,7 +417,7 @@ public class JvmProtoComparisonTestGenerated extends AbstractJvmProtoComparisonT } public void testAllFilesPresentInClassWithConstructorChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classMembersOnlyChanged/classWithConstructorChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classMembersOnlyChanged/classWithConstructorChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -429,7 +430,7 @@ public class JvmProtoComparisonTestGenerated extends AbstractJvmProtoComparisonT } public void testAllFilesPresentInClassWithFunAndValChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classMembersOnlyChanged/classWithFunAndValChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classMembersOnlyChanged/classWithFunAndValChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -442,7 +443,7 @@ public class JvmProtoComparisonTestGenerated extends AbstractJvmProtoComparisonT } public void testAllFilesPresentInClassWithNestedClassesChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classMembersOnlyChanged/classWithNestedClassesChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classMembersOnlyChanged/classWithNestedClassesChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -455,7 +456,7 @@ public class JvmProtoComparisonTestGenerated extends AbstractJvmProtoComparisonT } public void testAllFilesPresentInClassWitnEnumChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classMembersOnlyChanged/classWitnEnumChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classMembersOnlyChanged/classWitnEnumChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -468,7 +469,7 @@ public class JvmProtoComparisonTestGenerated extends AbstractJvmProtoComparisonT } public void testAllFilesPresentInDefaultValues() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classMembersOnlyChanged/defaultValues"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classMembersOnlyChanged/defaultValues"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -481,7 +482,7 @@ public class JvmProtoComparisonTestGenerated extends AbstractJvmProtoComparisonT } public void testAllFilesPresentInMembersAnnotationListChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classMembersOnlyChanged/membersAnnotationListChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classMembersOnlyChanged/membersAnnotationListChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -494,7 +495,7 @@ public class JvmProtoComparisonTestGenerated extends AbstractJvmProtoComparisonT } public void testAllFilesPresentInMembersFlagsChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classMembersOnlyChanged/membersFlagsChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classMembersOnlyChanged/membersFlagsChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -507,7 +508,7 @@ public class JvmProtoComparisonTestGenerated extends AbstractJvmProtoComparisonT } public void testAllFilesPresentInNestedClassMembersChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classMembersOnlyChanged/nestedClassMembersChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classMembersOnlyChanged/nestedClassMembersChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -520,7 +521,7 @@ public class JvmProtoComparisonTestGenerated extends AbstractJvmProtoComparisonT } public void testAllFilesPresentInSealedClassImplAdded() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classMembersOnlyChanged/sealedClassImplAdded"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/classMembersOnlyChanged/sealedClassImplAdded"), Pattern.compile("^([^\\.]+)$"), null, true); } } } @@ -534,7 +535,7 @@ public class JvmProtoComparisonTestGenerated extends AbstractJvmProtoComparisonT } public void testAllFilesPresentInPackageMembers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/packageMembers"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/packageMembers"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("defaultValues") @@ -571,7 +572,7 @@ public class JvmProtoComparisonTestGenerated extends AbstractJvmProtoComparisonT } public void testAllFilesPresentInDefaultValues() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/packageMembers/defaultValues"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/packageMembers/defaultValues"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -584,7 +585,7 @@ public class JvmProtoComparisonTestGenerated extends AbstractJvmProtoComparisonT } public void testAllFilesPresentInMembersAnnotationListChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/packageMembers/membersAnnotationListChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/packageMembers/membersAnnotationListChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -597,7 +598,7 @@ public class JvmProtoComparisonTestGenerated extends AbstractJvmProtoComparisonT } public void testAllFilesPresentInMembersFlagsChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/packageMembers/membersFlagsChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/packageMembers/membersFlagsChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -610,7 +611,7 @@ public class JvmProtoComparisonTestGenerated extends AbstractJvmProtoComparisonT } public void testAllFilesPresentInPackageFacadePrivateOnlyChanges() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/packageMembers/packageFacadePrivateOnlyChanges"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/packageMembers/packageFacadePrivateOnlyChanges"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -623,7 +624,7 @@ public class JvmProtoComparisonTestGenerated extends AbstractJvmProtoComparisonT } public void testAllFilesPresentInPackageFacadePublicChanges() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/packageMembers/packageFacadePublicChanges"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/packageMembers/packageFacadePublicChanges"), Pattern.compile("^([^\\.]+)$"), null, true); } } } @@ -637,7 +638,7 @@ public class JvmProtoComparisonTestGenerated extends AbstractJvmProtoComparisonT } public void testAllFilesPresentInUnchanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/unchanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/unchanged"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("unchangedClass") @@ -659,7 +660,7 @@ public class JvmProtoComparisonTestGenerated extends AbstractJvmProtoComparisonT } public void testAllFilesPresentInUnchangedClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/unchanged/unchangedClass"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/unchanged/unchangedClass"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -672,7 +673,7 @@ public class JvmProtoComparisonTestGenerated extends AbstractJvmProtoComparisonT } public void testAllFilesPresentInUnchangedPackageFacade() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/unchanged/unchangedPackageFacade"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/unchanged/unchangedPackageFacade"), Pattern.compile("^([^\\.]+)$"), null, true); } } } @@ -686,7 +687,7 @@ public class JvmProtoComparisonTestGenerated extends AbstractJvmProtoComparisonT } public void testAllFilesPresentInJvmOnly() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/jvmOnly"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/jvmOnly"), Pattern.compile("^([^\\.]+)$"), null, true); } @TestMetadata("classToFileFacade") @@ -718,7 +719,7 @@ public class JvmProtoComparisonTestGenerated extends AbstractJvmProtoComparisonT } public void testAllFilesPresentInClassToFileFacade() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/jvmOnly/classToFileFacade"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/jvmOnly/classToFileFacade"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -731,7 +732,7 @@ public class JvmProtoComparisonTestGenerated extends AbstractJvmProtoComparisonT } public void testAllFilesPresentInMembersFlagsChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/jvmOnly/membersFlagsChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/jvmOnly/membersFlagsChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -744,7 +745,7 @@ public class JvmProtoComparisonTestGenerated extends AbstractJvmProtoComparisonT } public void testAllFilesPresentInPackageFacadeMultifileClassChanged() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/jvmOnly/packageFacadeMultifileClassChanged"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/jvmOnly/packageFacadeMultifileClassChanged"), Pattern.compile("^([^\\.]+)$"), null, true); } } @@ -757,7 +758,7 @@ public class JvmProtoComparisonTestGenerated extends AbstractJvmProtoComparisonT } public void testAllFilesPresentInPackageFacadeToClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/jvmOnly/packageFacadeToClass"), Pattern.compile("^([^\\.]+)$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("jps-plugin/testData/comparison/jvmOnly/packageFacadeToClass"), Pattern.compile("^([^\\.]+)$"), null, true); } } } diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/DceTestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/DceTestGenerated.java index f2f2a538add..04c068e42fa 100644 --- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/DceTestGenerated.java +++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/DceTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.js.test; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class DceTestGenerated extends AbstractDceTest { } public void testAllFilesPresentInDce() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/dce"), Pattern.compile("(.+)\\.js"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/dce"), Pattern.compile("(.+)\\.js"), null, TargetBackend.JS, true); } @TestMetadata("amd.js") diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/JsLineNumberTestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/JsLineNumberTestGenerated.java index c1d15ef6d93..7f0bcdcb847 100644 --- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/JsLineNumberTestGenerated.java +++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/JsLineNumberTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.js.test; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class JsLineNumberTestGenerated extends AbstractJsLineNumberTest { } public void testAllFilesPresentInLineNumbers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/lineNumbers"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/lineNumbers"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("andAndWithSideEffect.kt") @@ -288,7 +289,7 @@ public class JsLineNumberTestGenerated extends AbstractJsLineNumberTest { } public void testAllFilesPresentInInlineMultiModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/lineNumbers/inlineMultiModule"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/lineNumbers/inlineMultiModule"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("simple.kt") diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/es6/semantics/IrBoxJsES6TestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/es6/semantics/IrBoxJsES6TestGenerated.java index 02cf8144ea6..8ef311b75fb 100644 --- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/es6/semantics/IrBoxJsES6TestGenerated.java +++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/es6/semantics/IrBoxJsES6TestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.js.test.es6.semantics; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInBox() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("js/js.translator/testData/box/annotation") @@ -38,7 +39,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInAnnotation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/annotation"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/annotation"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("annotationClass.kt") @@ -56,7 +57,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInBuiltins() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/builtins"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/builtins"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("hashCode.kt") @@ -84,7 +85,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/callableReference"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/callableReference"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("js/js.translator/testData/box/callableReference/function") @@ -96,7 +97,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/callableReference/function"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/callableReference/function"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("classMemberAndNonExtensionCompatibility.kt") @@ -154,7 +155,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/callableReference/property"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/callableReference/property"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("extensionProperty.kt") @@ -183,7 +184,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInChar() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/char"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/char"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("charBinaryOperations.kt") @@ -261,7 +262,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInClassObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/classObject"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/classObject"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("defaultObjectSameNamesAsInOuter.kt") @@ -319,7 +320,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInClosure() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/closure"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/closure"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("closureArrayListInstance.kt") @@ -557,7 +558,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInCoercion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/coercion"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/coercion"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("bridgeChar.kt") @@ -680,7 +681,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInCoroutines() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/coroutines"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/coroutines"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("debugStatement.kt") @@ -713,7 +714,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInCrossModuleRef() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/crossModuleRef"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/crossModuleRef"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("callableObjectRef.kt") @@ -806,7 +807,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInCrossModuleRefIR() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/crossModuleRefIR"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/crossModuleRefIR"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("callableObjectRef.kt") @@ -909,7 +910,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInDataClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/dataClass"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/dataClass"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("components.kt") @@ -962,7 +963,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInDefaultArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/defaultArguments"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/defaultArguments"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("complexExpressionAsConstructorDefaultArgument.kt") @@ -1085,7 +1086,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInDelegateProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/delegateProperty"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/delegateProperty"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("capturedLocalVal.kt") @@ -1213,7 +1214,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInDelegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/delegation"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/delegation"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("complexDelegation.kt") @@ -1316,7 +1317,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInDynamic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/dynamic"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/dynamic"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("binaryOperations.kt") @@ -1429,7 +1430,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/enum"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/enum"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("enumInheritedFromTrait.kt") @@ -1502,7 +1503,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInEs6classes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/es6classes"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/es6classes"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("builtItTypes.kt") @@ -1590,7 +1591,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInExamples() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/examples"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/examples"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("basicmethod.kt") @@ -1613,7 +1614,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInExport() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/export"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/export"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("nonIndetifierModuleName.kt") @@ -1636,7 +1637,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("js/js.translator/testData/box/expression/cast") @@ -1648,7 +1649,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInCast() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/cast"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/cast"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("castExtensionToKMutableProperty.kt") @@ -1796,7 +1797,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInCompareTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/compareTo"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/compareTo"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("booleanCompareTo.kt") @@ -1819,7 +1820,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInDollarParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/dollarParameter"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/dollarParameter"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("dollarParameter.kt") @@ -1837,7 +1838,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInEquals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/equals"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/equals"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("arrays.kt") @@ -1920,7 +1921,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInEvaluationOrder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/evaluationOrder"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/evaluationOrder"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("andAndWithBreakContinueReturn.kt") @@ -2123,7 +2124,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInFor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/for"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/for"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("forIteratesOverArray.kt") @@ -2216,7 +2217,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/function"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/function"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("anonymousWithLambda.kt") @@ -2399,7 +2400,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInIdentifierClash() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/identifierClash"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/identifierClash"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("overloadedFun.kt") @@ -2427,7 +2428,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInIdentityEquals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/identityEquals"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/identityEquals"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("identityEqualsMethod.kt") @@ -2450,7 +2451,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInIf() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/if"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/if"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("ifElseAsExpressionWithThrow.kt") @@ -2488,7 +2489,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInInvoke() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/invoke"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/invoke"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("explicitInvokeLambda.kt") @@ -2561,7 +2562,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInMisc() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/misc"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/misc"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("classWithoutPackage.kt") @@ -2784,7 +2785,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInStringClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/stringClass"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/stringClass"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("extensionMethods.kt") @@ -2862,7 +2863,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInStringTemplates() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/stringTemplates"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/stringTemplates"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("nonStrings.kt") @@ -2890,7 +2891,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInTry() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/try"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/try"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("exceptionToString.kt") @@ -2963,7 +2964,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInTypeCheck() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/typeCheck"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/typeCheck"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("simpleAsClass.kt") @@ -2996,7 +2997,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInWhen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/when"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/when"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("doWhileWithOneStmWhen.kt") @@ -3174,7 +3175,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInWhile() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/while"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/while"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("doWhileWithComplexCondition.kt") @@ -3213,7 +3214,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInExtensionFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/extensionFunction"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/extensionFunction"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("extensionForSuperclass.kt") @@ -3311,7 +3312,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInExtensionProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/extensionProperty"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/extensionProperty"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("externalExtensionProperty.kt") @@ -3354,7 +3355,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInIncremental() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/incremental"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/incremental"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("catchScope.kt") @@ -3462,7 +3463,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInInheritance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/inheritance"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/inheritance"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("baseCall.kt") @@ -3579,7 +3580,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInInterfaces() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/inheritance/interfaces"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/inheritance/interfaces"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("fromExternalInterface.kt") @@ -3613,7 +3614,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInInitialize() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/initialize"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/initialize"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("classInitializer.kt") @@ -3671,7 +3672,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/inline"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/inline"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("anonymousFunction.kt") @@ -4099,7 +4100,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInInlineEvaluationOrder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/inlineEvaluationOrder"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/inlineEvaluationOrder"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("alsoWithReassingment.kt") @@ -4377,7 +4378,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInInlineMultiFile() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/inlineMultiFile"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/inlineMultiFile"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("anonymousObjectInSimilarFunctions.kt") @@ -4540,7 +4541,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInInlineMultiModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/inlineMultiModule"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/inlineMultiModule"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("anotherModuleValInClosure.kt") @@ -4718,7 +4719,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInInlineSizeReduction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/inlineSizeReduction"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/inlineSizeReduction"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("inlineImportCleanup.kt") @@ -4816,7 +4817,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInInlineStdlib() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/inlineStdlib"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/inlineStdlib"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("callNameClash.kt") @@ -4874,7 +4875,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInIntrinsics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/intrinsics"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/intrinsics"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("typeof.kt") @@ -4892,7 +4893,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/java"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/java"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("js/js.translator/testData/box/java/abstractList") @@ -4904,7 +4905,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInAbstractList() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/java/abstractList"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/java/abstractList"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("iterator.kt") @@ -4927,7 +4928,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInArrayList() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/java/arrayList"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/java/arrayList"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("arrayAccess.kt") @@ -5016,7 +5017,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInJsCode() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/jsCode"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/jsCode"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("break.kt") @@ -5164,7 +5165,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInJsExport() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/jsExport"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/jsExport"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("dataClass.kt") @@ -5192,7 +5193,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInJsModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/jsModule"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/jsModule"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("externalClass.kt") @@ -5300,7 +5301,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInJsName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/jsName"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/jsName"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("avoidNameClash.kt") @@ -5378,7 +5379,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInJsQualifier() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/jsQualifier"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/jsQualifier"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("classes.kt") @@ -5416,7 +5417,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInKotlin_test() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/kotlin.test"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/kotlin.test"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("beforeAfter.kt") @@ -5474,7 +5475,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInLabels() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/labels"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/labels"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("labelOnExpression.kt") @@ -5547,7 +5548,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInMain() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/main"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/main"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("differentMains.kt") @@ -5600,7 +5601,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInMultiFile() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multiFile"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multiFile"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("classOfTheSameNameInAnotherPackage.kt") @@ -5643,7 +5644,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInMultiModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multiModule"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multiModule"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("clashedDeclLinkage.kt") @@ -5711,7 +5712,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInMultiModuleWrappers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multiModuleWrappers"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multiModuleWrappers"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("js/js.translator/testData/box/multiModuleWrappers/amd") @@ -5723,7 +5724,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInAmd() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multiModuleWrappers/amd"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multiModuleWrappers/amd"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("jsModuleOnPackage.kt") @@ -5751,7 +5752,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInCommon_js() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multiModuleWrappers/common_js"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multiModuleWrappers/common_js"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("inlineFromModuleWithNonIdentifierName.kt") @@ -5779,7 +5780,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInPlain() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multiModuleWrappers/plain"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multiModuleWrappers/plain"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("inlineFromModuleWithNonIdentifierName.kt") @@ -5807,7 +5808,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInUmd() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multiModuleWrappers/umd"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multiModuleWrappers/umd"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("moduleWithNonIdentifierName.kt") @@ -5831,7 +5832,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInMultiPackage() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multiPackage"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multiPackage"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("classesInheritedFromOtherPackage.kt") @@ -5889,7 +5890,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInMultideclaration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multideclaration"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multideclaration"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("multiValForArray.kt") @@ -5937,7 +5938,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInNameClashes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/nameClashes"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/nameClashes"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("classAndCompanionObjectMembers.kt") @@ -6050,7 +6051,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInNative() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/native"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/native"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("callbackOptionalParameter.kt") @@ -6248,7 +6249,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInNestedTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/nestedTypes"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/nestedTypes"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("implicitOuterThisFromLambda.kt") @@ -6341,7 +6342,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInNumber() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/number"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/number"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("assignmentIntOverflow.kt") @@ -6504,7 +6505,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInObjectDeclaration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/objectDeclaration"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/objectDeclaration"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("dontPolluteObject.kt") @@ -6577,7 +6578,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInOperatorOverloading() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/operatorOverloading"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/operatorOverloading"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("augmentedAssignmentLhs.kt") @@ -6705,7 +6706,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInPackage() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/package"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/package"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("classCreatedInDeeplyNestedPackage.kt") @@ -6748,7 +6749,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInPropertyAccess() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/propertyAccess"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/propertyAccess"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("classUsesPackageProperties.kt") @@ -6871,7 +6872,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInPropertyOverride() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/propertyOverride"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/propertyOverride"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("checkSupertypeOrder.kt") @@ -6939,7 +6940,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInRange() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/range"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/range"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("creatingProgressions.kt") @@ -7007,7 +7008,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInReflection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/reflection"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/reflection"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("classJsName.kt") @@ -7090,7 +7091,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInRegression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/regression"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/regression"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("companionObjectInExternalInterface.kt") @@ -7132,7 +7133,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInStdlibTestSnippets() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/regression/stdlibTestSnippets"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/regression/stdlibTestSnippets"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("arrayTest_plusInference.kt") @@ -7165,7 +7166,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInTypeChecks() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/regression/typeChecks"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/regression/typeChecks"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("booleanOperatorsTypes.kt") @@ -7199,7 +7200,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInReified() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/reified"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/reified"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("callChain.kt") @@ -7312,7 +7313,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInRtti() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/rtti"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/rtti"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("collectionClassesIsCheck.kt") @@ -7420,7 +7421,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInSafeCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/safeCall"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/safeCall"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("redundantSafeAccess.kt") @@ -7468,7 +7469,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInSimple() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/simple"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/simple"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("assign.kt") @@ -7641,7 +7642,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInStandardClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/standardClasses"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/standardClasses"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("any.kt") @@ -7744,7 +7745,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInSuperCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/superCall"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/superCall"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("classSuperCall.kt") @@ -7782,7 +7783,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInTrait() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/trait"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/trait"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("checkImplementationCharacteristics.kt") @@ -7840,7 +7841,7 @@ public class IrBoxJsES6TestGenerated extends AbstractIrBoxJsES6Test { } public void testAllFilesPresentInVararg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/vararg"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/vararg"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("jsExternalVarargCtor.kt") diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/es6/semantics/IrJsCodegenBoxES6TestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/es6/semantics/IrJsCodegenBoxES6TestGenerated.java index 34ca7cbeb78..b8a38136f6b 100644 --- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/es6/semantics/IrJsCodegenBoxES6TestGenerated.java +++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/es6/semantics/IrJsCodegenBoxES6TestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.js.test.es6.semantics; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInBox() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("compiler/testData/codegen/box/annotations") @@ -38,7 +39,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("nestedAnnotation.kt") @@ -70,7 +71,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInAnnotatedLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations/annotatedLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations/annotatedLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -83,7 +84,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInTypeAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations/typeAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations/typeAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("checkingNotincorporatedInputTypes.kt") @@ -102,7 +103,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInArgumentOrder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/argumentOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/argumentOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("argumentOrderInObjectSuperCall.kt") @@ -185,7 +186,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInArrays() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("arrayConstructorWithNonInlineLambda.kt") @@ -507,7 +508,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInArraysOfInlineClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/arraysOfInlineClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/arraysOfInlineClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("arrayOfInlineClassOfArrayOfInlineClass.kt") @@ -525,7 +526,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInForInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/forInReversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/forInReversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("reversedArrayOriginalUpdatedInLoopBody.kt") @@ -558,7 +559,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInMultiDecl() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("kt15560.kt") @@ -610,7 +611,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInInt() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -643,7 +644,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInLong() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -678,7 +679,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInAssert() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/assert"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/assert"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("alwaysDisable.kt") @@ -700,7 +701,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInJvm() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/assert/jvm"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/assert/jvm"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } } @@ -714,7 +715,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInBinaryOp() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/binaryOp"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/binaryOp"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("bitwiseOp.kt") @@ -837,7 +838,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInBoxingOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/boxingOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/boxingOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("boxedIntegersCmp.kt") @@ -990,7 +991,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInBridges() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/bridges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/bridges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("complexMultiInheritance.kt") @@ -1277,7 +1278,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInSubstitutionInSuperClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/bridges/substitutionInSuperClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/bridges/substitutionInSuperClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("boundedTypeArguments.kt") @@ -1341,7 +1342,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInBuilderInference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("callableReferenceAndCoercionToUnit.kt") @@ -1379,7 +1380,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInBuiltinStubMethods() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("customReadOnlyIterator.kt") @@ -1401,7 +1402,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInExtendJavaCollections() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/extendJavaCollections"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/extendJavaCollections"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("arrayList.kt") @@ -1429,7 +1430,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInMapGetOrDefault() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/mapGetOrDefault"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/mapGetOrDefault"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -1442,7 +1443,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInMapRemove() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/mapRemove"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/mapRemove"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } } @@ -1456,7 +1457,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("genericConstructorReference.kt") @@ -1488,7 +1489,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInAdaptedReferences() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/adaptedReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/adaptedReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("bothWithCoercionToUnit.kt") @@ -1625,7 +1626,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInSuspendConversion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("bound.kt") @@ -1704,7 +1705,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInBound() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("array.kt") @@ -1826,7 +1827,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInEquals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/bound/equals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/bound/equals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("nullableReceiverInEquals.kt") @@ -1860,7 +1861,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInEquality() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/equality"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/equality"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("capturedDefaults.kt") @@ -1938,7 +1939,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/function"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/function"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("argumentTypes.kt") @@ -2210,7 +2211,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInLocal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/function/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/function/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("captureOuter.kt") @@ -2329,7 +2330,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("delegated.kt") @@ -2487,7 +2488,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInSerializability() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/serializability"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/serializability"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } } @@ -2501,7 +2502,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInCasts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("as.kt") @@ -2628,7 +2629,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("asFunKBig.kt") @@ -2701,7 +2702,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInJavaInterop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -2714,7 +2715,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInLiteralExpressionAsGenericArgument() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/literalExpressionAsGenericArgument"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/literalExpressionAsGenericArgument"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("binaryExpressionCast.kt") @@ -2757,7 +2758,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInMutableCollections() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/mutableCollections"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/mutableCollections"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("asWithMutable.kt") @@ -2806,7 +2807,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInCheckcastOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/checkcastOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/checkcastOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("kt19128.kt") @@ -2829,7 +2830,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInClassLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("bareArray.kt") @@ -2846,7 +2847,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInBound() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classLiteral/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classLiteral/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("primitives.kt") @@ -2879,7 +2880,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classLiteral/java"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classLiteral/java"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("kt11943.kt") @@ -2898,7 +2899,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("boxPrimitiveTypeInClinitOfClassObject.kt") @@ -3475,7 +3476,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInInner() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classes/inner"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classes/inner"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("extensionWithOuter.kt") @@ -3524,7 +3525,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInClosures() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("anonymousObjectAsLastExpressionInLambda.kt") @@ -3751,7 +3752,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInCaptureInSuperConstructorCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/captureInSuperConstructorCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/captureInSuperConstructorCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("constructorParameterAndLocalCapturedInLambdaInLocalClass.kt") @@ -3924,7 +3925,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInCaptureOuterProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/captureOuterProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/captureOuterProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("captureFunctionInProperty.kt") @@ -3977,7 +3978,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInCapturedVarsOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/capturedVarsOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/capturedVarsOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("capturedInCrossinline.kt") @@ -4045,7 +4046,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInClosureInsideClosure() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/closureInsideClosure"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/closureInsideClosure"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("localFunInsideLocalFun.kt") @@ -4089,7 +4090,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInCollectionLiterals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/collectionLiterals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/collectionLiterals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -4107,7 +4108,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInCollections() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/collections"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/collections"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("inSetWithSmartCast.kt") @@ -4140,7 +4141,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInCompanion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/companion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/companion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("delegatedPropertyOnCompanion.kt") @@ -4163,7 +4164,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/compatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/compatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("privateCompanionObject.kt") @@ -4181,7 +4182,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInConstants() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/constants"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/constants"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("comparisonFalse.kt") @@ -4244,7 +4245,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInConstructorCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/constructorCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/constructorCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -4257,7 +4258,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInContracts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/contracts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/contracts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("constructorArgument.kt") @@ -4330,7 +4331,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInControlStructures() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("bottles.kt") @@ -4722,7 +4723,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInBreakContinueInExpressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("breakFromOuter.kt") @@ -4825,7 +4826,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInForInArray() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInArray"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInArray"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("forInArraySpecializedToUntil.kt") @@ -4888,7 +4889,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInForInArrayWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("forInArrayOfObjectArrayWithIndex.kt") @@ -5001,7 +5002,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInForInCharSequenceWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInCharSequenceWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInCharSequenceWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("forInCharSeqWithIndexStops.kt") @@ -5084,7 +5085,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInForInIterableWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInIterableWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInIterableWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("forInEmptyListWithIndex.kt") @@ -5147,7 +5148,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInForInSequenceWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInSequenceWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInSequenceWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("forInEmptySequenceWithIndex.kt") @@ -5210,7 +5211,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInReturnsNothing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/returnsNothing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/returnsNothing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("ifElse.kt") @@ -5248,7 +5249,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInTryCatchInExpressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("catch.kt") @@ -5422,7 +5423,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInCoroutines() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("asyncIteratorNullMerge_1_3.kt") @@ -5944,7 +5945,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInBridges() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/bridges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/bridges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("interfaceSpecialization.kt") @@ -5972,7 +5973,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInControlFlow() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/controlFlow"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/controlFlow"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("breakFinally.kt") @@ -6095,7 +6096,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInDebug() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/debug"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/debug"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -6108,7 +6109,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInFeatureIntersection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("breakWithNonEmptyStack.kt") @@ -6200,7 +6201,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("bigArity.kt") @@ -6222,7 +6223,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInBound() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("emptyLHS.kt") @@ -6240,7 +6241,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/function"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/function"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("genericCallableReferencesWithNullableTypes.kt") @@ -6257,7 +6258,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInLocal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/function/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/function/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("equalsHashCode.kt") @@ -6277,7 +6278,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInTailrec() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/tailrec"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/tailrec"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("controlFlowIf.kt") @@ -6356,7 +6357,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("nonLocalReturn.kt") @@ -6373,7 +6374,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInDirect() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses/direct"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses/direct"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("boxReturnValueOfSuspendFunctionReference.kt") @@ -6601,7 +6602,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInResume() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses/resume"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses/resume"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("boxReturnValueOfSuspendFunctionReference.kt") @@ -6829,7 +6830,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInResumeWithException() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("boxReturnValueOfSuspendFunctionReference.kt") @@ -7043,7 +7044,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInIntLikeVarSpilling() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/intLikeVarSpilling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/intLikeVarSpilling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("complicatedMerge.kt") @@ -7101,7 +7102,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInIntrinsicSemantics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/intrinsicSemantics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/intrinsicSemantics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("coroutineContext.kt") @@ -7154,7 +7155,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInJavaInterop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -7167,7 +7168,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInLocalFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/localFunctions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/localFunctions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("compiler/testData/codegen/box/coroutines/localFunctions/anonymous") @@ -7179,7 +7180,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInAnonymous() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/localFunctions/anonymous"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/localFunctions/anonymous"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("simple.kt") @@ -7197,7 +7198,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInNamed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/localFunctions/named"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/localFunctions/named"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("capturedParameters.kt") @@ -7261,7 +7262,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInMultiModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("inlineCrossModule.kt") @@ -7314,7 +7315,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInRedundantLocalsElimination() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/redundantLocalsElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/redundantLocalsElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("ktor_receivedMessage.kt") @@ -7332,7 +7333,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInReflect() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/reflect"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/reflect"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -7345,7 +7346,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInStackUnwinding() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/stackUnwinding"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/stackUnwinding"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("exception.kt") @@ -7388,7 +7389,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInSuspendConversion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/suspendConversion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/suspendConversion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("intersectionTypeToSubtypeConversion.kt") @@ -7421,7 +7422,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInSuspendFunctionAsCoroutine() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("dispatchResume.kt") @@ -7519,7 +7520,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInSuspendFunctionTypeCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/suspendFunctionTypeCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/suspendFunctionTypeCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("localVal.kt") @@ -7557,7 +7558,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInTailCallOptimizations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/tailCallOptimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/tailCallOptimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("crossinline.kt") @@ -7589,7 +7590,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInUnit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/tailCallOptimizations/unit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/tailCallOptimizations/unit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } } @@ -7603,7 +7604,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInTailOperations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/tailOperations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/tailOperations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("suspendWithIf.kt") @@ -7636,7 +7637,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInUnitTypeReturn() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/unitTypeReturn"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/unitTypeReturn"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("coroutineNonLocalReturn.kt") @@ -7684,7 +7685,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInVarSpilling() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/varSpilling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/varSpilling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("fakeInlinerVariables.kt") @@ -7728,7 +7729,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInDataClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("arrayParams.kt") @@ -7810,7 +7811,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInCopy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/copy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/copy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("constructorWithDefaultParam.kt") @@ -7863,7 +7864,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInEquals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/equals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/equals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("alreadyDeclared.kt") @@ -7906,7 +7907,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInHashCode() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/hashCode"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/hashCode"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("alreadyDeclared.kt") @@ -7974,7 +7975,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInToString() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/toString"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/toString"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("alreadyDeclared.kt") @@ -8018,7 +8019,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInDeadCodeElimination() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/deadCodeElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/deadCodeElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("emptyVariableRange.kt") @@ -8051,7 +8052,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInDefaultArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("callDefaultFromInitializer.kt") @@ -8128,7 +8129,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/constructor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/constructor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("annotation.kt") @@ -8216,7 +8217,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInConvention() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/convention"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/convention"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("incWithDefaultInGetter.kt") @@ -8264,7 +8265,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/function"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/function"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("complexInheritance.kt") @@ -8412,7 +8413,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInPrivate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("memberExtensionFunction.kt") @@ -8445,7 +8446,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/signature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/signature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("kt2789.kt") @@ -8479,7 +8480,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInDelegatedProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("beforeDeclarationContainerOptimization.kt") @@ -8711,7 +8712,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInLocal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("capturedLocalVal.kt") @@ -8804,7 +8805,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInOptimizedDelegatedProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/optimizedDelegatedProperties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/optimizedDelegatedProperties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("definedInSources.kt") @@ -8867,7 +8868,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInProvideDelegate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/provideDelegate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/provideDelegate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("delegatedPropertyWithIdProvideDelegate.kt") @@ -8986,7 +8987,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInDelegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("delegationWithPrivateConstructor.kt") @@ -9024,7 +9025,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInDestructuringDeclInLambdaParam() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/destructuringDeclInLambdaParam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/destructuringDeclInLambdaParam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("extensionComponents.kt") @@ -9077,7 +9078,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInDiagnostics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("compiler/testData/codegen/box/diagnostics/functions") @@ -9089,7 +9090,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("compiler/testData/codegen/box/diagnostics/functions/inference") @@ -9101,7 +9102,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInInference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/inference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/inference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("kt6176.kt") @@ -9119,7 +9120,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInInvoke() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/invoke"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/invoke"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects") @@ -9131,7 +9132,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInOnObjects() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("invokeOnClassObject1.kt") @@ -9195,7 +9196,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInTailRecursion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/tailRecursion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/tailRecursion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("defaultArgs.kt") @@ -9409,7 +9410,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInVararg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/vararg"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/vararg"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("kt4172.kt") @@ -9428,7 +9429,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInElvis() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/elvis"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/elvis"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("genericElvisWithMoreSpecificLHS.kt") @@ -9486,7 +9487,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("asReturnExpression.kt") @@ -9773,7 +9774,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInDefaultCtor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/enum/defaultCtor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/enum/defaultCtor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("constructorWithDefaultArguments.kt") @@ -9817,7 +9818,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInEvaluate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/evaluate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/evaluate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("kt9443.kt") @@ -9835,7 +9836,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInExclExcl() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/exclExcl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/exclExcl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("genericNull.kt") @@ -9858,7 +9859,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInExtensionFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/extensionFunctions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/extensionFunctions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("executionOrder.kt") @@ -9996,7 +9997,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInExtensionProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/extensionProperties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/extensionProperties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("genericValForPrimitiveType.kt") @@ -10074,7 +10075,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInExternal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/external"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/external"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -10087,7 +10088,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInFakeOverride() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fakeOverride"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fakeOverride"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("diamondFunction.kt") @@ -10130,7 +10131,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInFieldRename() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fieldRename"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fieldRename"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("constructorAndClassObject.kt") @@ -10158,7 +10159,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInFinally() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/finally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/finally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("breakAndOuterFinally.kt") @@ -10276,7 +10277,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInFullJdk() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("compiler/testData/codegen/box/fullJdk/native") @@ -10288,7 +10289,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInNative() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk/native"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk/native"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -10301,7 +10302,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInRegressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk/regressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk/regressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } } @@ -10315,7 +10316,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInFunInterface() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("basicFunInterface.kt") @@ -10432,7 +10433,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInEquality() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/funInterface/equality"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/funInterface/equality"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("functionReferencesBound.kt") @@ -10471,7 +10472,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("coerceVoidToArray.kt") @@ -10703,7 +10704,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInBigArity() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/bigArity"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/bigArity"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("function255.kt") @@ -10751,7 +10752,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInFunctionExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/functionExpression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/functionExpression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("functionExpression.kt") @@ -10794,7 +10795,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInInvoke() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/invoke"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/invoke"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("castFunctionToExtension.kt") @@ -10877,7 +10878,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInLocalFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/localFunctions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/localFunctions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("boundTypeParameterInSupertype.kt") @@ -11041,7 +11042,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInHashPMap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/hashPMap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/hashPMap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -11054,7 +11055,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInIeee754() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ieee754"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ieee754"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("anyToReal.kt") @@ -11247,7 +11248,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInIncrement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/increment"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/increment"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("argumentWithSideEffects.kt") @@ -11390,7 +11391,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInInference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("approximateNonTopLevelCapturedTypes.kt") @@ -11523,7 +11524,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("annotatedMemberExtensionProperty.kt") @@ -12275,7 +12276,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInBoxReturnValueInLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("boxAny.kt") @@ -12348,7 +12349,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInBoxReturnValueOnOverride() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("covariantOverrideChainErasedToAny.kt") @@ -12491,7 +12492,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInCallableReferences() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/callableReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/callableReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("boundInlineClassExtensionFun.kt") @@ -12654,7 +12655,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInContextsAndAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("captureInlineClassInstanceInLambda.kt") @@ -12722,7 +12723,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInDefaultParameterValues() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/defaultParameterValues"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/defaultParameterValues"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("defaultConstructorParameterValuesOfInlineClassType.kt") @@ -12795,7 +12796,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInFunctionNameMangling() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/functionNameMangling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/functionNameMangling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("anonymousObjectInFunctionWithMangledName.kt") @@ -12888,7 +12889,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInHiddenConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/hiddenConstructor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/hiddenConstructor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("constructorReferencedFromOtherFile1.kt") @@ -12966,7 +12967,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInInterfaceDelegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/interfaceDelegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/interfaceDelegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("interfaceImplementationByDelegation.kt") @@ -13019,7 +13020,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInInterfaceMethodCalls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("complexGenericMethodWithInlineClassOverride.kt") @@ -13087,7 +13088,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInJavaInterop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -13100,7 +13101,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInJvm8DefaultInterfaceMethods() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/jvm8DefaultInterfaceMethods"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/jvm8DefaultInterfaceMethods"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -13113,7 +13114,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInPropertyDelegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/propertyDelegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/propertyDelegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("captureLocalVarDelegatedToInlineClass.kt") @@ -13181,7 +13182,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInUnboxGenericParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface") @@ -13193,7 +13194,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInFunInterface() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("any.kt") @@ -13241,7 +13242,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("any.kt") @@ -13289,7 +13290,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInObjectLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("any.kt") @@ -13339,7 +13340,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInInnerNested() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/innerNested"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/innerNested"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("createNestedClass.kt") @@ -13476,7 +13477,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInSuperConstructorCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/innerNested/superConstructorCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/innerNested/superConstructorCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("deepInnerHierarchy.kt") @@ -13590,7 +13591,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInInstructions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/instructions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/instructions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("compiler/testData/codegen/box/instructions/swap") @@ -13602,7 +13603,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInSwap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/instructions/swap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/instructions/swap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("swapRefToSharedVarInt.kt") @@ -13626,7 +13627,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInIntrinsics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/intrinsics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/intrinsics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("charToInt.kt") @@ -13744,7 +13745,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInIr() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("anonymousClassLeak.kt") @@ -13836,7 +13837,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInClosureConversion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/closureConversion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/closureConversion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("closureConversion1.kt") @@ -13889,7 +13890,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInPrimitiveNumberComparisons() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/primitiveNumberComparisons"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/primitiveNumberComparisons"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("comparableToDouble.kt") @@ -13922,7 +13923,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInSerializationRegressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/serializationRegressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/serializationRegressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("deepGenericDelegatedProperty.kt") @@ -13976,7 +13977,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInJavaInterop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("compiler/testData/codegen/box/javaInterop/generics") @@ -13988,7 +13989,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInGenerics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/generics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/generics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("kt42824.kt") @@ -14011,7 +14012,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInNotNullAssertions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("mapPut.kt") @@ -14028,7 +14029,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInEnhancedNullability() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions/enhancedNullability"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions/enhancedNullability"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -14041,7 +14042,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInNullCheckOnLambdaReturnValue() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions/nullCheckOnLambdaReturnValue"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions/nullCheckOnLambdaReturnValue"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } } @@ -14055,7 +14056,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInObjectMethods() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/objectMethods"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/objectMethods"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("cloneCallsConstructor.kt") @@ -14089,7 +14090,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInJdk() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jdk"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jdk"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("arrayList.kt") @@ -14122,7 +14123,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInJvm8() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("compiler/testData/codegen/box/jvm8/defaults") @@ -14134,7 +14135,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInDefaults() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/allCompatibility") @@ -14146,7 +14147,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInAllCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/delegationBy") @@ -14158,7 +14159,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInDelegationBy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } } @@ -14172,7 +14173,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/compatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/compatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -14185,7 +14186,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInDelegationBy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -14198,7 +14199,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInNoDefaultImpls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/delegationBy") @@ -14210,7 +14211,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInDelegationBy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -14223,7 +14224,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInSpecialization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/specialization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/specialization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } } @@ -14237,7 +14238,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInNoDelegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDelegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDelegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -14250,7 +14251,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInReflection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/reflection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/reflection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } } @@ -14264,7 +14265,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInInterfaceFlag() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/interfaceFlag"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/interfaceFlag"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -14277,7 +14278,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInJavaDefaults() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/javaDefaults"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/javaDefaults"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } } @@ -14291,7 +14292,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInJvmField() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmField"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmField"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -14304,7 +14305,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInJvmName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("compiler/testData/codegen/box/jvmName/fileFacades") @@ -14316,7 +14317,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInFileFacades() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmName/fileFacades"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmName/fileFacades"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } } @@ -14330,7 +14331,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInJvmOverloads() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmOverloads"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmOverloads"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -14343,7 +14344,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInJvmPackageName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmPackageName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmPackageName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -14356,7 +14357,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInJvmStatic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmStatic"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmStatic"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -14369,7 +14370,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInLabels() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/labels"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/labels"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("controlLabelClashesWithFuncitonName.kt") @@ -14422,7 +14423,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInLazyCodegen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/lazyCodegen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/lazyCodegen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("exceptionInFieldInitializer.kt") @@ -14479,7 +14480,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInOptimizations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/lazyCodegen/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/lazyCodegen/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("negateConstantCompare.kt") @@ -14538,7 +14539,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInLocalClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/localClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/localClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("anonymousObjectInExtension.kt") @@ -14721,7 +14722,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInMangling() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/mangling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/mangling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("internal.kt") @@ -14764,7 +14765,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInMixedNamedPosition() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/mixedNamedPosition"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/mixedNamedPosition"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("defaults.kt") @@ -14797,7 +14798,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInMultiDecl() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("ComplexInitializer.kt") @@ -14879,7 +14880,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInForIterator() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forIterator"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forIterator"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("MultiDeclFor.kt") @@ -14916,7 +14917,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInLongIterator() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forIterator/longIterator"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forIterator/longIterator"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -14950,7 +14951,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInForRange() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("MultiDeclFor.kt") @@ -14997,7 +14998,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInExplicitRangeTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("MultiDeclFor.kt") @@ -15034,7 +15035,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInInt() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -15067,7 +15068,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInLong() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -15101,7 +15102,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInExplicitRangeToWithDot() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("MultiDeclFor.kt") @@ -15138,7 +15139,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInInt() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -15171,7 +15172,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInLong() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -15205,7 +15206,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInInt() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -15238,7 +15239,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInLong() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -15273,7 +15274,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInMultifileClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("compiler/testData/codegen/box/multifileClasses/optimized") @@ -15285,7 +15286,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInOptimized() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multifileClasses/optimized"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multifileClasses/optimized"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } } @@ -15299,7 +15300,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInMultiplatform() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("optionalExpectation.kt") @@ -15321,7 +15322,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInDefaultArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("bothInExpectAndActual.kt") @@ -15439,7 +15440,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInMultiModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("expectActualLink.kt") @@ -15468,7 +15469,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInNonLocalReturns() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nonLocalReturns"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nonLocalReturns"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("kt9644let.kt") @@ -15496,7 +15497,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInNothingValue() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nothingValue"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nothingValue"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("inNestedCall.kt") @@ -15519,7 +15520,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInNullCheckOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nullCheckOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nullCheckOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("isNullable.kt") @@ -15557,7 +15558,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInObjectIntrinsics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objectIntrinsics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objectIntrinsics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("objects.kt") @@ -15575,7 +15576,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInObjects() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("anonymousObjectPropertyInitialization.kt") @@ -15932,7 +15933,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInCompanionObjectAccess() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("kt27117.kt") @@ -16029,7 +16030,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInMultipleCompanionsWithAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("anonymousObjectInPropertyInitializer.kt") @@ -16097,7 +16098,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInPrimitiveCompanion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess/primitiveCompanion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess/primitiveCompanion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("byteCompanionObject.kt") @@ -16147,7 +16148,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInOldLanguageVersions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("dataClassEqualsHashCodeToString.kt") @@ -16164,7 +16165,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInControlStructures() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/controlStructures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/controlStructures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("compiler/testData/codegen/box/oldLanguageVersions/controlStructures/forInArray") @@ -16176,7 +16177,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInForInArray() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/controlStructures/forInArray"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/controlStructures/forInArray"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("forInArrayWithArrayVarUpdatedInLoopBody12.kt") @@ -16195,7 +16196,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInCoroutines() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("compiler/testData/codegen/box/oldLanguageVersions/coroutines/controlFlow") @@ -16207,7 +16208,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInControlFlow() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines/controlFlow"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines/controlFlow"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -16220,7 +16221,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInFeatureIntersection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines/featureIntersection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines/featureIntersection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("suspendFunction_1_2.kt") @@ -16238,7 +16239,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInMultiModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -16251,7 +16252,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInReflect() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines/reflect"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines/reflect"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -16264,7 +16265,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInSuspendFunctionAsCoroutine() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines/suspendFunctionAsCoroutine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines/suspendFunctionAsCoroutine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } } @@ -16278,7 +16279,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("compiler/testData/codegen/box/oldLanguageVersions/functions/bigArity") @@ -16290,7 +16291,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInBigArity() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/functions/bigArity"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/functions/bigArity"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("noBigFunctionTypes.kt") @@ -16309,7 +16310,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInIeee754() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/ieee754"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/ieee754"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("nullableDoubleEquals10.kt") @@ -16347,7 +16348,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInJavaInterop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("compiler/testData/codegen/box/oldLanguageVersions/javaInterop/notNullAssertions") @@ -16359,7 +16360,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInNotNullAssertions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/javaInterop/notNullAssertions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/javaInterop/notNullAssertions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } } @@ -16373,7 +16374,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInOperatorConventions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/operatorConventions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/operatorConventions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -16386,7 +16387,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInPlatformTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/platformTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/platformTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("compiler/testData/codegen/box/oldLanguageVersions/platformTypes/primitives") @@ -16398,7 +16399,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInPrimitives() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/platformTypes/primitives"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/platformTypes/primitives"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } } @@ -16413,7 +16414,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInOperatorConventions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/operatorConventions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/operatorConventions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("annotatedAssignment.kt") @@ -16525,7 +16526,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInCompareTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/operatorConventions/compareTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/operatorConventions/compareTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("boolean.kt") @@ -16594,7 +16595,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInOptimizations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("kt20844.kt") @@ -16612,7 +16613,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInPackage() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/package"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/package"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("boxPrimitiveTypeInClinit.kt") @@ -16680,7 +16681,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInParametersMetadata() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/parametersMetadata"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/parametersMetadata"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -16693,7 +16694,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInPlatformTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/platformTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/platformTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("inferenceFlexibleTToNullable.kt") @@ -16710,7 +16711,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInPrimitives() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/platformTypes/primitives"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/platformTypes/primitives"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("assign.kt") @@ -16819,7 +16820,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInPolymorphicSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/polymorphicSignature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/polymorphicSignature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -16832,7 +16833,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInPrimitiveTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("comparisonWithNullCallsFun.kt") @@ -17129,7 +17130,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInEqualityWithObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes/equalityWithObject"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes/equalityWithObject"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("boxedEqPrimitiveEvaluationOrder.kt") @@ -17186,7 +17187,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInGenerated() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("boxedEqPrimitiveBoolean.kt") @@ -17291,7 +17292,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInPrivate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("arrayConvention.kt") @@ -17314,7 +17315,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInPrivateConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/privateConstructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/privateConstructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("base.kt") @@ -17417,7 +17418,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("augmentedAssignmentsAndIncrements.kt") @@ -17774,7 +17775,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInConst() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/const"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/const"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("anotherFile.kt") @@ -17812,7 +17813,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInLateinit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("exceptionField.kt") @@ -17874,7 +17875,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInIsInitializedAndDeinitialize() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/isInitializedAndDeinitialize"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/isInitializedAndDeinitialize"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("companionObjectField.kt") @@ -17927,7 +17928,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInLocal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("capturedLocalLateinit.kt") @@ -17985,7 +17986,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInTopLevel() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/topLevel"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/topLevel"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("topLevelLateinit.kt") @@ -18015,7 +18016,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInPublishedApi() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/publishedApi"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/publishedApi"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("simple.kt") @@ -18038,7 +18039,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInRanges() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("forByteProgressionWithIntIncrement.kt") @@ -18130,7 +18131,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInContains() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/contains"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/contains"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("comparisonWithRangeBoundEliminated.kt") @@ -18342,7 +18343,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInGenerated() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/contains/generated"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/contains/generated"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("arrayIndices.kt") @@ -18426,7 +18427,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInEvaluationOrder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("forInDownTo.kt") @@ -18483,7 +18484,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInStepped() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo") @@ -18495,7 +18496,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInForInDownTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("forInDownToReversedStep.kt") @@ -18548,7 +18549,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInForInRangeLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInRangeLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInRangeLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("forInRangeLiteralReversedStep.kt") @@ -18601,7 +18602,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInForInUntil() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInUntil"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInUntil"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("forInUntilReversedStep.kt") @@ -18656,7 +18657,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("emptyDownto.kt") @@ -18819,7 +18820,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInForInDownTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInDownTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInDownTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("forIntInDownTo.kt") @@ -18857,7 +18858,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInForInIndices() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInIndices"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInIndices"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("forInArrayListIndices.kt") @@ -18975,7 +18976,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInForInProgressionWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInProgressionWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInProgressionWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("forInDownToWithIndex.kt") @@ -19063,7 +19064,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInForInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInReversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInReversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("forInReversedArrayIndices.kt") @@ -19166,7 +19167,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInForInUntil() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInUntil"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInUntil"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("forInUntilChar.kt") @@ -19254,7 +19255,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInForWithPossibleOverflow() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forWithPossibleOverflow"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forWithPossibleOverflow"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("forInDownToCharMinValue.kt") @@ -19332,7 +19333,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInJavaInterop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("compiler/testData/codegen/box/ranges/javaInterop/withIndex") @@ -19344,7 +19345,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/javaInterop/withIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/javaInterop/withIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } } @@ -19358,7 +19359,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("emptyDownto.kt") @@ -19521,7 +19522,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInNullableLoopParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/nullableLoopParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/nullableLoopParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("progressionExpression.kt") @@ -19549,7 +19550,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInStepped() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("compiler/testData/codegen/box/ranges/stepped/expression") @@ -19561,7 +19562,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("compiler/testData/codegen/box/ranges/stepped/expression/downTo") @@ -19573,7 +19574,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInDownTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/downTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/downTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("emptyProgression.kt") @@ -19665,7 +19666,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/downTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/downTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -19718,7 +19719,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/downTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/downTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("reversedThenStep.kt") @@ -19762,7 +19763,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInRangeTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("emptyProgression.kt") @@ -19854,7 +19855,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -19907,7 +19908,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("reversedThenStep.kt") @@ -19951,7 +19952,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInUntil() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/until"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/until"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("emptyProgression.kt") @@ -20048,7 +20049,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/until/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/until/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -20101,7 +20102,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/until/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/until/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("reversedThenStep.kt") @@ -20146,7 +20147,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("compiler/testData/codegen/box/ranges/stepped/literal/downTo") @@ -20158,7 +20159,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInDownTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/downTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/downTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("emptyProgression.kt") @@ -20250,7 +20251,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/downTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/downTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -20303,7 +20304,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/downTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/downTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("reversedThenStep.kt") @@ -20347,7 +20348,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInRangeTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("emptyProgression.kt") @@ -20439,7 +20440,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -20492,7 +20493,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("reversedThenStep.kt") @@ -20536,7 +20537,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInUntil() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/until"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/until"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("emptyProgression.kt") @@ -20633,7 +20634,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/until/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/until/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -20686,7 +20687,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/until/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/until/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("reversedThenStep.kt") @@ -20731,7 +20732,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInUnsigned() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/expression") @@ -20743,7 +20744,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo") @@ -20755,7 +20756,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInDownTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("emptyProgression.kt") @@ -20847,7 +20848,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -20900,7 +20901,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("reversedThenStep.kt") @@ -20944,7 +20945,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInRangeTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("emptyProgression.kt") @@ -21036,7 +21037,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -21089,7 +21090,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("reversedThenStep.kt") @@ -21133,7 +21134,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInUntil() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("emptyProgression.kt") @@ -21230,7 +21231,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -21283,7 +21284,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("reversedThenStep.kt") @@ -21328,7 +21329,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo") @@ -21340,7 +21341,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInDownTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("emptyProgression.kt") @@ -21432,7 +21433,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -21485,7 +21486,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("reversedThenStep.kt") @@ -21529,7 +21530,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInRangeTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("emptyProgression.kt") @@ -21621,7 +21622,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -21674,7 +21675,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("reversedThenStep.kt") @@ -21718,7 +21719,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInUntil() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("emptyProgression.kt") @@ -21815,7 +21816,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -21868,7 +21869,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("reversedThenStep.kt") @@ -21915,7 +21916,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInUnsigned() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("inMixedUnsignedRange.kt") @@ -21952,7 +21953,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("emptyDownto.kt") @@ -22115,7 +22116,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("emptyDownto.kt") @@ -22278,7 +22279,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInNullableLoopParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/nullableLoopParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/nullableLoopParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("progressionExpression.kt") @@ -22308,7 +22309,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInReflection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("compiler/testData/codegen/box/reflection/annotations") @@ -22320,7 +22321,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/annotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/annotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("annotationRetentionAnnotation.kt") @@ -22392,7 +22393,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInOnTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/annotations/onTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/annotations/onTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } } @@ -22406,7 +22407,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInBuiltins() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/builtins"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/builtins"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("enumNameOrdinal.kt") @@ -22429,7 +22430,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("bigArity.kt") @@ -22501,7 +22502,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInBound() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("companionObjectPropertyAccessors.kt") @@ -22554,7 +22555,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("constructorWithInlineClassParameters.kt") @@ -22618,7 +22619,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInCallBy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/callBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/callBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("boundExtensionFunction.kt") @@ -22741,7 +22742,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInClassLiterals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/classLiterals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/classLiterals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("annotationClassLiteral.kt") @@ -22774,7 +22775,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/classes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/classes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("companionObject.kt") @@ -22812,7 +22813,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/constructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/constructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("annotationClass.kt") @@ -22850,7 +22851,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInCreateAnnotation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/createAnnotation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/createAnnotation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("annotationType.kt") @@ -22903,7 +22904,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInEnclosing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/enclosing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/enclosing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -22916,7 +22917,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("enumValuesValueOf.kt") @@ -22949,7 +22950,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInGenericSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/genericSignature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/genericSignature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -22962,7 +22963,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInIsInstance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/isInstance"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/isInstance"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -22975,7 +22976,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInKClassInAnnotation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/kClassInAnnotation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/kClassInAnnotation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("forceWrapping.kt") @@ -22998,7 +22999,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInLambdaClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/lambdaClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/lambdaClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -23011,7 +23012,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInMapping() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("compiler/testData/codegen/box/reflection/mapping/fakeOverrides") @@ -23023,7 +23024,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInFakeOverrides() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/fakeOverrides"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/fakeOverrides"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -23036,7 +23037,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -23049,7 +23050,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInJvmStatic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/jvmStatic"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/jvmStatic"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -23062,7 +23063,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/types"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/types"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } } @@ -23076,7 +23077,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInMethodsFromAny() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/methodsFromAny"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/methodsFromAny"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("callableReferencesEqualToCallablesFromAPI.kt") @@ -23184,7 +23185,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInModifiers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/modifiers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/modifiers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("callableModality.kt") @@ -23232,7 +23233,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInMultifileClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -23245,7 +23246,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInNoReflectAtRuntime() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/noReflectAtRuntime"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/noReflectAtRuntime"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("propertyGetSetName.kt") @@ -23272,7 +23273,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInMethodsFromAny() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/noReflectAtRuntime/methodsFromAny"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/noReflectAtRuntime/methodsFromAny"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("callableReferences.kt") @@ -23296,7 +23297,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/parameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/parameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("bigArity.kt") @@ -23354,7 +23355,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("allVsDeclared.kt") @@ -23431,7 +23432,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/accessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/accessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("extensionPropertyAccessors.kt") @@ -23464,7 +23465,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInGetDelegate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/getDelegate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/getDelegate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -23477,7 +23478,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInJvmField() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/jvmField"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/jvmField"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -23490,7 +23491,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInLocalDelegated() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/localDelegated"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/localDelegated"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } } @@ -23504,7 +23505,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInSupertypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/supertypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/supertypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("genericSubstitution.kt") @@ -23532,7 +23533,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInTypeOf() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("classes.kt") @@ -23569,7 +23570,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInJs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/js"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/js"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("classes.kt") @@ -23622,7 +23623,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInNoReflect() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/noReflect"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/noReflect"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("typeReferenceEqualsHashCode.kt") @@ -23639,7 +23640,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInNonReifiedTypeParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/noReflect/nonReifiedTypeParameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/noReflect/nonReifiedTypeParameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } } @@ -23653,7 +23654,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInNonReifiedTypeParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/nonReifiedTypeParameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/nonReifiedTypeParameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("defaultUpperBound.kt") @@ -23732,7 +23733,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInTypeParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeParameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeParameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("declarationSiteVariance.kt") @@ -23760,7 +23761,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/types"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/types"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("classifierIsClass.kt") @@ -23797,7 +23798,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInCreateType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/types/createType"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/types/createType"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("equality.kt") @@ -23835,7 +23836,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInSubtyping() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/types/subtyping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/types/subtyping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("simpleGenericTypes.kt") @@ -23865,7 +23866,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInRegressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/regressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/regressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("arrayLengthNPE.kt") @@ -24208,7 +24209,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInReified() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reified"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reified"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("checkcast.kt") @@ -24300,7 +24301,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInArraysReification() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reified/arraysReification"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reified/arraysReification"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("instanceOf.kt") @@ -24334,7 +24335,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInSafeCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/safeCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/safeCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("genericNull.kt") @@ -24412,7 +24413,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInSam() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("compiler/testData/codegen/box/sam/constructors") @@ -24424,7 +24425,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam/constructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam/constructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("comparator.kt") @@ -24452,7 +24453,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInEquality() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam/equality"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam/equality"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } } @@ -24466,7 +24467,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInSealed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sealed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sealed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("multipleFiles_enabled.kt") @@ -24504,7 +24505,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInSecondaryConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/secondaryConstructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/secondaryConstructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("basicNoPrimaryManySinks.kt") @@ -24662,7 +24663,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInSignatureAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/signatureAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/signatureAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -24675,7 +24676,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInSmap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/smap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/smap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -24688,7 +24689,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInSmartCasts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/smartCasts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/smartCasts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("falseSmartCast.kt") @@ -24776,7 +24777,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInSpecialBuiltins() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/specialBuiltins"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/specialBuiltins"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("bridgeNotEmptyMap.kt") @@ -24909,7 +24910,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInStatics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/statics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/statics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("anonymousInitializerIObject.kt") @@ -24962,7 +24963,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInStoreStackBeforeInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/storeStackBeforeInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/storeStackBeforeInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("differentTypes.kt") @@ -25000,7 +25001,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInStrings() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/strings"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/strings"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("constInStringTemplate.kt") @@ -25118,7 +25119,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInSuper() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/super"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/super"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("basicmethodSuperClass.kt") @@ -25280,7 +25281,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInSuperConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/super/superConstructor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/super/superConstructor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("kt13846.kt") @@ -25329,7 +25330,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInSynchronized() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/synchronized"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/synchronized"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -25372,7 +25373,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInSyntheticAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/syntheticAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/syntheticAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("inline.kt") @@ -25440,7 +25441,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInThrows() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/throws"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/throws"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -25453,7 +25454,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInToArray() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/toArray"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/toArray"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("kt3177-toTypedArray.kt") @@ -25481,7 +25482,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInTopLevelPrivate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/topLevelPrivate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/topLevelPrivate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("privateInInlineNested.kt") @@ -25504,7 +25505,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInTrailingComma() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/trailingComma"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/trailingComma"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("noDisambiguation.kt") @@ -25527,7 +25528,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInTraits() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/traits"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/traits"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("diamondPropertyAccessors.kt") @@ -25700,7 +25701,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInTypeInfo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typeInfo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typeInfo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("ifOrWhenSpecialCall.kt") @@ -25743,7 +25744,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInTypeMapping() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typeMapping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typeMapping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("kt2831.kt") @@ -25791,7 +25792,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInTypealias() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typealias"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typealias"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("enumEntryQualifier.kt") @@ -25899,7 +25900,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInUnaryOp() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unaryOp"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unaryOp"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("call.kt") @@ -25942,7 +25943,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInUnit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("closureReturnsNullableUnit.kt") @@ -26010,7 +26011,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInUnsignedTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unsignedTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unsignedTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("boxConstValOfUnsignedType.kt") @@ -26217,7 +26218,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInJvm8Intrinsics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unsignedTypes/jvm8Intrinsics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unsignedTypes/jvm8Intrinsics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } } @@ -26231,7 +26232,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInValueClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/valueClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/valueClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("jvmInline.kt") @@ -26249,7 +26250,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInVararg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/vararg"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/vararg"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("doNotCopyImmediatelyCreatedArrays.kt") @@ -26327,7 +26328,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInWhen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("callProperty.kt") @@ -26539,7 +26540,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInEnumOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/enumOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/enumOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("bigEnum.kt") @@ -26642,7 +26643,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInStringOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/stringOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/stringOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("duplicatingItems.kt") @@ -26700,7 +26701,7 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes } public void testAllFilesPresentInWhenSubjectVariable() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/whenSubjectVariable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/whenSubjectVariable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("captureSubjectVariable.kt") diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/es6/semantics/IrJsCodegenInlineES6TestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/es6/semantics/IrJsCodegenInlineES6TestGenerated.java index 66dbe5bc502..1c01c15ab69 100644 --- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/es6/semantics/IrJsCodegenInlineES6TestGenerated.java +++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/es6/semantics/IrJsCodegenInlineES6TestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.js.test.es6.semantics; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInBoxInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("compiler/testData/codegen/boxInline/anonymousObject") @@ -38,7 +39,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInAnonymousObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("anonymousObjectInDefault.kt") @@ -315,7 +316,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInEnumWhen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/enumWhen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/enumWhen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("callSite.kt") @@ -348,7 +349,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInProperRecapturing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("inlineChain.kt") @@ -391,7 +392,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInProperRecapturingInClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("inlineChain.kt") @@ -464,7 +465,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInSam() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -477,7 +478,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInTwoCapturedReceivers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("kt8668.kt") @@ -516,7 +517,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInArgumentOrder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/argumentOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/argumentOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("boundFunctionReference.kt") @@ -599,7 +600,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInArrayConvention() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/arrayConvention"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/arrayConvention"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("simpleAccess.kt") @@ -642,7 +643,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInAssert() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/assert"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/assert"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -655,7 +656,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInBuilders() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/builders"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/builders"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -668,7 +669,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInBytecodePreprocessing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/bytecodePreprocessing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/bytecodePreprocessing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -686,7 +687,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("classLevel.kt") @@ -768,7 +769,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInBound() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("classProperty.kt") @@ -897,7 +898,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInCapture() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/capture"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/capture"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("captureInlinable.kt") @@ -940,7 +941,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInComplex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/complex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/complex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("closureChain.kt") @@ -978,7 +979,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInComplexStack() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/complexStack"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/complexStack"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("asCheck.kt") @@ -1036,7 +1037,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInContracts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/contracts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/contracts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("cfgDependendValInitialization.kt") @@ -1134,7 +1135,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInDefaultValues() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("defaultInExtension.kt") @@ -1236,7 +1237,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInLambdaInlining() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("checkLambdaClassIsPresent.kt") @@ -1398,7 +1399,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInCallableReferences() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("boundFunctionReference.kt") @@ -1532,7 +1533,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInMaskElimination() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/maskElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/maskElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("kt18792.kt") @@ -1571,7 +1572,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInDelegatedProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/delegatedProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/delegatedProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("kt16864.kt") @@ -1609,7 +1610,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInEnclosingInfo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/enclosingInfo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/enclosingInfo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -1622,7 +1623,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("kt10569.kt") @@ -1700,7 +1701,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInFunctionExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/functionExpression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/functionExpression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("extension.kt") @@ -1718,7 +1719,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("inlineClassWithInlineValReturningInlineClass.kt") @@ -1760,7 +1761,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInUnboxGenericParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/funInterface") @@ -1772,7 +1773,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInFunInterface() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("any.kt") @@ -1815,7 +1816,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/lambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/lambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("any.kt") @@ -1858,7 +1859,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInObjectLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/objectLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/objectLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("any.kt") @@ -1903,7 +1904,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInInnerClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/innerClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/innerClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("captureThisAndOuter.kt") @@ -1921,7 +1922,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInJvmPackageName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/jvmPackageName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/jvmPackageName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -1934,7 +1935,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInLambdaClassClash() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/lambdaClassClash"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/lambdaClassClash"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("lambdaClassClash.kt") @@ -1957,7 +1958,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInLambdaTransformation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/lambdaTransformation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/lambdaTransformation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("lambdaCloning.kt") @@ -1995,7 +1996,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInLocalFunInLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/localFunInLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/localFunInLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("defaultParam.kt") @@ -2028,7 +2029,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInMultiModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("tryCatchWithRecursiveInline.kt") @@ -2046,7 +2047,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInMultifileClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -2059,7 +2060,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInMultiplatform() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("compiler/testData/codegen/boxInline/multiplatform/defaultArguments") @@ -2071,7 +2072,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInDefaultArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiplatform/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiplatform/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("receiversAndParametersInLambda.kt") @@ -2090,7 +2091,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInNoInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/noInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/noInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("extensionReceiver.kt") @@ -2138,7 +2139,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInNonLocalReturns() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("explicitLocalReturn.kt") @@ -2220,7 +2221,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInDeparenthesize() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/deparenthesize"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/deparenthesize"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("bracket.kt") @@ -2243,7 +2244,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInTryFinally() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("kt16417.kt") @@ -2320,7 +2321,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInCallSite() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("callSite.kt") @@ -2363,7 +2364,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInChained() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("finallyInFinally.kt") @@ -2416,7 +2417,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInDeclSite() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("complex.kt") @@ -2489,7 +2490,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInExceptionTable() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("break.kt") @@ -2602,7 +2603,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInVariables() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/variables"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/variables"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("kt7792.kt") @@ -2622,7 +2623,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInOptimizations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("kt20844.kt") @@ -2655,7 +2656,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInPrivate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("effectivePrivate.kt") @@ -2708,7 +2709,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("augAssignmentAndInc.kt") @@ -2786,7 +2787,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInReified() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("arrayConstructor.kt") @@ -2858,7 +2859,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInCheckCast() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/checkCast"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/checkCast"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("chain.kt") @@ -2916,7 +2917,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInDefaultLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/defaultLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/defaultLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -2929,7 +2930,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInIsCheck() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/isCheck"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/isCheck"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("chain.kt") @@ -2958,7 +2959,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/signature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/signature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } } @@ -2971,7 +2972,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInSimple() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/simple"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/simple"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("captureAndArgumentIncompatibleTypes.kt") @@ -3099,7 +3100,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInSmap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("assertion.kt") @@ -3196,7 +3197,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInAnonymous() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/anonymous"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/anonymous"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("kt19175.kt") @@ -3259,7 +3260,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInDefaultLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/defaultLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/defaultLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("defaultLambdaInAnonymous.kt") @@ -3317,7 +3318,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInInlineOnly() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/inlineOnly"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/inlineOnly"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("noSmap.kt") @@ -3350,7 +3351,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInNewsmap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/newsmap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/newsmap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("differentMapping.kt") @@ -3383,7 +3384,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInResolve() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/resolve"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/resolve"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("inlineComponent.kt") @@ -3407,7 +3408,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInSpecial() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/special"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/special"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("identityCheck.kt") @@ -3465,7 +3466,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInStackOnReturn() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/stackOnReturn"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/stackOnReturn"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("elvis.kt") @@ -3558,7 +3559,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInSuspend() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("capturedVariables.kt") @@ -3685,7 +3686,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("isAsReified.kt") @@ -3723,7 +3724,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInDefaultParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/defaultParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/defaultParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("defaultValueCrossinline.kt") @@ -3756,7 +3757,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInInlineClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/inlineClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/inlineClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("returnUnboxedDirect.kt") @@ -3779,7 +3780,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInInlineUsedAsNoinline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/inlineUsedAsNoinline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/inlineUsedAsNoinline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("inlineOnly.kt") @@ -3802,7 +3803,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInReceiver() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/receiver"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/receiver"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("inlineOrdinaryOfCrossinlineSuspend.kt") @@ -3855,7 +3856,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInStateMachine() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/stateMachine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/stateMachine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("crossingCoroutineBoundaries.kt") @@ -3979,7 +3980,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInSyntheticAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/syntheticAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/syntheticAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("constField.kt") @@ -4031,7 +4032,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInWithinInlineLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("directFieldAccess.kt") @@ -4090,7 +4091,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInTrait() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/trait"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/trait"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("trait.kt") @@ -4108,7 +4109,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInTryCatchFinally() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/tryCatchFinally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/tryCatchFinally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("kt5863.kt") @@ -4141,7 +4142,7 @@ public class IrJsCodegenInlineES6TestGenerated extends AbstractIrJsCodegenInline } public void testAllFilesPresentInVarargs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/varargs"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/varargs"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("kt17653.kt") diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/es6/semantics/IrJsTypeScriptExportES6TestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/es6/semantics/IrJsTypeScriptExportES6TestGenerated.java index b6e7eab5ef7..9e539bd6eda 100644 --- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/es6/semantics/IrJsTypeScriptExportES6TestGenerated.java +++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/es6/semantics/IrJsTypeScriptExportES6TestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.js.test.es6.semantics; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class IrJsTypeScriptExportES6TestGenerated extends AbstractIrJsTypeScript } public void testAllFilesPresentInTypescript_export() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("js/js.translator/testData/typescript-export/constructors") @@ -38,7 +39,7 @@ public class IrJsTypeScriptExportES6TestGenerated extends AbstractIrJsTypeScript } public void testAllFilesPresentInConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export/constructors"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export/constructors"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("constructors.kt") @@ -56,7 +57,7 @@ public class IrJsTypeScriptExportES6TestGenerated extends AbstractIrJsTypeScript } public void testAllFilesPresentInDeclarations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export/declarations"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export/declarations"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("declarations.kt") @@ -74,7 +75,7 @@ public class IrJsTypeScriptExportES6TestGenerated extends AbstractIrJsTypeScript } public void testAllFilesPresentInInheritance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export/inheritance"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export/inheritance"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("inheritance.kt") @@ -92,7 +93,7 @@ public class IrJsTypeScriptExportES6TestGenerated extends AbstractIrJsTypeScript } public void testAllFilesPresentInModuleSystems() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export/moduleSystems"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export/moduleSystems"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("commonjs.kt") @@ -120,7 +121,7 @@ public class IrJsTypeScriptExportES6TestGenerated extends AbstractIrJsTypeScript } public void testAllFilesPresentInNamespaces() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export/namespaces"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export/namespaces"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("namespaces.kt") @@ -138,7 +139,7 @@ public class IrJsTypeScriptExportES6TestGenerated extends AbstractIrJsTypeScript } public void testAllFilesPresentInPrimitives() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export/primitives"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export/primitives"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("primitives.kt") @@ -156,7 +157,7 @@ public class IrJsTypeScriptExportES6TestGenerated extends AbstractIrJsTypeScript } public void testAllFilesPresentInSelectiveExport() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export/selectiveExport"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export/selectiveExport"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("selectiveExport.kt") @@ -174,7 +175,7 @@ public class IrJsTypeScriptExportES6TestGenerated extends AbstractIrJsTypeScript } public void testAllFilesPresentInVisibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export/visibility"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export/visibility"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR_ES6, true); } @TestMetadata("visibility.kt") diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/semantics/IrBoxJsTestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/semantics/IrBoxJsTestGenerated.java index 931a9b475e8..d51b4a391a2 100644 --- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/semantics/IrBoxJsTestGenerated.java +++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/semantics/IrBoxJsTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.js.test.ir.semantics; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInBox() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("js/js.translator/testData/box/annotation") @@ -38,7 +39,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInAnnotation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/annotation"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/annotation"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("annotationClass.kt") @@ -56,7 +57,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInBuiltins() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/builtins"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/builtins"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("hashCode.kt") @@ -84,7 +85,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/callableReference"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/callableReference"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("js/js.translator/testData/box/callableReference/function") @@ -96,7 +97,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/callableReference/function"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/callableReference/function"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("classMemberAndNonExtensionCompatibility.kt") @@ -154,7 +155,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/callableReference/property"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/callableReference/property"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("extensionProperty.kt") @@ -183,7 +184,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInChar() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/char"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/char"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("charBinaryOperations.kt") @@ -261,7 +262,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInClassObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/classObject"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/classObject"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("defaultObjectSameNamesAsInOuter.kt") @@ -319,7 +320,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInClosure() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/closure"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/closure"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("closureArrayListInstance.kt") @@ -557,7 +558,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInCoercion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/coercion"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/coercion"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("bridgeChar.kt") @@ -680,7 +681,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInCoroutines() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/coroutines"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/coroutines"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("debugStatement.kt") @@ -713,7 +714,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInCrossModuleRef() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/crossModuleRef"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/crossModuleRef"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("callableObjectRef.kt") @@ -806,7 +807,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInCrossModuleRefIR() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/crossModuleRefIR"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/crossModuleRefIR"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("callableObjectRef.kt") @@ -909,7 +910,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInDataClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/dataClass"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/dataClass"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("components.kt") @@ -962,7 +963,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInDefaultArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/defaultArguments"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/defaultArguments"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("complexExpressionAsConstructorDefaultArgument.kt") @@ -1085,7 +1086,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInDelegateProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/delegateProperty"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/delegateProperty"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("capturedLocalVal.kt") @@ -1213,7 +1214,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInDelegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/delegation"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/delegation"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("complexDelegation.kt") @@ -1316,7 +1317,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInDynamic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/dynamic"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/dynamic"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("binaryOperations.kt") @@ -1429,7 +1430,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/enum"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/enum"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("enumInheritedFromTrait.kt") @@ -1502,7 +1503,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInEs6classes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/es6classes"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/es6classes"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("builtItTypes.kt") @@ -1590,7 +1591,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInExamples() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/examples"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/examples"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("basicmethod.kt") @@ -1613,7 +1614,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInExport() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/export"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/export"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("nonIndetifierModuleName.kt") @@ -1636,7 +1637,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("js/js.translator/testData/box/expression/cast") @@ -1648,7 +1649,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInCast() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/cast"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/cast"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("castExtensionToKMutableProperty.kt") @@ -1796,7 +1797,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInCompareTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/compareTo"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/compareTo"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("booleanCompareTo.kt") @@ -1819,7 +1820,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInDollarParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/dollarParameter"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/dollarParameter"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("dollarParameter.kt") @@ -1837,7 +1838,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInEquals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/equals"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/equals"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("arrays.kt") @@ -1920,7 +1921,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInEvaluationOrder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/evaluationOrder"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/evaluationOrder"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("andAndWithBreakContinueReturn.kt") @@ -2123,7 +2124,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInFor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/for"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/for"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("forIteratesOverArray.kt") @@ -2216,7 +2217,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/function"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/function"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("anonymousWithLambda.kt") @@ -2399,7 +2400,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInIdentifierClash() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/identifierClash"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/identifierClash"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("overloadedFun.kt") @@ -2427,7 +2428,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInIdentityEquals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/identityEquals"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/identityEquals"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("identityEqualsMethod.kt") @@ -2450,7 +2451,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInIf() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/if"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/if"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("ifElseAsExpressionWithThrow.kt") @@ -2488,7 +2489,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInInvoke() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/invoke"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/invoke"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("explicitInvokeLambda.kt") @@ -2561,7 +2562,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInMisc() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/misc"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/misc"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("classWithoutPackage.kt") @@ -2784,7 +2785,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInStringClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/stringClass"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/stringClass"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("extensionMethods.kt") @@ -2862,7 +2863,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInStringTemplates() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/stringTemplates"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/stringTemplates"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("nonStrings.kt") @@ -2890,7 +2891,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInTry() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/try"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/try"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("exceptionToString.kt") @@ -2963,7 +2964,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInTypeCheck() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/typeCheck"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/typeCheck"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("simpleAsClass.kt") @@ -2996,7 +2997,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInWhen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/when"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/when"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("doWhileWithOneStmWhen.kt") @@ -3174,7 +3175,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInWhile() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/while"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/while"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("doWhileWithComplexCondition.kt") @@ -3213,7 +3214,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInExtensionFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/extensionFunction"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/extensionFunction"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("extensionForSuperclass.kt") @@ -3311,7 +3312,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInExtensionProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/extensionProperty"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/extensionProperty"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("externalExtensionProperty.kt") @@ -3354,7 +3355,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInIncremental() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/incremental"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/incremental"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("catchScope.kt") @@ -3462,7 +3463,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInInheritance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/inheritance"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/inheritance"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("baseCall.kt") @@ -3579,7 +3580,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInInterfaces() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/inheritance/interfaces"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/inheritance/interfaces"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("fromExternalInterface.kt") @@ -3613,7 +3614,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInInitialize() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/initialize"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/initialize"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("classInitializer.kt") @@ -3671,7 +3672,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/inline"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/inline"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("anonymousFunction.kt") @@ -4099,7 +4100,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInInlineEvaluationOrder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/inlineEvaluationOrder"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/inlineEvaluationOrder"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("alsoWithReassingment.kt") @@ -4377,7 +4378,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInInlineMultiFile() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/inlineMultiFile"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/inlineMultiFile"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("anonymousObjectInSimilarFunctions.kt") @@ -4540,7 +4541,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInInlineMultiModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/inlineMultiModule"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/inlineMultiModule"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("anotherModuleValInClosure.kt") @@ -4718,7 +4719,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInInlineSizeReduction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/inlineSizeReduction"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/inlineSizeReduction"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("inlineImportCleanup.kt") @@ -4816,7 +4817,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInInlineStdlib() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/inlineStdlib"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/inlineStdlib"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("callNameClash.kt") @@ -4874,7 +4875,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInIntrinsics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/intrinsics"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/intrinsics"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("typeof.kt") @@ -4892,7 +4893,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/java"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/java"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("js/js.translator/testData/box/java/abstractList") @@ -4904,7 +4905,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInAbstractList() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/java/abstractList"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/java/abstractList"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("iterator.kt") @@ -4927,7 +4928,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInArrayList() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/java/arrayList"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/java/arrayList"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("arrayAccess.kt") @@ -5016,7 +5017,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInJsCode() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/jsCode"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/jsCode"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("break.kt") @@ -5164,7 +5165,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInJsExport() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/jsExport"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/jsExport"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("dataClass.kt") @@ -5192,7 +5193,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInJsModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/jsModule"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/jsModule"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("externalClass.kt") @@ -5300,7 +5301,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInJsName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/jsName"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/jsName"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("avoidNameClash.kt") @@ -5378,7 +5379,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInJsQualifier() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/jsQualifier"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/jsQualifier"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("classes.kt") @@ -5416,7 +5417,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInKotlin_test() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/kotlin.test"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/kotlin.test"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("beforeAfter.kt") @@ -5474,7 +5475,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInLabels() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/labels"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/labels"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("labelOnExpression.kt") @@ -5547,7 +5548,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInMain() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/main"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/main"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("differentMains.kt") @@ -5600,7 +5601,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInMultiFile() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multiFile"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multiFile"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("classOfTheSameNameInAnotherPackage.kt") @@ -5643,7 +5644,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInMultiModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multiModule"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multiModule"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("clashedDeclLinkage.kt") @@ -5711,7 +5712,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInMultiModuleWrappers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multiModuleWrappers"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multiModuleWrappers"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("js/js.translator/testData/box/multiModuleWrappers/amd") @@ -5723,7 +5724,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInAmd() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multiModuleWrappers/amd"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multiModuleWrappers/amd"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("jsModuleOnPackage.kt") @@ -5751,7 +5752,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInCommon_js() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multiModuleWrappers/common_js"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multiModuleWrappers/common_js"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("inlineFromModuleWithNonIdentifierName.kt") @@ -5779,7 +5780,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInPlain() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multiModuleWrappers/plain"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multiModuleWrappers/plain"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("inlineFromModuleWithNonIdentifierName.kt") @@ -5807,7 +5808,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInUmd() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multiModuleWrappers/umd"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multiModuleWrappers/umd"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("moduleWithNonIdentifierName.kt") @@ -5831,7 +5832,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInMultiPackage() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multiPackage"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multiPackage"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("classesInheritedFromOtherPackage.kt") @@ -5889,7 +5890,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInMultideclaration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multideclaration"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multideclaration"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("multiValForArray.kt") @@ -5937,7 +5938,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInNameClashes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/nameClashes"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/nameClashes"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("classAndCompanionObjectMembers.kt") @@ -6050,7 +6051,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInNative() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/native"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/native"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("callbackOptionalParameter.kt") @@ -6248,7 +6249,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInNestedTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/nestedTypes"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/nestedTypes"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("implicitOuterThisFromLambda.kt") @@ -6341,7 +6342,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInNumber() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/number"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/number"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("assignmentIntOverflow.kt") @@ -6504,7 +6505,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInObjectDeclaration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/objectDeclaration"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/objectDeclaration"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("dontPolluteObject.kt") @@ -6577,7 +6578,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInOperatorOverloading() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/operatorOverloading"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/operatorOverloading"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("augmentedAssignmentLhs.kt") @@ -6705,7 +6706,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInPackage() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/package"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/package"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("classCreatedInDeeplyNestedPackage.kt") @@ -6748,7 +6749,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInPropertyAccess() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/propertyAccess"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/propertyAccess"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("classUsesPackageProperties.kt") @@ -6871,7 +6872,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInPropertyOverride() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/propertyOverride"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/propertyOverride"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("checkSupertypeOrder.kt") @@ -6939,7 +6940,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInRange() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/range"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/range"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("creatingProgressions.kt") @@ -7007,7 +7008,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInReflection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/reflection"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/reflection"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("classJsName.kt") @@ -7090,7 +7091,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInRegression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/regression"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/regression"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("companionObjectInExternalInterface.kt") @@ -7132,7 +7133,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInStdlibTestSnippets() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/regression/stdlibTestSnippets"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/regression/stdlibTestSnippets"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("arrayTest_plusInference.kt") @@ -7165,7 +7166,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInTypeChecks() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/regression/typeChecks"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/regression/typeChecks"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("booleanOperatorsTypes.kt") @@ -7199,7 +7200,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInReified() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/reified"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/reified"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("callChain.kt") @@ -7312,7 +7313,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInRtti() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/rtti"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/rtti"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("collectionClassesIsCheck.kt") @@ -7420,7 +7421,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInSafeCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/safeCall"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/safeCall"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("redundantSafeAccess.kt") @@ -7468,7 +7469,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInSimple() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/simple"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/simple"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("assign.kt") @@ -7641,7 +7642,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInStandardClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/standardClasses"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/standardClasses"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("any.kt") @@ -7744,7 +7745,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInSuperCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/superCall"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/superCall"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("classSuperCall.kt") @@ -7782,7 +7783,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInTrait() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/trait"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/trait"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("checkImplementationCharacteristics.kt") @@ -7840,7 +7841,7 @@ public class IrBoxJsTestGenerated extends AbstractIrBoxJsTest { } public void testAllFilesPresentInVararg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/vararg"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/vararg"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("jsExternalVarargCtor.kt") diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/semantics/IrJsCodegenBoxErrorTestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/semantics/IrJsCodegenBoxErrorTestGenerated.java index 3b4c3b5c8c2..8ddba725597 100644 --- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/semantics/IrJsCodegenBoxErrorTestGenerated.java +++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/semantics/IrJsCodegenBoxErrorTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.js.test.ir.semantics; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class IrJsCodegenBoxErrorTestGenerated extends AbstractIrJsCodegenBoxErro } public void testAllFilesPresentInBoxError() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxError"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxError"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("compiler/testData/codegen/boxError/semantic") @@ -38,7 +39,7 @@ public class IrJsCodegenBoxErrorTestGenerated extends AbstractIrJsCodegenBoxErro } public void testAllFilesPresentInSemantic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxError/semantic"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxError/semantic"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("castToErrorType.kt") @@ -96,7 +97,7 @@ public class IrJsCodegenBoxErrorTestGenerated extends AbstractIrJsCodegenBoxErro } public void testAllFilesPresentInSyntax() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxError/syntax"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxError/syntax"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("arrowReference.kt") diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/semantics/IrJsCodegenBoxTestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/semantics/IrJsCodegenBoxTestGenerated.java index 3feb9e3640c..ca1f06642fd 100644 --- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/semantics/IrJsCodegenBoxTestGenerated.java +++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/semantics/IrJsCodegenBoxTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.js.test.ir.semantics; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInBox() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("compiler/testData/codegen/box/annotations") @@ -38,7 +39,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("nestedAnnotation.kt") @@ -70,7 +71,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInAnnotatedLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations/annotatedLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations/annotatedLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -83,7 +84,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInTypeAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations/typeAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations/typeAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("checkingNotincorporatedInputTypes.kt") @@ -102,7 +103,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInArgumentOrder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/argumentOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/argumentOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("argumentOrderInObjectSuperCall.kt") @@ -185,7 +186,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInArrays() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("arrayConstructorWithNonInlineLambda.kt") @@ -507,7 +508,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInArraysOfInlineClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/arraysOfInlineClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/arraysOfInlineClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("arrayOfInlineClassOfArrayOfInlineClass.kt") @@ -525,7 +526,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInForInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/forInReversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/forInReversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("reversedArrayOriginalUpdatedInLoopBody.kt") @@ -558,7 +559,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInMultiDecl() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("kt15560.kt") @@ -610,7 +611,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInInt() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -643,7 +644,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInLong() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -678,7 +679,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInAssert() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/assert"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/assert"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("alwaysDisable.kt") @@ -700,7 +701,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInJvm() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/assert/jvm"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/assert/jvm"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } } @@ -714,7 +715,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInBinaryOp() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/binaryOp"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/binaryOp"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("bitwiseOp.kt") @@ -837,7 +838,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInBoxingOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/boxingOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/boxingOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("boxedIntegersCmp.kt") @@ -990,7 +991,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInBridges() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/bridges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/bridges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("complexMultiInheritance.kt") @@ -1277,7 +1278,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInSubstitutionInSuperClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/bridges/substitutionInSuperClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/bridges/substitutionInSuperClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("boundedTypeArguments.kt") @@ -1341,7 +1342,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInBuilderInference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("callableReferenceAndCoercionToUnit.kt") @@ -1379,7 +1380,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInBuiltinStubMethods() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("customReadOnlyIterator.kt") @@ -1401,7 +1402,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInExtendJavaCollections() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/extendJavaCollections"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/extendJavaCollections"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("arrayList.kt") @@ -1429,7 +1430,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInMapGetOrDefault() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/mapGetOrDefault"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/mapGetOrDefault"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -1442,7 +1443,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInMapRemove() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/mapRemove"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/mapRemove"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } } @@ -1456,7 +1457,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("genericConstructorReference.kt") @@ -1488,7 +1489,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInAdaptedReferences() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/adaptedReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/adaptedReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("bothWithCoercionToUnit.kt") @@ -1625,7 +1626,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInSuspendConversion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("bound.kt") @@ -1704,7 +1705,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInBound() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("array.kt") @@ -1826,7 +1827,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInEquals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/bound/equals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/bound/equals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("nullableReceiverInEquals.kt") @@ -1860,7 +1861,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInEquality() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/equality"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/equality"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("capturedDefaults.kt") @@ -1938,7 +1939,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/function"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/function"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("argumentTypes.kt") @@ -2210,7 +2211,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInLocal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/function/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/function/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("captureOuter.kt") @@ -2329,7 +2330,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("delegated.kt") @@ -2487,7 +2488,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInSerializability() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/serializability"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/serializability"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } } @@ -2501,7 +2502,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInCasts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("as.kt") @@ -2628,7 +2629,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("asFunKBig.kt") @@ -2701,7 +2702,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInJavaInterop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -2714,7 +2715,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInLiteralExpressionAsGenericArgument() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/literalExpressionAsGenericArgument"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/literalExpressionAsGenericArgument"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("binaryExpressionCast.kt") @@ -2757,7 +2758,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInMutableCollections() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/mutableCollections"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/mutableCollections"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("asWithMutable.kt") @@ -2806,7 +2807,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInCheckcastOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/checkcastOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/checkcastOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("kt19128.kt") @@ -2829,7 +2830,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInClassLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("bareArray.kt") @@ -2846,7 +2847,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInBound() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classLiteral/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classLiteral/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("primitives.kt") @@ -2879,7 +2880,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classLiteral/java"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classLiteral/java"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("kt11943.kt") @@ -2898,7 +2899,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("boxPrimitiveTypeInClinitOfClassObject.kt") @@ -3475,7 +3476,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInInner() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classes/inner"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classes/inner"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("extensionWithOuter.kt") @@ -3524,7 +3525,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInClosures() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("anonymousObjectAsLastExpressionInLambda.kt") @@ -3751,7 +3752,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInCaptureInSuperConstructorCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/captureInSuperConstructorCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/captureInSuperConstructorCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("constructorParameterAndLocalCapturedInLambdaInLocalClass.kt") @@ -3924,7 +3925,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInCaptureOuterProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/captureOuterProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/captureOuterProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("captureFunctionInProperty.kt") @@ -3977,7 +3978,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInCapturedVarsOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/capturedVarsOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/capturedVarsOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("capturedInCrossinline.kt") @@ -4045,7 +4046,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInClosureInsideClosure() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/closureInsideClosure"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/closureInsideClosure"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("localFunInsideLocalFun.kt") @@ -4089,7 +4090,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInCollectionLiterals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/collectionLiterals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/collectionLiterals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -4107,7 +4108,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInCollections() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/collections"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/collections"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("inSetWithSmartCast.kt") @@ -4140,7 +4141,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInCompanion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/companion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/companion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("delegatedPropertyOnCompanion.kt") @@ -4163,7 +4164,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/compatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/compatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("privateCompanionObject.kt") @@ -4181,7 +4182,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInConstants() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/constants"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/constants"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("comparisonFalse.kt") @@ -4244,7 +4245,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInConstructorCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/constructorCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/constructorCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -4257,7 +4258,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInContracts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/contracts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/contracts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("constructorArgument.kt") @@ -4330,7 +4331,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInControlStructures() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("bottles.kt") @@ -4722,7 +4723,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInBreakContinueInExpressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("breakFromOuter.kt") @@ -4825,7 +4826,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInForInArray() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInArray"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInArray"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("forInArraySpecializedToUntil.kt") @@ -4888,7 +4889,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInForInArrayWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("forInArrayOfObjectArrayWithIndex.kt") @@ -5001,7 +5002,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInForInCharSequenceWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInCharSequenceWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInCharSequenceWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("forInCharSeqWithIndexStops.kt") @@ -5084,7 +5085,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInForInIterableWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInIterableWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInIterableWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("forInEmptyListWithIndex.kt") @@ -5147,7 +5148,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInForInSequenceWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInSequenceWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInSequenceWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("forInEmptySequenceWithIndex.kt") @@ -5210,7 +5211,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInReturnsNothing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/returnsNothing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/returnsNothing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("ifElse.kt") @@ -5248,7 +5249,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInTryCatchInExpressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("catch.kt") @@ -5422,7 +5423,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInCoroutines() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("asyncIteratorNullMerge_1_3.kt") @@ -5944,7 +5945,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInBridges() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/bridges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/bridges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("interfaceSpecialization.kt") @@ -5972,7 +5973,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInControlFlow() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/controlFlow"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/controlFlow"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("breakFinally.kt") @@ -6095,7 +6096,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInDebug() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/debug"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/debug"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -6108,7 +6109,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInFeatureIntersection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("breakWithNonEmptyStack.kt") @@ -6200,7 +6201,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("bigArity.kt") @@ -6222,7 +6223,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInBound() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("emptyLHS.kt") @@ -6240,7 +6241,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/function"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/function"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("genericCallableReferencesWithNullableTypes.kt") @@ -6257,7 +6258,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInLocal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/function/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/function/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("equalsHashCode.kt") @@ -6277,7 +6278,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInTailrec() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/tailrec"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/tailrec"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("controlFlowIf.kt") @@ -6356,7 +6357,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("nonLocalReturn.kt") @@ -6373,7 +6374,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInDirect() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses/direct"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses/direct"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("boxReturnValueOfSuspendFunctionReference.kt") @@ -6601,7 +6602,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInResume() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses/resume"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses/resume"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("boxReturnValueOfSuspendFunctionReference.kt") @@ -6829,7 +6830,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInResumeWithException() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("boxReturnValueOfSuspendFunctionReference.kt") @@ -7043,7 +7044,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInIntLikeVarSpilling() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/intLikeVarSpilling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/intLikeVarSpilling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("complicatedMerge.kt") @@ -7101,7 +7102,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInIntrinsicSemantics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/intrinsicSemantics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/intrinsicSemantics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("coroutineContext.kt") @@ -7154,7 +7155,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInJavaInterop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -7167,7 +7168,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInLocalFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/localFunctions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/localFunctions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("compiler/testData/codegen/box/coroutines/localFunctions/anonymous") @@ -7179,7 +7180,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInAnonymous() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/localFunctions/anonymous"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/localFunctions/anonymous"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("simple.kt") @@ -7197,7 +7198,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInNamed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/localFunctions/named"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/localFunctions/named"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("capturedParameters.kt") @@ -7261,7 +7262,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInMultiModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("inlineCrossModule.kt") @@ -7314,7 +7315,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInRedundantLocalsElimination() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/redundantLocalsElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/redundantLocalsElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("ktor_receivedMessage.kt") @@ -7332,7 +7333,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInReflect() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/reflect"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/reflect"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -7345,7 +7346,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInStackUnwinding() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/stackUnwinding"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/stackUnwinding"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("exception.kt") @@ -7388,7 +7389,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInSuspendConversion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/suspendConversion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/suspendConversion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("intersectionTypeToSubtypeConversion.kt") @@ -7421,7 +7422,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInSuspendFunctionAsCoroutine() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("dispatchResume.kt") @@ -7519,7 +7520,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInSuspendFunctionTypeCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/suspendFunctionTypeCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/suspendFunctionTypeCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("localVal.kt") @@ -7557,7 +7558,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInTailCallOptimizations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/tailCallOptimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/tailCallOptimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("crossinline.kt") @@ -7589,7 +7590,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInUnit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/tailCallOptimizations/unit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/tailCallOptimizations/unit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } } @@ -7603,7 +7604,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInTailOperations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/tailOperations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/tailOperations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("suspendWithIf.kt") @@ -7636,7 +7637,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInUnitTypeReturn() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/unitTypeReturn"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/unitTypeReturn"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("coroutineNonLocalReturn.kt") @@ -7684,7 +7685,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInVarSpilling() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/varSpilling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/varSpilling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("fakeInlinerVariables.kt") @@ -7728,7 +7729,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInDataClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("arrayParams.kt") @@ -7810,7 +7811,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInCopy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/copy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/copy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("constructorWithDefaultParam.kt") @@ -7863,7 +7864,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInEquals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/equals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/equals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("alreadyDeclared.kt") @@ -7906,7 +7907,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInHashCode() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/hashCode"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/hashCode"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("alreadyDeclared.kt") @@ -7974,7 +7975,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInToString() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/toString"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/toString"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("alreadyDeclared.kt") @@ -8018,7 +8019,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInDeadCodeElimination() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/deadCodeElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/deadCodeElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("emptyVariableRange.kt") @@ -8051,7 +8052,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInDefaultArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("callDefaultFromInitializer.kt") @@ -8128,7 +8129,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/constructor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/constructor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("annotation.kt") @@ -8216,7 +8217,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInConvention() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/convention"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/convention"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("incWithDefaultInGetter.kt") @@ -8264,7 +8265,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/function"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/function"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("complexInheritance.kt") @@ -8412,7 +8413,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInPrivate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("memberExtensionFunction.kt") @@ -8445,7 +8446,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/signature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/signature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("kt2789.kt") @@ -8479,7 +8480,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInDelegatedProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("beforeDeclarationContainerOptimization.kt") @@ -8711,7 +8712,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInLocal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("capturedLocalVal.kt") @@ -8804,7 +8805,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInOptimizedDelegatedProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/optimizedDelegatedProperties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/optimizedDelegatedProperties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("definedInSources.kt") @@ -8867,7 +8868,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInProvideDelegate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/provideDelegate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/provideDelegate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("delegatedPropertyWithIdProvideDelegate.kt") @@ -8986,7 +8987,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInDelegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("delegationWithPrivateConstructor.kt") @@ -9024,7 +9025,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInDestructuringDeclInLambdaParam() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/destructuringDeclInLambdaParam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/destructuringDeclInLambdaParam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("extensionComponents.kt") @@ -9077,7 +9078,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInDiagnostics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("compiler/testData/codegen/box/diagnostics/functions") @@ -9089,7 +9090,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("compiler/testData/codegen/box/diagnostics/functions/inference") @@ -9101,7 +9102,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInInference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/inference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/inference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("kt6176.kt") @@ -9119,7 +9120,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInInvoke() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/invoke"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/invoke"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects") @@ -9131,7 +9132,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInOnObjects() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("invokeOnClassObject1.kt") @@ -9195,7 +9196,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInTailRecursion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/tailRecursion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/tailRecursion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("defaultArgs.kt") @@ -9409,7 +9410,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInVararg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/vararg"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/vararg"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("kt4172.kt") @@ -9428,7 +9429,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInElvis() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/elvis"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/elvis"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("genericElvisWithMoreSpecificLHS.kt") @@ -9486,7 +9487,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("asReturnExpression.kt") @@ -9773,7 +9774,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInDefaultCtor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/enum/defaultCtor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/enum/defaultCtor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("constructorWithDefaultArguments.kt") @@ -9817,7 +9818,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInEvaluate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/evaluate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/evaluate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("kt9443.kt") @@ -9835,7 +9836,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInExclExcl() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/exclExcl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/exclExcl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("genericNull.kt") @@ -9858,7 +9859,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInExtensionFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/extensionFunctions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/extensionFunctions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("executionOrder.kt") @@ -9996,7 +9997,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInExtensionProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/extensionProperties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/extensionProperties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("genericValForPrimitiveType.kt") @@ -10074,7 +10075,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInExternal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/external"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/external"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -10087,7 +10088,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInFakeOverride() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fakeOverride"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fakeOverride"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("diamondFunction.kt") @@ -10130,7 +10131,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInFieldRename() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fieldRename"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fieldRename"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("constructorAndClassObject.kt") @@ -10158,7 +10159,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInFinally() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/finally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/finally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("breakAndOuterFinally.kt") @@ -10276,7 +10277,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInFullJdk() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("compiler/testData/codegen/box/fullJdk/native") @@ -10288,7 +10289,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInNative() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk/native"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk/native"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -10301,7 +10302,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInRegressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk/regressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk/regressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } } @@ -10315,7 +10316,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInFunInterface() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("basicFunInterface.kt") @@ -10432,7 +10433,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInEquality() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/funInterface/equality"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/funInterface/equality"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("functionReferencesBound.kt") @@ -10471,7 +10472,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("coerceVoidToArray.kt") @@ -10703,7 +10704,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInBigArity() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/bigArity"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/bigArity"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("function255.kt") @@ -10751,7 +10752,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInFunctionExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/functionExpression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/functionExpression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("functionExpression.kt") @@ -10794,7 +10795,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInInvoke() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/invoke"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/invoke"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("castFunctionToExtension.kt") @@ -10877,7 +10878,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInLocalFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/localFunctions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/localFunctions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("boundTypeParameterInSupertype.kt") @@ -11041,7 +11042,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInHashPMap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/hashPMap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/hashPMap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -11054,7 +11055,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInIeee754() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ieee754"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ieee754"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("anyToReal.kt") @@ -11247,7 +11248,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInIncrement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/increment"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/increment"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("argumentWithSideEffects.kt") @@ -11390,7 +11391,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInInference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("approximateNonTopLevelCapturedTypes.kt") @@ -11523,7 +11524,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("annotatedMemberExtensionProperty.kt") @@ -12275,7 +12276,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInBoxReturnValueInLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("boxAny.kt") @@ -12348,7 +12349,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInBoxReturnValueOnOverride() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("covariantOverrideChainErasedToAny.kt") @@ -12491,7 +12492,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInCallableReferences() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/callableReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/callableReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("boundInlineClassExtensionFun.kt") @@ -12654,7 +12655,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInContextsAndAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("captureInlineClassInstanceInLambda.kt") @@ -12722,7 +12723,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInDefaultParameterValues() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/defaultParameterValues"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/defaultParameterValues"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("defaultConstructorParameterValuesOfInlineClassType.kt") @@ -12795,7 +12796,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInFunctionNameMangling() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/functionNameMangling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/functionNameMangling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("anonymousObjectInFunctionWithMangledName.kt") @@ -12888,7 +12889,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInHiddenConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/hiddenConstructor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/hiddenConstructor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("constructorReferencedFromOtherFile1.kt") @@ -12966,7 +12967,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInInterfaceDelegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/interfaceDelegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/interfaceDelegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("interfaceImplementationByDelegation.kt") @@ -13019,7 +13020,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInInterfaceMethodCalls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("complexGenericMethodWithInlineClassOverride.kt") @@ -13087,7 +13088,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInJavaInterop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -13100,7 +13101,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInJvm8DefaultInterfaceMethods() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/jvm8DefaultInterfaceMethods"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/jvm8DefaultInterfaceMethods"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -13113,7 +13114,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInPropertyDelegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/propertyDelegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/propertyDelegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("captureLocalVarDelegatedToInlineClass.kt") @@ -13181,7 +13182,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInUnboxGenericParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface") @@ -13193,7 +13194,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInFunInterface() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("any.kt") @@ -13241,7 +13242,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("any.kt") @@ -13289,7 +13290,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInObjectLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("any.kt") @@ -13339,7 +13340,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInInnerNested() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/innerNested"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/innerNested"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("createNestedClass.kt") @@ -13476,7 +13477,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInSuperConstructorCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/innerNested/superConstructorCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/innerNested/superConstructorCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("deepInnerHierarchy.kt") @@ -13590,7 +13591,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInInstructions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/instructions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/instructions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("compiler/testData/codegen/box/instructions/swap") @@ -13602,7 +13603,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInSwap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/instructions/swap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/instructions/swap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("swapRefToSharedVarInt.kt") @@ -13626,7 +13627,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInIntrinsics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/intrinsics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/intrinsics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("charToInt.kt") @@ -13744,7 +13745,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInIr() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("anonymousClassLeak.kt") @@ -13836,7 +13837,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInClosureConversion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/closureConversion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/closureConversion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("closureConversion1.kt") @@ -13889,7 +13890,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInPrimitiveNumberComparisons() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/primitiveNumberComparisons"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/primitiveNumberComparisons"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("comparableToDouble.kt") @@ -13922,7 +13923,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInSerializationRegressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/serializationRegressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/serializationRegressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("deepGenericDelegatedProperty.kt") @@ -13976,7 +13977,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInJavaInterop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("compiler/testData/codegen/box/javaInterop/generics") @@ -13988,7 +13989,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInGenerics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/generics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/generics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("kt42824.kt") @@ -14011,7 +14012,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInNotNullAssertions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("mapPut.kt") @@ -14028,7 +14029,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInEnhancedNullability() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions/enhancedNullability"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions/enhancedNullability"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -14041,7 +14042,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInNullCheckOnLambdaReturnValue() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions/nullCheckOnLambdaReturnValue"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions/nullCheckOnLambdaReturnValue"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } } @@ -14055,7 +14056,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInObjectMethods() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/objectMethods"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/objectMethods"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("cloneCallsConstructor.kt") @@ -14089,7 +14090,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInJdk() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jdk"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jdk"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("arrayList.kt") @@ -14122,7 +14123,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInJvm8() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("compiler/testData/codegen/box/jvm8/defaults") @@ -14134,7 +14135,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInDefaults() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/allCompatibility") @@ -14146,7 +14147,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInAllCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/delegationBy") @@ -14158,7 +14159,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInDelegationBy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } } @@ -14172,7 +14173,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/compatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/compatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -14185,7 +14186,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInDelegationBy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -14198,7 +14199,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInNoDefaultImpls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/delegationBy") @@ -14210,7 +14211,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInDelegationBy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -14223,7 +14224,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInSpecialization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/specialization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/specialization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } } @@ -14237,7 +14238,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInNoDelegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDelegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDelegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -14250,7 +14251,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInReflection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/reflection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/reflection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } } @@ -14264,7 +14265,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInInterfaceFlag() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/interfaceFlag"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/interfaceFlag"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -14277,7 +14278,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInJavaDefaults() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/javaDefaults"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/javaDefaults"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } } @@ -14291,7 +14292,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInJvmField() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmField"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmField"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -14304,7 +14305,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInJvmName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("compiler/testData/codegen/box/jvmName/fileFacades") @@ -14316,7 +14317,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInFileFacades() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmName/fileFacades"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmName/fileFacades"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } } @@ -14330,7 +14331,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInJvmOverloads() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmOverloads"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmOverloads"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -14343,7 +14344,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInJvmPackageName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmPackageName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmPackageName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -14356,7 +14357,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInJvmStatic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmStatic"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmStatic"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -14369,7 +14370,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInLabels() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/labels"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/labels"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("controlLabelClashesWithFuncitonName.kt") @@ -14422,7 +14423,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInLazyCodegen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/lazyCodegen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/lazyCodegen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("exceptionInFieldInitializer.kt") @@ -14479,7 +14480,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInOptimizations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/lazyCodegen/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/lazyCodegen/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("negateConstantCompare.kt") @@ -14538,7 +14539,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInLocalClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/localClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/localClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("anonymousObjectInExtension.kt") @@ -14721,7 +14722,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInMangling() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/mangling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/mangling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("internal.kt") @@ -14764,7 +14765,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInMixedNamedPosition() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/mixedNamedPosition"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/mixedNamedPosition"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("defaults.kt") @@ -14797,7 +14798,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInMultiDecl() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("ComplexInitializer.kt") @@ -14879,7 +14880,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInForIterator() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forIterator"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forIterator"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("MultiDeclFor.kt") @@ -14916,7 +14917,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInLongIterator() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forIterator/longIterator"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forIterator/longIterator"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -14950,7 +14951,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInForRange() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("MultiDeclFor.kt") @@ -14997,7 +14998,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInExplicitRangeTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("MultiDeclFor.kt") @@ -15034,7 +15035,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInInt() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -15067,7 +15068,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInLong() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -15101,7 +15102,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInExplicitRangeToWithDot() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("MultiDeclFor.kt") @@ -15138,7 +15139,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInInt() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -15171,7 +15172,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInLong() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -15205,7 +15206,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInInt() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -15238,7 +15239,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInLong() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -15273,7 +15274,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInMultifileClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("compiler/testData/codegen/box/multifileClasses/optimized") @@ -15285,7 +15286,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInOptimized() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multifileClasses/optimized"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multifileClasses/optimized"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } } @@ -15299,7 +15300,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInMultiplatform() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("optionalExpectation.kt") @@ -15321,7 +15322,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInDefaultArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("bothInExpectAndActual.kt") @@ -15439,7 +15440,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInMultiModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("expectActualLink.kt") @@ -15468,7 +15469,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInNonLocalReturns() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nonLocalReturns"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nonLocalReturns"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("kt9644let.kt") @@ -15496,7 +15497,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInNothingValue() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nothingValue"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nothingValue"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("inNestedCall.kt") @@ -15519,7 +15520,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInNullCheckOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nullCheckOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nullCheckOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("isNullable.kt") @@ -15557,7 +15558,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInObjectIntrinsics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objectIntrinsics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objectIntrinsics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("objects.kt") @@ -15575,7 +15576,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInObjects() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("anonymousObjectPropertyInitialization.kt") @@ -15932,7 +15933,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInCompanionObjectAccess() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("kt27117.kt") @@ -16029,7 +16030,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInMultipleCompanionsWithAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("anonymousObjectInPropertyInitializer.kt") @@ -16097,7 +16098,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInPrimitiveCompanion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess/primitiveCompanion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess/primitiveCompanion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("byteCompanionObject.kt") @@ -16147,7 +16148,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInOldLanguageVersions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("dataClassEqualsHashCodeToString.kt") @@ -16164,7 +16165,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInControlStructures() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/controlStructures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/controlStructures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("compiler/testData/codegen/box/oldLanguageVersions/controlStructures/forInArray") @@ -16176,7 +16177,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInForInArray() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/controlStructures/forInArray"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/controlStructures/forInArray"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("forInArrayWithArrayVarUpdatedInLoopBody12.kt") @@ -16195,7 +16196,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInCoroutines() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("compiler/testData/codegen/box/oldLanguageVersions/coroutines/controlFlow") @@ -16207,7 +16208,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInControlFlow() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines/controlFlow"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines/controlFlow"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -16220,7 +16221,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInFeatureIntersection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines/featureIntersection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines/featureIntersection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("suspendFunction_1_2.kt") @@ -16238,7 +16239,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInMultiModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -16251,7 +16252,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInReflect() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines/reflect"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines/reflect"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -16264,7 +16265,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInSuspendFunctionAsCoroutine() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines/suspendFunctionAsCoroutine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines/suspendFunctionAsCoroutine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } } @@ -16278,7 +16279,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("compiler/testData/codegen/box/oldLanguageVersions/functions/bigArity") @@ -16290,7 +16291,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInBigArity() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/functions/bigArity"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/functions/bigArity"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("noBigFunctionTypes.kt") @@ -16309,7 +16310,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInIeee754() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/ieee754"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/ieee754"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("nullableDoubleEquals10.kt") @@ -16347,7 +16348,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInJavaInterop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("compiler/testData/codegen/box/oldLanguageVersions/javaInterop/notNullAssertions") @@ -16359,7 +16360,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInNotNullAssertions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/javaInterop/notNullAssertions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/javaInterop/notNullAssertions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } } @@ -16373,7 +16374,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInOperatorConventions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/operatorConventions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/operatorConventions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -16386,7 +16387,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInPlatformTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/platformTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/platformTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("compiler/testData/codegen/box/oldLanguageVersions/platformTypes/primitives") @@ -16398,7 +16399,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInPrimitives() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/platformTypes/primitives"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/platformTypes/primitives"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } } @@ -16413,7 +16414,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInOperatorConventions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/operatorConventions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/operatorConventions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("annotatedAssignment.kt") @@ -16525,7 +16526,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInCompareTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/operatorConventions/compareTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/operatorConventions/compareTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("boolean.kt") @@ -16594,7 +16595,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInOptimizations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("kt20844.kt") @@ -16612,7 +16613,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInPackage() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/package"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/package"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("boxPrimitiveTypeInClinit.kt") @@ -16680,7 +16681,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInParametersMetadata() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/parametersMetadata"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/parametersMetadata"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -16693,7 +16694,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInPlatformTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/platformTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/platformTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("inferenceFlexibleTToNullable.kt") @@ -16710,7 +16711,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInPrimitives() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/platformTypes/primitives"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/platformTypes/primitives"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("assign.kt") @@ -16819,7 +16820,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInPolymorphicSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/polymorphicSignature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/polymorphicSignature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -16832,7 +16833,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInPrimitiveTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("comparisonWithNullCallsFun.kt") @@ -17129,7 +17130,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInEqualityWithObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes/equalityWithObject"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes/equalityWithObject"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("boxedEqPrimitiveEvaluationOrder.kt") @@ -17186,7 +17187,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInGenerated() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("boxedEqPrimitiveBoolean.kt") @@ -17291,7 +17292,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInPrivate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("arrayConvention.kt") @@ -17314,7 +17315,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInPrivateConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/privateConstructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/privateConstructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("base.kt") @@ -17417,7 +17418,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("augmentedAssignmentsAndIncrements.kt") @@ -17774,7 +17775,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInConst() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/const"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/const"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("anotherFile.kt") @@ -17812,7 +17813,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInLateinit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("exceptionField.kt") @@ -17874,7 +17875,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInIsInitializedAndDeinitialize() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/isInitializedAndDeinitialize"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/isInitializedAndDeinitialize"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("companionObjectField.kt") @@ -17927,7 +17928,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInLocal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("capturedLocalLateinit.kt") @@ -17985,7 +17986,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInTopLevel() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/topLevel"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/topLevel"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("topLevelLateinit.kt") @@ -18015,7 +18016,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInPublishedApi() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/publishedApi"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/publishedApi"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("simple.kt") @@ -18038,7 +18039,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInRanges() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("forByteProgressionWithIntIncrement.kt") @@ -18130,7 +18131,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInContains() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/contains"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/contains"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("comparisonWithRangeBoundEliminated.kt") @@ -18342,7 +18343,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInGenerated() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/contains/generated"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/contains/generated"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("arrayIndices.kt") @@ -18426,7 +18427,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInEvaluationOrder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("forInDownTo.kt") @@ -18483,7 +18484,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInStepped() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo") @@ -18495,7 +18496,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInForInDownTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("forInDownToReversedStep.kt") @@ -18548,7 +18549,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInForInRangeLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInRangeLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInRangeLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("forInRangeLiteralReversedStep.kt") @@ -18601,7 +18602,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInForInUntil() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInUntil"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInUntil"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("forInUntilReversedStep.kt") @@ -18656,7 +18657,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("emptyDownto.kt") @@ -18819,7 +18820,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInForInDownTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInDownTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInDownTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("forIntInDownTo.kt") @@ -18857,7 +18858,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInForInIndices() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInIndices"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInIndices"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("forInArrayListIndices.kt") @@ -18975,7 +18976,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInForInProgressionWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInProgressionWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInProgressionWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("forInDownToWithIndex.kt") @@ -19063,7 +19064,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInForInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInReversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInReversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("forInReversedArrayIndices.kt") @@ -19166,7 +19167,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInForInUntil() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInUntil"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInUntil"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("forInUntilChar.kt") @@ -19254,7 +19255,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInForWithPossibleOverflow() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forWithPossibleOverflow"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forWithPossibleOverflow"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("forInDownToCharMinValue.kt") @@ -19332,7 +19333,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInJavaInterop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("compiler/testData/codegen/box/ranges/javaInterop/withIndex") @@ -19344,7 +19345,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/javaInterop/withIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/javaInterop/withIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } } @@ -19358,7 +19359,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("emptyDownto.kt") @@ -19521,7 +19522,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInNullableLoopParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/nullableLoopParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/nullableLoopParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("progressionExpression.kt") @@ -19549,7 +19550,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInStepped() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("compiler/testData/codegen/box/ranges/stepped/expression") @@ -19561,7 +19562,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("compiler/testData/codegen/box/ranges/stepped/expression/downTo") @@ -19573,7 +19574,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInDownTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/downTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/downTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("emptyProgression.kt") @@ -19665,7 +19666,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/downTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/downTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -19718,7 +19719,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/downTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/downTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("reversedThenStep.kt") @@ -19762,7 +19763,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInRangeTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("emptyProgression.kt") @@ -19854,7 +19855,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -19907,7 +19908,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("reversedThenStep.kt") @@ -19951,7 +19952,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInUntil() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/until"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/until"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("emptyProgression.kt") @@ -20048,7 +20049,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/until/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/until/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -20101,7 +20102,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/until/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/until/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("reversedThenStep.kt") @@ -20146,7 +20147,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("compiler/testData/codegen/box/ranges/stepped/literal/downTo") @@ -20158,7 +20159,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInDownTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/downTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/downTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("emptyProgression.kt") @@ -20250,7 +20251,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/downTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/downTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -20303,7 +20304,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/downTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/downTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("reversedThenStep.kt") @@ -20347,7 +20348,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInRangeTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("emptyProgression.kt") @@ -20439,7 +20440,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -20492,7 +20493,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("reversedThenStep.kt") @@ -20536,7 +20537,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInUntil() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/until"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/until"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("emptyProgression.kt") @@ -20633,7 +20634,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/until/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/until/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -20686,7 +20687,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/until/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/until/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("reversedThenStep.kt") @@ -20731,7 +20732,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInUnsigned() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/expression") @@ -20743,7 +20744,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo") @@ -20755,7 +20756,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInDownTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("emptyProgression.kt") @@ -20847,7 +20848,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -20900,7 +20901,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("reversedThenStep.kt") @@ -20944,7 +20945,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInRangeTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("emptyProgression.kt") @@ -21036,7 +21037,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -21089,7 +21090,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("reversedThenStep.kt") @@ -21133,7 +21134,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInUntil() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("emptyProgression.kt") @@ -21230,7 +21231,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -21283,7 +21284,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("reversedThenStep.kt") @@ -21328,7 +21329,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo") @@ -21340,7 +21341,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInDownTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("emptyProgression.kt") @@ -21432,7 +21433,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -21485,7 +21486,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("reversedThenStep.kt") @@ -21529,7 +21530,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInRangeTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("emptyProgression.kt") @@ -21621,7 +21622,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -21674,7 +21675,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("reversedThenStep.kt") @@ -21718,7 +21719,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInUntil() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("emptyProgression.kt") @@ -21815,7 +21816,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -21868,7 +21869,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("reversedThenStep.kt") @@ -21915,7 +21916,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInUnsigned() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("inMixedUnsignedRange.kt") @@ -21952,7 +21953,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("emptyDownto.kt") @@ -22115,7 +22116,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("emptyDownto.kt") @@ -22278,7 +22279,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInNullableLoopParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/nullableLoopParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/nullableLoopParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("progressionExpression.kt") @@ -22308,7 +22309,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInReflection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("compiler/testData/codegen/box/reflection/annotations") @@ -22320,7 +22321,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/annotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/annotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("annotationRetentionAnnotation.kt") @@ -22392,7 +22393,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInOnTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/annotations/onTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/annotations/onTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } } @@ -22406,7 +22407,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInBuiltins() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/builtins"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/builtins"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("enumNameOrdinal.kt") @@ -22429,7 +22430,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("bigArity.kt") @@ -22501,7 +22502,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInBound() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("companionObjectPropertyAccessors.kt") @@ -22554,7 +22555,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("constructorWithInlineClassParameters.kt") @@ -22618,7 +22619,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInCallBy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/callBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/callBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("boundExtensionFunction.kt") @@ -22741,7 +22742,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInClassLiterals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/classLiterals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/classLiterals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("annotationClassLiteral.kt") @@ -22774,7 +22775,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/classes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/classes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("companionObject.kt") @@ -22812,7 +22813,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/constructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/constructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("annotationClass.kt") @@ -22850,7 +22851,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInCreateAnnotation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/createAnnotation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/createAnnotation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("annotationType.kt") @@ -22903,7 +22904,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInEnclosing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/enclosing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/enclosing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -22916,7 +22917,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("enumValuesValueOf.kt") @@ -22949,7 +22950,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInGenericSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/genericSignature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/genericSignature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -22962,7 +22963,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInIsInstance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/isInstance"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/isInstance"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -22975,7 +22976,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInKClassInAnnotation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/kClassInAnnotation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/kClassInAnnotation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("forceWrapping.kt") @@ -22998,7 +22999,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInLambdaClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/lambdaClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/lambdaClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -23011,7 +23012,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInMapping() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("compiler/testData/codegen/box/reflection/mapping/fakeOverrides") @@ -23023,7 +23024,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInFakeOverrides() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/fakeOverrides"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/fakeOverrides"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -23036,7 +23037,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -23049,7 +23050,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInJvmStatic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/jvmStatic"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/jvmStatic"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -23062,7 +23063,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/types"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/types"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } } @@ -23076,7 +23077,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInMethodsFromAny() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/methodsFromAny"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/methodsFromAny"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("callableReferencesEqualToCallablesFromAPI.kt") @@ -23184,7 +23185,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInModifiers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/modifiers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/modifiers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("callableModality.kt") @@ -23232,7 +23233,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInMultifileClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -23245,7 +23246,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInNoReflectAtRuntime() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/noReflectAtRuntime"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/noReflectAtRuntime"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("propertyGetSetName.kt") @@ -23272,7 +23273,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInMethodsFromAny() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/noReflectAtRuntime/methodsFromAny"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/noReflectAtRuntime/methodsFromAny"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("callableReferences.kt") @@ -23296,7 +23297,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/parameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/parameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("bigArity.kt") @@ -23354,7 +23355,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("allVsDeclared.kt") @@ -23431,7 +23432,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/accessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/accessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("extensionPropertyAccessors.kt") @@ -23464,7 +23465,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInGetDelegate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/getDelegate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/getDelegate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -23477,7 +23478,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInJvmField() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/jvmField"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/jvmField"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -23490,7 +23491,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInLocalDelegated() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/localDelegated"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/localDelegated"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } } @@ -23504,7 +23505,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInSupertypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/supertypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/supertypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("genericSubstitution.kt") @@ -23532,7 +23533,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInTypeOf() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("classes.kt") @@ -23569,7 +23570,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInJs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/js"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/js"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("classes.kt") @@ -23622,7 +23623,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInNoReflect() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/noReflect"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/noReflect"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("typeReferenceEqualsHashCode.kt") @@ -23639,7 +23640,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInNonReifiedTypeParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/noReflect/nonReifiedTypeParameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/noReflect/nonReifiedTypeParameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } } @@ -23653,7 +23654,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInNonReifiedTypeParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/nonReifiedTypeParameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/nonReifiedTypeParameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("defaultUpperBound.kt") @@ -23732,7 +23733,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInTypeParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeParameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeParameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("declarationSiteVariance.kt") @@ -23760,7 +23761,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/types"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/types"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("classifierIsClass.kt") @@ -23797,7 +23798,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInCreateType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/types/createType"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/types/createType"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("equality.kt") @@ -23835,7 +23836,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInSubtyping() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/types/subtyping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/types/subtyping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("simpleGenericTypes.kt") @@ -23865,7 +23866,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInRegressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/regressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/regressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("arrayLengthNPE.kt") @@ -24208,7 +24209,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInReified() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reified"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reified"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("checkcast.kt") @@ -24300,7 +24301,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInArraysReification() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reified/arraysReification"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reified/arraysReification"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("instanceOf.kt") @@ -24334,7 +24335,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInSafeCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/safeCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/safeCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("genericNull.kt") @@ -24412,7 +24413,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInSam() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("compiler/testData/codegen/box/sam/constructors") @@ -24424,7 +24425,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam/constructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam/constructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("comparator.kt") @@ -24452,7 +24453,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInEquality() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam/equality"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam/equality"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } } @@ -24466,7 +24467,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInSealed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sealed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sealed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("multipleFiles_enabled.kt") @@ -24504,7 +24505,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInSecondaryConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/secondaryConstructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/secondaryConstructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("basicNoPrimaryManySinks.kt") @@ -24662,7 +24663,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInSignatureAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/signatureAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/signatureAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -24675,7 +24676,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInSmap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/smap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/smap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -24688,7 +24689,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInSmartCasts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/smartCasts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/smartCasts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("falseSmartCast.kt") @@ -24776,7 +24777,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInSpecialBuiltins() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/specialBuiltins"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/specialBuiltins"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("bridgeNotEmptyMap.kt") @@ -24909,7 +24910,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInStatics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/statics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/statics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("anonymousInitializerIObject.kt") @@ -24962,7 +24963,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInStoreStackBeforeInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/storeStackBeforeInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/storeStackBeforeInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("differentTypes.kt") @@ -25000,7 +25001,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInStrings() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/strings"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/strings"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("constInStringTemplate.kt") @@ -25118,7 +25119,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInSuper() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/super"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/super"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("basicmethodSuperClass.kt") @@ -25280,7 +25281,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInSuperConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/super/superConstructor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/super/superConstructor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("kt13846.kt") @@ -25329,7 +25330,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInSynchronized() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/synchronized"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/synchronized"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -25372,7 +25373,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInSyntheticAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/syntheticAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/syntheticAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("inline.kt") @@ -25440,7 +25441,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInThrows() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/throws"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/throws"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -25453,7 +25454,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInToArray() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/toArray"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/toArray"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("kt3177-toTypedArray.kt") @@ -25481,7 +25482,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInTopLevelPrivate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/topLevelPrivate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/topLevelPrivate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("privateInInlineNested.kt") @@ -25504,7 +25505,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInTrailingComma() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/trailingComma"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/trailingComma"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("noDisambiguation.kt") @@ -25527,7 +25528,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInTraits() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/traits"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/traits"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("diamondPropertyAccessors.kt") @@ -25700,7 +25701,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInTypeInfo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typeInfo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typeInfo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("ifOrWhenSpecialCall.kt") @@ -25743,7 +25744,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInTypeMapping() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typeMapping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typeMapping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("kt2831.kt") @@ -25791,7 +25792,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInTypealias() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typealias"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typealias"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("enumEntryQualifier.kt") @@ -25899,7 +25900,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInUnaryOp() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unaryOp"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unaryOp"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("call.kt") @@ -25942,7 +25943,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInUnit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("closureReturnsNullableUnit.kt") @@ -26010,7 +26011,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInUnsignedTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unsignedTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unsignedTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("boxConstValOfUnsignedType.kt") @@ -26217,7 +26218,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInJvm8Intrinsics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unsignedTypes/jvm8Intrinsics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unsignedTypes/jvm8Intrinsics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } } @@ -26231,7 +26232,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInValueClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/valueClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/valueClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("jvmInline.kt") @@ -26249,7 +26250,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInVararg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/vararg"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/vararg"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("doNotCopyImmediatelyCreatedArrays.kt") @@ -26327,7 +26328,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInWhen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("callProperty.kt") @@ -26539,7 +26540,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInEnumOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/enumOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/enumOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("bigEnum.kt") @@ -26642,7 +26643,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInStringOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/stringOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/stringOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("duplicatingItems.kt") @@ -26700,7 +26701,7 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { } public void testAllFilesPresentInWhenSubjectVariable() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/whenSubjectVariable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/whenSubjectVariable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("captureSubjectVariable.kt") diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/semantics/IrJsCodegenInlineTestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/semantics/IrJsCodegenInlineTestGenerated.java index e4fc9475d11..d3cfecc60d6 100644 --- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/semantics/IrJsCodegenInlineTestGenerated.java +++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/semantics/IrJsCodegenInlineTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.js.test.ir.semantics; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInBoxInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("compiler/testData/codegen/boxInline/anonymousObject") @@ -38,7 +39,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInAnonymousObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("anonymousObjectInDefault.kt") @@ -315,7 +316,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInEnumWhen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/enumWhen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/enumWhen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("callSite.kt") @@ -348,7 +349,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInProperRecapturing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("inlineChain.kt") @@ -391,7 +392,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInProperRecapturingInClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("inlineChain.kt") @@ -464,7 +465,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInSam() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -477,7 +478,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInTwoCapturedReceivers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("kt8668.kt") @@ -516,7 +517,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInArgumentOrder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/argumentOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/argumentOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("boundFunctionReference.kt") @@ -599,7 +600,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInArrayConvention() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/arrayConvention"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/arrayConvention"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("simpleAccess.kt") @@ -642,7 +643,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInAssert() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/assert"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/assert"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -655,7 +656,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInBuilders() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/builders"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/builders"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -668,7 +669,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInBytecodePreprocessing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/bytecodePreprocessing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/bytecodePreprocessing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -686,7 +687,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("classLevel.kt") @@ -768,7 +769,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInBound() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("classProperty.kt") @@ -897,7 +898,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInCapture() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/capture"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/capture"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("captureInlinable.kt") @@ -940,7 +941,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInComplex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/complex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/complex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("closureChain.kt") @@ -978,7 +979,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInComplexStack() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/complexStack"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/complexStack"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("asCheck.kt") @@ -1036,7 +1037,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInContracts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/contracts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/contracts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("cfgDependendValInitialization.kt") @@ -1134,7 +1135,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInDefaultValues() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("defaultInExtension.kt") @@ -1236,7 +1237,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInLambdaInlining() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("checkLambdaClassIsPresent.kt") @@ -1398,7 +1399,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInCallableReferences() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("boundFunctionReference.kt") @@ -1532,7 +1533,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInMaskElimination() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/maskElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/maskElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("kt18792.kt") @@ -1571,7 +1572,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInDelegatedProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/delegatedProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/delegatedProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("kt16864.kt") @@ -1609,7 +1610,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInEnclosingInfo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/enclosingInfo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/enclosingInfo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -1622,7 +1623,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("kt10569.kt") @@ -1700,7 +1701,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInFunctionExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/functionExpression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/functionExpression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("extension.kt") @@ -1718,7 +1719,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("inlineClassWithInlineValReturningInlineClass.kt") @@ -1760,7 +1761,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInUnboxGenericParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/funInterface") @@ -1772,7 +1773,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInFunInterface() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("any.kt") @@ -1815,7 +1816,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/lambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/lambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("any.kt") @@ -1858,7 +1859,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInObjectLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/objectLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/objectLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("any.kt") @@ -1903,7 +1904,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInInnerClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/innerClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/innerClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("captureThisAndOuter.kt") @@ -1921,7 +1922,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInJvmPackageName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/jvmPackageName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/jvmPackageName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -1934,7 +1935,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInLambdaClassClash() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/lambdaClassClash"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/lambdaClassClash"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("lambdaClassClash.kt") @@ -1957,7 +1958,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInLambdaTransformation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/lambdaTransformation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/lambdaTransformation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("lambdaCloning.kt") @@ -1995,7 +1996,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInLocalFunInLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/localFunInLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/localFunInLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("defaultParam.kt") @@ -2028,7 +2029,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInMultiModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("tryCatchWithRecursiveInline.kt") @@ -2046,7 +2047,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInMultifileClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -2059,7 +2060,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInMultiplatform() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("compiler/testData/codegen/boxInline/multiplatform/defaultArguments") @@ -2071,7 +2072,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInDefaultArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiplatform/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiplatform/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("receiversAndParametersInLambda.kt") @@ -2090,7 +2091,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInNoInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/noInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/noInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("extensionReceiver.kt") @@ -2138,7 +2139,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInNonLocalReturns() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("explicitLocalReturn.kt") @@ -2220,7 +2221,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInDeparenthesize() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/deparenthesize"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/deparenthesize"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("bracket.kt") @@ -2243,7 +2244,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInTryFinally() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("kt16417.kt") @@ -2320,7 +2321,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInCallSite() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("callSite.kt") @@ -2363,7 +2364,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInChained() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("finallyInFinally.kt") @@ -2416,7 +2417,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInDeclSite() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("complex.kt") @@ -2489,7 +2490,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInExceptionTable() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("break.kt") @@ -2602,7 +2603,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInVariables() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/variables"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/variables"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("kt7792.kt") @@ -2622,7 +2623,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInOptimizations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("kt20844.kt") @@ -2655,7 +2656,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInPrivate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("effectivePrivate.kt") @@ -2708,7 +2709,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("augAssignmentAndInc.kt") @@ -2786,7 +2787,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInReified() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("arrayConstructor.kt") @@ -2858,7 +2859,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInCheckCast() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/checkCast"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/checkCast"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("chain.kt") @@ -2916,7 +2917,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInDefaultLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/defaultLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/defaultLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -2929,7 +2930,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInIsCheck() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/isCheck"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/isCheck"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("chain.kt") @@ -2958,7 +2959,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/signature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/signature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } } @@ -2971,7 +2972,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInSimple() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/simple"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/simple"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("captureAndArgumentIncompatibleTypes.kt") @@ -3099,7 +3100,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInSmap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("assertion.kt") @@ -3196,7 +3197,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInAnonymous() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/anonymous"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/anonymous"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("kt19175.kt") @@ -3259,7 +3260,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInDefaultLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/defaultLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/defaultLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("defaultLambdaInAnonymous.kt") @@ -3317,7 +3318,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInInlineOnly() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/inlineOnly"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/inlineOnly"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("noSmap.kt") @@ -3350,7 +3351,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInNewsmap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/newsmap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/newsmap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("differentMapping.kt") @@ -3383,7 +3384,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInResolve() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/resolve"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/resolve"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("inlineComponent.kt") @@ -3407,7 +3408,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInSpecial() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/special"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/special"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("identityCheck.kt") @@ -3465,7 +3466,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInStackOnReturn() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/stackOnReturn"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/stackOnReturn"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("elvis.kt") @@ -3558,7 +3559,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInSuspend() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("capturedVariables.kt") @@ -3685,7 +3686,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("isAsReified.kt") @@ -3723,7 +3724,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInDefaultParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/defaultParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/defaultParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("defaultValueCrossinline.kt") @@ -3756,7 +3757,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInInlineClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/inlineClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/inlineClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("returnUnboxedDirect.kt") @@ -3779,7 +3780,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInInlineUsedAsNoinline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/inlineUsedAsNoinline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/inlineUsedAsNoinline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("inlineOnly.kt") @@ -3802,7 +3803,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInReceiver() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/receiver"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/receiver"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("inlineOrdinaryOfCrossinlineSuspend.kt") @@ -3855,7 +3856,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInStateMachine() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/stateMachine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/stateMachine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("crossingCoroutineBoundaries.kt") @@ -3979,7 +3980,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInSyntheticAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/syntheticAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/syntheticAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("constField.kt") @@ -4031,7 +4032,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInWithinInlineLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("directFieldAccess.kt") @@ -4090,7 +4091,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInTrait() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/trait"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/trait"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("trait.kt") @@ -4108,7 +4109,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInTryCatchFinally() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/tryCatchFinally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/tryCatchFinally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("kt5863.kt") @@ -4141,7 +4142,7 @@ public class IrJsCodegenInlineTestGenerated extends AbstractIrJsCodegenInlineTes } public void testAllFilesPresentInVarargs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/varargs"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/varargs"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("kt17653.kt") diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/semantics/IrJsTypeScriptExportTestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/semantics/IrJsTypeScriptExportTestGenerated.java index cc029d5de4e..8ad857f44b4 100644 --- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/semantics/IrJsTypeScriptExportTestGenerated.java +++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/semantics/IrJsTypeScriptExportTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.js.test.ir.semantics; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class IrJsTypeScriptExportTestGenerated extends AbstractIrJsTypeScriptExp } public void testAllFilesPresentInTypescript_export() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("js/js.translator/testData/typescript-export/constructors") @@ -38,7 +39,7 @@ public class IrJsTypeScriptExportTestGenerated extends AbstractIrJsTypeScriptExp } public void testAllFilesPresentInConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export/constructors"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export/constructors"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("constructors.kt") @@ -56,7 +57,7 @@ public class IrJsTypeScriptExportTestGenerated extends AbstractIrJsTypeScriptExp } public void testAllFilesPresentInDeclarations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export/declarations"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export/declarations"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("declarations.kt") @@ -74,7 +75,7 @@ public class IrJsTypeScriptExportTestGenerated extends AbstractIrJsTypeScriptExp } public void testAllFilesPresentInInheritance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export/inheritance"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export/inheritance"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("inheritance.kt") @@ -92,7 +93,7 @@ public class IrJsTypeScriptExportTestGenerated extends AbstractIrJsTypeScriptExp } public void testAllFilesPresentInModuleSystems() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export/moduleSystems"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export/moduleSystems"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("commonjs.kt") @@ -120,7 +121,7 @@ public class IrJsTypeScriptExportTestGenerated extends AbstractIrJsTypeScriptExp } public void testAllFilesPresentInNamespaces() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export/namespaces"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export/namespaces"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("namespaces.kt") @@ -138,7 +139,7 @@ public class IrJsTypeScriptExportTestGenerated extends AbstractIrJsTypeScriptExp } public void testAllFilesPresentInPrimitives() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export/primitives"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export/primitives"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("primitives.kt") @@ -156,7 +157,7 @@ public class IrJsTypeScriptExportTestGenerated extends AbstractIrJsTypeScriptExp } public void testAllFilesPresentInSelectiveExport() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export/selectiveExport"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export/selectiveExport"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("selectiveExport.kt") @@ -174,7 +175,7 @@ public class IrJsTypeScriptExportTestGenerated extends AbstractIrJsTypeScriptExp } public void testAllFilesPresentInVisibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export/visibility"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export/visibility"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS_IR, true); } @TestMetadata("visibility.kt") diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/semantics/BoxJsTestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/semantics/BoxJsTestGenerated.java index 39dd28a2554..db41c015f78 100644 --- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/semantics/BoxJsTestGenerated.java +++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/semantics/BoxJsTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.js.test.semantics; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInBox() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("js/js.translator/testData/box/annotation") @@ -38,7 +39,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInAnnotation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/annotation"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/annotation"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("annotationClass.kt") @@ -56,7 +57,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInBuiltins() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/builtins"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/builtins"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("hashCode.kt") @@ -84,7 +85,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/callableReference"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/callableReference"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("js/js.translator/testData/box/callableReference/function") @@ -96,7 +97,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/callableReference/function"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/callableReference/function"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("classMemberAndNonExtensionCompatibility.kt") @@ -154,7 +155,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/callableReference/property"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/callableReference/property"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("extensionProperty.kt") @@ -183,7 +184,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInChar() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/char"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/char"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("charBinaryOperations.kt") @@ -261,7 +262,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInClassObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/classObject"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/classObject"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("defaultObjectSameNamesAsInOuter.kt") @@ -319,7 +320,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInClosure() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/closure"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/closure"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("closureArrayListInstance.kt") @@ -557,7 +558,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInCoercion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/coercion"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/coercion"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("bridgeChar.kt") @@ -680,7 +681,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInCoroutines() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/coroutines"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/coroutines"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("debugStatement.kt") @@ -713,7 +714,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInCrossModuleRef() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/crossModuleRef"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/crossModuleRef"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("callableObjectRef.kt") @@ -806,7 +807,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInCrossModuleRefIR() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/crossModuleRefIR"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/crossModuleRefIR"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("callableObjectRef.kt") @@ -909,7 +910,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInDataClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/dataClass"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/dataClass"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("components.kt") @@ -962,7 +963,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInDefaultArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/defaultArguments"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/defaultArguments"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("complexExpressionAsConstructorDefaultArgument.kt") @@ -1085,7 +1086,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInDelegateProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/delegateProperty"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/delegateProperty"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("capturedLocalVal.kt") @@ -1213,7 +1214,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInDelegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/delegation"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/delegation"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("complexDelegation.kt") @@ -1316,7 +1317,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInDynamic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/dynamic"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/dynamic"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("binaryOperations.kt") @@ -1434,7 +1435,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/enum"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/enum"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("enumInheritedFromTrait.kt") @@ -1507,7 +1508,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInEs6classes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/es6classes"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/es6classes"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("builtItTypes.kt") @@ -1595,7 +1596,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInExamples() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/examples"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/examples"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("basicmethod.kt") @@ -1618,7 +1619,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInExport() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/export"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/export"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("nonIndetifierModuleName.kt") @@ -1641,7 +1642,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("js/js.translator/testData/box/expression/cast") @@ -1653,7 +1654,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInCast() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/cast"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/cast"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("castExtensionToKMutableProperty.kt") @@ -1806,7 +1807,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInCompareTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/compareTo"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/compareTo"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("booleanCompareTo.kt") @@ -1829,7 +1830,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInDollarParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/dollarParameter"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/dollarParameter"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("dollarParameter.kt") @@ -1847,7 +1848,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInEquals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/equals"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/equals"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("arrays.kt") @@ -1930,7 +1931,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInEvaluationOrder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/evaluationOrder"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/evaluationOrder"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("andAndWithBreakContinueReturn.kt") @@ -2133,7 +2134,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInFor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/for"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/for"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("forIteratesOverArray.kt") @@ -2226,7 +2227,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/function"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/function"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("anonymousWithLambda.kt") @@ -2409,7 +2410,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInIdentifierClash() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/identifierClash"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/identifierClash"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("overloadedFun.kt") @@ -2437,7 +2438,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInIdentityEquals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/identityEquals"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/identityEquals"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("identityEqualsMethod.kt") @@ -2460,7 +2461,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInIf() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/if"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/if"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("ifElseAsExpressionWithThrow.kt") @@ -2498,7 +2499,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInInvoke() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/invoke"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/invoke"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("explicitInvokeLambda.kt") @@ -2571,7 +2572,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInMisc() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/misc"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/misc"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("classWithoutPackage.kt") @@ -2794,7 +2795,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInStringClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/stringClass"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/stringClass"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("extensionMethods.kt") @@ -2872,7 +2873,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInStringTemplates() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/stringTemplates"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/stringTemplates"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("nonStrings.kt") @@ -2900,7 +2901,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInTry() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/try"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/try"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("exceptionToString.kt") @@ -2978,7 +2979,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInTypeCheck() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/typeCheck"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/typeCheck"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("simpleAsClass.kt") @@ -3011,7 +3012,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInWhen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/when"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/when"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("doWhileWithOneStmWhen.kt") @@ -3189,7 +3190,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInWhile() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/while"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/expression/while"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("doWhileWithComplexCondition.kt") @@ -3228,7 +3229,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInExtensionFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/extensionFunction"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/extensionFunction"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("extensionForSuperclass.kt") @@ -3326,7 +3327,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInExtensionProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/extensionProperty"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/extensionProperty"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("externalExtensionProperty.kt") @@ -3369,7 +3370,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInIncremental() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/incremental"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/incremental"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("catchScope.kt") @@ -3477,7 +3478,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInInheritance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/inheritance"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/inheritance"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("baseCall.kt") @@ -3594,7 +3595,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInInterfaces() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/inheritance/interfaces"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/inheritance/interfaces"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("fromExternalInterface.kt") @@ -3628,7 +3629,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInInitialize() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/initialize"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/initialize"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("classInitializer.kt") @@ -3686,7 +3687,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/inline"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/inline"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("anonymousFunction.kt") @@ -4114,7 +4115,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInInlineEvaluationOrder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/inlineEvaluationOrder"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/inlineEvaluationOrder"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("alsoWithReassingment.kt") @@ -4392,7 +4393,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInInlineMultiFile() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/inlineMultiFile"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/inlineMultiFile"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("anonymousObjectInSimilarFunctions.kt") @@ -4555,7 +4556,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInInlineMultiModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/inlineMultiModule"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/inlineMultiModule"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("anotherModuleValInClosure.kt") @@ -4733,7 +4734,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInInlineSizeReduction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/inlineSizeReduction"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/inlineSizeReduction"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("inlineImportCleanup.kt") @@ -4831,7 +4832,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInInlineStdlib() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/inlineStdlib"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/inlineStdlib"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("callNameClash.kt") @@ -4889,7 +4890,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInIntrinsics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/intrinsics"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/intrinsics"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("typeof.kt") @@ -4907,7 +4908,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/java"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/java"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("js/js.translator/testData/box/java/abstractList") @@ -4919,7 +4920,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInAbstractList() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/java/abstractList"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/java/abstractList"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("iterator.kt") @@ -4942,7 +4943,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInArrayList() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/java/arrayList"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/java/arrayList"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("arrayAccess.kt") @@ -5031,7 +5032,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInJsCode() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/jsCode"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/jsCode"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("break.kt") @@ -5179,7 +5180,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInJsExport() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/jsExport"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/jsExport"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("dataClass.kt") @@ -5207,7 +5208,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInJsModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/jsModule"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/jsModule"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("externalClass.kt") @@ -5315,7 +5316,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInJsName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/jsName"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/jsName"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("avoidNameClash.kt") @@ -5393,7 +5394,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInJsQualifier() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/jsQualifier"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/jsQualifier"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("classes.kt") @@ -5431,7 +5432,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInKotlin_test() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/kotlin.test"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/kotlin.test"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("beforeAfter.kt") @@ -5489,7 +5490,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInLabels() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/labels"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/labels"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("labelOnExpression.kt") @@ -5562,7 +5563,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInMain() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/main"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/main"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("differentMains.kt") @@ -5615,7 +5616,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInMultiFile() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multiFile"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multiFile"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("classOfTheSameNameInAnotherPackage.kt") @@ -5658,7 +5659,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInMultiModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multiModule"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multiModule"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("clashedDeclLinkage.kt") @@ -5726,7 +5727,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInMultiModuleWrappers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multiModuleWrappers"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multiModuleWrappers"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("js/js.translator/testData/box/multiModuleWrappers/amd") @@ -5738,7 +5739,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInAmd() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multiModuleWrappers/amd"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multiModuleWrappers/amd"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("jsModuleOnPackage.kt") @@ -5766,7 +5767,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInCommon_js() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multiModuleWrappers/common_js"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multiModuleWrappers/common_js"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("inlineFromModuleWithNonIdentifierName.kt") @@ -5794,7 +5795,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInPlain() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multiModuleWrappers/plain"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multiModuleWrappers/plain"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("inlineFromModuleWithNonIdentifierName.kt") @@ -5822,7 +5823,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInUmd() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multiModuleWrappers/umd"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multiModuleWrappers/umd"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("moduleWithNonIdentifierName.kt") @@ -5846,7 +5847,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInMultiPackage() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multiPackage"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multiPackage"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("classesInheritedFromOtherPackage.kt") @@ -5904,7 +5905,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInMultideclaration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multideclaration"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/multideclaration"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("multiValForArray.kt") @@ -5952,7 +5953,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInNameClashes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/nameClashes"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/nameClashes"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("classAndCompanionObjectMembers.kt") @@ -6065,7 +6066,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInNative() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/native"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/native"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("callbackOptionalParameter.kt") @@ -6268,7 +6269,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInNestedTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/nestedTypes"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/nestedTypes"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("implicitOuterThisFromLambda.kt") @@ -6361,7 +6362,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInNumber() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/number"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/number"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("assignmentIntOverflow.kt") @@ -6524,7 +6525,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInObjectDeclaration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/objectDeclaration"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/objectDeclaration"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("dontPolluteObject.kt") @@ -6597,7 +6598,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInOperatorOverloading() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/operatorOverloading"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/operatorOverloading"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("augmentedAssignmentLhs.kt") @@ -6725,7 +6726,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInPackage() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/package"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/package"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("classCreatedInDeeplyNestedPackage.kt") @@ -6773,7 +6774,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInPropertyAccess() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/propertyAccess"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/propertyAccess"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("classUsesPackageProperties.kt") @@ -6901,7 +6902,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInPropertyOverride() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/propertyOverride"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/propertyOverride"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("checkSupertypeOrder.kt") @@ -6969,7 +6970,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInRange() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/range"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/range"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("creatingProgressions.kt") @@ -7037,7 +7038,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInReflection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/reflection"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/reflection"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("classJsName.kt") @@ -7120,7 +7121,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInRegression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/regression"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/regression"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("companionObjectInExternalInterface.kt") @@ -7162,7 +7163,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInStdlibTestSnippets() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/regression/stdlibTestSnippets"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/regression/stdlibTestSnippets"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("arrayTest_plusInference.kt") @@ -7195,7 +7196,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInTypeChecks() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/regression/typeChecks"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/regression/typeChecks"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("booleanOperatorsTypes.kt") @@ -7229,7 +7230,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInReified() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/reified"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/reified"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("callChain.kt") @@ -7342,7 +7343,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInRtti() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/rtti"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/rtti"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("collectionClassesIsCheck.kt") @@ -7450,7 +7451,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInSafeCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/safeCall"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/safeCall"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("redundantSafeAccess.kt") @@ -7498,7 +7499,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInSimple() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/simple"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/simple"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("assign.kt") @@ -7671,7 +7672,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInStandardClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/standardClasses"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/standardClasses"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("any.kt") @@ -7774,7 +7775,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInSuperCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/superCall"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/superCall"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("classSuperCall.kt") @@ -7812,7 +7813,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInTrait() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/trait"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/trait"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("checkImplementationCharacteristics.kt") @@ -7870,7 +7871,7 @@ public class BoxJsTestGenerated extends AbstractBoxJsTest { } public void testAllFilesPresentInVararg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/vararg"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/vararg"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("jsExternalVarargCtor.kt") diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java index 95c1521dc26..ddc4f01c978 100644 --- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java +++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.js.test.semantics; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInBox() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("compiler/testData/codegen/box/annotations") @@ -38,7 +39,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("nestedAnnotation.kt") @@ -70,7 +71,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInAnnotatedLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations/annotatedLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations/annotatedLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } @@ -83,7 +84,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInTypeAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations/typeAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations/typeAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("checkingNotincorporatedInputTypes.kt") @@ -102,7 +103,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInArgumentOrder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/argumentOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/argumentOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("argumentOrderInObjectSuperCall.kt") @@ -185,7 +186,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInArrays() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("arrayConstructorWithNonInlineLambda.kt") @@ -507,7 +508,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInArraysOfInlineClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/arraysOfInlineClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/arraysOfInlineClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("arrayOfInlineClassOfArrayOfInlineClass.kt") @@ -525,7 +526,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInForInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/forInReversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/forInReversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("reversedArrayOriginalUpdatedInLoopBody.kt") @@ -558,7 +559,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInMultiDecl() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("kt15560.kt") @@ -610,7 +611,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInInt() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -643,7 +644,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInLong() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -678,7 +679,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInAssert() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/assert"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/assert"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("alwaysDisable.kt") @@ -700,7 +701,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInJvm() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/assert/jvm"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/assert/jvm"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } } @@ -714,7 +715,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInBinaryOp() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/binaryOp"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/binaryOp"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("bitwiseOp.kt") @@ -837,7 +838,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInBoxingOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/boxingOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/boxingOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("boxedIntegersCmp.kt") @@ -990,7 +991,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInBridges() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/bridges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/bridges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("complexMultiInheritance.kt") @@ -1277,7 +1278,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInSubstitutionInSuperClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/bridges/substitutionInSuperClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/bridges/substitutionInSuperClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("boundedTypeArguments.kt") @@ -1341,7 +1342,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInBuilderInference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("callableReferenceAndCoercionToUnit.kt") @@ -1379,7 +1380,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInBuiltinStubMethods() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("customReadOnlyIterator.kt") @@ -1401,7 +1402,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInExtendJavaCollections() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/extendJavaCollections"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/extendJavaCollections"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("arrayList.kt") @@ -1429,7 +1430,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInMapGetOrDefault() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/mapGetOrDefault"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/mapGetOrDefault"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } @@ -1442,7 +1443,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInMapRemove() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/mapRemove"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/mapRemove"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } } @@ -1456,7 +1457,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("genericConstructorReference.kt") @@ -1488,7 +1489,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInAdaptedReferences() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/adaptedReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/adaptedReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("bothWithCoercionToUnit.kt") @@ -1625,7 +1626,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInSuspendConversion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("bound.kt") @@ -1704,7 +1705,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInBound() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("array.kt") @@ -1826,7 +1827,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInEquals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/bound/equals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/bound/equals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("nullableReceiverInEquals.kt") @@ -1860,7 +1861,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInEquality() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/equality"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/equality"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("capturedDefaults.kt") @@ -1938,7 +1939,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/function"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/function"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("argumentTypes.kt") @@ -2210,7 +2211,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInLocal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/function/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/function/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("captureOuter.kt") @@ -2329,7 +2330,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("delegated.kt") @@ -2487,7 +2488,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInSerializability() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/serializability"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/serializability"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } } @@ -2501,7 +2502,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInCasts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("as.kt") @@ -2628,7 +2629,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("asFunKBig.kt") @@ -2701,7 +2702,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInJavaInterop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } @@ -2714,7 +2715,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInLiteralExpressionAsGenericArgument() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/literalExpressionAsGenericArgument"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/literalExpressionAsGenericArgument"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("binaryExpressionCast.kt") @@ -2757,7 +2758,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInMutableCollections() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/mutableCollections"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/mutableCollections"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("asWithMutable.kt") @@ -2806,7 +2807,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInCheckcastOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/checkcastOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/checkcastOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("kt19128.kt") @@ -2829,7 +2830,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInClassLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("bareArray.kt") @@ -2846,7 +2847,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInBound() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classLiteral/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classLiteral/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("primitives.kt") @@ -2879,7 +2880,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classLiteral/java"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classLiteral/java"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("kt11943.kt") @@ -2898,7 +2899,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("boxPrimitiveTypeInClinitOfClassObject.kt") @@ -3475,7 +3476,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInInner() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classes/inner"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classes/inner"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("extensionWithOuter.kt") @@ -3524,7 +3525,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInClosures() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("anonymousObjectAsLastExpressionInLambda.kt") @@ -3751,7 +3752,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInCaptureInSuperConstructorCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/captureInSuperConstructorCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/captureInSuperConstructorCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("constructorParameterAndLocalCapturedInLambdaInLocalClass.kt") @@ -3924,7 +3925,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInCaptureOuterProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/captureOuterProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/captureOuterProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("captureFunctionInProperty.kt") @@ -3977,7 +3978,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInCapturedVarsOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/capturedVarsOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/capturedVarsOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("capturedInCrossinline.kt") @@ -4045,7 +4046,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInClosureInsideClosure() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/closureInsideClosure"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/closureInsideClosure"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("localFunInsideLocalFun.kt") @@ -4089,7 +4090,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInCollectionLiterals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/collectionLiterals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/collectionLiterals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } @@ -4107,7 +4108,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInCollections() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/collections"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/collections"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("inSetWithSmartCast.kt") @@ -4140,7 +4141,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInCompanion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/companion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/companion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("delegatedPropertyOnCompanion.kt") @@ -4163,7 +4164,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/compatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/compatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("privateCompanionObject.kt") @@ -4181,7 +4182,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInConstants() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/constants"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/constants"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("comparisonFalse.kt") @@ -4244,7 +4245,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInConstructorCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/constructorCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/constructorCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } @@ -4257,7 +4258,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInContracts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/contracts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/contracts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("constructorArgument.kt") @@ -4330,7 +4331,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInControlStructures() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("bottles.kt") @@ -4722,7 +4723,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInBreakContinueInExpressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("breakFromOuter.kt") @@ -4825,7 +4826,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInForInArray() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInArray"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInArray"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("forInArraySpecializedToUntil.kt") @@ -4888,7 +4889,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInForInArrayWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("forInArrayOfObjectArrayWithIndex.kt") @@ -5001,7 +5002,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInForInCharSequenceWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInCharSequenceWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInCharSequenceWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("forInCharSeqWithIndexStops.kt") @@ -5084,7 +5085,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInForInIterableWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInIterableWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInIterableWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("forInEmptyListWithIndex.kt") @@ -5147,7 +5148,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInForInSequenceWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInSequenceWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInSequenceWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("forInEmptySequenceWithIndex.kt") @@ -5210,7 +5211,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInReturnsNothing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/returnsNothing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/returnsNothing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("ifElse.kt") @@ -5248,7 +5249,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInTryCatchInExpressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("catch.kt") @@ -5422,7 +5423,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInCoroutines() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("asyncIteratorNullMerge_1_3.kt") @@ -5944,7 +5945,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInBridges() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/bridges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/bridges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("interfaceSpecialization.kt") @@ -5972,7 +5973,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInControlFlow() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/controlFlow"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/controlFlow"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("breakFinally.kt") @@ -6095,7 +6096,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInDebug() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/debug"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/debug"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } @@ -6108,7 +6109,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInFeatureIntersection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("breakWithNonEmptyStack.kt") @@ -6200,7 +6201,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("bigArity.kt") @@ -6222,7 +6223,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInBound() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("emptyLHS.kt") @@ -6240,7 +6241,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/function"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/function"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("genericCallableReferencesWithNullableTypes.kt") @@ -6257,7 +6258,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInLocal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/function/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/function/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("equalsHashCode.kt") @@ -6277,7 +6278,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInTailrec() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/tailrec"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/tailrec"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("controlFlowIf.kt") @@ -6356,7 +6357,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("nonLocalReturn.kt") @@ -6373,7 +6374,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInDirect() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses/direct"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses/direct"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("boxReturnValueOfSuspendFunctionReference.kt") @@ -6601,7 +6602,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInResume() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses/resume"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses/resume"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("boxReturnValueOfSuspendFunctionReference.kt") @@ -6829,7 +6830,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInResumeWithException() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("boxReturnValueOfSuspendFunctionReference.kt") @@ -7043,7 +7044,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInIntLikeVarSpilling() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/intLikeVarSpilling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/intLikeVarSpilling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("complicatedMerge.kt") @@ -7101,7 +7102,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInIntrinsicSemantics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/intrinsicSemantics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/intrinsicSemantics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("coroutineContext.kt") @@ -7154,7 +7155,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInJavaInterop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } @@ -7167,7 +7168,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInLocalFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/localFunctions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/localFunctions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("compiler/testData/codegen/box/coroutines/localFunctions/anonymous") @@ -7179,7 +7180,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInAnonymous() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/localFunctions/anonymous"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/localFunctions/anonymous"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("simple.kt") @@ -7197,7 +7198,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInNamed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/localFunctions/named"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/localFunctions/named"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("capturedParameters.kt") @@ -7261,7 +7262,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInMultiModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("inlineCrossModule.kt") @@ -7314,7 +7315,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInRedundantLocalsElimination() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/redundantLocalsElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/redundantLocalsElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("ktor_receivedMessage.kt") @@ -7332,7 +7333,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInReflect() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/reflect"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/reflect"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } @@ -7345,7 +7346,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInStackUnwinding() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/stackUnwinding"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/stackUnwinding"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("exception.kt") @@ -7388,7 +7389,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInSuspendConversion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/suspendConversion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/suspendConversion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("intersectionTypeToSubtypeConversion.kt") @@ -7421,7 +7422,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInSuspendFunctionAsCoroutine() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("dispatchResume.kt") @@ -7519,7 +7520,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInSuspendFunctionTypeCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/suspendFunctionTypeCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/suspendFunctionTypeCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("localVal.kt") @@ -7557,7 +7558,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInTailCallOptimizations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/tailCallOptimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/tailCallOptimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("crossinline.kt") @@ -7589,7 +7590,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInUnit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/tailCallOptimizations/unit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/tailCallOptimizations/unit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } } @@ -7603,7 +7604,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInTailOperations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/tailOperations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/tailOperations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("suspendWithIf.kt") @@ -7636,7 +7637,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInUnitTypeReturn() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/unitTypeReturn"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/unitTypeReturn"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("coroutineNonLocalReturn.kt") @@ -7684,7 +7685,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInVarSpilling() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/varSpilling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/varSpilling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("fakeInlinerVariables.kt") @@ -7728,7 +7729,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInDataClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("arrayParams.kt") @@ -7810,7 +7811,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInCopy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/copy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/copy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("constructorWithDefaultParam.kt") @@ -7863,7 +7864,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInEquals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/equals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/equals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("alreadyDeclared.kt") @@ -7906,7 +7907,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInHashCode() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/hashCode"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/hashCode"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("alreadyDeclared.kt") @@ -7974,7 +7975,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInToString() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/toString"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/toString"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("alreadyDeclared.kt") @@ -8018,7 +8019,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInDeadCodeElimination() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/deadCodeElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/deadCodeElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("emptyVariableRange.kt") @@ -8051,7 +8052,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInDefaultArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("callDefaultFromInitializer.kt") @@ -8128,7 +8129,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/constructor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/constructor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("annotation.kt") @@ -8216,7 +8217,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInConvention() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/convention"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/convention"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("incWithDefaultInGetter.kt") @@ -8264,7 +8265,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/function"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/function"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("complexInheritance.kt") @@ -8412,7 +8413,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInPrivate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("memberExtensionFunction.kt") @@ -8445,7 +8446,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/signature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/signature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("kt2789.kt") @@ -8479,7 +8480,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInDelegatedProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("beforeDeclarationContainerOptimization.kt") @@ -8711,7 +8712,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInLocal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("capturedLocalVal.kt") @@ -8804,7 +8805,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInOptimizedDelegatedProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/optimizedDelegatedProperties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/optimizedDelegatedProperties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("definedInSources.kt") @@ -8867,7 +8868,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInProvideDelegate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/provideDelegate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/provideDelegate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("delegatedPropertyWithIdProvideDelegate.kt") @@ -8986,7 +8987,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInDelegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("delegationWithPrivateConstructor.kt") @@ -9024,7 +9025,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInDestructuringDeclInLambdaParam() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/destructuringDeclInLambdaParam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/destructuringDeclInLambdaParam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("extensionComponents.kt") @@ -9077,7 +9078,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInDiagnostics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("compiler/testData/codegen/box/diagnostics/functions") @@ -9089,7 +9090,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("compiler/testData/codegen/box/diagnostics/functions/inference") @@ -9101,7 +9102,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInInference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/inference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/inference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("kt6176.kt") @@ -9119,7 +9120,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInInvoke() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/invoke"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/invoke"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects") @@ -9131,7 +9132,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInOnObjects() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("invokeOnClassObject1.kt") @@ -9195,7 +9196,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInTailRecursion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/tailRecursion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/tailRecursion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("defaultArgs.kt") @@ -9409,7 +9410,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInVararg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/vararg"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/vararg"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("kt4172.kt") @@ -9428,7 +9429,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInElvis() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/elvis"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/elvis"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("genericElvisWithMoreSpecificLHS.kt") @@ -9486,7 +9487,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("asReturnExpression.kt") @@ -9773,7 +9774,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInDefaultCtor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/enum/defaultCtor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/enum/defaultCtor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("constructorWithDefaultArguments.kt") @@ -9817,7 +9818,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInEvaluate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/evaluate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/evaluate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("kt9443.kt") @@ -9835,7 +9836,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInExclExcl() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/exclExcl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/exclExcl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("genericNull.kt") @@ -9858,7 +9859,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInExtensionFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/extensionFunctions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/extensionFunctions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("executionOrder.kt") @@ -9996,7 +9997,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInExtensionProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/extensionProperties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/extensionProperties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("genericValForPrimitiveType.kt") @@ -10074,7 +10075,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInExternal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/external"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/external"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } @@ -10087,7 +10088,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInFakeOverride() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fakeOverride"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fakeOverride"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("diamondFunction.kt") @@ -10130,7 +10131,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInFieldRename() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fieldRename"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fieldRename"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("constructorAndClassObject.kt") @@ -10158,7 +10159,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInFinally() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/finally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/finally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("breakAndOuterFinally.kt") @@ -10276,7 +10277,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInFullJdk() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("compiler/testData/codegen/box/fullJdk/native") @@ -10288,7 +10289,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInNative() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk/native"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk/native"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } @@ -10301,7 +10302,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInRegressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk/regressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk/regressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } } @@ -10315,7 +10316,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInFunInterface() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("basicFunInterface.kt") @@ -10432,7 +10433,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInEquality() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/funInterface/equality"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/funInterface/equality"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("functionReferencesBound.kt") @@ -10471,7 +10472,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("coerceVoidToArray.kt") @@ -10703,7 +10704,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInBigArity() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/bigArity"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/bigArity"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("function255.kt") @@ -10751,7 +10752,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInFunctionExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/functionExpression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/functionExpression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("functionExpression.kt") @@ -10794,7 +10795,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInInvoke() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/invoke"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/invoke"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("castFunctionToExtension.kt") @@ -10877,7 +10878,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInLocalFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/localFunctions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/localFunctions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("boundTypeParameterInSupertype.kt") @@ -11041,7 +11042,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInHashPMap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/hashPMap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/hashPMap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } @@ -11054,7 +11055,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInIeee754() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ieee754"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ieee754"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("anyToReal.kt") @@ -11312,7 +11313,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInIncrement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/increment"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/increment"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("argumentWithSideEffects.kt") @@ -11455,7 +11456,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInInference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("approximateNonTopLevelCapturedTypes.kt") @@ -11588,7 +11589,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("annotatedMemberExtensionProperty.kt") @@ -12340,7 +12341,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInBoxReturnValueInLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("boxAny.kt") @@ -12413,7 +12414,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInBoxReturnValueOnOverride() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("covariantOverrideChainErasedToAny.kt") @@ -12556,7 +12557,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInCallableReferences() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/callableReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/callableReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("boundInlineClassExtensionFun.kt") @@ -12719,7 +12720,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInContextsAndAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("captureInlineClassInstanceInLambda.kt") @@ -12787,7 +12788,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInDefaultParameterValues() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/defaultParameterValues"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/defaultParameterValues"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("defaultConstructorParameterValuesOfInlineClassType.kt") @@ -12860,7 +12861,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInFunctionNameMangling() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/functionNameMangling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/functionNameMangling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("anonymousObjectInFunctionWithMangledName.kt") @@ -12953,7 +12954,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInHiddenConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/hiddenConstructor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/hiddenConstructor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("constructorReferencedFromOtherFile1.kt") @@ -13031,7 +13032,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInInterfaceDelegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/interfaceDelegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/interfaceDelegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("interfaceImplementationByDelegation.kt") @@ -13084,7 +13085,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInInterfaceMethodCalls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("complexGenericMethodWithInlineClassOverride.kt") @@ -13152,7 +13153,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInJavaInterop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } @@ -13165,7 +13166,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInJvm8DefaultInterfaceMethods() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/jvm8DefaultInterfaceMethods"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/jvm8DefaultInterfaceMethods"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } @@ -13178,7 +13179,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInPropertyDelegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/propertyDelegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/propertyDelegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("captureLocalVarDelegatedToInlineClass.kt") @@ -13246,7 +13247,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInUnboxGenericParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface") @@ -13258,7 +13259,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInFunInterface() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("any.kt") @@ -13306,7 +13307,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("any.kt") @@ -13354,7 +13355,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInObjectLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("any.kt") @@ -13404,7 +13405,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInInnerNested() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/innerNested"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/innerNested"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("createNestedClass.kt") @@ -13541,7 +13542,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInSuperConstructorCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/innerNested/superConstructorCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/innerNested/superConstructorCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("deepInnerHierarchy.kt") @@ -13655,7 +13656,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInInstructions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/instructions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/instructions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("compiler/testData/codegen/box/instructions/swap") @@ -13667,7 +13668,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInSwap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/instructions/swap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/instructions/swap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("swapRefToSharedVarInt.kt") @@ -13691,7 +13692,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInIntrinsics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/intrinsics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/intrinsics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("charToInt.kt") @@ -13809,7 +13810,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInIr() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("anonymousClassLeak.kt") @@ -13901,7 +13902,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInClosureConversion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/closureConversion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/closureConversion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("closureConversion1.kt") @@ -13954,7 +13955,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInPrimitiveNumberComparisons() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/primitiveNumberComparisons"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/primitiveNumberComparisons"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("comparableToDouble.kt") @@ -13987,7 +13988,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInSerializationRegressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/serializationRegressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/serializationRegressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("deepGenericDelegatedProperty.kt") @@ -14041,7 +14042,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInJavaInterop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("compiler/testData/codegen/box/javaInterop/generics") @@ -14053,7 +14054,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInGenerics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/generics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/generics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("kt42824.kt") @@ -14076,7 +14077,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInNotNullAssertions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("mapPut.kt") @@ -14093,7 +14094,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInEnhancedNullability() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions/enhancedNullability"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions/enhancedNullability"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } @@ -14106,7 +14107,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInNullCheckOnLambdaReturnValue() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions/nullCheckOnLambdaReturnValue"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions/nullCheckOnLambdaReturnValue"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } } @@ -14120,7 +14121,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInObjectMethods() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/objectMethods"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/objectMethods"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("cloneCallsConstructor.kt") @@ -14154,7 +14155,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInJdk() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jdk"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jdk"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("arrayList.kt") @@ -14187,7 +14188,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInJvm8() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("compiler/testData/codegen/box/jvm8/defaults") @@ -14199,7 +14200,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInDefaults() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/allCompatibility") @@ -14211,7 +14212,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInAllCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/delegationBy") @@ -14223,7 +14224,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInDelegationBy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } } @@ -14237,7 +14238,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/compatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/compatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } @@ -14250,7 +14251,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInDelegationBy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } @@ -14263,7 +14264,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInNoDefaultImpls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/delegationBy") @@ -14275,7 +14276,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInDelegationBy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } @@ -14288,7 +14289,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInSpecialization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/specialization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/specialization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } } @@ -14302,7 +14303,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInNoDelegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDelegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDelegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } @@ -14315,7 +14316,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInReflection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/reflection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/reflection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } } @@ -14329,7 +14330,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInInterfaceFlag() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/interfaceFlag"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/interfaceFlag"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } @@ -14342,7 +14343,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInJavaDefaults() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/javaDefaults"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/javaDefaults"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } } @@ -14356,7 +14357,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInJvmField() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmField"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmField"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } @@ -14369,7 +14370,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInJvmName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("compiler/testData/codegen/box/jvmName/fileFacades") @@ -14381,7 +14382,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInFileFacades() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmName/fileFacades"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmName/fileFacades"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } } @@ -14395,7 +14396,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInJvmOverloads() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmOverloads"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmOverloads"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } @@ -14408,7 +14409,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInJvmPackageName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmPackageName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmPackageName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } @@ -14421,7 +14422,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInJvmStatic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmStatic"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmStatic"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } @@ -14434,7 +14435,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInLabels() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/labels"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/labels"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("controlLabelClashesWithFuncitonName.kt") @@ -14487,7 +14488,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInLazyCodegen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/lazyCodegen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/lazyCodegen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("exceptionInFieldInitializer.kt") @@ -14544,7 +14545,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInOptimizations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/lazyCodegen/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/lazyCodegen/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("negateConstantCompare.kt") @@ -14603,7 +14604,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInLocalClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/localClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/localClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("anonymousObjectInExtension.kt") @@ -14786,7 +14787,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInMangling() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/mangling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/mangling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("internal.kt") @@ -14829,7 +14830,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInMixedNamedPosition() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/mixedNamedPosition"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/mixedNamedPosition"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("defaults.kt") @@ -14862,7 +14863,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInMultiDecl() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("ComplexInitializer.kt") @@ -14944,7 +14945,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInForIterator() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forIterator"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forIterator"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("MultiDeclFor.kt") @@ -14981,7 +14982,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInLongIterator() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forIterator/longIterator"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forIterator/longIterator"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -15015,7 +15016,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInForRange() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("MultiDeclFor.kt") @@ -15062,7 +15063,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInExplicitRangeTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("MultiDeclFor.kt") @@ -15099,7 +15100,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInInt() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -15132,7 +15133,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInLong() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -15166,7 +15167,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInExplicitRangeToWithDot() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("MultiDeclFor.kt") @@ -15203,7 +15204,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInInt() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -15236,7 +15237,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInLong() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -15270,7 +15271,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInInt() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -15303,7 +15304,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInLong() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -15338,7 +15339,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInMultifileClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("compiler/testData/codegen/box/multifileClasses/optimized") @@ -15350,7 +15351,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInOptimized() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multifileClasses/optimized"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multifileClasses/optimized"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } } @@ -15364,7 +15365,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInMultiplatform() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("optionalExpectation.kt") @@ -15386,7 +15387,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInDefaultArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("bothInExpectAndActual.kt") @@ -15504,7 +15505,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInMultiModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("expectActualLink.kt") @@ -15533,7 +15534,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInNonLocalReturns() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nonLocalReturns"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nonLocalReturns"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("kt9644let.kt") @@ -15561,7 +15562,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInNothingValue() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nothingValue"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nothingValue"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("inNestedCall.kt") @@ -15584,7 +15585,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInNullCheckOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nullCheckOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nullCheckOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("isNullable.kt") @@ -15622,7 +15623,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInObjectIntrinsics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objectIntrinsics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objectIntrinsics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("objects.kt") @@ -15640,7 +15641,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInObjects() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("anonymousObjectPropertyInitialization.kt") @@ -15997,7 +15998,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInCompanionObjectAccess() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("kt27117.kt") @@ -16094,7 +16095,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInMultipleCompanionsWithAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("anonymousObjectInPropertyInitializer.kt") @@ -16162,7 +16163,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInPrimitiveCompanion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess/primitiveCompanion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess/primitiveCompanion"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("byteCompanionObject.kt") @@ -16212,7 +16213,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInOldLanguageVersions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("dataClassEqualsHashCodeToString.kt") @@ -16229,7 +16230,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInControlStructures() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/controlStructures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/controlStructures"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("compiler/testData/codegen/box/oldLanguageVersions/controlStructures/forInArray") @@ -16241,7 +16242,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInForInArray() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/controlStructures/forInArray"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/controlStructures/forInArray"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("forInArrayWithArrayVarUpdatedInLoopBody12.kt") @@ -16260,7 +16261,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInCoroutines() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("asyncIteratorNullMerge_1_2.kt") @@ -16292,7 +16293,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInControlFlow() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines/controlFlow"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines/controlFlow"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("kt22694_1_2.kt") @@ -16310,7 +16311,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInFeatureIntersection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines/featureIntersection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines/featureIntersection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("suspendFunction_1_2.kt") @@ -16328,7 +16329,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInMultiModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } @@ -16341,7 +16342,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInReflect() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines/reflect"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines/reflect"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("isSuspend_1_2.kt") @@ -16359,7 +16360,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInSuspendFunctionAsCoroutine() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines/suspendFunctionAsCoroutine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/coroutines/suspendFunctionAsCoroutine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("ifExpressionInsideCoroutine_1_2.kt") @@ -16378,7 +16379,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("compiler/testData/codegen/box/oldLanguageVersions/functions/bigArity") @@ -16390,7 +16391,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInBigArity() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/functions/bigArity"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/functions/bigArity"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("noBigFunctionTypes.kt") @@ -16409,7 +16410,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInIeee754() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/ieee754"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/ieee754"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("nullableDoubleEquals10.kt") @@ -16452,7 +16453,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInJavaInterop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("compiler/testData/codegen/box/oldLanguageVersions/javaInterop/notNullAssertions") @@ -16464,7 +16465,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInNotNullAssertions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/javaInterop/notNullAssertions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/javaInterop/notNullAssertions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } } @@ -16478,7 +16479,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInOperatorConventions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/operatorConventions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/operatorConventions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } @@ -16491,7 +16492,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInPlatformTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/platformTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/platformTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("compiler/testData/codegen/box/oldLanguageVersions/platformTypes/primitives") @@ -16503,7 +16504,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInPrimitives() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/platformTypes/primitives"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/oldLanguageVersions/platformTypes/primitives"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } } @@ -16518,7 +16519,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInOperatorConventions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/operatorConventions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/operatorConventions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("annotatedAssignment.kt") @@ -16630,7 +16631,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInCompareTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/operatorConventions/compareTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/operatorConventions/compareTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("boolean.kt") @@ -16699,7 +16700,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInOptimizations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("kt20844.kt") @@ -16717,7 +16718,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInPackage() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/package"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/package"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("boxPrimitiveTypeInClinit.kt") @@ -16785,7 +16786,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInParametersMetadata() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/parametersMetadata"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/parametersMetadata"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } @@ -16798,7 +16799,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInPlatformTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/platformTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/platformTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("inferenceFlexibleTToNullable.kt") @@ -16815,7 +16816,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInPrimitives() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/platformTypes/primitives"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/platformTypes/primitives"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("assign.kt") @@ -16924,7 +16925,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInPolymorphicSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/polymorphicSignature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/polymorphicSignature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } @@ -16937,7 +16938,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInPrimitiveTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("comparisonWithNullCallsFun.kt") @@ -17234,7 +17235,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInEqualityWithObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes/equalityWithObject"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes/equalityWithObject"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("boxedEqPrimitiveEvaluationOrder.kt") @@ -17291,7 +17292,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInGenerated() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("boxedEqPrimitiveBoolean.kt") @@ -17396,7 +17397,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInPrivate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("arrayConvention.kt") @@ -17419,7 +17420,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInPrivateConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/privateConstructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/privateConstructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("base.kt") @@ -17522,7 +17523,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("augmentedAssignmentsAndIncrements.kt") @@ -17864,7 +17865,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInConst() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/const"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/const"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("anotherFile.kt") @@ -17902,7 +17903,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInLateinit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("exceptionField.kt") @@ -17964,7 +17965,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInIsInitializedAndDeinitialize() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/isInitializedAndDeinitialize"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/isInitializedAndDeinitialize"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("companionObjectField.kt") @@ -18017,7 +18018,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInLocal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/local"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("capturedLocalLateinit.kt") @@ -18075,7 +18076,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInTopLevel() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/topLevel"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/topLevel"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("topLevelLateinit.kt") @@ -18105,7 +18106,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInPublishedApi() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/publishedApi"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/publishedApi"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("simple.kt") @@ -18128,7 +18129,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInRanges() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("forByteProgressionWithIntIncrement.kt") @@ -18220,7 +18221,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInContains() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/contains"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/contains"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("comparisonWithRangeBoundEliminated.kt") @@ -18432,7 +18433,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInGenerated() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/contains/generated"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/contains/generated"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("arrayIndices.kt") @@ -18516,7 +18517,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInEvaluationOrder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("forInDownTo.kt") @@ -18573,7 +18574,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInStepped() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo") @@ -18585,7 +18586,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInForInDownTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("forInDownToReversedStep.kt") @@ -18638,7 +18639,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInForInRangeLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInRangeLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInRangeLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("forInRangeLiteralReversedStep.kt") @@ -18691,7 +18692,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInForInUntil() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInUntil"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInUntil"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("forInUntilReversedStep.kt") @@ -18746,7 +18747,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("emptyDownto.kt") @@ -18909,7 +18910,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInForInDownTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInDownTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInDownTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("forIntInDownTo.kt") @@ -18947,7 +18948,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInForInIndices() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInIndices"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInIndices"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("forInArrayListIndices.kt") @@ -19065,7 +19066,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInForInProgressionWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInProgressionWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInProgressionWithIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("forInDownToWithIndex.kt") @@ -19153,7 +19154,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInForInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInReversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInReversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("forInReversedArrayIndices.kt") @@ -19256,7 +19257,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInForInUntil() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInUntil"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInUntil"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("forInUntilChar.kt") @@ -19344,7 +19345,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInForWithPossibleOverflow() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forWithPossibleOverflow"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forWithPossibleOverflow"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("forInDownToCharMinValue.kt") @@ -19422,7 +19423,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInJavaInterop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/javaInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("compiler/testData/codegen/box/ranges/javaInterop/withIndex") @@ -19434,7 +19435,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/javaInterop/withIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/javaInterop/withIndex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } } @@ -19448,7 +19449,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("emptyDownto.kt") @@ -19611,7 +19612,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInNullableLoopParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/nullableLoopParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/nullableLoopParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("progressionExpression.kt") @@ -19639,7 +19640,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInStepped() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("compiler/testData/codegen/box/ranges/stepped/expression") @@ -19651,7 +19652,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("compiler/testData/codegen/box/ranges/stepped/expression/downTo") @@ -19663,7 +19664,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInDownTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/downTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/downTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("emptyProgression.kt") @@ -19755,7 +19756,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/downTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/downTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -19808,7 +19809,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/downTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/downTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("reversedThenStep.kt") @@ -19852,7 +19853,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInRangeTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("emptyProgression.kt") @@ -19944,7 +19945,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -19997,7 +19998,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("reversedThenStep.kt") @@ -20041,7 +20042,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInUntil() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/until"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/until"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("emptyProgression.kt") @@ -20138,7 +20139,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/until/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/until/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -20191,7 +20192,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/until/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/until/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("reversedThenStep.kt") @@ -20236,7 +20237,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("compiler/testData/codegen/box/ranges/stepped/literal/downTo") @@ -20248,7 +20249,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInDownTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/downTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/downTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("emptyProgression.kt") @@ -20325,7 +20326,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/downTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/downTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -20378,7 +20379,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/downTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/downTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("reversedThenStep.kt") @@ -20422,7 +20423,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInRangeTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("emptyProgression.kt") @@ -20499,7 +20500,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -20552,7 +20553,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("reversedThenStep.kt") @@ -20596,7 +20597,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInUntil() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/until"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/until"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("emptyProgression.kt") @@ -20678,7 +20679,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/until/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/until/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -20731,7 +20732,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/until/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/until/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("reversedThenStep.kt") @@ -20776,7 +20777,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInUnsigned() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/expression") @@ -20788,7 +20789,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo") @@ -20800,7 +20801,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInDownTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("emptyProgression.kt") @@ -20892,7 +20893,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -20945,7 +20946,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("reversedThenStep.kt") @@ -20989,7 +20990,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInRangeTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("emptyProgression.kt") @@ -21081,7 +21082,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -21134,7 +21135,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("reversedThenStep.kt") @@ -21178,7 +21179,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInUntil() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("emptyProgression.kt") @@ -21275,7 +21276,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -21328,7 +21329,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("reversedThenStep.kt") @@ -21373,7 +21374,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo") @@ -21385,7 +21386,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInDownTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("emptyProgression.kt") @@ -21462,7 +21463,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -21515,7 +21516,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("reversedThenStep.kt") @@ -21559,7 +21560,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInRangeTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("emptyProgression.kt") @@ -21636,7 +21637,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -21689,7 +21690,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("reversedThenStep.kt") @@ -21733,7 +21734,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInUntil() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("emptyProgression.kt") @@ -21815,7 +21816,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/nestedStep"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("stepOneThenStepOne.kt") @@ -21868,7 +21869,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/reversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("reversedThenStep.kt") @@ -21915,7 +21916,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInUnsigned() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("inMixedUnsignedRange.kt") @@ -21952,7 +21953,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/expression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("emptyDownto.kt") @@ -22115,7 +22116,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/literal"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("emptyDownto.kt") @@ -22278,7 +22279,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInNullableLoopParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/nullableLoopParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/nullableLoopParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("progressionExpression.kt") @@ -22308,7 +22309,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInReflection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("compiler/testData/codegen/box/reflection/annotations") @@ -22320,7 +22321,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/annotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/annotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("annotationRetentionAnnotation.kt") @@ -22392,7 +22393,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInOnTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/annotations/onTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/annotations/onTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } } @@ -22406,7 +22407,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInBuiltins() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/builtins"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/builtins"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("enumNameOrdinal.kt") @@ -22429,7 +22430,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("bigArity.kt") @@ -22501,7 +22502,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInBound() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("companionObjectPropertyAccessors.kt") @@ -22554,7 +22555,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("constructorWithInlineClassParameters.kt") @@ -22618,7 +22619,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInCallBy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/callBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/callBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("boundExtensionFunction.kt") @@ -22741,7 +22742,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInClassLiterals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/classLiterals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/classLiterals"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("annotationClassLiteral.kt") @@ -22774,7 +22775,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/classes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/classes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("companionObject.kt") @@ -22812,7 +22813,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/constructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/constructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("annotationClass.kt") @@ -22850,7 +22851,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInCreateAnnotation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/createAnnotation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/createAnnotation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("annotationType.kt") @@ -22903,7 +22904,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInEnclosing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/enclosing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/enclosing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } @@ -22916,7 +22917,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/functions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("enumValuesValueOf.kt") @@ -22949,7 +22950,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInGenericSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/genericSignature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/genericSignature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } @@ -22962,7 +22963,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInIsInstance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/isInstance"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/isInstance"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } @@ -22975,7 +22976,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInKClassInAnnotation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/kClassInAnnotation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/kClassInAnnotation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("forceWrapping.kt") @@ -22998,7 +22999,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInLambdaClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/lambdaClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/lambdaClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } @@ -23011,7 +23012,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInMapping() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("compiler/testData/codegen/box/reflection/mapping/fakeOverrides") @@ -23023,7 +23024,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInFakeOverrides() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/fakeOverrides"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/fakeOverrides"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } @@ -23036,7 +23037,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } @@ -23049,7 +23050,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInJvmStatic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/jvmStatic"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/jvmStatic"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } @@ -23062,7 +23063,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/types"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/types"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } } @@ -23076,7 +23077,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInMethodsFromAny() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/methodsFromAny"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/methodsFromAny"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("callableReferencesEqualToCallablesFromAPI.kt") @@ -23184,7 +23185,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInModifiers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/modifiers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/modifiers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("callableModality.kt") @@ -23232,7 +23233,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInMultifileClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } @@ -23245,7 +23246,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInNoReflectAtRuntime() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/noReflectAtRuntime"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/noReflectAtRuntime"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("propertyGetSetName.kt") @@ -23272,7 +23273,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInMethodsFromAny() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/noReflectAtRuntime/methodsFromAny"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/noReflectAtRuntime/methodsFromAny"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("callableReferences.kt") @@ -23296,7 +23297,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/parameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/parameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("bigArity.kt") @@ -23354,7 +23355,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("allVsDeclared.kt") @@ -23431,7 +23432,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/accessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/accessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("extensionPropertyAccessors.kt") @@ -23464,7 +23465,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInGetDelegate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/getDelegate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/getDelegate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } @@ -23477,7 +23478,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInJvmField() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/jvmField"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/jvmField"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } @@ -23490,7 +23491,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInLocalDelegated() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/localDelegated"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/localDelegated"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } } @@ -23504,7 +23505,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInSupertypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/supertypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/supertypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("genericSubstitution.kt") @@ -23532,7 +23533,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInTypeOf() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("classes.kt") @@ -23569,7 +23570,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInJs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/js"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/js"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("classes.kt") @@ -23622,7 +23623,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInNoReflect() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/noReflect"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/noReflect"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("typeReferenceEqualsHashCode.kt") @@ -23639,7 +23640,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInNonReifiedTypeParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/noReflect/nonReifiedTypeParameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/noReflect/nonReifiedTypeParameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } } @@ -23653,7 +23654,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInNonReifiedTypeParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/nonReifiedTypeParameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/nonReifiedTypeParameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("defaultUpperBound.kt") @@ -23732,7 +23733,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInTypeParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeParameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeParameters"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("declarationSiteVariance.kt") @@ -23760,7 +23761,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/types"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/types"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("classifierIsClass.kt") @@ -23797,7 +23798,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInCreateType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/types/createType"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/types/createType"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("equality.kt") @@ -23835,7 +23836,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInSubtyping() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/types/subtyping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/types/subtyping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("simpleGenericTypes.kt") @@ -23865,7 +23866,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInRegressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/regressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/regressions"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("arrayLengthNPE.kt") @@ -24208,7 +24209,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInReified() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reified"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reified"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("checkcast.kt") @@ -24300,7 +24301,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInArraysReification() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reified/arraysReification"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reified/arraysReification"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("instanceOf.kt") @@ -24334,7 +24335,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInSafeCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/safeCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/safeCall"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("genericNull.kt") @@ -24412,7 +24413,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInSam() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("compiler/testData/codegen/box/sam/constructors") @@ -24424,7 +24425,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam/constructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam/constructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("comparator.kt") @@ -24452,7 +24453,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInEquality() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam/equality"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam/equality"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } } @@ -24466,7 +24467,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInSealed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sealed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sealed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("multipleFiles_enabled.kt") @@ -24504,7 +24505,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInSecondaryConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/secondaryConstructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/secondaryConstructors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("basicNoPrimaryManySinks.kt") @@ -24662,7 +24663,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInSignatureAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/signatureAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/signatureAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } @@ -24675,7 +24676,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInSmap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/smap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/smap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } @@ -24688,7 +24689,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInSmartCasts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/smartCasts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/smartCasts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("falseSmartCast.kt") @@ -24776,7 +24777,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInSpecialBuiltins() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/specialBuiltins"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/specialBuiltins"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("bridgeNotEmptyMap.kt") @@ -24909,7 +24910,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInStatics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/statics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/statics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("anonymousInitializerIObject.kt") @@ -24962,7 +24963,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInStoreStackBeforeInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/storeStackBeforeInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/storeStackBeforeInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("differentTypes.kt") @@ -25000,7 +25001,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInStrings() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/strings"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/strings"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("constInStringTemplate.kt") @@ -25118,7 +25119,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInSuper() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/super"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/super"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("basicmethodSuperClass.kt") @@ -25280,7 +25281,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInSuperConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/super/superConstructor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/super/superConstructor"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("kt13846.kt") @@ -25329,7 +25330,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInSynchronized() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/synchronized"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/synchronized"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } @@ -25372,7 +25373,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInSyntheticAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/syntheticAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/syntheticAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("inline.kt") @@ -25440,7 +25441,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInThrows() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/throws"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/throws"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } @@ -25453,7 +25454,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInToArray() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/toArray"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/toArray"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("kt3177-toTypedArray.kt") @@ -25481,7 +25482,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInTopLevelPrivate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/topLevelPrivate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/topLevelPrivate"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("privateInInlineNested.kt") @@ -25504,7 +25505,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInTrailingComma() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/trailingComma"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/trailingComma"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("noDisambiguation.kt") @@ -25527,7 +25528,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInTraits() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/traits"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/traits"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("diamondPropertyAccessors.kt") @@ -25700,7 +25701,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInTypeInfo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typeInfo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typeInfo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("ifOrWhenSpecialCall.kt") @@ -25743,7 +25744,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInTypeMapping() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typeMapping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typeMapping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("kt2831.kt") @@ -25791,7 +25792,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInTypealias() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typealias"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typealias"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("enumEntryQualifier.kt") @@ -25899,7 +25900,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInUnaryOp() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unaryOp"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unaryOp"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("call.kt") @@ -25942,7 +25943,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInUnit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unit"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("closureReturnsNullableUnit.kt") @@ -26010,7 +26011,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInUnsignedTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unsignedTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unsignedTypes"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("boxConstValOfUnsignedType.kt") @@ -26217,7 +26218,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInJvm8Intrinsics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unsignedTypes/jvm8Intrinsics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unsignedTypes/jvm8Intrinsics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } } @@ -26231,7 +26232,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInValueClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/valueClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/valueClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("jvmInline.kt") @@ -26249,7 +26250,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInVararg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/vararg"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/vararg"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("doNotCopyImmediatelyCreatedArrays.kt") @@ -26327,7 +26328,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInWhen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("callProperty.kt") @@ -26539,7 +26540,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInEnumOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/enumOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/enumOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("bigEnum.kt") @@ -26642,7 +26643,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInStringOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/stringOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/stringOptimization"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("duplicatingItems.kt") @@ -26700,7 +26701,7 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { } public void testAllFilesPresentInWhenSubjectVariable() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/whenSubjectVariable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/whenSubjectVariable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("captureSubjectVariable.kt") diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/semantics/JsCodegenInlineTestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/semantics/JsCodegenInlineTestGenerated.java index 0e519de0f46..a3a79974890 100644 --- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/semantics/JsCodegenInlineTestGenerated.java +++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/semantics/JsCodegenInlineTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.js.test.semantics; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInBoxInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("compiler/testData/codegen/boxInline/anonymousObject") @@ -38,7 +39,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInAnonymousObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("anonymousObjectInDefault.kt") @@ -315,7 +316,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInEnumWhen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/enumWhen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/enumWhen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("callSite.kt") @@ -348,7 +349,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInProperRecapturing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("inlineChain.kt") @@ -391,7 +392,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInProperRecapturingInClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("inlineChain.kt") @@ -464,7 +465,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInSam() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } @@ -477,7 +478,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInTwoCapturedReceivers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("kt8668.kt") @@ -516,7 +517,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInArgumentOrder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/argumentOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/argumentOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("boundFunctionReference.kt") @@ -599,7 +600,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInArrayConvention() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/arrayConvention"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/arrayConvention"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("simpleAccess.kt") @@ -642,7 +643,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInAssert() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/assert"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/assert"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } @@ -655,7 +656,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInBuilders() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/builders"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/builders"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } @@ -668,7 +669,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInBytecodePreprocessing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/bytecodePreprocessing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/bytecodePreprocessing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } @@ -686,7 +687,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("classLevel.kt") @@ -768,7 +769,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInBound() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("classProperty.kt") @@ -897,7 +898,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInCapture() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/capture"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/capture"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("captureInlinable.kt") @@ -940,7 +941,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInComplex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/complex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/complex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("closureChain.kt") @@ -978,7 +979,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInComplexStack() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/complexStack"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/complexStack"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("asCheck.kt") @@ -1036,7 +1037,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInContracts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/contracts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/contracts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("cfgDependendValInitialization.kt") @@ -1134,7 +1135,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInDefaultValues() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("defaultInExtension.kt") @@ -1236,7 +1237,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInLambdaInlining() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("checkLambdaClassIsPresent.kt") @@ -1398,7 +1399,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInCallableReferences() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("boundFunctionReference.kt") @@ -1532,7 +1533,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInMaskElimination() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/maskElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/maskElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("kt18792.kt") @@ -1571,7 +1572,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInDelegatedProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/delegatedProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/delegatedProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("kt16864.kt") @@ -1609,7 +1610,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInEnclosingInfo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/enclosingInfo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/enclosingInfo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } @@ -1622,7 +1623,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("kt10569.kt") @@ -1700,7 +1701,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInFunctionExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/functionExpression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/functionExpression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("extension.kt") @@ -1718,7 +1719,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("inlineClassWithInlineValReturningInlineClass.kt") @@ -1760,7 +1761,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInUnboxGenericParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/funInterface") @@ -1772,7 +1773,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInFunInterface() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("any.kt") @@ -1815,7 +1816,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/lambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/lambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("any.kt") @@ -1858,7 +1859,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInObjectLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/objectLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/objectLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("any.kt") @@ -1903,7 +1904,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInInnerClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/innerClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/innerClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("captureThisAndOuter.kt") @@ -1921,7 +1922,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInJvmPackageName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/jvmPackageName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/jvmPackageName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } @@ -1934,7 +1935,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInLambdaClassClash() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/lambdaClassClash"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/lambdaClassClash"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("lambdaClassClash.kt") @@ -1957,7 +1958,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInLambdaTransformation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/lambdaTransformation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/lambdaTransformation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("lambdaCloning.kt") @@ -1995,7 +1996,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInLocalFunInLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/localFunInLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/localFunInLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("defaultParam.kt") @@ -2028,7 +2029,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInMultiModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("tryCatchWithRecursiveInline.kt") @@ -2046,7 +2047,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInMultifileClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } @@ -2059,7 +2060,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInMultiplatform() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("compiler/testData/codegen/boxInline/multiplatform/defaultArguments") @@ -2071,7 +2072,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInDefaultArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiplatform/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiplatform/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("receiversAndParametersInLambda.kt") @@ -2090,7 +2091,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInNoInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/noInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/noInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("extensionReceiver.kt") @@ -2138,7 +2139,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInNonLocalReturns() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("explicitLocalReturn.kt") @@ -2220,7 +2221,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInDeparenthesize() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/deparenthesize"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/deparenthesize"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("bracket.kt") @@ -2243,7 +2244,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInTryFinally() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("kt16417.kt") @@ -2320,7 +2321,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInCallSite() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("callSite.kt") @@ -2363,7 +2364,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInChained() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("finallyInFinally.kt") @@ -2416,7 +2417,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInDeclSite() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("complex.kt") @@ -2489,7 +2490,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInExceptionTable() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("break.kt") @@ -2602,7 +2603,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInVariables() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/variables"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/variables"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("kt7792.kt") @@ -2622,7 +2623,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInOptimizations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("kt20844.kt") @@ -2655,7 +2656,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInPrivate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("effectivePrivate.kt") @@ -2708,7 +2709,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("augAssignmentAndInc.kt") @@ -2786,7 +2787,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInReified() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("arrayConstructor.kt") @@ -2858,7 +2859,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInCheckCast() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/checkCast"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/checkCast"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("chain.kt") @@ -2916,7 +2917,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInDefaultLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/defaultLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/defaultLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } @@ -2929,7 +2930,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInIsCheck() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/isCheck"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/isCheck"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("chain.kt") @@ -2958,7 +2959,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/signature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/signature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } } @@ -2971,7 +2972,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInSimple() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/simple"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/simple"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("captureAndArgumentIncompatibleTypes.kt") @@ -3099,7 +3100,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInSmap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("assertion.kt") @@ -3196,7 +3197,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInAnonymous() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/anonymous"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/anonymous"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("kt19175.kt") @@ -3259,7 +3260,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInDefaultLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/defaultLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/defaultLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("defaultLambdaInAnonymous.kt") @@ -3317,7 +3318,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInInlineOnly() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/inlineOnly"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/inlineOnly"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("noSmap.kt") @@ -3350,7 +3351,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInNewsmap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/newsmap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/newsmap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("differentMapping.kt") @@ -3383,7 +3384,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInResolve() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/resolve"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/resolve"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("inlineComponent.kt") @@ -3407,7 +3408,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInSpecial() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/special"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/special"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("identityCheck.kt") @@ -3465,7 +3466,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInStackOnReturn() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/stackOnReturn"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/stackOnReturn"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("elvis.kt") @@ -3558,7 +3559,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInSuspend() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("capturedVariables.kt") @@ -3685,7 +3686,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("isAsReified.kt") @@ -3723,7 +3724,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInDefaultParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/defaultParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/defaultParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("defaultValueCrossinline.kt") @@ -3756,7 +3757,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInInlineClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/inlineClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/inlineClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("returnUnboxedDirect.kt") @@ -3779,7 +3780,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInInlineUsedAsNoinline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/inlineUsedAsNoinline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/inlineUsedAsNoinline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("inlineOnly.kt") @@ -3802,7 +3803,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInReceiver() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/receiver"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/receiver"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("inlineOrdinaryOfCrossinlineSuspend.kt") @@ -3855,7 +3856,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInStateMachine() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/stateMachine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/stateMachine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("crossingCoroutineBoundaries.kt") @@ -3979,7 +3980,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInSyntheticAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/syntheticAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/syntheticAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("constField.kt") @@ -4031,7 +4032,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInWithinInlineLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("directFieldAccess.kt") @@ -4090,7 +4091,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInTrait() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/trait"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/trait"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("trait.kt") @@ -4108,7 +4109,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInTryCatchFinally() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/tryCatchFinally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/tryCatchFinally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("kt5863.kt") @@ -4141,7 +4142,7 @@ public class JsCodegenInlineTestGenerated extends AbstractJsCodegenInlineTest { } public void testAllFilesPresentInVarargs() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/varargs"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/varargs"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("kt17653.kt") diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/semantics/JsLegacyPrimitiveArraysBoxTestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/semantics/JsLegacyPrimitiveArraysBoxTestGenerated.java index 9ff6ec4ea64..07ef06ac735 100644 --- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/semantics/JsLegacyPrimitiveArraysBoxTestGenerated.java +++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/semantics/JsLegacyPrimitiveArraysBoxTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.js.test.semantics; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class JsLegacyPrimitiveArraysBoxTestGenerated extends AbstractJsLegacyPri } public void testAllFilesPresentInArrays() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("arrayConstructorWithNonInlineLambda.kt") @@ -348,7 +349,7 @@ public class JsLegacyPrimitiveArraysBoxTestGenerated extends AbstractJsLegacyPri } public void testAllFilesPresentInArraysOfInlineClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/arraysOfInlineClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/arraysOfInlineClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("arrayOfInlineClassOfArrayOfInlineClass.kt") @@ -366,7 +367,7 @@ public class JsLegacyPrimitiveArraysBoxTestGenerated extends AbstractJsLegacyPri } public void testAllFilesPresentInForInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/forInReversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/forInReversed"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("reversedArrayOriginalUpdatedInLoopBody.kt") @@ -399,7 +400,7 @@ public class JsLegacyPrimitiveArraysBoxTestGenerated extends AbstractJsLegacyPri } public void testAllFilesPresentInMultiDecl() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("kt15560.kt") @@ -451,7 +452,7 @@ public class JsLegacyPrimitiveArraysBoxTestGenerated extends AbstractJsLegacyPri } public void testAllFilesPresentInInt() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl/int"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -484,7 +485,7 @@ public class JsLegacyPrimitiveArraysBoxTestGenerated extends AbstractJsLegacyPri } public void testAllFilesPresentInLong() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl/long"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/semantics/LegacyJsTypeScriptExportTestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/semantics/LegacyJsTypeScriptExportTestGenerated.java index 368ed7b8bd4..b9e05b3078d 100644 --- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/semantics/LegacyJsTypeScriptExportTestGenerated.java +++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/semantics/LegacyJsTypeScriptExportTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.js.test.semantics; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class LegacyJsTypeScriptExportTestGenerated extends AbstractLegacyJsTypeS } public void testAllFilesPresentInTypescript_export() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("js/js.translator/testData/typescript-export/constructors") @@ -38,7 +39,7 @@ public class LegacyJsTypeScriptExportTestGenerated extends AbstractLegacyJsTypeS } public void testAllFilesPresentInConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export/constructors"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export/constructors"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } } @@ -51,7 +52,7 @@ public class LegacyJsTypeScriptExportTestGenerated extends AbstractLegacyJsTypeS } public void testAllFilesPresentInDeclarations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export/declarations"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export/declarations"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("declarations.kt") @@ -69,7 +70,7 @@ public class LegacyJsTypeScriptExportTestGenerated extends AbstractLegacyJsTypeS } public void testAllFilesPresentInInheritance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export/inheritance"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export/inheritance"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("inheritance.kt") @@ -87,7 +88,7 @@ public class LegacyJsTypeScriptExportTestGenerated extends AbstractLegacyJsTypeS } public void testAllFilesPresentInModuleSystems() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export/moduleSystems"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export/moduleSystems"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("commonjs.kt") @@ -115,7 +116,7 @@ public class LegacyJsTypeScriptExportTestGenerated extends AbstractLegacyJsTypeS } public void testAllFilesPresentInNamespaces() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export/namespaces"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export/namespaces"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("namespaces.kt") @@ -133,7 +134,7 @@ public class LegacyJsTypeScriptExportTestGenerated extends AbstractLegacyJsTypeS } public void testAllFilesPresentInPrimitives() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export/primitives"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export/primitives"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("primitives.kt") @@ -151,7 +152,7 @@ public class LegacyJsTypeScriptExportTestGenerated extends AbstractLegacyJsTypeS } public void testAllFilesPresentInSelectiveExport() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export/selectiveExport"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export/selectiveExport"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("selectiveExport.kt") @@ -169,7 +170,7 @@ public class LegacyJsTypeScriptExportTestGenerated extends AbstractLegacyJsTypeS } public void testAllFilesPresentInVisibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export/visibility"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/typescript-export/visibility"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("visibility.kt") diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/semantics/OutputPrefixPostfixTestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/semantics/OutputPrefixPostfixTestGenerated.java index 6b4bb148b2b..f5539abaa20 100644 --- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/semantics/OutputPrefixPostfixTestGenerated.java +++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/semantics/OutputPrefixPostfixTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.js.test.semantics; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class OutputPrefixPostfixTestGenerated extends AbstractOutputPrefixPostfi } public void testAllFilesPresentInOutputPrefixPostfix() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/outputPrefixPostfix"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/outputPrefixPostfix"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("simple.kt") diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/semantics/SourceMapGenerationSmokeTestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/semantics/SourceMapGenerationSmokeTestGenerated.java index c849e44ca12..5e7766fb699 100644 --- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/semantics/SourceMapGenerationSmokeTestGenerated.java +++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/semantics/SourceMapGenerationSmokeTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.js.test.semantics; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class SourceMapGenerationSmokeTestGenerated extends AbstractSourceMapGene } public void testAllFilesPresentInSourcemap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/sourcemap"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/sourcemap"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.JS, true); } @TestMetadata("binaryOperation.kt") diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/wasm/semantics/IrCodegenBoxWasmTestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/wasm/semantics/IrCodegenBoxWasmTestGenerated.java index 86c26a57ad7..4461339f686 100644 --- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/wasm/semantics/IrCodegenBoxWasmTestGenerated.java +++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/wasm/semantics/IrCodegenBoxWasmTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.js.test.wasm.semantics; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInBox() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true, "toArray", "classLiteral", "reflection", "contracts", "platformTypes", "ranges/stepped/unsigned", "coroutines", "parametersMetadata", "finally", "deadCodeElimination", "controlStructures/tryCatchInExpressions", "delegatedProperty", "oldLanguageVersions"); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true, "toArray", "classLiteral", "reflection", "contracts", "platformTypes", "ranges/stepped/unsigned", "coroutines", "parametersMetadata", "finally", "deadCodeElimination", "controlStructures/tryCatchInExpressions", "delegatedProperty", "oldLanguageVersions"); } @TestMetadata("compiler/testData/codegen/box/annotations") @@ -38,7 +39,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("nestedAnnotation.kt") @@ -65,7 +66,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInAnnotatedLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations/annotatedLambda"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations/annotatedLambda"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } @@ -78,7 +79,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInTypeAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations/typeAnnotations"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations/typeAnnotations"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("checkingNotincorporatedInputTypes.kt") @@ -97,7 +98,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInArgumentOrder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/argumentOrder"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/argumentOrder"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("argumentOrderInObjectSuperCall.kt") @@ -175,7 +176,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInArrays() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("arrayConstructorWithNonInlineLambda.kt") @@ -422,7 +423,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInArraysOfInlineClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/arraysOfInlineClass"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/arraysOfInlineClass"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("arrayOfInlineClassOfArrayOfInlineClass.kt") @@ -440,7 +441,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInForInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/forInReversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/forInReversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("reversedArrayOriginalUpdatedInLoopBody.kt") @@ -463,7 +464,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInMultiDecl() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("kt15560.kt") @@ -515,7 +516,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInInt() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl/int"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl/int"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -548,7 +549,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInLong() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl/long"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl/long"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -583,7 +584,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInAssert() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/assert"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/assert"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("compiler/testData/codegen/box/assert/jvm") @@ -595,7 +596,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInJvm() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/assert/jvm"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/assert/jvm"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } @@ -609,7 +610,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInBinaryOp() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/binaryOp"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/binaryOp"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("bitwiseOp.kt") @@ -727,7 +728,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInBoxingOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/boxingOptimization"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/boxingOptimization"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("boxedIntegersCmp.kt") @@ -860,7 +861,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInBridges() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/bridges"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/bridges"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("complexMultiInheritance.kt") @@ -1112,7 +1113,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInSubstitutionInSuperClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/bridges/substitutionInSuperClass"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/bridges/substitutionInSuperClass"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("boundedTypeArguments.kt") @@ -1171,7 +1172,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInBuilderInference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builderInference"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("kt41164.kt") @@ -1199,7 +1200,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInBuiltinStubMethods() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("customReadOnlyIterator.kt") @@ -1216,7 +1217,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInExtendJavaCollections() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/extendJavaCollections"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/extendJavaCollections"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } @@ -1229,7 +1230,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInMapGetOrDefault() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/mapGetOrDefault"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/mapGetOrDefault"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } @@ -1242,7 +1243,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInMapRemove() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/mapRemove"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/mapRemove"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } @@ -1256,7 +1257,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInCallableReference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("kt37604.kt") @@ -1278,7 +1279,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInAdaptedReferences() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/adaptedReferences"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/adaptedReferences"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("defaultWithGenericExpectedType.kt") @@ -1335,7 +1336,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInSuspendConversion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } @@ -1349,7 +1350,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInBound() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/bound"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/bound"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("captureVarInInitBlock.kt") @@ -1376,7 +1377,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInEquals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/bound/equals"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/bound/equals"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } @@ -1390,7 +1391,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInEquality() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/equality"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/equality"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("extensionReceiverVsDefault.kt") @@ -1423,7 +1424,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/function"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/function"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("booleanNotIntrinsic.kt") @@ -1630,7 +1631,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInLocal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/function/local"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/function/local"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("captureOuter.kt") @@ -1734,7 +1735,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/property"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/property"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } @@ -1747,7 +1748,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInSerializability() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/serializability"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/serializability"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } @@ -1761,7 +1762,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInCasts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("asSafeFail.kt") @@ -1828,7 +1829,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/functions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/functions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } @@ -1841,7 +1842,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInJavaInterop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/javaInterop"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/javaInterop"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } @@ -1854,7 +1855,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInLiteralExpressionAsGenericArgument() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/literalExpressionAsGenericArgument"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/literalExpressionAsGenericArgument"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("binaryExpressionCast.kt") @@ -1897,7 +1898,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInMutableCollections() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/mutableCollections"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/mutableCollections"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } @@ -1911,7 +1912,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInCheckcastOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/checkcastOptimization"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/checkcastOptimization"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("kt19128.kt") @@ -1934,7 +1935,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classes"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classes"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("boxPrimitiveTypeInClinitOfClassObject.kt") @@ -2381,7 +2382,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInInner() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classes/inner"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classes/inner"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("extensionWithOuter.kt") @@ -2430,7 +2431,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInClosures() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("anonymousObjectAsLastExpressionInLambda.kt") @@ -2647,7 +2648,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInCaptureInSuperConstructorCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/captureInSuperConstructorCall"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/captureInSuperConstructorCall"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("constructorParameterAndLocalCapturedInLambdaInLocalClass.kt") @@ -2805,7 +2806,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInCaptureOuterProperty() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/captureOuterProperty"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/captureOuterProperty"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("captureFunctionInProperty.kt") @@ -2858,7 +2859,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInCapturedVarsOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/capturedVarsOptimization"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/capturedVarsOptimization"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("capturedInCrossinline.kt") @@ -2911,7 +2912,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInClosureInsideClosure() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/closureInsideClosure"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/closureInsideClosure"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("localFunInsideLocalFun.kt") @@ -2950,7 +2951,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInCollectionLiterals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/collectionLiterals"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/collectionLiterals"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } @@ -2968,7 +2969,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInCollections() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/collections"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/collections"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("internalRemove.kt") @@ -2991,7 +2992,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInCompanion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/companion"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/companion"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("inlineFunctionCompanionPropertyAccess.kt") @@ -3009,7 +3010,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/compatibility"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/compatibility"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("privateCompanionObject.kt") @@ -3027,7 +3028,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInConstants() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/constants"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/constants"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("comparisonFalse.kt") @@ -3060,7 +3061,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInConstructorCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/constructorCall"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/constructorCall"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } @@ -3073,7 +3074,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInControlStructures() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true, "tryCatchInExpressions"); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true, "tryCatchInExpressions"); } @TestMetadata("bottles.kt") @@ -3340,7 +3341,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInBreakContinueInExpressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("breakInDoWhile.kt") @@ -3423,7 +3424,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInForInArray() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInArray"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInArray"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("forInArraySpecializedToUntil.kt") @@ -3476,7 +3477,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInForInArrayWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } @@ -3489,7 +3490,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInForInCharSequenceWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInCharSequenceWithIndex"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInCharSequenceWithIndex"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("forInEmptyStringWithIndex.kt") @@ -3507,7 +3508,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInForInIterableWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInIterableWithIndex"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInIterableWithIndex"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } @@ -3520,7 +3521,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInForInSequenceWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInSequenceWithIndex"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInSequenceWithIndex"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } @@ -3533,7 +3534,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInReturnsNothing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/returnsNothing"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/returnsNothing"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("ifElse.kt") @@ -3562,7 +3563,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInDataClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("arrayParams.kt") @@ -3629,7 +3630,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInCopy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/copy"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/copy"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("constructorWithDefaultParam.kt") @@ -3682,7 +3683,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInEquals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/equals"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/equals"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("alreadyDeclared.kt") @@ -3725,7 +3726,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInHashCode() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/hashCode"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/hashCode"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("alreadyDeclared.kt") @@ -3793,7 +3794,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInToString() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/toString"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/toString"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("alreadyDeclared.kt") @@ -3827,7 +3828,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInDefaultArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("callDefaultFromInitializer.kt") @@ -3894,7 +3895,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/constructor"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/constructor"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("annotation.kt") @@ -3982,7 +3983,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInConvention() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/convention"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/convention"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("incWithDefaultInGetter.kt") @@ -4030,7 +4031,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/function"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/function"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("complexInheritance.kt") @@ -4173,7 +4174,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInPrivate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/private"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/private"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("memberExtensionFunction.kt") @@ -4206,7 +4207,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/signature"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/signature"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("kt2789.kt") @@ -4235,7 +4236,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInDelegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegation"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegation"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("delegationWithPrivateConstructor.kt") @@ -4273,7 +4274,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInDestructuringDeclInLambdaParam() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/destructuringDeclInLambdaParam"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/destructuringDeclInLambdaParam"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("extensionComponents.kt") @@ -4316,7 +4317,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInDiagnostics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("compiler/testData/codegen/box/diagnostics/functions") @@ -4328,7 +4329,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("compiler/testData/codegen/box/diagnostics/functions/inference") @@ -4340,7 +4341,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInInference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/inference"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/inference"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("kt6176.kt") @@ -4358,7 +4359,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInInvoke() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/invoke"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/invoke"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects") @@ -4370,7 +4371,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInOnObjects() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("invokeOnClassObject1.kt") @@ -4434,7 +4435,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInTailRecursion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/tailRecursion"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/tailRecursion"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("defaultArgs.kt") @@ -4518,7 +4519,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInVararg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/vararg"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/vararg"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("kt4172.kt") @@ -4537,7 +4538,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInElvis() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/elvis"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/elvis"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("genericNull.kt") @@ -4585,7 +4586,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/enum"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/enum"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("asReturnExpression.kt") @@ -4837,7 +4838,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInDefaultCtor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/enum/defaultCtor"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/enum/defaultCtor"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("constructorWithDefaultArguments.kt") @@ -4881,7 +4882,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInEvaluate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/evaluate"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/evaluate"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("kt9443.kt") @@ -4899,7 +4900,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInExclExcl() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/exclExcl"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/exclExcl"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("primitive.kt") @@ -4917,7 +4918,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInExtensionFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/extensionFunctions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/extensionFunctions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("executionOrder.kt") @@ -5020,7 +5021,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInExtensionProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/extensionProperties"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/extensionProperties"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("genericValForPrimitiveType.kt") @@ -5098,7 +5099,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInExternal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/external"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/external"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } @@ -5111,7 +5112,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInFakeOverride() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fakeOverride"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fakeOverride"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("diamondFunction.kt") @@ -5154,7 +5155,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInFieldRename() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fieldRename"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fieldRename"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("constructorAndClassObject.kt") @@ -5177,7 +5178,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInFullJdk() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("compiler/testData/codegen/box/fullJdk/native") @@ -5189,7 +5190,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInNative() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk/native"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk/native"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } @@ -5202,7 +5203,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInRegressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk/regressions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk/regressions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } @@ -5216,7 +5217,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInFunInterface() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/funInterface"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/funInterface"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("basicFunInterface.kt") @@ -5273,7 +5274,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInEquality() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/funInterface/equality"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/funInterface/equality"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("simpleLambdas.kt") @@ -5292,7 +5293,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("defaultargs.kt") @@ -5484,7 +5485,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInBigArity() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/bigArity"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/bigArity"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } @@ -5497,7 +5498,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInFunctionExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/functionExpression"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/functionExpression"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("functionExpression.kt") @@ -5540,7 +5541,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInInvoke() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/invoke"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/invoke"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("castFunctionToExtension.kt") @@ -5608,7 +5609,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInLocalFunctions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/localFunctions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/localFunctions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("boundTypeParameterInSupertype.kt") @@ -5762,7 +5763,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInHashPMap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/hashPMap"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/hashPMap"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } @@ -5775,7 +5776,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInIeee754() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ieee754"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ieee754"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("anyToReal.kt") @@ -5963,7 +5964,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInIncrement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/increment"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/increment"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("argumentWithSideEffects.kt") @@ -6101,7 +6102,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInInference() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inference"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inference"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("approximateNonTopLevelCapturedTypes.kt") @@ -6179,7 +6180,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInInlineClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("annotatedMemberExtensionProperty.kt") @@ -6796,7 +6797,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInBoxReturnValueInLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("boxAny.kt") @@ -6859,7 +6860,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInBoxReturnValueOnOverride() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("covariantOverrideChainErasedToAny.kt") @@ -6982,7 +6983,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInCallableReferences() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/callableReferences"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/callableReferences"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("constructorWithInlineClassParameters.kt") @@ -7075,7 +7076,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInContextsAndAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("captureInlineClassInstanceInLambda.kt") @@ -7138,7 +7139,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInDefaultParameterValues() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/defaultParameterValues"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/defaultParameterValues"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("defaultConstructorParameterValuesOfInlineClassType.kt") @@ -7206,7 +7207,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInFunctionNameMangling() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/functionNameMangling"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/functionNameMangling"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("anonymousObjectInFunctionWithMangledName.kt") @@ -7284,7 +7285,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInHiddenConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/hiddenConstructor"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/hiddenConstructor"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("constructorReferencedFromOtherFile1.kt") @@ -7357,7 +7358,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInInterfaceDelegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/interfaceDelegation"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/interfaceDelegation"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("interfaceImplementationByDelegation.kt") @@ -7405,7 +7406,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInInterfaceMethodCalls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("complexGenericMethodWithInlineClassOverride.kt") @@ -7473,7 +7474,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInJavaInterop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/javaInterop"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/javaInterop"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } @@ -7486,7 +7487,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInJvm8DefaultInterfaceMethods() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/jvm8DefaultInterfaceMethods"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/jvm8DefaultInterfaceMethods"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } @@ -7499,7 +7500,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInPropertyDelegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/propertyDelegation"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/propertyDelegation"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } @@ -7512,7 +7513,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInUnboxGenericParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface") @@ -7524,7 +7525,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInFunInterface() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("any.kt") @@ -7572,7 +7573,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInLambda() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("any.kt") @@ -7620,7 +7621,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInObjectLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("any.kt") @@ -7670,7 +7671,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInInnerNested() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/innerNested"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/innerNested"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("createNestedClass.kt") @@ -7807,7 +7808,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInSuperConstructorCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/innerNested/superConstructorCall"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/innerNested/superConstructorCall"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("deepInnerHierarchy.kt") @@ -7921,7 +7922,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInInstructions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/instructions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/instructions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("compiler/testData/codegen/box/instructions/swap") @@ -7933,7 +7934,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInSwap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/instructions/swap"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/instructions/swap"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("swapRefToSharedVarInt.kt") @@ -7957,7 +7958,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInIntrinsics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/intrinsics"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/intrinsics"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("charToInt.kt") @@ -8045,7 +8046,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInIr() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("anonymousObjectInGenericFun.kt") @@ -8122,7 +8123,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInClosureConversion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/closureConversion"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/closureConversion"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("closureConversion1.kt") @@ -8175,7 +8176,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInPrimitiveNumberComparisons() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/primitiveNumberComparisons"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/primitiveNumberComparisons"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("comparableToDouble.kt") @@ -8208,7 +8209,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInSerializationRegressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/serializationRegressions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/serializationRegressions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("innerClassInEnumEntryClass.kt") @@ -8237,7 +8238,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInJavaInterop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("compiler/testData/codegen/box/javaInterop/generics") @@ -8249,7 +8250,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInGenerics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/generics"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/generics"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } @@ -8262,7 +8263,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInNotNullAssertions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("compiler/testData/codegen/box/javaInterop/notNullAssertions/enhancedNullability") @@ -8274,7 +8275,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInEnhancedNullability() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions/enhancedNullability"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions/enhancedNullability"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } @@ -8287,7 +8288,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInNullCheckOnLambdaReturnValue() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions/nullCheckOnLambdaReturnValue"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions/nullCheckOnLambdaReturnValue"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } @@ -8301,7 +8302,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInObjectMethods() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/objectMethods"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/objectMethods"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } @@ -8315,7 +8316,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInJdk() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jdk"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jdk"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } @@ -8328,7 +8329,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInJvm8() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("compiler/testData/codegen/box/jvm8/defaults") @@ -8340,7 +8341,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInDefaults() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/allCompatibility") @@ -8352,7 +8353,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInAllCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/allCompatibility"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/allCompatibility"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/delegationBy") @@ -8364,7 +8365,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInDelegationBy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/delegationBy"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/delegationBy"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } @@ -8378,7 +8379,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInCompatibility() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/compatibility"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/compatibility"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } @@ -8391,7 +8392,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInDelegationBy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/delegationBy"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/delegationBy"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } @@ -8404,7 +8405,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInNoDefaultImpls() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/delegationBy") @@ -8416,7 +8417,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInDelegationBy() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/delegationBy"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/delegationBy"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } @@ -8429,7 +8430,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInSpecialization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/specialization"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/specialization"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } @@ -8443,7 +8444,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInNoDelegation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDelegation"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDelegation"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } @@ -8456,7 +8457,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInReflection() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/reflection"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/reflection"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } @@ -8470,7 +8471,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInInterfaceFlag() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/interfaceFlag"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/interfaceFlag"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } @@ -8483,7 +8484,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInJavaDefaults() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/javaDefaults"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/javaDefaults"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } @@ -8497,7 +8498,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInJvmField() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmField"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmField"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } @@ -8510,7 +8511,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInJvmName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmName"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmName"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("compiler/testData/codegen/box/jvmName/fileFacades") @@ -8522,7 +8523,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInFileFacades() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmName/fileFacades"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmName/fileFacades"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } @@ -8536,7 +8537,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInJvmOverloads() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmOverloads"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmOverloads"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } @@ -8549,7 +8550,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInJvmPackageName() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmPackageName"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmPackageName"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } @@ -8562,7 +8563,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInJvmStatic() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmStatic"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmStatic"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } @@ -8575,7 +8576,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInLabels() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/labels"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/labels"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("controlLabelClashesWithFuncitonName.kt") @@ -8628,7 +8629,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInLazyCodegen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/lazyCodegen"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/lazyCodegen"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("ifElse.kt") @@ -8670,7 +8671,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInOptimizations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/lazyCodegen/optimizations"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/lazyCodegen/optimizations"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("negateConstantCompare.kt") @@ -8729,7 +8730,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInLocalClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/localClasses"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/localClasses"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("anonymousObjectInExtension.kt") @@ -8897,7 +8898,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInMangling() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/mangling"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/mangling"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("internal.kt") @@ -8935,7 +8936,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInMixedNamedPosition() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/mixedNamedPosition"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/mixedNamedPosition"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("defaults.kt") @@ -8958,7 +8959,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInMultiDecl() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("ComplexInitializer.kt") @@ -9030,7 +9031,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInForIterator() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forIterator"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forIterator"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("compiler/testData/codegen/box/multiDecl/forIterator/longIterator") @@ -9042,7 +9043,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInLongIterator() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forIterator/longIterator"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forIterator/longIterator"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } @@ -9056,7 +9057,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInForRange() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("MultiDeclFor.kt") @@ -9103,7 +9104,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInExplicitRangeTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("MultiDeclFor.kt") @@ -9140,7 +9141,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInInt() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/int"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/int"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -9173,7 +9174,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInLong() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/long"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/long"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -9207,7 +9208,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInExplicitRangeToWithDot() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("MultiDeclFor.kt") @@ -9244,7 +9245,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInInt() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/int"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/int"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -9277,7 +9278,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInLong() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/long"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/long"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -9311,7 +9312,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInInt() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/int"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/int"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -9344,7 +9345,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInLong() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/long"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/long"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("MultiDeclForComponentExtensions.kt") @@ -9379,7 +9380,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInMultifileClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multifileClasses"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multifileClasses"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("compiler/testData/codegen/box/multifileClasses/optimized") @@ -9391,7 +9392,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInOptimized() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multifileClasses/optimized"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multifileClasses/optimized"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } @@ -9405,7 +9406,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInMultiplatform() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("optionalExpectation.kt") @@ -9427,7 +9428,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInDefaultArguments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/defaultArguments"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/defaultArguments"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("bothInExpectAndActual.kt") @@ -9530,7 +9531,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInMultiModule() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/multiModule"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/multiModule"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("expectActualLink.kt") @@ -9559,7 +9560,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInNonLocalReturns() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nonLocalReturns"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nonLocalReturns"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("kt9644let.kt") @@ -9587,7 +9588,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInNothingValue() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nothingValue"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nothingValue"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("inNestedCall.kt") @@ -9605,7 +9606,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInNullCheckOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nullCheckOptimization"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nullCheckOptimization"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("isNullable.kt") @@ -9643,7 +9644,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInObjectIntrinsics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objectIntrinsics"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objectIntrinsics"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } @@ -9656,7 +9657,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInObjects() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("anonymousObjectPropertyInitialization.kt") @@ -9978,7 +9979,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInCompanionObjectAccess() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("kt27117.kt") @@ -10075,7 +10076,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInMultipleCompanionsWithAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("anonymousObjectInPropertyInitializer.kt") @@ -10143,7 +10144,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInPrimitiveCompanion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess/primitiveCompanion"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess/primitiveCompanion"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("byteCompanionObject.kt") @@ -10193,7 +10194,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInOperatorConventions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/operatorConventions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/operatorConventions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("annotatedAssignment.kt") @@ -10295,7 +10296,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInCompareTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/operatorConventions/compareTo"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/operatorConventions/compareTo"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("boolean.kt") @@ -10364,7 +10365,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInOptimizations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/optimizations"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/optimizations"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } @@ -10377,7 +10378,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInPackage() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/package"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/package"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("boxPrimitiveTypeInClinit.kt") @@ -10430,7 +10431,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInPolymorphicSignature() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/polymorphicSignature"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/polymorphicSignature"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } @@ -10443,7 +10444,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInPrimitiveTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("comparisonWithNullCallsFun.kt") @@ -10690,7 +10691,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInEqualityWithObject() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes/equalityWithObject"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes/equalityWithObject"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("boxedEqPrimitiveEvaluationOrder.kt") @@ -10747,7 +10748,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInGenerated() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("boxedEqPrimitiveBoolean.kt") @@ -10852,7 +10853,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInPrivate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/private"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/private"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("arrayConvention.kt") @@ -10875,7 +10876,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInPrivateConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/privateConstructors"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/privateConstructors"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("base.kt") @@ -10973,7 +10974,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("classArtificialFieldInsideNested.kt") @@ -11250,7 +11251,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInConst() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/const"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/const"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("anotherFile.kt") @@ -11278,7 +11279,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInLateinit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("nameClash.kt") @@ -11320,7 +11321,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInIsInitializedAndDeinitialize() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/isInitializedAndDeinitialize"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/isInitializedAndDeinitialize"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("companionObjectField.kt") @@ -11373,7 +11374,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInLocal() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/local"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/local"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("capturedLocalLateinit.kt") @@ -11401,7 +11402,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInTopLevel() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/topLevel"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/topLevel"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("topLevelLateinit.kt") @@ -11421,7 +11422,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInPublishedApi() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/publishedApi"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/publishedApi"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("simple.kt") @@ -11444,7 +11445,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInRanges() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true, "stepped/unsigned"); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true, "stepped/unsigned"); } @TestMetadata("forByteProgressionWithIntIncrement.kt") @@ -11491,7 +11492,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInContains() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/contains"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/contains"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("comparisonWithRangeBoundEliminated.kt") @@ -11588,7 +11589,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInGenerated() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/contains/generated"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/contains/generated"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("arrayIndices.kt") @@ -11657,7 +11658,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInEvaluationOrder() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("compiler/testData/codegen/box/ranges/evaluationOrder/stepped") @@ -11669,7 +11670,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInStepped() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo") @@ -11681,7 +11682,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInForInDownTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } @@ -11694,7 +11695,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInForInRangeLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInRangeLiteral"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInRangeLiteral"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } @@ -11707,7 +11708,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInForInUntil() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInUntil"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInUntil"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } @@ -11722,7 +11723,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/expression"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/expression"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } @@ -11735,7 +11736,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInForInDownTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInDownTo"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInDownTo"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("forIntInDownTo.kt") @@ -11773,7 +11774,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInForInIndices() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInIndices"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInIndices"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("forInCharSequenceIndices.kt") @@ -11881,7 +11882,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInForInProgressionWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInProgressionWithIndex"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInProgressionWithIndex"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("kt42909.kt") @@ -11899,7 +11900,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInForInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInReversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInReversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("forInReversedArrayIndices.kt") @@ -12002,7 +12003,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInForInUntil() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInUntil"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInUntil"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("forInUntilChar.kt") @@ -12090,7 +12091,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInForWithPossibleOverflow() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forWithPossibleOverflow"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forWithPossibleOverflow"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("forInDownToCharMinValue.kt") @@ -12168,7 +12169,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInJavaInterop() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/javaInterop"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/javaInterop"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("compiler/testData/codegen/box/ranges/javaInterop/withIndex") @@ -12180,7 +12181,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInWithIndex() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/javaInterop/withIndex"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/javaInterop/withIndex"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } @@ -12194,7 +12195,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/literal"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/literal"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } @@ -12207,7 +12208,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInNullableLoopParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/nullableLoopParameter"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/nullableLoopParameter"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("progressionExpression.kt") @@ -12235,7 +12236,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInStepped() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true, "unsigned"); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true, "unsigned"); } @TestMetadata("compiler/testData/codegen/box/ranges/stepped/expression") @@ -12247,7 +12248,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("compiler/testData/codegen/box/ranges/stepped/expression/downTo") @@ -12259,7 +12260,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInDownTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/downTo"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/downTo"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("compiler/testData/codegen/box/ranges/stepped/expression/downTo/nestedStep") @@ -12271,7 +12272,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/downTo/nestedStep"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/downTo/nestedStep"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } @@ -12284,7 +12285,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/downTo/reversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/downTo/reversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } @@ -12298,7 +12299,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInRangeTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/nestedStep") @@ -12310,7 +12311,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/nestedStep"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/nestedStep"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } @@ -12323,7 +12324,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/reversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/reversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } @@ -12337,7 +12338,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInUntil() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/until"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/until"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("compiler/testData/codegen/box/ranges/stepped/expression/until/nestedStep") @@ -12349,7 +12350,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/until/nestedStep"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/until/nestedStep"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } @@ -12362,7 +12363,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/until/reversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/until/reversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } @@ -12377,7 +12378,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("compiler/testData/codegen/box/ranges/stepped/literal/downTo") @@ -12389,7 +12390,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInDownTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/downTo"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/downTo"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("compiler/testData/codegen/box/ranges/stepped/literal/downTo/nestedStep") @@ -12401,7 +12402,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/downTo/nestedStep"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/downTo/nestedStep"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } @@ -12414,7 +12415,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/downTo/reversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/downTo/reversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } @@ -12428,7 +12429,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInRangeTo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/nestedStep") @@ -12440,7 +12441,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/nestedStep"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/nestedStep"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } @@ -12453,7 +12454,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/reversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/reversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } @@ -12467,7 +12468,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInUntil() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/until"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/until"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("compiler/testData/codegen/box/ranges/stepped/literal/until/nestedStep") @@ -12479,7 +12480,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInNestedStep() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/until/nestedStep"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/until/nestedStep"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } @@ -12492,7 +12493,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInReversed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/until/reversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/until/reversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } @@ -12508,7 +12509,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInUnsigned() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("inMixedUnsignedRange.kt") @@ -12540,7 +12541,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/expression"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/expression"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } @@ -12553,7 +12554,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/literal"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/literal"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } @@ -12566,7 +12567,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInNullableLoopParameter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/nullableLoopParameter"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/nullableLoopParameter"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("progressionExpression.kt") @@ -12596,7 +12597,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInRegressions() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/regressions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/regressions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("arrayLengthNPE.kt") @@ -12849,7 +12850,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInReified() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reified"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reified"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("instanceof.kt") @@ -12896,7 +12897,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInArraysReification() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reified/arraysReification"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reified/arraysReification"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("jaggedArray.kt") @@ -12920,7 +12921,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInSafeCall() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/safeCall"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/safeCall"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("genericNull.kt") @@ -12993,7 +12994,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInSam() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("compiler/testData/codegen/box/sam/constructors") @@ -13005,7 +13006,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam/constructors"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam/constructors"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } @@ -13018,7 +13019,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInEquality() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam/equality"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam/equality"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } @@ -13032,7 +13033,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInSealed() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sealed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sealed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("multipleFiles_enabled.kt") @@ -13070,7 +13071,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInSecondaryConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/secondaryConstructors"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/secondaryConstructors"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("basicNoPrimaryManySinks.kt") @@ -13198,7 +13199,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInSignatureAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/signatureAnnotations"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/signatureAnnotations"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } @@ -13211,7 +13212,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInSmap() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/smap"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/smap"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } @@ -13224,7 +13225,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInSmartCasts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/smartCasts"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/smartCasts"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("falseSmartCast.kt") @@ -13297,7 +13298,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInSpecialBuiltins() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/specialBuiltins"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/specialBuiltins"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("bridgeNotEmptyMap.kt") @@ -13380,7 +13381,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInStatics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/statics"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/statics"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("anonymousInitializerIObject.kt") @@ -13433,7 +13434,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInStoreStackBeforeInline() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/storeStackBeforeInline"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/storeStackBeforeInline"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("differentTypes.kt") @@ -13471,7 +13472,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInStrings() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/strings"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/strings"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("ea35743.kt") @@ -13559,7 +13560,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInSuper() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/super"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/super"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("basicmethodSuperTrait.kt") @@ -13716,7 +13717,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInSuperConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/super/superConstructor"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/super/superConstructor"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("kt17464_arrayOf.kt") @@ -13750,7 +13751,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInSynchronized() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/synchronized"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/synchronized"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } @@ -13793,7 +13794,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInSyntheticAccessors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/syntheticAccessors"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/syntheticAccessors"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("inline.kt") @@ -13861,7 +13862,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInThrows() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/throws"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/throws"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } @@ -13874,7 +13875,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInTopLevelPrivate() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/topLevelPrivate"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/topLevelPrivate"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("privateInInlineNested.kt") @@ -13897,7 +13898,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInTrailingComma() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/trailingComma"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/trailingComma"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("noDisambiguation.kt") @@ -13920,7 +13921,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInTraits() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/traits"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/traits"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("diamondPropertyAccessors.kt") @@ -14083,7 +14084,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInTypeInfo() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typeInfo"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typeInfo"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("ifOrWhenSpecialCall.kt") @@ -14126,7 +14127,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInTypeMapping() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typeMapping"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typeMapping"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("kt2831.kt") @@ -14164,7 +14165,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInTypealias() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typealias"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typealias"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("enumEntryQualifier.kt") @@ -14267,7 +14268,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInUnaryOp() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unaryOp"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unaryOp"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("call.kt") @@ -14310,7 +14311,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInUnit() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unit"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unit"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("ifElse.kt") @@ -14338,7 +14339,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInUnsignedTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unsignedTypes"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unsignedTypes"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("boxConstValOfUnsignedType.kt") @@ -14470,7 +14471,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInJvm8Intrinsics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unsignedTypes/jvm8Intrinsics"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unsignedTypes/jvm8Intrinsics"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } @@ -14484,7 +14485,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInValueClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/valueClasses"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/valueClasses"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("jvmInline.kt") @@ -14502,7 +14503,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInVararg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/vararg"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/vararg"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("evaluationOrder.kt") @@ -14545,7 +14546,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInWhen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("callProperty.kt") @@ -14687,7 +14688,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInEnumOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/enumOptimization"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/enumOptimization"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("bigEnum.kt") @@ -14790,7 +14791,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInStringOptimization() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/stringOptimization"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/stringOptimization"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("duplicatingItems.kt") @@ -14843,7 +14844,7 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } public void testAllFilesPresentInWhenSubjectVariable() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/whenSubjectVariable"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/whenSubjectVariable"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @TestMetadata("captureSubjectVariable.kt") diff --git a/libraries/tools/kotlinp/test/org/jetbrains/kotlin/kotlinp/test/KotlinpTestGenerated.java b/libraries/tools/kotlinp/test/org/jetbrains/kotlin/kotlinp/test/KotlinpTestGenerated.java index 772224c1e5e..eb6bb062a0f 100644 --- a/libraries/tools/kotlinp/test/org/jetbrains/kotlin/kotlinp/test/KotlinpTestGenerated.java +++ b/libraries/tools/kotlinp/test/org/jetbrains/kotlin/kotlinp/test/KotlinpTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.kotlinp.test; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class KotlinpTestGenerated extends AbstractKotlinpTest { } public void testAllFilesPresentInTestData() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("libraries/tools/kotlinp/testData"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("libraries/tools/kotlinp/testData"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Annotations.kt") diff --git a/libraries/tools/new-project-wizard/new-project-wizard-cli/tests/org/jetbrains/kotlin/tools/projectWizard/cli/ProjectTemplateBuildFileGenerationTestGenerated.java b/libraries/tools/new-project-wizard/new-project-wizard-cli/tests/org/jetbrains/kotlin/tools/projectWizard/cli/ProjectTemplateBuildFileGenerationTestGenerated.java index 47fb7212c04..38c1f30e2ca 100644 --- a/libraries/tools/new-project-wizard/new-project-wizard-cli/tests/org/jetbrains/kotlin/tools/projectWizard/cli/ProjectTemplateBuildFileGenerationTestGenerated.java +++ b/libraries/tools/new-project-wizard/new-project-wizard-cli/tests/org/jetbrains/kotlin/tools/projectWizard/cli/ProjectTemplateBuildFileGenerationTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.tools.projectWizard.cli; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class ProjectTemplateBuildFileGenerationTestGenerated extends AbstractPro } public void testAllFilesPresentInProjectTemplatesBuildFileGeneration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("libraries/tools/new-project-wizard/new-project-wizard-cli/testData/projectTemplatesBuildFileGeneration"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("libraries/tools/new-project-wizard/new-project-wizard-cli/testData/projectTemplatesBuildFileGeneration"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("backendApplication") diff --git a/libraries/tools/new-project-wizard/new-project-wizard-cli/tests/org/jetbrains/kotlin/tools/projectWizard/cli/YamlBuildFileGenerationTestGenerated.java b/libraries/tools/new-project-wizard/new-project-wizard-cli/tests/org/jetbrains/kotlin/tools/projectWizard/cli/YamlBuildFileGenerationTestGenerated.java index 7a41ec491f7..ba04d6acf83 100644 --- a/libraries/tools/new-project-wizard/new-project-wizard-cli/tests/org/jetbrains/kotlin/tools/projectWizard/cli/YamlBuildFileGenerationTestGenerated.java +++ b/libraries/tools/new-project-wizard/new-project-wizard-cli/tests/org/jetbrains/kotlin/tools/projectWizard/cli/YamlBuildFileGenerationTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.tools.projectWizard.cli; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class YamlBuildFileGenerationTestGenerated extends AbstractYamlBuildFileG } public void testAllFilesPresentInBuildFileGeneration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("libraries/tools/new-project-wizard/new-project-wizard-cli/testData/buildFileGeneration"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("libraries/tools/new-project-wizard/new-project-wizard-cli/testData/buildFileGeneration"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("android") diff --git a/nj2k/tests/org/jetbrains/kotlin/nj2k/NewJavaToKotlinConverterMultiFileTestGenerated.java b/nj2k/tests/org/jetbrains/kotlin/nj2k/NewJavaToKotlinConverterMultiFileTestGenerated.java index 89e8a4ea183..e83973cb4b3 100644 --- a/nj2k/tests/org/jetbrains/kotlin/nj2k/NewJavaToKotlinConverterMultiFileTestGenerated.java +++ b/nj2k/tests/org/jetbrains/kotlin/nj2k/NewJavaToKotlinConverterMultiFileTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.nj2k; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class NewJavaToKotlinConverterMultiFileTestGenerated extends AbstractNewJ } public void testAllFilesPresentInMultiFile() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/multiFile"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/multiFile"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("AnnotationWithArrayParameter") diff --git a/nj2k/tests/org/jetbrains/kotlin/nj2k/NewJavaToKotlinConverterSingleFileTestGenerated.java b/nj2k/tests/org/jetbrains/kotlin/nj2k/NewJavaToKotlinConverterSingleFileTestGenerated.java index 34b0e6c1189..8ecf6b6427a 100644 --- a/nj2k/tests/org/jetbrains/kotlin/nj2k/NewJavaToKotlinConverterSingleFileTestGenerated.java +++ b/nj2k/tests/org/jetbrains/kotlin/nj2k/NewJavaToKotlinConverterSingleFileTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.nj2k; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInNewJ2k() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("nj2k/testData/newJ2k/annotations") @@ -37,7 +38,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/annotations"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/annotations"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("annotationArrayArgument.java") @@ -155,7 +156,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInAnonymousBlock() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/anonymousBlock"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/anonymousBlock"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("oneAnonBlock.java") @@ -178,7 +179,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInAnonymousClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/anonymousClass"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/anonymousClass"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("kt-13146.java") @@ -201,7 +202,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInArrayAccessExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/arrayAccessExpression"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/arrayAccessExpression"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("expressionIndex.java") @@ -229,7 +230,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInArrayInitializerExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/arrayInitializerExpression"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/arrayInitializerExpression"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("doubleArray.java") @@ -302,7 +303,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInArrayType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/arrayType"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/arrayType"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("arrayInitializationStatement.java") @@ -370,7 +371,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInAssertStatement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/assertStatement"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/assertStatement"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("assertNotNull.java") @@ -408,7 +409,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInAssignmentExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/assignmentExpression"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/assignmentExpression"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("and.java") @@ -546,7 +547,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInBinaryExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/binaryExpression"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/binaryExpression"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("and.java") @@ -659,7 +660,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInBlocks() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/blocks"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/blocks"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("Blocks.java") @@ -677,7 +678,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInBoxedType() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/boxedType"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/boxedType"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("boolean.java") @@ -745,7 +746,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInBreakStatement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/breakStatement"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/breakStatement"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("breakWithLabel.java") @@ -768,7 +769,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInCallChainExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/callChainExpression"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/callChainExpression"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("libraryFieldCall.java") @@ -821,7 +822,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/class"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/class"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("anonymousClass.java") @@ -1004,7 +1005,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInClassExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/classExpression"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/classExpression"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("complexExample.java") @@ -1037,7 +1038,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInComments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/comments"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/comments"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("beginningOfCommentInsideMultilineOne.java") @@ -1105,7 +1106,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInConditionalExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/conditionalExpression"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/conditionalExpression"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("multiline.java") @@ -1138,7 +1139,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInConstructors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/constructors"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/constructors"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("artificialPrimary.java") @@ -1346,7 +1347,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInContinueStatement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/continueStatement"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/continueStatement"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("continueWithLabel.java") @@ -1369,7 +1370,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInDeclarationStatement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/declarationStatement"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/declarationStatement"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("multiplyFinalIntDeclaration.java") @@ -1427,7 +1428,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInDetectProperties() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/detectProperties"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/detectProperties"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("AnonymousClass.java") @@ -1690,7 +1691,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInDoWhileStatement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/doWhileStatement"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/doWhileStatement"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("whileWithAssignmentAsExpression.java") @@ -1733,7 +1734,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInDocComments() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/docComments"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/docComments"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("deprecatedDocTag.java") @@ -1816,7 +1817,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInEnum() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/enum"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/enum"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("colorEnum.java") @@ -1924,7 +1925,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInEquals() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/equals"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/equals"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("EqOperator.java") @@ -1967,7 +1968,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInField() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/field"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/field"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("classChildExtendsBase.java") @@ -2045,7 +2046,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInFor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/for"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/for"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("arrayIndicesReversed.java") @@ -2293,7 +2294,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInForeachStatement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/foreachStatement"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/foreachStatement"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("enhancedForWithBlock.java") @@ -2336,7 +2337,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInFormatting() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/formatting"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/formatting"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("chainedCall.java") @@ -2389,7 +2390,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInFunction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/function"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/function"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("classGenericParam.java") @@ -2617,7 +2618,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInFunctionalInterfaces() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/functionalInterfaces"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/functionalInterfaces"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("InterfacesHierarchy.java") @@ -2655,7 +2656,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInIdentifier() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/identifier"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/identifier"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("finalFieldReference.java") @@ -2683,7 +2684,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInIfStatement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/ifStatement"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/ifStatement"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("assignmentAsExpressionInIf.java") @@ -2736,7 +2737,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInImplicitCasts() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/implicitCasts"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/implicitCasts"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("arithmeticInFunctionCall.java") @@ -2754,7 +2755,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInImportStatement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/importStatement"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/importStatement"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("importWithKeywords.java") @@ -2792,7 +2793,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInInheritance() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/inheritance"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/inheritance"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("classOneExtendsBaseGeneric.java") @@ -2830,7 +2831,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInIsOperator() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/isOperator"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/isOperator"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("complicatedExpression.java") @@ -2858,7 +2859,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInIssues() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/issues"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/issues"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("arrayLength.java") @@ -3311,7 +3312,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInJavaStreamsApi() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/javaStreamsApi"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/javaStreamsApi"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("collectStream.java") @@ -3354,7 +3355,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInKotlinApiAccess() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/kotlinApiAccess"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/kotlinApiAccess"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("ClassObjectMembers.java") @@ -3462,7 +3463,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInLabelStatement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/labelStatement"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/labelStatement"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("complicatedExampleFromJavaTutorial.java") @@ -3480,7 +3481,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInList() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/list"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/list"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("ForEach.java") @@ -3503,7 +3504,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInLiteralExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/literalExpression"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/literalExpression"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("binary.java") @@ -3611,7 +3612,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInLocalVariable() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/localVariable"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/localVariable"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("autoBangBang.java") @@ -3669,7 +3670,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInMethodCallExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/methodCallExpression"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/methodCallExpression"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("callWithKeywords.java") @@ -3762,7 +3763,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInMisc() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/misc"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/misc"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("packageWithClass.java") @@ -3805,7 +3806,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInMutableCollections() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/mutableCollections"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/mutableCollections"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("FunctionParameters.java") @@ -3868,7 +3869,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInNewClassExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/newClassExpression"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/newClassExpression"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("classWithParam.java") @@ -3956,7 +3957,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInNullability() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/nullability"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/nullability"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("autoNotNull.java") @@ -4169,7 +4170,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInObjectLiteral() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/objectLiteral"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/objectLiteral"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("kt-36149.java") @@ -4207,7 +4208,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInOverloads() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/overloads"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/overloads"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("Annotations.java") @@ -4250,7 +4251,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInPackageStatement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/packageStatement"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/packageStatement"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("keywordInPackageName.java") @@ -4268,7 +4269,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInParenthesizedExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/parenthesizedExpression"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/parenthesizedExpression"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("parenthesized.java") @@ -4296,7 +4297,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInPolyadicExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/polyadicExpression"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/polyadicExpression"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("divide.java") @@ -4339,7 +4340,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInPostProcessing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/postProcessing"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/postProcessing"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("AnonymousObject.java") @@ -4427,7 +4428,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInPostfixOperator() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/postfixOperator"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/postfixOperator"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("decrement.java") @@ -4450,7 +4451,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInPrefixOperator() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/prefixOperator"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/prefixOperator"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("decrement.java") @@ -4493,7 +4494,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInProjections() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/projections"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/projections"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("projections.java") @@ -4511,7 +4512,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInProtected() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/protected"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/protected"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("constructorProperty.java") @@ -4559,7 +4560,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInRawGenerics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/rawGenerics"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/rawGenerics"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("kt-540.java") @@ -4592,7 +4593,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInReturnStatement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/returnStatement"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/returnStatement"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("currentMethodBug.java") @@ -4630,7 +4631,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInSettings() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/settings"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/settings"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("openByDefault.java") @@ -4663,7 +4664,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInStaticMembers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/staticMembers"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/staticMembers"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("PrivateStaticMembers.java") @@ -4716,7 +4717,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInStrings() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/strings"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/strings"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("escapedBackslash.java") @@ -4744,7 +4745,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInSuperExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/superExpression"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/superExpression"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("classAdotSuperFoo.java") @@ -4777,7 +4778,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInSwitch() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/switch"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/switch"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("caseWithBlock.java") @@ -4870,7 +4871,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInSynchronizedStatement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/synchronizedStatement"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/synchronizedStatement"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("singleLineExample.java") @@ -4888,7 +4889,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInThisExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/thisExpression"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/thisExpression"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("classAdotThisFoo.java") @@ -4911,7 +4912,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInThrowStatement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/throwStatement"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/throwStatement"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("simpleThrowStatement.java") @@ -4929,7 +4930,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInToArray() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/toArray"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/toArray"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("toArray.java") @@ -4947,7 +4948,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInToKotlinClasses() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/toKotlinClasses"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/toKotlinClasses"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("iterableAndIterator.java") @@ -4990,7 +4991,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInTrait() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/trait"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/trait"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("emptyInterface.java") @@ -5053,7 +5054,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInTryStatement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/tryStatement"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/tryStatement"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("commonCaseForTryStatement.java") @@ -5091,7 +5092,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInTryWithResource() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/tryWithResource"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/tryWithResource"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("Java9.java") @@ -5164,7 +5165,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInTypeCastExpression() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/typeCastExpression"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/typeCastExpression"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("beforeDot.java") @@ -5232,7 +5233,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInTypeParameters() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/typeParameters"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/typeParameters"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("classDoubleParametrizationWithTwoBoundsWithExtending.java") @@ -5320,7 +5321,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInTypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/types"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/types"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("capturedTypeInStreamsLambda.java") @@ -5358,7 +5359,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInVarArg() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/varArg"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/varArg"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("ellipsisTypeSeveralParams.java") @@ -5386,7 +5387,7 @@ public class NewJavaToKotlinConverterSingleFileTestGenerated extends AbstractNew } public void testAllFilesPresentInWhileStatement() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/whileStatement"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/newJ2k/whileStatement"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("whileWithAssignmentAsExpression.java") diff --git a/nj2k/tests/org/jetbrains/kotlin/nj2k/NewJavaToKotlinCopyPasteConversionTestGenerated.java b/nj2k/tests/org/jetbrains/kotlin/nj2k/NewJavaToKotlinCopyPasteConversionTestGenerated.java index 6737268b67a..83b959606b8 100644 --- a/nj2k/tests/org/jetbrains/kotlin/nj2k/NewJavaToKotlinCopyPasteConversionTestGenerated.java +++ b/nj2k/tests/org/jetbrains/kotlin/nj2k/NewJavaToKotlinCopyPasteConversionTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.nj2k; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -55,7 +56,7 @@ public class NewJavaToKotlinCopyPasteConversionTestGenerated extends AbstractNew } public void testAllFilesPresentInCopyPaste() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/copyPaste"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/copyPaste"), Pattern.compile("^([^\\.]+)\\.java$"), null, true); } @TestMetadata("Arithmetic.java") diff --git a/nj2k/tests/org/jetbrains/kotlin/nj2k/TextNewJavaToKotlinCopyPasteConversionTestGenerated.java b/nj2k/tests/org/jetbrains/kotlin/nj2k/TextNewJavaToKotlinCopyPasteConversionTestGenerated.java index 208f92fbf8a..4369f008d53 100644 --- a/nj2k/tests/org/jetbrains/kotlin/nj2k/TextNewJavaToKotlinCopyPasteConversionTestGenerated.java +++ b/nj2k/tests/org/jetbrains/kotlin/nj2k/TextNewJavaToKotlinCopyPasteConversionTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.nj2k; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class TextNewJavaToKotlinCopyPasteConversionTestGenerated extends Abstrac } public void testAllFilesPresentInCopyPastePlainText() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/copyPastePlainText"), Pattern.compile("^([^\\.]+)\\.txt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/copyPastePlainText"), Pattern.compile("^([^\\.]+)\\.txt$"), null, true); } @TestMetadata("AsExpression.txt") diff --git a/nj2k/tests/org/jetbrains/kotlin/nj2k/inference/common/CommonConstraintCollectorTestGenerated.java b/nj2k/tests/org/jetbrains/kotlin/nj2k/inference/common/CommonConstraintCollectorTestGenerated.java index a6fc2972c79..7307ae99d13 100644 --- a/nj2k/tests/org/jetbrains/kotlin/nj2k/inference/common/CommonConstraintCollectorTestGenerated.java +++ b/nj2k/tests/org/jetbrains/kotlin/nj2k/inference/common/CommonConstraintCollectorTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.nj2k.inference.common; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class CommonConstraintCollectorTestGenerated extends AbstractCommonConstr } public void testAllFilesPresentInCommon() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/inference/common"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/inference/common"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("arrayAssignment.kt") diff --git a/nj2k/tests/org/jetbrains/kotlin/nj2k/inference/mutability/MutabilityInferenceTestGenerated.java b/nj2k/tests/org/jetbrains/kotlin/nj2k/inference/mutability/MutabilityInferenceTestGenerated.java index ae0ee1f1f1a..03b0b1cf360 100644 --- a/nj2k/tests/org/jetbrains/kotlin/nj2k/inference/mutability/MutabilityInferenceTestGenerated.java +++ b/nj2k/tests/org/jetbrains/kotlin/nj2k/inference/mutability/MutabilityInferenceTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.nj2k.inference.mutability; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class MutabilityInferenceTestGenerated extends AbstractMutabilityInferenc } public void testAllFilesPresentInMutability() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/inference/mutability"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/inference/mutability"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("arrayList.kt") diff --git a/nj2k/tests/org/jetbrains/kotlin/nj2k/inference/nullability/NullabilityInferenceTestGenerated.java b/nj2k/tests/org/jetbrains/kotlin/nj2k/inference/nullability/NullabilityInferenceTestGenerated.java index 2b48616feef..58b4f973c40 100644 --- a/nj2k/tests/org/jetbrains/kotlin/nj2k/inference/nullability/NullabilityInferenceTestGenerated.java +++ b/nj2k/tests/org/jetbrains/kotlin/nj2k/inference/nullability/NullabilityInferenceTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.nj2k.inference.nullability; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class NullabilityInferenceTestGenerated extends AbstractNullabilityInfere } public void testAllFilesPresentInNullability() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/inference/nullability"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("nj2k/testData/inference/nullability"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("arrayOfArraysOfNull.kt") diff --git a/plugins/allopen/allopen-cli/test/org/jetbrains/kotlin/allopen/BytecodeListingTestForAllOpenGenerated.java b/plugins/allopen/allopen-cli/test/org/jetbrains/kotlin/allopen/BytecodeListingTestForAllOpenGenerated.java index db508a29e2a..ba671abe42e 100644 --- a/plugins/allopen/allopen-cli/test/org/jetbrains/kotlin/allopen/BytecodeListingTestForAllOpenGenerated.java +++ b/plugins/allopen/allopen-cli/test/org/jetbrains/kotlin/allopen/BytecodeListingTestForAllOpenGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.allopen; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class BytecodeListingTestForAllOpenGenerated extends AbstractBytecodeList } public void testAllFilesPresentInBytecodeListing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/allopen/allopen-cli/testData/bytecodeListing"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/allopen/allopen-cli/testData/bytecodeListing"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("allOpenOnNotClasses.kt") diff --git a/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/parcel/ParcelBoxTestGenerated.java b/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/parcel/ParcelBoxTestGenerated.java index deec2350535..79140be5d1f 100644 --- a/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/parcel/ParcelBoxTestGenerated.java +++ b/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/parcel/ParcelBoxTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.android.parcel; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class ParcelBoxTestGenerated extends AbstractParcelBoxTest { } public void testAllFilesPresentInBox() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/android-extensions/android-extensions-compiler/testData/parcel/box"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/android-extensions/android-extensions-compiler/testData/parcel/box"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("allPrimitiveTypes.kt") diff --git a/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/parcel/ParcelBytecodeListingTestGenerated.java b/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/parcel/ParcelBytecodeListingTestGenerated.java index 98216faf66f..24de7ac5a61 100644 --- a/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/parcel/ParcelBytecodeListingTestGenerated.java +++ b/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/parcel/ParcelBytecodeListingTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.android.parcel; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class ParcelBytecodeListingTestGenerated extends AbstractParcelBytecodeLi } public void testAllFilesPresentInCodegen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/android-extensions/android-extensions-compiler/testData/parcel/codegen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/android-extensions/android-extensions-compiler/testData/parcel/codegen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("customDescribeContents.kt") diff --git a/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/parcel/ParcelIrBoxTestGenerated.java b/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/parcel/ParcelIrBoxTestGenerated.java index 80b1d9bc5cb..04c65a03978 100644 --- a/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/parcel/ParcelIrBoxTestGenerated.java +++ b/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/parcel/ParcelIrBoxTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.android.parcel; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class ParcelIrBoxTestGenerated extends AbstractParcelIrBoxTest { } public void testAllFilesPresentInBox() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/android-extensions/android-extensions-compiler/testData/parcel/box"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/android-extensions/android-extensions-compiler/testData/parcel/box"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("allPrimitiveTypes.kt") diff --git a/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/parcel/ParcelIrBoxTestWithSerializableLikeExtension.kt b/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/parcel/ParcelIrBoxTestWithSerializableLikeExtension.kt index f6d585e1afb..f7b015ddcdd 100644 --- a/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/parcel/ParcelIrBoxTestWithSerializableLikeExtension.kt +++ b/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/parcel/ParcelIrBoxTestWithSerializableLikeExtension.kt @@ -11,9 +11,6 @@ import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.extensions.SyntheticResolveExtension -import org.jetbrains.kotlin.test.JUnit3RunnerWithInners -import org.jetbrains.kotlin.test.TargetBackend -import org.junit.runner.RunWith class ParcelIrBoxTestWithSerializableLikeExtension : AbstractParcelIrBoxTest() { fun testSimple() = doTest("plugins/android-extensions/android-extensions-compiler/testData/parcel/box/simple.kt") diff --git a/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/parcel/ParcelIrBytecodeListingTestGenerated.java b/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/parcel/ParcelIrBytecodeListingTestGenerated.java index fba8199a761..07311bf4481 100644 --- a/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/parcel/ParcelIrBytecodeListingTestGenerated.java +++ b/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/parcel/ParcelIrBytecodeListingTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.android.parcel; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class ParcelIrBytecodeListingTestGenerated extends AbstractParcelIrByteco } public void testAllFilesPresentInCodegen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/android-extensions/android-extensions-compiler/testData/parcel/codegen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/android-extensions/android-extensions-compiler/testData/parcel/codegen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("customDescribeContents.kt") diff --git a/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/synthetic/test/AndroidBoxTestGenerated.java b/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/synthetic/test/AndroidBoxTestGenerated.java index 641337b6eba..ed6e06fb93f 100644 --- a/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/synthetic/test/AndroidBoxTestGenerated.java +++ b/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/synthetic/test/AndroidBoxTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.android.synthetic.test; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -27,7 +28,7 @@ public class AndroidBoxTestGenerated extends AbstractAndroidBoxTest { } public void testAllFilesPresentInAndroid() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/android-extensions/android-extensions-compiler/testData/codegen/android"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/android-extensions/android-extensions-compiler/testData/codegen/android"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("androidEntity") @@ -90,7 +91,7 @@ public class AndroidBoxTestGenerated extends AbstractAndroidBoxTest { } public void testAllFilesPresentInInvoke() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/android-extensions/android-extensions-compiler/testData/codegen/android"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/android-extensions/android-extensions-compiler/testData/codegen/android"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("androidEntity") diff --git a/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/synthetic/test/AndroidBytecodeShapeTestGenerated.java b/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/synthetic/test/AndroidBytecodeShapeTestGenerated.java index 7a71c6d5dad..b9f706b47dc 100644 --- a/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/synthetic/test/AndroidBytecodeShapeTestGenerated.java +++ b/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/synthetic/test/AndroidBytecodeShapeTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.android.synthetic.test; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -30,7 +31,7 @@ public class AndroidBytecodeShapeTestGenerated extends AbstractAndroidBytecodeSh } public void testAllFilesPresentInBytecodeShape() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/android-extensions/android-extensions-compiler/testData/codegen/bytecodeShape"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/android-extensions/android-extensions-compiler/testData/codegen/bytecodeShape"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("baseClass") diff --git a/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/synthetic/test/AndroidIrBoxTestGenerated.java b/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/synthetic/test/AndroidIrBoxTestGenerated.java index 49bbd2809f7..9b4f62a8f10 100644 --- a/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/synthetic/test/AndroidIrBoxTestGenerated.java +++ b/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/synthetic/test/AndroidIrBoxTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.android.synthetic.test; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -28,7 +29,7 @@ public class AndroidIrBoxTestGenerated extends AbstractAndroidIrBoxTest { } public void testAllFilesPresentInAndroid() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/android-extensions/android-extensions-compiler/testData/codegen/android"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/android-extensions/android-extensions-compiler/testData/codegen/android"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, false); } @TestMetadata("androidEntity") @@ -91,7 +92,7 @@ public class AndroidIrBoxTestGenerated extends AbstractAndroidIrBoxTest { } public void testAllFilesPresentInInvoke() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/android-extensions/android-extensions-compiler/testData/codegen/android"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/android-extensions/android-extensions-compiler/testData/codegen/android"), Pattern.compile("^([^\\.]+)$"), null, TargetBackend.JVM_IR, false); } @TestMetadata("androidEntity") diff --git a/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/synthetic/test/AndroidSyntheticPropertyDescriptorTestGenerated.java b/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/synthetic/test/AndroidSyntheticPropertyDescriptorTestGenerated.java index c6128179461..9150ec4b115 100644 --- a/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/synthetic/test/AndroidSyntheticPropertyDescriptorTestGenerated.java +++ b/plugins/android-extensions/android-extensions-compiler/test/org/jetbrains/kotlin/android/synthetic/test/AndroidSyntheticPropertyDescriptorTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.android.synthetic.test; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class AndroidSyntheticPropertyDescriptorTestGenerated extends AbstractAnd } public void testAllFilesPresentInDescriptors() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/android-extensions/android-extensions-compiler/testData/descriptors"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/android-extensions/android-extensions-compiler/testData/descriptors"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("escapedLayoutName") diff --git a/plugins/android-extensions/android-extensions-idea/tests/org/jetbrains/kotlin/android/AndroidCompletionTestGenerated.java b/plugins/android-extensions/android-extensions-idea/tests/org/jetbrains/kotlin/android/AndroidCompletionTestGenerated.java index 590d29cddaa..192973c6eb0 100644 --- a/plugins/android-extensions/android-extensions-idea/tests/org/jetbrains/kotlin/android/AndroidCompletionTestGenerated.java +++ b/plugins/android-extensions/android-extensions-idea/tests/org/jetbrains/kotlin/android/AndroidCompletionTestGenerated.java @@ -26,7 +26,7 @@ public class AndroidCompletionTestGenerated extends AbstractAndroidCompletionTes } public void testAllFilesPresentInCompletion() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("plugins/android-extensions/android-extensions-idea/testData/android/completion"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, false); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadata(this.getClass(), new File("plugins/android-extensions/android-extensions-idea/testData/android/completion"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, false); } @TestMetadata("fqNameInAttr") diff --git a/plugins/android-extensions/android-extensions-idea/tests/org/jetbrains/kotlin/android/AndroidExtractionTestGenerated.java b/plugins/android-extensions/android-extensions-idea/tests/org/jetbrains/kotlin/android/AndroidExtractionTestGenerated.java index 0dbb0fea25f..cf1728004d2 100644 --- a/plugins/android-extensions/android-extensions-idea/tests/org/jetbrains/kotlin/android/AndroidExtractionTestGenerated.java +++ b/plugins/android-extensions/android-extensions-idea/tests/org/jetbrains/kotlin/android/AndroidExtractionTestGenerated.java @@ -26,7 +26,7 @@ public class AndroidExtractionTestGenerated extends AbstractAndroidExtractionTes } public void testAllFilesPresentInExtraction() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("plugins/android-extensions/android-extensions-idea/testData/android/extraction"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, false); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadata(this.getClass(), new File("plugins/android-extensions/android-extensions-idea/testData/android/extraction"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, false); } @TestMetadata("toTopLevelFun") diff --git a/plugins/android-extensions/android-extensions-idea/tests/org/jetbrains/kotlin/android/AndroidFindUsagesTestGenerated.java b/plugins/android-extensions/android-extensions-idea/tests/org/jetbrains/kotlin/android/AndroidFindUsagesTestGenerated.java index f91927212fa..e4038d0e099 100644 --- a/plugins/android-extensions/android-extensions-idea/tests/org/jetbrains/kotlin/android/AndroidFindUsagesTestGenerated.java +++ b/plugins/android-extensions/android-extensions-idea/tests/org/jetbrains/kotlin/android/AndroidFindUsagesTestGenerated.java @@ -26,7 +26,7 @@ public class AndroidFindUsagesTestGenerated extends AbstractAndroidFindUsagesTes } public void testAllFilesPresentInFindUsages() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("plugins/android-extensions/android-extensions-idea/testData/android/findUsages"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, false); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadata(this.getClass(), new File("plugins/android-extensions/android-extensions-idea/testData/android/findUsages"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, false); } @TestMetadata("fqNameInAttr") diff --git a/plugins/android-extensions/android-extensions-idea/tests/org/jetbrains/kotlin/android/AndroidGotoTestGenerated.java b/plugins/android-extensions/android-extensions-idea/tests/org/jetbrains/kotlin/android/AndroidGotoTestGenerated.java index 386dd005fbc..f2ea9c137a0 100644 --- a/plugins/android-extensions/android-extensions-idea/tests/org/jetbrains/kotlin/android/AndroidGotoTestGenerated.java +++ b/plugins/android-extensions/android-extensions-idea/tests/org/jetbrains/kotlin/android/AndroidGotoTestGenerated.java @@ -26,7 +26,7 @@ public class AndroidGotoTestGenerated extends AbstractAndroidGotoTest { } public void testAllFilesPresentInGoto() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("plugins/android-extensions/android-extensions-idea/testData/android/goto"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, false); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadata(this.getClass(), new File("plugins/android-extensions/android-extensions-idea/testData/android/goto"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, false); } @TestMetadata("customNamespaceName") diff --git a/plugins/android-extensions/android-extensions-idea/tests/org/jetbrains/kotlin/android/AndroidLayoutRenameTestGenerated.java b/plugins/android-extensions/android-extensions-idea/tests/org/jetbrains/kotlin/android/AndroidLayoutRenameTestGenerated.java index 6137acc047b..41566876129 100644 --- a/plugins/android-extensions/android-extensions-idea/tests/org/jetbrains/kotlin/android/AndroidLayoutRenameTestGenerated.java +++ b/plugins/android-extensions/android-extensions-idea/tests/org/jetbrains/kotlin/android/AndroidLayoutRenameTestGenerated.java @@ -26,7 +26,7 @@ public class AndroidLayoutRenameTestGenerated extends AbstractAndroidLayoutRenam } public void testAllFilesPresentInRenameLayout() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("plugins/android-extensions/android-extensions-idea/testData/android/renameLayout"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, false); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadata(this.getClass(), new File("plugins/android-extensions/android-extensions-idea/testData/android/renameLayout"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, false); } @TestMetadata("simple") diff --git a/plugins/android-extensions/android-extensions-idea/tests/org/jetbrains/kotlin/android/AndroidRenameTestGenerated.java b/plugins/android-extensions/android-extensions-idea/tests/org/jetbrains/kotlin/android/AndroidRenameTestGenerated.java index feac45f9bbe..adf52c84175 100644 --- a/plugins/android-extensions/android-extensions-idea/tests/org/jetbrains/kotlin/android/AndroidRenameTestGenerated.java +++ b/plugins/android-extensions/android-extensions-idea/tests/org/jetbrains/kotlin/android/AndroidRenameTestGenerated.java @@ -26,7 +26,7 @@ public class AndroidRenameTestGenerated extends AbstractAndroidRenameTest { } public void testAllFilesPresentInRename() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("plugins/android-extensions/android-extensions-idea/testData/android/rename"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, false); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadata(this.getClass(), new File("plugins/android-extensions/android-extensions-idea/testData/android/rename"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, false); } @TestMetadata("commonElementId") diff --git a/plugins/android-extensions/android-extensions-idea/tests/org/jetbrains/kotlin/android/AndroidUsageHighlightingTestGenerated.java b/plugins/android-extensions/android-extensions-idea/tests/org/jetbrains/kotlin/android/AndroidUsageHighlightingTestGenerated.java index acde29b9752..12c26aef30e 100644 --- a/plugins/android-extensions/android-extensions-idea/tests/org/jetbrains/kotlin/android/AndroidUsageHighlightingTestGenerated.java +++ b/plugins/android-extensions/android-extensions-idea/tests/org/jetbrains/kotlin/android/AndroidUsageHighlightingTestGenerated.java @@ -26,7 +26,7 @@ public class AndroidUsageHighlightingTestGenerated extends AbstractAndroidUsageH } public void testAllFilesPresentInUsageHighlighting() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("plugins/android-extensions/android-extensions-idea/testData/android/usageHighlighting"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, false); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadata(this.getClass(), new File("plugins/android-extensions/android-extensions-idea/testData/android/usageHighlighting"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, false); } @TestMetadata("simple") diff --git a/plugins/android-extensions/android-extensions-idea/tests/org/jetbrains/kotlin/android/ParcelCheckerTestGenerated.java b/plugins/android-extensions/android-extensions-idea/tests/org/jetbrains/kotlin/android/ParcelCheckerTestGenerated.java index 136383d21a6..017d357ccab 100644 --- a/plugins/android-extensions/android-extensions-idea/tests/org/jetbrains/kotlin/android/ParcelCheckerTestGenerated.java +++ b/plugins/android-extensions/android-extensions-idea/tests/org/jetbrains/kotlin/android/ParcelCheckerTestGenerated.java @@ -26,7 +26,7 @@ public class ParcelCheckerTestGenerated extends AbstractParcelCheckerTest { } public void testAllFilesPresentInChecker() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("plugins/android-extensions/android-extensions-idea/testData/android/parcel/checker"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadata(this.getClass(), new File("plugins/android-extensions/android-extensions-idea/testData/android/parcel/checker"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); } @TestMetadata("constructors.kt") diff --git a/plugins/android-extensions/android-extensions-idea/tests/org/jetbrains/kotlin/android/ParcelQuickFixTestGenerated.java b/plugins/android-extensions/android-extensions-idea/tests/org/jetbrains/kotlin/android/ParcelQuickFixTestGenerated.java index be4c132cf4e..1a6c73ea84a 100644 --- a/plugins/android-extensions/android-extensions-idea/tests/org/jetbrains/kotlin/android/ParcelQuickFixTestGenerated.java +++ b/plugins/android-extensions/android-extensions-idea/tests/org/jetbrains/kotlin/android/ParcelQuickFixTestGenerated.java @@ -26,7 +26,7 @@ public class ParcelQuickFixTestGenerated extends AbstractParcelQuickFixTest { } public void testAllFilesPresentInQuickfix() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("plugins/android-extensions/android-extensions-idea/testData/android/parcel/quickfix"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), TargetBackend.ANY, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadata(this.getClass(), new File("plugins/android-extensions/android-extensions-idea/testData/android/parcel/quickfix"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), TargetBackend.ANY, true); } @TestMetadata("plugins/android-extensions/android-extensions-idea/testData/android/parcel/quickfix/addPrimaryConstructor") @@ -38,7 +38,7 @@ public class ParcelQuickFixTestGenerated extends AbstractParcelQuickFixTest { } public void testAllFilesPresentInAddPrimaryConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("plugins/android-extensions/android-extensions-idea/testData/android/parcel/quickfix/addPrimaryConstructor"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), TargetBackend.ANY, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadata(this.getClass(), new File("plugins/android-extensions/android-extensions-idea/testData/android/parcel/quickfix/addPrimaryConstructor"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), TargetBackend.ANY, true); } @TestMetadata("constructorWithDelegate.before.Main.kt") @@ -66,7 +66,7 @@ public class ParcelQuickFixTestGenerated extends AbstractParcelQuickFixTest { } public void testAllFilesPresentInCantBeInnerClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("plugins/android-extensions/android-extensions-idea/testData/android/parcel/quickfix/cantBeInnerClass"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), TargetBackend.ANY, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadata(this.getClass(), new File("plugins/android-extensions/android-extensions-idea/testData/android/parcel/quickfix/cantBeInnerClass"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), TargetBackend.ANY, true); } @TestMetadata("simple.before.Main.kt") @@ -84,7 +84,7 @@ public class ParcelQuickFixTestGenerated extends AbstractParcelQuickFixTest { } public void testAllFilesPresentInClassShouldBeAnnotated() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("plugins/android-extensions/android-extensions-idea/testData/android/parcel/quickfix/classShouldBeAnnotated"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), TargetBackend.ANY, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadata(this.getClass(), new File("plugins/android-extensions/android-extensions-idea/testData/android/parcel/quickfix/classShouldBeAnnotated"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), TargetBackend.ANY, true); } @TestMetadata("simple.before.Main.kt") @@ -102,7 +102,7 @@ public class ParcelQuickFixTestGenerated extends AbstractParcelQuickFixTest { } public void testAllFilesPresentInDeleteIncompatible() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("plugins/android-extensions/android-extensions-idea/testData/android/parcel/quickfix/deleteIncompatible"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), TargetBackend.ANY, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadata(this.getClass(), new File("plugins/android-extensions/android-extensions-idea/testData/android/parcel/quickfix/deleteIncompatible"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), TargetBackend.ANY, true); } @TestMetadata("creatorField.before.Main.kt") @@ -125,7 +125,7 @@ public class ParcelQuickFixTestGenerated extends AbstractParcelQuickFixTest { } public void testAllFilesPresentInMigrations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("plugins/android-extensions/android-extensions-idea/testData/android/parcel/quickfix/migrations"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), TargetBackend.ANY, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadata(this.getClass(), new File("plugins/android-extensions/android-extensions-idea/testData/android/parcel/quickfix/migrations"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), TargetBackend.ANY, true); } @TestMetadata("basic.before.Main.kt") @@ -178,7 +178,7 @@ public class ParcelQuickFixTestGenerated extends AbstractParcelQuickFixTest { } public void testAllFilesPresentInNoParcelableSupertype() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("plugins/android-extensions/android-extensions-idea/testData/android/parcel/quickfix/noParcelableSupertype"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), TargetBackend.ANY, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadata(this.getClass(), new File("plugins/android-extensions/android-extensions-idea/testData/android/parcel/quickfix/noParcelableSupertype"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), TargetBackend.ANY, true); } @TestMetadata("alreadyHasSupertype.before.Main.kt") @@ -201,7 +201,7 @@ public class ParcelQuickFixTestGenerated extends AbstractParcelQuickFixTest { } public void testAllFilesPresentInPropertyWontBeSerialized() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("plugins/android-extensions/android-extensions-idea/testData/android/parcel/quickfix/propertyWontBeSerialized"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), TargetBackend.ANY, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadata(this.getClass(), new File("plugins/android-extensions/android-extensions-idea/testData/android/parcel/quickfix/propertyWontBeSerialized"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), TargetBackend.ANY, true); } @TestMetadata("simple.before.Main.kt") @@ -219,7 +219,7 @@ public class ParcelQuickFixTestGenerated extends AbstractParcelQuickFixTest { } public void testAllFilesPresentInRemoveDuplicatingTypeParcelerAnnotation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("plugins/android-extensions/android-extensions-idea/testData/android/parcel/quickfix/removeDuplicatingTypeParcelerAnnotation"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), TargetBackend.ANY, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadata(this.getClass(), new File("plugins/android-extensions/android-extensions-idea/testData/android/parcel/quickfix/removeDuplicatingTypeParcelerAnnotation"), Pattern.compile("^(\\w+)\\.((before\\.Main\\.\\w+)|(test))$"), TargetBackend.ANY, true); } @TestMetadata("simple.before.Main.kt") diff --git a/plugins/fir/fir-plugin-prototype/tests/org/jetbrains/kotlin/fir/plugin/FirAllOpenDiagnosticTestGenerated.java b/plugins/fir/fir-plugin-prototype/tests/org/jetbrains/kotlin/fir/plugin/FirAllOpenDiagnosticTestGenerated.java index f84a2ee1708..c7d8aacd7e0 100644 --- a/plugins/fir/fir-plugin-prototype/tests/org/jetbrains/kotlin/fir/plugin/FirAllOpenDiagnosticTestGenerated.java +++ b/plugins/fir/fir-plugin-prototype/tests/org/jetbrains/kotlin/fir/plugin/FirAllOpenDiagnosticTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.fir.plugin; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class FirAllOpenDiagnosticTestGenerated extends AbstractFirAllOpenDiagnos } public void testAllFilesPresentInTestData() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/fir/fir-plugin-prototype/testData"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/fir/fir-plugin-prototype/testData"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("plugins/fir/fir-plugin-prototype/testData/checkers") @@ -37,7 +38,7 @@ public class FirAllOpenDiagnosticTestGenerated extends AbstractFirAllOpenDiagnos } public void testAllFilesPresentInCheckers() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/fir/fir-plugin-prototype/testData/checkers"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/fir/fir-plugin-prototype/testData/checkers"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("simple.kt") @@ -55,7 +56,7 @@ public class FirAllOpenDiagnosticTestGenerated extends AbstractFirAllOpenDiagnos } public void testAllFilesPresentInMemberGen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/fir/fir-plugin-prototype/testData/memberGen"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/fir/fir-plugin-prototype/testData/memberGen"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("functionForProperty.kt") @@ -88,7 +89,7 @@ public class FirAllOpenDiagnosticTestGenerated extends AbstractFirAllOpenDiagnos } public void testAllFilesPresentInStatus() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/fir/fir-plugin-prototype/testData/status"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/fir/fir-plugin-prototype/testData/status"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("metaAnnotation.kt") @@ -116,7 +117,7 @@ public class FirAllOpenDiagnosticTestGenerated extends AbstractFirAllOpenDiagnos } public void testAllFilesPresentInSupertypes() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/fir/fir-plugin-prototype/testData/supertypes"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/fir/fir-plugin-prototype/testData/supertypes"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("simple.kt") diff --git a/plugins/jvm-abi-gen/test/org/jetbrains/kotlin/jvm/abi/CompareJvmAbiTestGenerated.java b/plugins/jvm-abi-gen/test/org/jetbrains/kotlin/jvm/abi/CompareJvmAbiTestGenerated.java index b4d5d0020f3..b8ae2ad9c10 100644 --- a/plugins/jvm-abi-gen/test/org/jetbrains/kotlin/jvm/abi/CompareJvmAbiTestGenerated.java +++ b/plugins/jvm-abi-gen/test/org/jetbrains/kotlin/jvm/abi/CompareJvmAbiTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.jvm.abi; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class CompareJvmAbiTestGenerated extends AbstractCompareJvmAbiTest { } public void testAllFilesPresentInCompare() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/jvm-abi-gen/testData/compare"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/jvm-abi-gen/testData/compare"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("classFlags") diff --git a/plugins/jvm-abi-gen/test/org/jetbrains/kotlin/jvm/abi/CompileAgainstJvmAbiTestGenerated.java b/plugins/jvm-abi-gen/test/org/jetbrains/kotlin/jvm/abi/CompileAgainstJvmAbiTestGenerated.java index 0b851be3ab6..197202ef040 100644 --- a/plugins/jvm-abi-gen/test/org/jetbrains/kotlin/jvm/abi/CompileAgainstJvmAbiTestGenerated.java +++ b/plugins/jvm-abi-gen/test/org/jetbrains/kotlin/jvm/abi/CompileAgainstJvmAbiTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.jvm.abi; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class CompileAgainstJvmAbiTestGenerated extends AbstractCompileAgainstJvm } public void testAllFilesPresentInCompile() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/jvm-abi-gen/testData/compile"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/jvm-abi-gen/testData/compile"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("anonymousObject") diff --git a/plugins/jvm-abi-gen/test/org/jetbrains/kotlin/jvm/abi/JvmAbiContentTestGenerated.java b/plugins/jvm-abi-gen/test/org/jetbrains/kotlin/jvm/abi/JvmAbiContentTestGenerated.java index 1126e309ce5..fdead7d1a16 100644 --- a/plugins/jvm-abi-gen/test/org/jetbrains/kotlin/jvm/abi/JvmAbiContentTestGenerated.java +++ b/plugins/jvm-abi-gen/test/org/jetbrains/kotlin/jvm/abi/JvmAbiContentTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.jvm.abi; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class JvmAbiContentTestGenerated extends AbstractJvmAbiContentTest { } public void testAllFilesPresentInContent() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/jvm-abi-gen/testData/content"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/jvm-abi-gen/testData/content"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("class") diff --git a/plugins/kapt3/kapt3-cli/test/org/jetbrains/kotlin/kapt/cli/test/ArgumentParsingTestGenerated.java b/plugins/kapt3/kapt3-cli/test/org/jetbrains/kotlin/kapt/cli/test/ArgumentParsingTestGenerated.java index 909275dde21..9863d6c6535 100644 --- a/plugins/kapt3/kapt3-cli/test/org/jetbrains/kotlin/kapt/cli/test/ArgumentParsingTestGenerated.java +++ b/plugins/kapt3/kapt3-cli/test/org/jetbrains/kotlin/kapt/cli/test/ArgumentParsingTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.kapt.cli.test; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class ArgumentParsingTestGenerated extends AbstractArgumentParsingTest { } public void testAllFilesPresentInArgumentParsing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/kapt3/kapt3-cli/testData/argumentParsing"), Pattern.compile("^(.+)\\.txt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/kapt3/kapt3-cli/testData/argumentParsing"), Pattern.compile("^(.+)\\.txt$"), null, true); } @TestMetadata("errorFlag.txt") diff --git a/plugins/kapt3/kapt3-cli/test/org/jetbrains/kotlin/kapt/cli/test/KaptToolIntegrationTestGenerated.java b/plugins/kapt3/kapt3-cli/test/org/jetbrains/kotlin/kapt/cli/test/KaptToolIntegrationTestGenerated.java index 471cc2135be..c690fb167b9 100644 --- a/plugins/kapt3/kapt3-cli/test/org/jetbrains/kotlin/kapt/cli/test/KaptToolIntegrationTestGenerated.java +++ b/plugins/kapt3/kapt3-cli/test/org/jetbrains/kotlin/kapt/cli/test/KaptToolIntegrationTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.kapt.cli.test; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class KaptToolIntegrationTestGenerated extends AbstractKaptToolIntegratio } public void testAllFilesPresentInIntegration() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/kapt3/kapt3-cli/testData/integration"), Pattern.compile("^([^\\.]+)$"), null, false); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/kapt3/kapt3-cli/testData/integration"), Pattern.compile("^([^\\.]+)$"), null, false); } @TestMetadata("argfile") diff --git a/plugins/kapt3/kapt3-compiler/test/org/jetbrains/kotlin/kapt3/test/ClassFileToSourceStubConverterTestGenerated.java b/plugins/kapt3/kapt3-compiler/test/org/jetbrains/kotlin/kapt3/test/ClassFileToSourceStubConverterTestGenerated.java index 20e4e068157..04424b8ac39 100644 --- a/plugins/kapt3/kapt3-compiler/test/org/jetbrains/kotlin/kapt3/test/ClassFileToSourceStubConverterTestGenerated.java +++ b/plugins/kapt3/kapt3-compiler/test/org/jetbrains/kotlin/kapt3/test/ClassFileToSourceStubConverterTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.kapt3.test; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -40,7 +41,7 @@ public class ClassFileToSourceStubConverterTestGenerated extends AbstractClassFi } public void testAllFilesPresentInConverter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/kapt3/kapt3-compiler/testData/converter"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/kapt3/kapt3-compiler/testData/converter"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("annotationWithFqNames.kt") diff --git a/plugins/kapt3/kapt3-compiler/test/org/jetbrains/kotlin/kapt3/test/IrClassFileToSourceStubConverterTestGenerated.java b/plugins/kapt3/kapt3-compiler/test/org/jetbrains/kotlin/kapt3/test/IrClassFileToSourceStubConverterTestGenerated.java index 809c09cc404..0d4b258cd98 100644 --- a/plugins/kapt3/kapt3-compiler/test/org/jetbrains/kotlin/kapt3/test/IrClassFileToSourceStubConverterTestGenerated.java +++ b/plugins/kapt3/kapt3-compiler/test/org/jetbrains/kotlin/kapt3/test/IrClassFileToSourceStubConverterTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.kapt3.test; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -41,7 +42,7 @@ public class IrClassFileToSourceStubConverterTestGenerated extends AbstractIrCla } public void testAllFilesPresentInConverter() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/kapt3/kapt3-compiler/testData/converter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/kapt3/kapt3-compiler/testData/converter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("annotationWithFqNames.kt") diff --git a/plugins/kapt3/kapt3-compiler/test/org/jetbrains/kotlin/kapt3/test/IrKotlinKaptContextTestGenerated.java b/plugins/kapt3/kapt3-compiler/test/org/jetbrains/kotlin/kapt3/test/IrKotlinKaptContextTestGenerated.java index 29f90f8220a..089c7289d02 100644 --- a/plugins/kapt3/kapt3-compiler/test/org/jetbrains/kotlin/kapt3/test/IrKotlinKaptContextTestGenerated.java +++ b/plugins/kapt3/kapt3-compiler/test/org/jetbrains/kotlin/kapt3/test/IrKotlinKaptContextTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.kapt3.test; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class IrKotlinKaptContextTestGenerated extends AbstractIrKotlinKaptContex } public void testAllFilesPresentInKotlinRunner() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/kapt3/kapt3-compiler/testData/kotlinRunner"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/kapt3/kapt3-compiler/testData/kotlinRunner"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("DefaultParameterValues.kt") diff --git a/plugins/kapt3/kapt3-compiler/test/org/jetbrains/kotlin/kapt3/test/KotlinKaptContextTestGenerated.java b/plugins/kapt3/kapt3-compiler/test/org/jetbrains/kotlin/kapt3/test/KotlinKaptContextTestGenerated.java index 6b438196e6d..f2370e9cd18 100644 --- a/plugins/kapt3/kapt3-compiler/test/org/jetbrains/kotlin/kapt3/test/KotlinKaptContextTestGenerated.java +++ b/plugins/kapt3/kapt3-compiler/test/org/jetbrains/kotlin/kapt3/test/KotlinKaptContextTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.kapt3.test; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class KotlinKaptContextTestGenerated extends AbstractKotlinKaptContextTes } public void testAllFilesPresentInKotlinRunner() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/kapt3/kapt3-compiler/testData/kotlinRunner"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/kapt3/kapt3-compiler/testData/kotlinRunner"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("DefaultParameterValues.kt") diff --git a/plugins/kotlin-serialization/kotlin-serialization-compiler/test/org/jetbrains/kotlinx/serialization/SerializationIrBytecodeListingTestGenerated.java b/plugins/kotlin-serialization/kotlin-serialization-compiler/test/org/jetbrains/kotlinx/serialization/SerializationIrBytecodeListingTestGenerated.java index 1d70f5a45e3..6e1ffafbdfc 100644 --- a/plugins/kotlin-serialization/kotlin-serialization-compiler/test/org/jetbrains/kotlinx/serialization/SerializationIrBytecodeListingTestGenerated.java +++ b/plugins/kotlin-serialization/kotlin-serialization-compiler/test/org/jetbrains/kotlinx/serialization/SerializationIrBytecodeListingTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlinx.serialization; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class SerializationIrBytecodeListingTestGenerated extends AbstractSeriali } public void testAllFilesPresentInCodegen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/kotlin-serialization/kotlin-serialization-compiler/testData/codegen"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/kotlin-serialization/kotlin-serialization-compiler/testData/codegen"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Basic.kt") diff --git a/plugins/kotlin-serialization/kotlin-serialization-compiler/test/org/jetbrains/kotlinx/serialization/SerializationPluginBytecodeListingTestGenerated.java b/plugins/kotlin-serialization/kotlin-serialization-compiler/test/org/jetbrains/kotlinx/serialization/SerializationPluginBytecodeListingTestGenerated.java index b48bffee20a..ba7aec4bc52 100644 --- a/plugins/kotlin-serialization/kotlin-serialization-compiler/test/org/jetbrains/kotlinx/serialization/SerializationPluginBytecodeListingTestGenerated.java +++ b/plugins/kotlin-serialization/kotlin-serialization-compiler/test/org/jetbrains/kotlinx/serialization/SerializationPluginBytecodeListingTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlinx.serialization; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class SerializationPluginBytecodeListingTestGenerated extends AbstractSer } public void testAllFilesPresentInCodegen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/kotlin-serialization/kotlin-serialization-compiler/testData/codegen"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/kotlin-serialization/kotlin-serialization-compiler/testData/codegen"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("Basic.kt") diff --git a/plugins/kotlin-serialization/kotlin-serialization-compiler/test/org/jetbrains/kotlinx/serialization/SerializationPluginDiagnosticTestGenerated.java b/plugins/kotlin-serialization/kotlin-serialization-compiler/test/org/jetbrains/kotlinx/serialization/SerializationPluginDiagnosticTestGenerated.java index 525821a41ac..80ef3b54c19 100644 --- a/plugins/kotlin-serialization/kotlin-serialization-compiler/test/org/jetbrains/kotlinx/serialization/SerializationPluginDiagnosticTestGenerated.java +++ b/plugins/kotlin-serialization/kotlin-serialization-compiler/test/org/jetbrains/kotlinx/serialization/SerializationPluginDiagnosticTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlinx.serialization; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class SerializationPluginDiagnosticTestGenerated extends AbstractSerializ } public void testAllFilesPresentInDiagnostics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/kotlin-serialization/kotlin-serialization-compiler/testData/diagnostics"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/kotlin-serialization/kotlin-serialization-compiler/testData/diagnostics"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("DuplicateSerialName.kt") diff --git a/plugins/noarg/noarg-cli/test/org/jetbrains/kotlin/noarg/BlackBoxCodegenTestForNoArgGenerated.java b/plugins/noarg/noarg-cli/test/org/jetbrains/kotlin/noarg/BlackBoxCodegenTestForNoArgGenerated.java index b4994ab197e..e58d85a283f 100644 --- a/plugins/noarg/noarg-cli/test/org/jetbrains/kotlin/noarg/BlackBoxCodegenTestForNoArgGenerated.java +++ b/plugins/noarg/noarg-cli/test/org/jetbrains/kotlin/noarg/BlackBoxCodegenTestForNoArgGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.noarg; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class BlackBoxCodegenTestForNoArgGenerated extends AbstractBlackBoxCodege } public void testAllFilesPresentInBox() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/noarg/noarg-cli/testData/box"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/noarg/noarg-cli/testData/box"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("initializers.kt") diff --git a/plugins/noarg/noarg-cli/test/org/jetbrains/kotlin/noarg/BytecodeListingTestForNoArgGenerated.java b/plugins/noarg/noarg-cli/test/org/jetbrains/kotlin/noarg/BytecodeListingTestForNoArgGenerated.java index 87e919a2586..fcc6d255bcb 100644 --- a/plugins/noarg/noarg-cli/test/org/jetbrains/kotlin/noarg/BytecodeListingTestForNoArgGenerated.java +++ b/plugins/noarg/noarg-cli/test/org/jetbrains/kotlin/noarg/BytecodeListingTestForNoArgGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.noarg; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class BytecodeListingTestForNoArgGenerated extends AbstractBytecodeListin } public void testAllFilesPresentInBytecodeListing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/noarg/noarg-cli/testData/bytecodeListing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/noarg/noarg-cli/testData/bytecodeListing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("annoOnNotClass.kt") diff --git a/plugins/noarg/noarg-cli/test/org/jetbrains/kotlin/noarg/DiagnosticsTestForNoArgGenerated.java b/plugins/noarg/noarg-cli/test/org/jetbrains/kotlin/noarg/DiagnosticsTestForNoArgGenerated.java index ed4e047208b..c6d90ac438c 100644 --- a/plugins/noarg/noarg-cli/test/org/jetbrains/kotlin/noarg/DiagnosticsTestForNoArgGenerated.java +++ b/plugins/noarg/noarg-cli/test/org/jetbrains/kotlin/noarg/DiagnosticsTestForNoArgGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.noarg; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class DiagnosticsTestForNoArgGenerated extends AbstractDiagnosticsTestFor } public void testAllFilesPresentInDiagnostics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/noarg/noarg-cli/testData/diagnostics"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/noarg/noarg-cli/testData/diagnostics"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("innerClass.kt") diff --git a/plugins/noarg/noarg-cli/test/org/jetbrains/kotlin/noarg/IrBlackBoxCodegenTestForNoArgGenerated.java b/plugins/noarg/noarg-cli/test/org/jetbrains/kotlin/noarg/IrBlackBoxCodegenTestForNoArgGenerated.java index ebb0e88b286..5f0aae27db3 100644 --- a/plugins/noarg/noarg-cli/test/org/jetbrains/kotlin/noarg/IrBlackBoxCodegenTestForNoArgGenerated.java +++ b/plugins/noarg/noarg-cli/test/org/jetbrains/kotlin/noarg/IrBlackBoxCodegenTestForNoArgGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.noarg; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class IrBlackBoxCodegenTestForNoArgGenerated extends AbstractIrBlackBoxCo } public void testAllFilesPresentInBox() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/noarg/noarg-cli/testData/box"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/noarg/noarg-cli/testData/box"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("initializers.kt") diff --git a/plugins/noarg/noarg-cli/test/org/jetbrains/kotlin/noarg/IrBytecodeListingTestForNoArgGenerated.java b/plugins/noarg/noarg-cli/test/org/jetbrains/kotlin/noarg/IrBytecodeListingTestForNoArgGenerated.java index af7c70a19ff..151ea23ac4e 100644 --- a/plugins/noarg/noarg-cli/test/org/jetbrains/kotlin/noarg/IrBytecodeListingTestForNoArgGenerated.java +++ b/plugins/noarg/noarg-cli/test/org/jetbrains/kotlin/noarg/IrBytecodeListingTestForNoArgGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.noarg; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class IrBytecodeListingTestForNoArgGenerated extends AbstractIrBytecodeLi } public void testAllFilesPresentInBytecodeListing() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/noarg/noarg-cli/testData/bytecodeListing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/noarg/noarg-cli/testData/bytecodeListing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("annoOnNotClass.kt") diff --git a/plugins/parcelize/parcelize-compiler/tests/org/jetbrains/kotlin/parcelize/test/ParcelizeBoxTestGenerated.java b/plugins/parcelize/parcelize-compiler/tests/org/jetbrains/kotlin/parcelize/test/ParcelizeBoxTestGenerated.java index aae880f144d..86a3ae9d9a6 100644 --- a/plugins/parcelize/parcelize-compiler/tests/org/jetbrains/kotlin/parcelize/test/ParcelizeBoxTestGenerated.java +++ b/plugins/parcelize/parcelize-compiler/tests/org/jetbrains/kotlin/parcelize/test/ParcelizeBoxTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.parcelize.test; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class ParcelizeBoxTestGenerated extends AbstractParcelizeBoxTest { } public void testAllFilesPresentInBox() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/parcelize/parcelize-compiler/testData/box"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/parcelize/parcelize-compiler/testData/box"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("allPrimitiveTypes.kt") diff --git a/plugins/parcelize/parcelize-compiler/tests/org/jetbrains/kotlin/parcelize/test/ParcelizeBytecodeListingTestGenerated.java b/plugins/parcelize/parcelize-compiler/tests/org/jetbrains/kotlin/parcelize/test/ParcelizeBytecodeListingTestGenerated.java index 89fd28d75b6..babd9780b5e 100644 --- a/plugins/parcelize/parcelize-compiler/tests/org/jetbrains/kotlin/parcelize/test/ParcelizeBytecodeListingTestGenerated.java +++ b/plugins/parcelize/parcelize-compiler/tests/org/jetbrains/kotlin/parcelize/test/ParcelizeBytecodeListingTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.parcelize.test; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class ParcelizeBytecodeListingTestGenerated extends AbstractParcelizeByte } public void testAllFilesPresentInCodegen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/parcelize/parcelize-compiler/testData/codegen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/parcelize/parcelize-compiler/testData/codegen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM, true); } @TestMetadata("customDescribeContents.kt") diff --git a/plugins/parcelize/parcelize-compiler/tests/org/jetbrains/kotlin/parcelize/test/ParcelizeIrBoxTestGenerated.java b/plugins/parcelize/parcelize-compiler/tests/org/jetbrains/kotlin/parcelize/test/ParcelizeIrBoxTestGenerated.java index 87ff0a316fb..7e57b435772 100644 --- a/plugins/parcelize/parcelize-compiler/tests/org/jetbrains/kotlin/parcelize/test/ParcelizeIrBoxTestGenerated.java +++ b/plugins/parcelize/parcelize-compiler/tests/org/jetbrains/kotlin/parcelize/test/ParcelizeIrBoxTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.parcelize.test; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class ParcelizeIrBoxTestGenerated extends AbstractParcelizeIrBoxTest { } public void testAllFilesPresentInBox() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/parcelize/parcelize-compiler/testData/box"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/parcelize/parcelize-compiler/testData/box"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("allPrimitiveTypes.kt") diff --git a/plugins/parcelize/parcelize-compiler/tests/org/jetbrains/kotlin/parcelize/test/ParcelizeIrBytecodeListingTestGenerated.java b/plugins/parcelize/parcelize-compiler/tests/org/jetbrains/kotlin/parcelize/test/ParcelizeIrBytecodeListingTestGenerated.java index ff96ef25d2d..3ecc19ee6f6 100644 --- a/plugins/parcelize/parcelize-compiler/tests/org/jetbrains/kotlin/parcelize/test/ParcelizeIrBytecodeListingTestGenerated.java +++ b/plugins/parcelize/parcelize-compiler/tests/org/jetbrains/kotlin/parcelize/test/ParcelizeIrBytecodeListingTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.parcelize.test; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -26,7 +27,7 @@ public class ParcelizeIrBytecodeListingTestGenerated extends AbstractParcelizeIr } public void testAllFilesPresentInCodegen() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/parcelize/parcelize-compiler/testData/codegen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/parcelize/parcelize-compiler/testData/codegen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } @TestMetadata("customDescribeContents.kt") diff --git a/plugins/parcelize/parcelize-ide/tests/org/jetbrains/kotlin/pacelize/ide/test/ParcelizeCheckerTestGenerated.java b/plugins/parcelize/parcelize-ide/tests/org/jetbrains/kotlin/pacelize/ide/test/ParcelizeCheckerTestGenerated.java index df4773f5f2d..72c0c5b81a8 100644 --- a/plugins/parcelize/parcelize-ide/tests/org/jetbrains/kotlin/pacelize/ide/test/ParcelizeCheckerTestGenerated.java +++ b/plugins/parcelize/parcelize-ide/tests/org/jetbrains/kotlin/pacelize/ide/test/ParcelizeCheckerTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.pacelize.ide.test; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class ParcelizeCheckerTestGenerated extends AbstractParcelizeCheckerTest } public void testAllFilesPresentInChecker() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/parcelize/parcelize-ide/testData/checker"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/parcelize/parcelize-ide/testData/checker"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("constructors.kt") diff --git a/plugins/parcelize/parcelize-ide/tests/org/jetbrains/kotlin/pacelize/ide/test/ParcelizeQuickFixTestGenerated.java b/plugins/parcelize/parcelize-ide/tests/org/jetbrains/kotlin/pacelize/ide/test/ParcelizeQuickFixTestGenerated.java index e609e53df82..c240abc7050 100644 --- a/plugins/parcelize/parcelize-ide/tests/org/jetbrains/kotlin/pacelize/ide/test/ParcelizeQuickFixTestGenerated.java +++ b/plugins/parcelize/parcelize-ide/tests/org/jetbrains/kotlin/pacelize/ide/test/ParcelizeQuickFixTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.pacelize.ide.test; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class ParcelizeQuickFixTestGenerated extends AbstractParcelizeQuickFixTes } public void testAllFilesPresentInQuickfix() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/parcelize/parcelize-ide/testData/quickfix"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/parcelize/parcelize-ide/testData/quickfix"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("plugins/parcelize/parcelize-ide/testData/quickfix/addPrimaryConstructor") @@ -37,7 +38,7 @@ public class ParcelizeQuickFixTestGenerated extends AbstractParcelizeQuickFixTes } public void testAllFilesPresentInAddPrimaryConstructor() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/parcelize/parcelize-ide/testData/quickfix/addPrimaryConstructor"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/parcelize/parcelize-ide/testData/quickfix/addPrimaryConstructor"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("constructorWithDelegate.kt") @@ -65,7 +66,7 @@ public class ParcelizeQuickFixTestGenerated extends AbstractParcelizeQuickFixTes } public void testAllFilesPresentInCantBeInnerClass() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/parcelize/parcelize-ide/testData/quickfix/cantBeInnerClass"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/parcelize/parcelize-ide/testData/quickfix/cantBeInnerClass"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("simple.kt") @@ -83,7 +84,7 @@ public class ParcelizeQuickFixTestGenerated extends AbstractParcelizeQuickFixTes } public void testAllFilesPresentInClassShouldBeAnnotated() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/parcelize/parcelize-ide/testData/quickfix/classShouldBeAnnotated"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/parcelize/parcelize-ide/testData/quickfix/classShouldBeAnnotated"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("simple.kt") @@ -101,7 +102,7 @@ public class ParcelizeQuickFixTestGenerated extends AbstractParcelizeQuickFixTes } public void testAllFilesPresentInDeleteIncompatible() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/parcelize/parcelize-ide/testData/quickfix/deleteIncompatible"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/parcelize/parcelize-ide/testData/quickfix/deleteIncompatible"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("creatorField.kt") @@ -124,7 +125,7 @@ public class ParcelizeQuickFixTestGenerated extends AbstractParcelizeQuickFixTes } public void testAllFilesPresentInMigrations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/parcelize/parcelize-ide/testData/quickfix/migrations"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/parcelize/parcelize-ide/testData/quickfix/migrations"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("basic.kt") @@ -172,7 +173,7 @@ public class ParcelizeQuickFixTestGenerated extends AbstractParcelizeQuickFixTes } public void testAllFilesPresentInNoParcelableSupertype() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/parcelize/parcelize-ide/testData/quickfix/noParcelableSupertype"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/parcelize/parcelize-ide/testData/quickfix/noParcelableSupertype"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("alreadyHasSupertype.kt") @@ -195,7 +196,7 @@ public class ParcelizeQuickFixTestGenerated extends AbstractParcelizeQuickFixTes } public void testAllFilesPresentInPropertyWontBeSerialized() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/parcelize/parcelize-ide/testData/quickfix/propertyWontBeSerialized"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/parcelize/parcelize-ide/testData/quickfix/propertyWontBeSerialized"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("simple.kt") @@ -213,7 +214,7 @@ public class ParcelizeQuickFixTestGenerated extends AbstractParcelizeQuickFixTes } public void testAllFilesPresentInRemoveDuplicatingTypeParcelerAnnotation() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/parcelize/parcelize-ide/testData/quickfix/removeDuplicatingTypeParcelerAnnotation"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/parcelize/parcelize-ide/testData/quickfix/removeDuplicatingTypeParcelerAnnotation"), Pattern.compile("^([\\w\\-_]+)\\.kt$"), null, true); } @TestMetadata("simple.kt") diff --git a/plugins/sam-with-receiver/sam-with-receiver-cli/test/org/jetbrains/kotlin/samWithReceiver/SamWithReceiverScriptNewDefTestGenerated.java b/plugins/sam-with-receiver/sam-with-receiver-cli/test/org/jetbrains/kotlin/samWithReceiver/SamWithReceiverScriptNewDefTestGenerated.java index 3a6602d98d0..ad2cf1b4fd2 100644 --- a/plugins/sam-with-receiver/sam-with-receiver-cli/test/org/jetbrains/kotlin/samWithReceiver/SamWithReceiverScriptNewDefTestGenerated.java +++ b/plugins/sam-with-receiver/sam-with-receiver-cli/test/org/jetbrains/kotlin/samWithReceiver/SamWithReceiverScriptNewDefTestGenerated.java @@ -25,7 +25,7 @@ public class SamWithReceiverScriptNewDefTestGenerated extends AbstractSamWithRec } public void testAllFilesPresentInScript() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/sam-with-receiver/sam-with-receiver-cli/testData/script"), Pattern.compile("^(.+)\\.kts$"), null, true); + org.jetbrains.kotlin.test.util.KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/sam-with-receiver/sam-with-receiver-cli/testData/script"), Pattern.compile("^(.+)\\.kts$"), null, true); } @TestMetadata("samConversionSimple.kts") diff --git a/plugins/sam-with-receiver/sam-with-receiver-cli/test/org/jetbrains/kotlin/samWithReceiver/SamWithReceiverScriptTestGenerated.java b/plugins/sam-with-receiver/sam-with-receiver-cli/test/org/jetbrains/kotlin/samWithReceiver/SamWithReceiverScriptTestGenerated.java index ec8b2385c93..a2218f254a4 100644 --- a/plugins/sam-with-receiver/sam-with-receiver-cli/test/org/jetbrains/kotlin/samWithReceiver/SamWithReceiverScriptTestGenerated.java +++ b/plugins/sam-with-receiver/sam-with-receiver-cli/test/org/jetbrains/kotlin/samWithReceiver/SamWithReceiverScriptTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.samWithReceiver; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class SamWithReceiverScriptTestGenerated extends AbstractSamWithReceiverS } public void testAllFilesPresentInScript() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/sam-with-receiver/sam-with-receiver-cli/testData/script"), Pattern.compile("^(.+)\\.kts$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/sam-with-receiver/sam-with-receiver-cli/testData/script"), Pattern.compile("^(.+)\\.kts$"), null, true); } @TestMetadata("samConversionSimple.kts") diff --git a/plugins/sam-with-receiver/sam-with-receiver-cli/test/org/jetbrains/kotlin/samWithReceiver/SamWithReceiverTestGenerated.java b/plugins/sam-with-receiver/sam-with-receiver-cli/test/org/jetbrains/kotlin/samWithReceiver/SamWithReceiverTestGenerated.java index 65b380f8bd0..652152d9e5e 100644 --- a/plugins/sam-with-receiver/sam-with-receiver-cli/test/org/jetbrains/kotlin/samWithReceiver/SamWithReceiverTestGenerated.java +++ b/plugins/sam-with-receiver/sam-with-receiver-cli/test/org/jetbrains/kotlin/samWithReceiver/SamWithReceiverTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.samWithReceiver; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class SamWithReceiverTestGenerated extends AbstractSamWithReceiverTest { } public void testAllFilesPresentInDiagnostics() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/sam-with-receiver/sam-with-receiver-cli/testData/diagnostics"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/sam-with-receiver/sam-with-receiver-cli/testData/diagnostics"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("noParameters.kt") From d15c7861b279bdcdde959f7af945a09fcd728075 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Mon, 14 Dec 2020 13:37:33 +0300 Subject: [PATCH 113/196] [TEST] Invert dependency between :test-generator and :tests-common modules This is needed to provide ability for declaring new implementations of test generators, based on existing infrastructure, which won't add dependency on :compiler:tests-common Also this commit removes implicit dependency on :compiler:tests-common from :compiler:tests-common-new --- .../kotlin/test/ConfigurationKind.kt | 0 .../jetbrains/kotlin/test/TestJdkKind.java | 0 .../tests/GenerateCompilerTestsAgainstKlib.kt | 2 +- .../test/runners/DiagnosticTestGenerated.java | 2 +- .../DiagnosticUsingJavacTestGenerated.java | 2 +- .../runners/FirDiagnosticTestGenerated.java | 2 +- ...irOldFrontendDiagnosticsTestGenerated.java | 2 +- .../generators/GenerateNewCompilerTests.kt | 2 ++ .../test/generators/NewTestGeneratorImpl.kt | 17 +++------ compiler/tests-common/build.gradle.kts | 2 ++ .../generators/impl/RunTestMethodGenerator.kt | 0 .../generators/impl/TestGenerationDSL.kt | 33 +++++++++++++++++ .../generators/impl/TestGeneratorImpl.kt | 0 .../DiagnosticsTestWithJsStdLibGenerated.java | 2 +- .../generators/tests/GenerateJava8Tests.kt | 2 +- .../spec/utils/tasks/GenerateSpecTests.kt | 2 +- .../generators/tests/GenerateCompilerTests.kt | 2 +- .../tests/GenerateRuntimeDescriptorTests.kt | 2 +- generators/test-generator/build.gradle.kts | 2 +- .../kotlin/generators/TestGenerationDSL.kt | 25 ------------- .../model/CoroutinesTestMethodModel.kt | 35 ------------------- .../kotlin/generators/tests/GenerateTests.kt | 2 +- .../generators/tests/GenerateTests.kt.as41 | 2 +- .../generators/tests/GenerateTests.kt.as42 | 2 +- .../generators/tests/GenerateJsTests.kt | 2 +- libraries/tools/kotlinp/build.gradle.kts | 1 + .../kotlinp/test/GenerateKotlinpTests.kt | 2 +- 27 files changed, 59 insertions(+), 88 deletions(-) rename compiler/{tests-common => test-infrastructure-utils}/tests/org/jetbrains/kotlin/test/ConfigurationKind.kt (100%) rename compiler/{tests-common => test-infrastructure-utils}/tests/org/jetbrains/kotlin/test/TestJdkKind.java (100%) rename {generators/test-generator => compiler/tests-common}/tests/org/jetbrains/kotlin/generators/impl/RunTestMethodGenerator.kt (100%) create mode 100644 compiler/tests-common/tests/org/jetbrains/kotlin/generators/impl/TestGenerationDSL.kt rename {generators/test-generator => compiler/tests-common}/tests/org/jetbrains/kotlin/generators/impl/TestGeneratorImpl.kt (100%) delete mode 100644 generators/test-generator/tests/org/jetbrains/kotlin/generators/model/CoroutinesTestMethodModel.kt diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/test/ConfigurationKind.kt b/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/ConfigurationKind.kt similarity index 100% rename from compiler/tests-common/tests/org/jetbrains/kotlin/test/ConfigurationKind.kt rename to compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/ConfigurationKind.kt diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/test/TestJdkKind.java b/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/TestJdkKind.java similarity index 100% rename from compiler/tests-common/tests/org/jetbrains/kotlin/test/TestJdkKind.java rename to compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/TestJdkKind.java diff --git a/compiler/tests-against-klib/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTestsAgainstKlib.kt b/compiler/tests-against-klib/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTestsAgainstKlib.kt index 72096fe2337..bfcbf80e52a 100644 --- a/compiler/tests-against-klib/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTestsAgainstKlib.kt +++ b/compiler/tests-against-klib/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTestsAgainstKlib.kt @@ -6,7 +6,7 @@ package org.jetbrains.kotlin.generators.tests import org.jetbrains.kotlin.codegen.ir.AbstractCompileKotlinAgainstKlibTest -import org.jetbrains.kotlin.generators.generateTestGroupSuite +import org.jetbrains.kotlin.generators.impl.generateTestGroupSuite import org.jetbrains.kotlin.test.TargetBackend fun main(args: Array) { diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java index 961fae208a3..6d07fe643a5 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java @@ -14,7 +14,7 @@ import org.junit.jupiter.api.Test; import java.io.File; import java.util.regex.Pattern; -/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */ +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ @SuppressWarnings("all") public class DiagnosticTestGenerated extends AbstractDiagnosticTest { @Nested diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticUsingJavacTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticUsingJavacTestGenerated.java index 70b8d92d33d..449b963beca 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticUsingJavacTestGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticUsingJavacTestGenerated.java @@ -14,7 +14,7 @@ import org.junit.jupiter.api.Test; import java.io.File; import java.util.regex.Pattern; -/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */ +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ @SuppressWarnings("all") @TestMetadata("compiler/testData/diagnostics/tests/javac") @TestDataPath("$PROJECT_ROOT") diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/FirDiagnosticTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/FirDiagnosticTestGenerated.java index bc9296a4f9d..0c45772647f 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/FirDiagnosticTestGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/FirDiagnosticTestGenerated.java @@ -14,7 +14,7 @@ import org.junit.jupiter.api.Test; import java.io.File; import java.util.regex.Pattern; -/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */ +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ @SuppressWarnings("all") public class FirDiagnosticTestGenerated extends AbstractFirDiagnosticTest { @Nested diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java index 6838d378e17..33db9111fc8 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java @@ -14,7 +14,7 @@ import org.junit.jupiter.api.Test; import java.io.File; import java.util.regex.Pattern; -/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */ +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ @SuppressWarnings("all") public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosticTest { @Nested diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/generators/GenerateNewCompilerTests.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/generators/GenerateNewCompilerTests.kt index dacb7084f04..b6c7372d5a3 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/generators/GenerateNewCompilerTests.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/generators/GenerateNewCompilerTests.kt @@ -36,3 +36,5 @@ fun main(args: Array) { } } } + +const val TEST_GENERATOR_NAME = "GenerateNewCompilerTests.kt" diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/generators/NewTestGeneratorImpl.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/generators/NewTestGeneratorImpl.kt index ee63c382f21..c6902c89a75 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/generators/NewTestGeneratorImpl.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/generators/NewTestGeneratorImpl.kt @@ -8,10 +8,11 @@ package org.jetbrains.kotlin.test.generators import org.jetbrains.kotlin.generators.MethodGenerator import org.jetbrains.kotlin.generators.TestGenerator import org.jetbrains.kotlin.generators.TestGroup -import org.jetbrains.kotlin.generators.impl.* +import org.jetbrains.kotlin.generators.impl.SimpleTestClassModelTestAllFilesPresentMethodGenerator +import org.jetbrains.kotlin.generators.impl.SimpleTestMethodGenerator +import org.jetbrains.kotlin.generators.impl.SingleClassTestModelAllFilesPresentedMethodGenerator import org.jetbrains.kotlin.generators.model.* import org.jetbrains.kotlin.generators.util.GeneratorsFileUtil -import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.TestMetadata import org.jetbrains.kotlin.test.util.KtTestUtil import org.jetbrains.kotlin.utils.Printer @@ -22,7 +23,6 @@ import java.io.IOException import java.util.* private val METHOD_GENERATORS = listOf( - RunTestMethodGenerator, SimpleTestClassModelTestAllFilesPresentMethodGenerator, SimpleTestMethodGenerator, SingleClassTestModelAllFilesPresentedMethodGenerator @@ -82,15 +82,8 @@ object NewTestGeneratorImpl : TestGenerator(METHOD_GENERATORS) { suiteTestClassFqName: String, baseTestClassFqName: String, private val testClassModels: Collection, - methodGenerators: Map> + private val methodGenerators: Map> ) { - private val methodGenerators = methodGenerators.toMutableMap().apply { - val newGenerator = this.computeIfPresent(CoroutinesTestMethodModel.Kind) { _, _ -> - SimpleTestMethodGenerator - } ?: return@apply - this[CoroutinesTestMethodModel.Kind] = newGenerator - } - private val baseTestClassPackage: String = baseTestClassFqName.substringBeforeLast('.', "") private val baseTestClassName: String = baseTestClassFqName.substringAfterLast('.', baseTestClassFqName) private val suiteClassPackage: String = suiteTestClassFqName.substringBeforeLast('.', baseTestClassPackage) @@ -148,7 +141,7 @@ object NewTestGeneratorImpl : TestGenerator(METHOD_GENERATORS) { p.println("import java.io.File;") p.println("import java.util.regex.Pattern;") p.println() - p.println("/** This class is generated by {@link ", KotlinTestUtils.TEST_GENERATOR_NAME, "}. DO NOT MODIFY MANUALLY */") + p.println("/** This class is generated by {@link ", TEST_GENERATOR_NAME, "}. DO NOT MODIFY MANUALLY */") p.generateSuppressAllWarnings() diff --git a/compiler/tests-common/build.gradle.kts b/compiler/tests-common/build.gradle.kts index 236b42857a4..f326e3dcd6d 100644 --- a/compiler/tests-common/build.gradle.kts +++ b/compiler/tests-common/build.gradle.kts @@ -45,6 +45,8 @@ dependencies { testCompile(project(":js:js.translator")) testCompile(project(":native:frontend.native")) testCompileOnly(project(":plugins:android-extensions-compiler")) + testApi(projectTests(":generators:test-generator")) + testCompile(projectTests(":compiler:tests-classic-compiler-utils")) testCompile(project(":kotlin-test:kotlin-test-jvm")) testCompile(projectTests(":compiler:tests-common-jvm6")) testCompile(project(":kotlin-scripting-compiler-impl")) diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/impl/RunTestMethodGenerator.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/generators/impl/RunTestMethodGenerator.kt similarity index 100% rename from generators/test-generator/tests/org/jetbrains/kotlin/generators/impl/RunTestMethodGenerator.kt rename to compiler/tests-common/tests/org/jetbrains/kotlin/generators/impl/RunTestMethodGenerator.kt diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/generators/impl/TestGenerationDSL.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/generators/impl/TestGenerationDSL.kt new file mode 100644 index 00000000000..e450be255ae --- /dev/null +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/generators/impl/TestGenerationDSL.kt @@ -0,0 +1,33 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.generators.impl + +import org.jetbrains.kotlin.generators.InconsistencyChecker +import org.jetbrains.kotlin.generators.InconsistencyChecker.Companion.inconsistencyChecker +import org.jetbrains.kotlin.generators.TestGroupSuite +import org.jetbrains.kotlin.generators.testGroupSuite + +fun generateTestGroupSuite( + args: Array, + init: TestGroupSuite.() -> Unit +) { + generateTestGroupSuite(InconsistencyChecker.hasDryRunArg(args), init) +} + +fun generateTestGroupSuite( + dryRun: Boolean = false, + init: TestGroupSuite.() -> Unit +) { + val suite = testGroupSuite(init) + for (testGroup in suite.testGroups) { + for (testClass in testGroup.testClasses) { + val (changed, testSourceFilePath) = TestGeneratorImpl.generateAndSave(testClass, dryRun) + if (changed) { + inconsistencyChecker(dryRun).add(testSourceFilePath) + } + } + } +} diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/impl/TestGeneratorImpl.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/generators/impl/TestGeneratorImpl.kt similarity index 100% rename from generators/test-generator/tests/org/jetbrains/kotlin/generators/impl/TestGeneratorImpl.kt rename to compiler/tests-common/tests/org/jetbrains/kotlin/generators/impl/TestGeneratorImpl.kt diff --git a/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsTestWithJsStdLibGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsTestWithJsStdLibGenerated.java index d49b371fdea..c0b7f831644 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsTestWithJsStdLibGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsTestWithJsStdLibGenerated.java @@ -15,7 +15,7 @@ import org.junit.runner.RunWith; import java.io.File; import java.util.regex.Pattern; -/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */ +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ @SuppressWarnings("all") @TestMetadata("compiler/testData/diagnostics/testsWithJsStdLib") @TestDataPath("$PROJECT_ROOT") diff --git a/compiler/tests-java8/tests/org/jetbrains/kotlin/generators/tests/GenerateJava8Tests.kt b/compiler/tests-java8/tests/org/jetbrains/kotlin/generators/tests/GenerateJava8Tests.kt index f7dcd0b338f..6e08b32fb75 100644 --- a/compiler/tests-java8/tests/org/jetbrains/kotlin/generators/tests/GenerateJava8Tests.kt +++ b/compiler/tests-java8/tests/org/jetbrains/kotlin/generators/tests/GenerateJava8Tests.kt @@ -21,7 +21,7 @@ import org.jetbrains.kotlin.checkers.AbstractForeignJava8AnnotationsNoAnnotation import org.jetbrains.kotlin.checkers.AbstractForeignJava8AnnotationsTest import org.jetbrains.kotlin.checkers.AbstractJspecifyAnnotationsTest import org.jetbrains.kotlin.checkers.javac.AbstractJavacForeignJava8AnnotationsTest -import org.jetbrains.kotlin.generators.generateTestGroupSuite +import org.jetbrains.kotlin.generators.impl.generateTestGroupSuite import org.jetbrains.kotlin.jvm.compiler.AbstractLoadJava8Test import org.jetbrains.kotlin.jvm.compiler.AbstractLoadJava8WithPsiClassReadingTest import org.jetbrains.kotlin.jvm.compiler.javac.AbstractLoadJava8UsingJavacTest diff --git a/compiler/tests-spec/tests/org/jetbrains/kotlin/spec/utils/tasks/GenerateSpecTests.kt b/compiler/tests-spec/tests/org/jetbrains/kotlin/spec/utils/tasks/GenerateSpecTests.kt index 9c981538503..4ce74268fda 100644 --- a/compiler/tests-spec/tests/org/jetbrains/kotlin/spec/utils/tasks/GenerateSpecTests.kt +++ b/compiler/tests-spec/tests/org/jetbrains/kotlin/spec/utils/tasks/GenerateSpecTests.kt @@ -5,7 +5,7 @@ package org.jetbrains.kotlin.spec.utils.tasks -import org.jetbrains.kotlin.generators.generateTestGroupSuite +import org.jetbrains.kotlin.generators.impl.generateTestGroupSuite import org.jetbrains.kotlin.spec.checkers.AbstractDiagnosticsTestSpec import org.jetbrains.kotlin.spec.checkers.AbstractFirDiagnosticsTestSpec import org.jetbrains.kotlin.spec.codegen.AbstractBlackBoxCodegenTestSpec diff --git a/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt b/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt index fa92b5f0fc4..054895e8556 100644 --- a/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt +++ b/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt @@ -29,7 +29,7 @@ import org.jetbrains.kotlin.fir.java.AbstractFirOldFrontendLightClassesTest import org.jetbrains.kotlin.fir.java.AbstractFirTypeEnhancementTest import org.jetbrains.kotlin.fir.java.AbstractOwnFirTypeEnhancementTest import org.jetbrains.kotlin.fir.lightTree.AbstractLightTree2FirConverterTestCase -import org.jetbrains.kotlin.generators.generateTestGroupSuite +import org.jetbrains.kotlin.generators.impl.generateTestGroupSuite import org.jetbrains.kotlin.generators.util.TestGeneratorUtil.KT_OR_KTS_WITHOUT_DOTS_IN_NAME import org.jetbrains.kotlin.generators.util.TestGeneratorUtil.KT_WITHOUT_DOTS_IN_NAME import org.jetbrains.kotlin.integration.AbstractAntTaskTest diff --git a/core/descriptors.runtime/tests/org/jetbrains/kotlin/generators/tests/GenerateRuntimeDescriptorTests.kt b/core/descriptors.runtime/tests/org/jetbrains/kotlin/generators/tests/GenerateRuntimeDescriptorTests.kt index 2836c757ddf..4ef9773d4c7 100644 --- a/core/descriptors.runtime/tests/org/jetbrains/kotlin/generators/tests/GenerateRuntimeDescriptorTests.kt +++ b/core/descriptors.runtime/tests/org/jetbrains/kotlin/generators/tests/GenerateRuntimeDescriptorTests.kt @@ -16,7 +16,7 @@ package org.jetbrains.kotlin.generators.tests -import org.jetbrains.kotlin.generators.generateTestGroupSuite +import org.jetbrains.kotlin.generators.impl.generateTestGroupSuite import org.jetbrains.kotlin.jvm.runtime.AbstractJvm8RuntimeDescriptorLoaderTest import org.jetbrains.kotlin.jvm.runtime.AbstractJvmRuntimeDescriptorLoaderTest diff --git a/generators/test-generator/build.gradle.kts b/generators/test-generator/build.gradle.kts index 1360363a085..eb9cadc61a2 100644 --- a/generators/test-generator/build.gradle.kts +++ b/generators/test-generator/build.gradle.kts @@ -7,7 +7,7 @@ plugins { dependencies { testCompile(intellijDep()) { includeJars("util") } testCompile(project(":core:util.runtime")) - testCompile(projectTests(":compiler:tests-common")) + testApi(projectTests(":compiler:test-infrastructure-utils")) testCompile(kotlinStdlib()) testCompile(commonDep("junit:junit")) testCompile(project(":generators")) diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/TestGenerationDSL.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/TestGenerationDSL.kt index a66e9c1a13a..263ec402de0 100644 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/TestGenerationDSL.kt +++ b/generators/test-generator/tests/org/jetbrains/kotlin/generators/TestGenerationDSL.kt @@ -5,10 +5,7 @@ package org.jetbrains.kotlin.generators -import org.jetbrains.kotlin.generators.impl.TestGeneratorImpl import org.jetbrains.kotlin.generators.model.* -import org.jetbrains.kotlin.generators.InconsistencyChecker.Companion.hasDryRunArg -import org.jetbrains.kotlin.generators.InconsistencyChecker.Companion.inconsistencyChecker import org.jetbrains.kotlin.generators.util.TestGeneratorUtil import org.jetbrains.kotlin.test.TargetBackend import java.io.File @@ -21,28 +18,6 @@ fun testGroupSuite( return TestGroupSuite().apply(init) } -fun generateTestGroupSuite( - args: Array, - init: TestGroupSuite.() -> Unit -) { - generateTestGroupSuite(hasDryRunArg(args), init) -} - -fun generateTestGroupSuite( - dryRun: Boolean = false, - init: TestGroupSuite.() -> Unit -) { - val suite = testGroupSuite(init) - for (testGroup in suite.testGroups) { - for (testClass in testGroup.testClasses) { - val (changed, testSourceFilePath) = TestGeneratorImpl.generateAndSave(testClass, dryRun) - if (changed) { - inconsistencyChecker(dryRun).add(testSourceFilePath) - } - } - } -} - class TestGroupSuite { private val _testGroups = mutableListOf() val testGroups: List diff --git a/generators/test-generator/tests/org/jetbrains/kotlin/generators/model/CoroutinesTestMethodModel.kt b/generators/test-generator/tests/org/jetbrains/kotlin/generators/model/CoroutinesTestMethodModel.kt deleted file mode 100644 index 0ae612dab1f..00000000000 --- a/generators/test-generator/tests/org/jetbrains/kotlin/generators/model/CoroutinesTestMethodModel.kt +++ /dev/null @@ -1,35 +0,0 @@ -/* - * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. - * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. - */ - -package org.jetbrains.kotlin.generators.model - -import org.jetbrains.kotlin.test.TargetBackend -import java.io.File -import java.util.regex.Pattern - -class CoroutinesTestMethodModel( - rootDir: File, - file: File, - filenamePattern: Pattern, - checkFilenameStartsLowerCase: Boolean?, - targetBackend: TargetBackend, - skipIgnored: Boolean, - val isLanguageVersion1_3: Boolean -) : SimpleTestMethodModel( - rootDir, - file, - filenamePattern, - checkFilenameStartsLowerCase, - targetBackend, - skipIgnored -) { - object Kind : MethodModel.Kind() - - override val kind: MethodModel.Kind - get() = Kind - - override val name: String - get() = super.name + if (isLanguageVersion1_3) "_1_3" else "_1_2" -} diff --git a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt index 2ee65a13b1d..598a8d160a1 100644 --- a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt +++ b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt @@ -25,7 +25,7 @@ import org.jetbrains.kotlin.fir.plugin.AbstractFirAllOpenDiagnosticTest import org.jetbrains.kotlin.formatter.AbstractFormatterTest import org.jetbrains.kotlin.formatter.AbstractTypingIndentationTestBase import org.jetbrains.kotlin.generators.TestGroup -import org.jetbrains.kotlin.generators.generateTestGroupSuite +import org.jetbrains.kotlin.generators.impl.generateTestGroupSuite import org.jetbrains.kotlin.generators.util.TestGeneratorUtil.KT_OR_KTS import org.jetbrains.kotlin.generators.util.TestGeneratorUtil.KT_OR_KTS_WITHOUT_DOTS_IN_NAME import org.jetbrains.kotlin.generators.util.TestGeneratorUtil.KT_WITHOUT_DOTS_IN_NAME diff --git a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.as41 b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.as41 index 8f42e940994..19aacbb1a76 100644 --- a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.as41 +++ b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.as41 @@ -30,7 +30,7 @@ import org.jetbrains.kotlin.findUsages.AbstractKotlinFindUsagesWithLibraryTest import org.jetbrains.kotlin.formatter.AbstractFormatterTest import org.jetbrains.kotlin.formatter.AbstractTypingIndentationTestBase import org.jetbrains.kotlin.generators.TestGroup -import org.jetbrains.kotlin.generators.generateTestGroupSuite +import org.jetbrains.kotlin.generators.impl.generateTestGroupSuite import org.jetbrains.kotlin.generators.util.TestGeneratorUtil.KT_OR_KTS import org.jetbrains.kotlin.generators.util.TestGeneratorUtil.KT_OR_KTS_WITHOUT_DOTS_IN_NAME import org.jetbrains.kotlin.generators.util.TestGeneratorUtil.KT_WITHOUT_DOTS_IN_NAME diff --git a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.as42 b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.as42 index 8d15228c1a8..c74929eb79b 100644 --- a/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.as42 +++ b/generators/tests/org/jetbrains/kotlin/generators/tests/GenerateTests.kt.as42 @@ -30,7 +30,7 @@ import org.jetbrains.kotlin.findUsages.AbstractKotlinFindUsagesWithLibraryTest import org.jetbrains.kotlin.formatter.AbstractFormatterTest import org.jetbrains.kotlin.formatter.AbstractTypingIndentationTestBase import org.jetbrains.kotlin.generators.TestGroup -import org.jetbrains.kotlin.generators.generateTestGroupSuite +import org.jetbrains.kotlin.generators.impl.generateTestGroupSuite import org.jetbrains.kotlin.generators.util.TestGeneratorUtil.KT_OR_KTS import org.jetbrains.kotlin.generators.util.TestGeneratorUtil.KT_OR_KTS_WITHOUT_DOTS_IN_NAME import org.jetbrains.kotlin.generators.util.TestGeneratorUtil.KT_WITHOUT_DOTS_IN_NAME diff --git a/js/js.tests/test/org/jetbrains/kotlin/generators/tests/GenerateJsTests.kt b/js/js.tests/test/org/jetbrains/kotlin/generators/tests/GenerateJsTests.kt index c87be5fad87..0042c3b6ee6 100644 --- a/js/js.tests/test/org/jetbrains/kotlin/generators/tests/GenerateJsTests.kt +++ b/js/js.tests/test/org/jetbrains/kotlin/generators/tests/GenerateJsTests.kt @@ -5,7 +5,7 @@ package org.jetbrains.kotlin.generators.tests -import org.jetbrains.kotlin.generators.generateTestGroupSuite +import org.jetbrains.kotlin.generators.impl.generateTestGroupSuite import org.jetbrains.kotlin.js.test.AbstractDceTest import org.jetbrains.kotlin.js.test.AbstractJsLineNumberTest import org.jetbrains.kotlin.js.test.es6.semantics.* diff --git a/libraries/tools/kotlinp/build.gradle.kts b/libraries/tools/kotlinp/build.gradle.kts index 96a77bc4918..8d863d34fec 100644 --- a/libraries/tools/kotlinp/build.gradle.kts +++ b/libraries/tools/kotlinp/build.gradle.kts @@ -23,6 +23,7 @@ dependencies { testCompileOnly(project(":kotlinx-metadata")) testCompileOnly(project(":kotlinx-metadata-jvm")) testCompile(commonDep("junit:junit")) + testCompile(projectTests(":compiler:tests-common")) testCompile(projectTests(":generators:test-generator")) testRuntime(project(":kotlinx-metadata-jvm", configuration = "runtime")) diff --git a/libraries/tools/kotlinp/test/org/jetbrains/kotlin/kotlinp/test/GenerateKotlinpTests.kt b/libraries/tools/kotlinp/test/org/jetbrains/kotlin/kotlinp/test/GenerateKotlinpTests.kt index 4246f620da1..39ecb0dd840 100644 --- a/libraries/tools/kotlinp/test/org/jetbrains/kotlin/kotlinp/test/GenerateKotlinpTests.kt +++ b/libraries/tools/kotlinp/test/org/jetbrains/kotlin/kotlinp/test/GenerateKotlinpTests.kt @@ -5,7 +5,7 @@ package org.jetbrains.kotlin.kotlinp.test -import org.jetbrains.kotlin.generators.generateTestGroupSuite +import org.jetbrains.kotlin.generators.impl.generateTestGroupSuite fun main(args: Array) { System.setProperty("java.awt.headless", "true") From 1fe5148f0d3f36c42a83f752811b53627a149f7f Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Mon, 14 Dec 2020 15:20:28 +0300 Subject: [PATCH 114/196] [TEST] Extract compiler-specific test utils from :tests-common to new module --- .../AbstractFirResolveTestCaseWithStdlib.kt | 3 +- .../org/jetbrains/kotlin/test/Assertions.kt | 45 +++++++++++++ .../kotlin/test/model/AnalysisHandler.kt | 2 +- .../kotlin/test/services/Assertions.kt | 25 +------ .../test/services/DependencyProvider.kt | 1 + .../impl/RegisteredDirectivesParser.kt | 2 +- compiler/tests-common-new/build.gradle.kts | 26 ++++++- .../test/builders/TestConfigurationBuilder.kt | 2 +- .../fir/handlers/FirCfgConsistencyHandler.kt | 4 +- .../kotlin/test/impl/TestConfigurationImpl.kt | 4 +- .../kotlin/test/services/JUnit5Assertions.kt | 10 ++- .../impl/ModuleStructureExtractorImpl.kt | 1 + compiler/tests-common/build.gradle.kts | 2 +- .../checkers/AbstractDiagnosticsTest.kt | 7 +- .../kotlin/fir/AbstractFirDiagnosticTest.kt | 63 +---------------- .../AbstractCompileJavaAgainstKotlinTest.kt | 7 +- .../AbstractCompileKotlinAgainstJavaTest.kt | 7 +- .../jvm/compiler/AbstractLoadJavaTest.java | 12 +++- .../AbstractLocalClassProtoTest.kt | 9 +-- .../AbstractBuiltInsWithJDKMembersTest.kt | 3 +- .../jetbrains/kotlin/test/KotlinBaseTest.kt | 1 - .../kotlin/test/util/JUnit4Assertions.kt | 50 ++++++++++++++ .../RecursiveDescriptorComparatorAdaptor.java | 54 +++++++++++++++ .../tests-compiler-utils/build.gradle.kts | 55 +++++++++++++++ .../kotlin/fir/FirCfgConsistencyChecker.kt | 67 +++++++++++++++++++ .../kotlin/fir/RenderingForDebugInfo.kt | 0 .../jvm/compiler/ExpectedLoadErrorsUtil.java | 28 +++----- .../kotlin/test/util/DescriptorValidator.java | 18 +---- .../util/RecursiveDescriptorComparator.java | 45 ++++++------- .../util/RecursiveDescriptorProcessor.java | 0 .../kotlin/jvm/repl/ReplCompilerJava8Test.kt | 2 +- .../cli/jvm/KotlinCliJavaFileManagerTest.kt | 2 +- .../CompileKotlinAgainstCustomBinariesTest.kt | 2 +- .../jvm/compiler/KotlinClassFinderTest.kt | 6 +- .../KotlinJavacBasedClassFinderTest.kt | 6 +- .../jvm/compiler/MemoryOptimizationsTest.kt | 2 +- .../TypeQualifierAnnotationResolverTest.kt | 6 +- .../builtins/BuiltInsSerializerTest.kt | 9 +-- .../builtins/LoadBuiltinsTest.java | 4 +- .../js/KotlinJavascriptSerializerTest.kt | 9 +-- .../AbstractJvmRuntimeDescriptorLoaderTest.kt | 6 +- .../idea/stubs/AbstractResolveByStubTest.kt | 3 +- settings.gradle | 1 + 43 files changed, 412 insertions(+), 199 deletions(-) create mode 100644 compiler/tests-common/tests/org/jetbrains/kotlin/test/util/JUnit4Assertions.kt create mode 100644 compiler/tests-common/tests/org/jetbrains/kotlin/test/util/RecursiveDescriptorComparatorAdaptor.java create mode 100644 compiler/tests-compiler-utils/build.gradle.kts create mode 100644 compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/fir/FirCfgConsistencyChecker.kt rename compiler/{tests-common => tests-compiler-utils}/tests/org/jetbrains/kotlin/fir/RenderingForDebugInfo.kt (100%) rename compiler/{tests-common => tests-compiler-utils}/tests/org/jetbrains/kotlin/jvm/compiler/ExpectedLoadErrorsUtil.java (81%) rename compiler/{tests-common => tests-compiler-utils}/tests/org/jetbrains/kotlin/test/util/DescriptorValidator.java (96%) rename compiler/{tests-common => tests-compiler-utils}/tests/org/jetbrains/kotlin/test/util/RecursiveDescriptorComparator.java (95%) rename compiler/{tests-common => tests-compiler-utils}/tests/org/jetbrains/kotlin/test/util/RecursiveDescriptorProcessor.java (100%) diff --git a/compiler/fir/analysis-tests/tests/org/jetbrains/kotlin/fir/AbstractFirResolveTestCaseWithStdlib.kt b/compiler/fir/analysis-tests/tests/org/jetbrains/kotlin/fir/AbstractFirResolveTestCaseWithStdlib.kt index 4e64e4b2d27..7349332a74d 100644 --- a/compiler/fir/analysis-tests/tests/org/jetbrains/kotlin/fir/AbstractFirResolveTestCaseWithStdlib.kt +++ b/compiler/fir/analysis-tests/tests/org/jetbrains/kotlin/fir/AbstractFirResolveTestCaseWithStdlib.kt @@ -6,11 +6,10 @@ package org.jetbrains.kotlin.fir import org.jetbrains.kotlin.test.ConfigurationKind -import org.jetbrains.kotlin.test.TestJdkKind abstract class AbstractFirDiagnosticsWithStdlibTest : AbstractFirDiagnosticsTest() { override fun extractConfigurationKind(files: List): ConfigurationKind { return ConfigurationKind.ALL } -} \ No newline at end of file +} diff --git a/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/Assertions.kt b/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/Assertions.kt index c9a1d5c38b5..c503da26b99 100644 --- a/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/Assertions.kt +++ b/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/Assertions.kt @@ -7,6 +7,9 @@ package org.jetbrains.kotlin.test +import java.io.File +import java.util.* +import kotlin.collections.ArrayList import kotlin.contracts.ExperimentalContracts import kotlin.contracts.contract @@ -34,3 +37,45 @@ internal fun assertTrue(message: String, value: Boolean) { fail(message) } } + +abstract class Assertions { + fun assertEqualsToFile(expectedFile: File, actual: String, sanitizer: (String) -> String = { it }) { + assertEqualsToFile(expectedFile, actual, sanitizer) { "Actual data differs from file content" } + } + + abstract fun assertEqualsToFile( + expectedFile: File, + actual: String, + sanitizer: (String) -> String = { it }, + message: (() -> String) + ) + + abstract fun assertEquals(expected: Any?, actual: Any?, message: (() -> String)? = null) + abstract fun assertNotEquals(expected: Any?, actual: Any?, message: (() -> String)? = null) + abstract fun assertTrue(value: Boolean, message: (() -> String)? = null) + abstract fun assertFalse(value: Boolean, message: (() -> String)? = null) + abstract fun assertNotNull(value: Any?, message: (() -> String)? = null) + abstract fun assertSameElements(expected: Collection, actual: Collection, message: (() -> String)?) + + fun assertContainsElements(collection: Collection, vararg expected: T) { + assertContainsElements(collection, expected.toList()) + } + + fun assertContainsElements(collection: Collection, expected: Collection) { + val copy = ArrayList(collection) + copy.retainAll(expected) + assertSameElements(copy, expected) { renderCollectionToString(collection) } + } + + fun renderCollectionToString(collection: Iterable<*>): String { + if (!collection.iterator().hasNext()) { + return "" + } + + return collection.joinToString("\n") + } + + abstract fun assertAll(exceptions: List) + + abstract fun fail(message: () -> String): Nothing +} diff --git a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/model/AnalysisHandler.kt b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/model/AnalysisHandler.kt index ae0564a165e..cb394e4da06 100644 --- a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/model/AnalysisHandler.kt +++ b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/model/AnalysisHandler.kt @@ -5,8 +5,8 @@ package org.jetbrains.kotlin.test.model +import org.jetbrains.kotlin.test.Assertions import org.jetbrains.kotlin.test.directives.model.DirectivesContainer -import org.jetbrains.kotlin.test.services.Assertions import org.jetbrains.kotlin.test.services.ServiceRegistrationData import org.jetbrains.kotlin.test.services.TestServices import org.jetbrains.kotlin.test.services.assertions diff --git a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/Assertions.kt b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/Assertions.kt index c2e8fbab2a3..5db9ff12286 100644 --- a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/Assertions.kt +++ b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/Assertions.kt @@ -5,27 +5,8 @@ package org.jetbrains.kotlin.test.services -import java.io.File +import org.jetbrains.kotlin.test.Assertions -abstract class Assertions : TestService { - fun assertEqualsToFile(expectedFile: File, actual: String, sanitizer: (String) -> String = { it }) { - assertEqualsToFile(expectedFile, actual, sanitizer) { "Actual data differs from file content" } - } +abstract class AssertionsService : Assertions(), TestService - abstract fun assertEqualsToFile( - expectedFile: File, - actual: String, - sanitizer: (String) -> String = { it }, - message: (() -> String) - ) - - abstract fun assertEquals(expected: Any?, actual: Any?, message: (() -> String)? = null) - abstract fun assertNotEquals(expected: Any?, actual: Any?, message: (() -> String)? = null) - abstract fun assertTrue(value: Boolean, message: (() -> String)? = null) - abstract fun assertFalse(value: Boolean, message: (() -> String)? = null) - abstract fun assertAll(exceptions: List) - - abstract fun fail(message: () -> String): Nothing -} - -val TestServices.assertions: Assertions by TestServices.testServiceAccessor() +val TestServices.assertions: AssertionsService by TestServices.testServiceAccessor() diff --git a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/DependencyProvider.kt b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/DependencyProvider.kt index 7bb7fbe234e..1f0fcb396c0 100644 --- a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/DependencyProvider.kt +++ b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/DependencyProvider.kt @@ -5,6 +5,7 @@ package org.jetbrains.kotlin.test.services +import org.jetbrains.kotlin.test.Assertions import org.jetbrains.kotlin.test.model.* abstract class DependencyProvider : TestService { diff --git a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/impl/RegisteredDirectivesParser.kt b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/impl/RegisteredDirectivesParser.kt index 42faa246966..6e895097bbc 100644 --- a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/impl/RegisteredDirectivesParser.kt +++ b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/services/impl/RegisteredDirectivesParser.kt @@ -5,8 +5,8 @@ package org.jetbrains.kotlin.test.services.impl +import org.jetbrains.kotlin.test.Assertions import org.jetbrains.kotlin.test.directives.model.* -import org.jetbrains.kotlin.test.services.Assertions class RegisteredDirectivesParser(private val container: DirectivesContainer, private val assertions: Assertions) { companion object { diff --git a/compiler/tests-common-new/build.gradle.kts b/compiler/tests-common-new/build.gradle.kts index 092fae7b00d..77faab3ee3f 100644 --- a/compiler/tests-common-new/build.gradle.kts +++ b/compiler/tests-common-new/build.gradle.kts @@ -22,6 +22,7 @@ dependencies { testImplementation("org.junit.platform:junit-platform-commons:1.7.0") testApi(projectTests(":compiler:test-infrastructure")) testImplementation(projectTests(":compiler:test-infrastructure-utils")) + testImplementation(projectTests(":compiler:tests-compiler-utils")) testImplementation(intellijDep()) { // This dependency is needed only for FileComparisonFailure @@ -32,7 +33,30 @@ dependencies { // This is needed only for using FileComparisonFailure, which relies on JUnit 3 classes testRuntimeOnly(commonDep("junit:junit")) testRuntimeOnly(intellijDep()) { - includeJars("jna", rootProject = rootProject) + includeJars( + "jps-model", + "extensions", + "util", + "platform-api", + "platform-impl", + "idea", + "guava", + "trove4j", + "asm-all", + "log4j", + "jdom", + "streamex", + "bootstrap", + "jna", + rootProject = rootProject + ) + } + + Platform[202] { + testRuntimeOnly(intellijDep()) { includeJars("intellij-deps-fastutil-8.3.1-1") } + } + Platform[203].orHigher { + testRuntimeOnly(intellijDep()) { includeJars("intellij-deps-fastutil-8.3.1-3") } } testRuntimeOnly(toolsJar()) } diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/builders/TestConfigurationBuilder.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/builders/TestConfigurationBuilder.kt index 3f407a61efc..fac2eca53fd 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/builders/TestConfigurationBuilder.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/builders/TestConfigurationBuilder.kt @@ -16,7 +16,7 @@ typealias Constructor = (TestServices) -> T @DefaultsDsl class TestConfigurationBuilder { val defaultsProviderBuilder: DefaultsProviderBuilder = DefaultsProviderBuilder() - lateinit var assertions: Assertions + lateinit var assertions: AssertionsService private val facades: MutableList>> = mutableListOf() diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirCfgConsistencyHandler.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirCfgConsistencyHandler.kt index df1afe15cd5..dd3bcd92b19 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirCfgConsistencyHandler.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirCfgConsistencyHandler.kt @@ -5,14 +5,14 @@ package org.jetbrains.kotlin.test.frontend.fir.handlers -import org.jetbrains.kotlin.fir.AbstractFirDiagnosticsTest +import org.jetbrains.kotlin.fir.FirCfgConsistencyChecker import org.jetbrains.kotlin.test.frontend.fir.FirOutputArtifact import org.jetbrains.kotlin.test.model.TestModule import org.jetbrains.kotlin.test.services.TestServices class FirCfgConsistencyHandler(testServices: TestServices) : FirAnalysisHandler(testServices) { override fun processModule(module: TestModule, info: FirOutputArtifact) { - info.firFiles.values.forEach { it.accept(AbstractFirDiagnosticsTest.CfgConsistencyChecker) } + info.firFiles.values.forEach { it.accept(FirCfgConsistencyChecker(assertions)) } } override fun processAfterAllModules(someAssertionWasFailed: Boolean) {} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/impl/TestConfigurationImpl.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/impl/TestConfigurationImpl.kt index ea840bbe034..164a0e9ca09 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/impl/TestConfigurationImpl.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/impl/TestConfigurationImpl.kt @@ -18,7 +18,7 @@ import org.jetbrains.kotlin.test.utils.TestDisposable class TestConfigurationImpl( defaultsProvider: DefaultsProvider, - assertions: Assertions, + assertions: AssertionsService, facades: List>>, @@ -86,7 +86,7 @@ class TestConfigurationImpl( ) register(CompilerConfigurationProvider::class, environmentProvider) - register(Assertions::class, assertions) + register(AssertionsService::class, assertions) register(DefaultsProvider::class, defaultsProvider) register(DefaultRegisteredDirectivesProvider::class, DefaultRegisteredDirectivesProvider(defaultRegisteredDirectives)) diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/JUnit5Assertions.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/JUnit5Assertions.kt index 670e65e2815..3596f788b2a 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/JUnit5Assertions.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/JUnit5Assertions.kt @@ -14,7 +14,7 @@ import java.io.File import java.io.IOException import org.junit.jupiter.api.Assertions as JUnit5PlatformAssertions -object JUnit5Assertions : Assertions() { +object JUnit5Assertions : AssertionsService() { override fun assertEqualsToFile(expectedFile: File, actual: String, sanitizer: (String) -> String, message: () -> String) { try { val actualText = actual.trim { it <= ' ' }.convertLineSeparators().trimTrailingWhitespacesAndAddNewlineAtEOF() @@ -56,6 +56,14 @@ object JUnit5Assertions : Assertions() { JUnit5PlatformAssertions.assertAll(exceptions.map { Executable { throw it } }) } + override fun assertNotNull(value: Any?, message: (() -> String)?) { + JUnit5PlatformAssertions.assertNotNull(value, message) + } + + override fun assertSameElements(expected: Collection, actual: Collection, message: (() -> String)?) { + JUnit5PlatformAssertions.assertIterableEquals(expected, actual, message) + } + override fun fail(message: () -> String): Nothing { org.junit.jupiter.api.fail(message) } diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/impl/ModuleStructureExtractorImpl.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/impl/ModuleStructureExtractorImpl.kt index eadecfdb5d4..3842cf57d23 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/impl/ModuleStructureExtractorImpl.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/impl/ModuleStructureExtractorImpl.kt @@ -10,6 +10,7 @@ import org.jetbrains.kotlin.platform.TargetPlatform import org.jetbrains.kotlin.platform.js.JsPlatforms import org.jetbrains.kotlin.platform.jvm.JvmPlatforms import org.jetbrains.kotlin.platform.konan.NativePlatforms +import org.jetbrains.kotlin.test.Assertions import org.jetbrains.kotlin.test.builders.LanguageVersionSettingsBuilder import org.jetbrains.kotlin.test.directives.ModuleStructureDirectives import org.jetbrains.kotlin.test.directives.model.ComposedRegisteredDirectives diff --git a/compiler/tests-common/build.gradle.kts b/compiler/tests-common/build.gradle.kts index f326e3dcd6d..74da03d5318 100644 --- a/compiler/tests-common/build.gradle.kts +++ b/compiler/tests-common/build.gradle.kts @@ -46,7 +46,7 @@ dependencies { testCompile(project(":native:frontend.native")) testCompileOnly(project(":plugins:android-extensions-compiler")) testApi(projectTests(":generators:test-generator")) - testCompile(projectTests(":compiler:tests-classic-compiler-utils")) + testCompile(projectTests(":compiler:tests-compiler-utils")) testCompile(project(":kotlin-test:kotlin-test-jvm")) testCompile(projectTests(":compiler:tests-common-jvm6")) testCompile(project(":kotlin-scripting-compiler-impl")) diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractDiagnosticsTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractDiagnosticsTest.kt index 1a0ee265e1c..9848f73c4bd 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractDiagnosticsTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractDiagnosticsTest.kt @@ -525,7 +525,12 @@ abstract class AbstractDiagnosticsTest : BaseDiagnosticsTest() { return } - val comparator = RecursiveDescriptorComparator(createdAffectedPackagesConfiguration(testFiles, modules.values)) + val comparator = RecursiveDescriptorComparator( + createdAffectedPackagesConfiguration( + testFiles, + modules.values + ) + ) val isMultiModuleTest = modules.size != 1 diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/fir/AbstractFirDiagnosticTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/fir/AbstractFirDiagnosticTest.kt index d984edb56d9..c20c140747e 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/fir/AbstractFirDiagnosticTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/fir/AbstractFirDiagnosticTest.kt @@ -6,7 +6,6 @@ package org.jetbrains.kotlin.fir import com.intellij.psi.PsiElement -import junit.framework.TestCase import org.jetbrains.kotlin.KtNodeTypes import org.jetbrains.kotlin.checkers.diagnostics.factories.DebugInfoDiagnosticFactory1 import org.jetbrains.kotlin.checkers.utils.TypeOfCall @@ -21,13 +20,8 @@ import org.jetbrains.kotlin.fir.declarations.FirProperty import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.expressions.FirExpressionWithSmartcast import org.jetbrains.kotlin.fir.expressions.FirFunctionCall -import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference import org.jetbrains.kotlin.fir.references.FirNamedReference import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference -import org.jetbrains.kotlin.fir.resolve.dfa.FirControlFlowGraphReferenceImpl -import org.jetbrains.kotlin.fir.resolve.dfa.cfg.CFGNode -import org.jetbrains.kotlin.fir.resolve.dfa.cfg.ControlFlowGraph -import org.jetbrains.kotlin.fir.resolve.dfa.cfg.EdgeKind import org.jetbrains.kotlin.fir.resolve.dfa.cfg.FirControlFlowGraphRenderVisitor import org.jetbrains.kotlin.fir.resolve.transformers.createAllCompilerResolveProcessors import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol @@ -38,9 +32,9 @@ import org.jetbrains.kotlin.fir.types.ConeKotlinType import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.types.coneTypeSafe import org.jetbrains.kotlin.fir.visitors.FirDefaultVisitorVoid -import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid import org.jetbrains.kotlin.name.FqNameUnsafe import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.JUnit4Assertions import org.jetbrains.kotlin.util.OperatorNameConventions import org.jetbrains.kotlin.utils.addIfNotNull import java.io.File @@ -292,60 +286,7 @@ abstract class AbstractFirDiagnosticsTest : AbstractFirBaseDiagnosticsTest() { } private fun checkCfgEdgeConsistency(firFiles: List) { - firFiles.forEach { it.accept(CfgConsistencyChecker) } - } - - object CfgConsistencyChecker : FirVisitorVoid() { - override fun visitElement(element: FirElement) { - element.acceptChildren(this) - } - - override fun visitControlFlowGraphReference(controlFlowGraphReference: FirControlFlowGraphReference) { - val graph = (controlFlowGraphReference as? FirControlFlowGraphReferenceImpl)?.controlFlowGraph ?: return - assertEquals(ControlFlowGraph.State.Completed, graph.state) - checkConsistency(graph) - checkOrder(graph) - } - - private fun checkConsistency(graph: ControlFlowGraph) { - for (node in graph.nodes) { - for (to in node.followingNodes) { - checkEdge(node, to) - } - for (from in node.previousNodes) { - checkEdge(from, node) - } - if (node.followingNodes.isEmpty() && node.previousNodes.isEmpty()) { - throw AssertionError("Unconnected CFG node: $node") - } - } - } - - private val cfgKinds = listOf(EdgeKind.DeadForward, EdgeKind.CfgForward, EdgeKind.DeadBackward, EdgeKind.CfgBackward) - - private fun checkEdge(from: CFGNode<*>, to: CFGNode<*>) { - assertContainsElements(from.followingNodes, to) - assertContainsElements(to.previousNodes, from) - val fromKind = from.outgoingEdges.getValue(to).kind - val toKind = to.incomingEdges.getValue(from).kind - TestCase.assertEquals(fromKind, toKind) - if (from.isDead && to.isDead) { - assertContainsElements(cfgKinds, toKind) - } - } - - private fun checkOrder(graph: ControlFlowGraph) { - val visited = mutableSetOf>() - for (node in graph.nodes) { - for (previousNode in node.previousNodes) { - if (previousNode.owner != graph) continue - if (!node.incomingEdges.getValue(previousNode).kind.isBack) { - assertTrue(previousNode in visited) - } - } - visited += node - } - } + firFiles.forEach { it.accept(FirCfgConsistencyChecker(JUnit4Assertions)) } } private fun checkCfgDumpNotExists(testDataFile: File) { diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileJavaAgainstKotlinTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileJavaAgainstKotlinTest.kt index 5d05ccfbacb..31c1a5df7cc 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileJavaAgainstKotlinTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileJavaAgainstKotlinTest.kt @@ -39,7 +39,7 @@ import org.jetbrains.kotlin.test.KotlinTestUtils.newConfiguration import org.jetbrains.kotlin.test.TestCaseWithTmpdir import org.jetbrains.kotlin.test.TestJdkKind import org.jetbrains.kotlin.test.util.KtTestUtil -import org.jetbrains.kotlin.test.util.RecursiveDescriptorComparator.validateAndCompareDescriptorWithFile +import org.jetbrains.kotlin.test.util.RecursiveDescriptorComparatorAdaptor.validateAndCompareDescriptorWithFile import org.junit.Assert import java.io.File import java.io.IOException @@ -83,8 +83,9 @@ abstract class AbstractCompileJavaAgainstKotlinTest : TestCaseWithTmpdir() { if (!compiledSuccessfully) return - val configuration = newConfiguration(ConfigurationKind.ALL, TestJdkKind.FULL_JDK, - KtTestUtil.getAnnotationsJar(), out) + val configuration = newConfiguration( + ConfigurationKind.ALL, TestJdkKind.FULL_JDK, + KtTestUtil.getAnnotationsJar(), out) configuration.put(JVMConfigurationKeys.USE_PSI_CLASS_FILES_READING, true) val environment = KotlinCoreEnvironment.createForTests(testRootDisposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES) setupLanguageVersionSettingsForCompilerTests(ktFile.readText(), environment) diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileKotlinAgainstJavaTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileKotlinAgainstJavaTest.kt index 14339751282..2f5a936071a 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileKotlinAgainstJavaTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileKotlinAgainstJavaTest.kt @@ -38,7 +38,7 @@ import org.jetbrains.kotlin.test.KotlinTestUtils.newConfiguration import org.jetbrains.kotlin.test.TestCaseWithTmpdir import org.jetbrains.kotlin.test.TestJdkKind import org.jetbrains.kotlin.test.util.KtTestUtil -import org.jetbrains.kotlin.test.util.RecursiveDescriptorComparator.validateAndCompareDescriptorWithFile +import org.jetbrains.kotlin.test.util.RecursiveDescriptorComparatorAdaptor.validateAndCompareDescriptorWithFile import org.junit.Assert import java.io.File import java.lang.annotation.Retention @@ -69,8 +69,9 @@ abstract class AbstractCompileKotlinAgainstJavaTest : TestCaseWithTmpdir() { val environment = KotlinCoreEnvironment.createForTests( testRootDisposable, - newConfiguration(ConfigurationKind.ALL, TestJdkKind.MOCK_JDK, - KtTestUtil.getAnnotationsJar(), out), + newConfiguration( + ConfigurationKind.ALL, TestJdkKind.MOCK_JDK, + KtTestUtil.getAnnotationsJar(), out), EnvironmentConfigFiles.JVM_CONFIG_FILES ) diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java b/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java index 2855bf494d9..cbbbe39d4a1 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java @@ -31,7 +31,9 @@ import org.jetbrains.kotlin.resolve.DescriptorUtils; import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedClassDescriptor; import org.jetbrains.kotlin.test.*; import org.jetbrains.kotlin.test.util.DescriptorValidator; +import org.jetbrains.kotlin.test.util.JUnit4Assertions; import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.kotlin.test.util.RecursiveDescriptorComparator.Configuration; import org.junit.Assert; import java.io.File; @@ -44,14 +46,18 @@ import static org.jetbrains.kotlin.test.KotlinTestUtils.compileKotlinWithJava; import static org.jetbrains.kotlin.test.KotlinTestUtils.newConfiguration; import static org.jetbrains.kotlin.test.util.DescriptorValidator.ValidationVisitor.errorTypesAllowed; import static org.jetbrains.kotlin.test.util.DescriptorValidator.ValidationVisitor.errorTypesForbidden; -import static org.jetbrains.kotlin.test.util.RecursiveDescriptorComparator.*; +import static org.jetbrains.kotlin.test.util.RecursiveDescriptorComparator.DONT_INCLUDE_METHODS_OF_OBJECT; +import static org.jetbrains.kotlin.test.util.RecursiveDescriptorComparator.RECURSIVE; +import static org.jetbrains.kotlin.test.util.RecursiveDescriptorComparatorAdaptor.compareDescriptors; +import static org.jetbrains.kotlin.test.util.RecursiveDescriptorComparatorAdaptor.validateAndCompareDescriptorWithFile; /* The generated test compares package descriptors loaded from kotlin sources and read from compiled java. */ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { // There are two modules in each test case (sources and dependencies), so we should render declarations from both of them - public static final Configuration COMPARATOR_CONFIGURATION = DONT_INCLUDE_METHODS_OF_OBJECT.renderDeclarationsFromOtherModules(true); + public static final Configuration + COMPARATOR_CONFIGURATION = DONT_INCLUDE_METHODS_OF_OBJECT.renderDeclarationsFromOtherModules(true); protected void doTestCompiledJava(@NotNull String javaFileName) throws Exception { doTestCompiledJava(javaFileName, COMPARATOR_CONFIGURATION); @@ -346,7 +352,7 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { ) { boolean fail = false; try { - ExpectedLoadErrorsUtil.checkForLoadErrors(javaPackage, bindingContext); + ExpectedLoadErrorsUtil.checkForLoadErrors(javaPackage, bindingContext, JUnit4Assertions.INSTANCE); } catch (ComparisonFailure e) { // to let the next check run even if this one failed diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/serialization/AbstractLocalClassProtoTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/serialization/AbstractLocalClassProtoTest.kt index c22dd6bd34c..cb460624203 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/serialization/AbstractLocalClassProtoTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/serialization/AbstractLocalClassProtoTest.kt @@ -30,6 +30,7 @@ import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil import org.jetbrains.kotlin.test.* import org.jetbrains.kotlin.test.util.RecursiveDescriptorComparator +import org.jetbrains.kotlin.test.util.RecursiveDescriptorComparatorAdaptor import java.io.File import java.net.URLClassLoader @@ -64,10 +65,10 @@ abstract class AbstractLocalClassProtoTest : TestCaseWithTmpdir() { val classDescriptor = components.classDeserializer.deserializeClass(clazz.classId) ?: error("Class is not resolved: $clazz (classId = ${clazz.classId})") - RecursiveDescriptorComparator.validateAndCompareDescriptorWithFile( - classDescriptor, - RecursiveDescriptorComparator.DONT_INCLUDE_METHODS_OF_OBJECT, - KotlinTestUtils.replaceExtension(source, "txt") + RecursiveDescriptorComparatorAdaptor.validateAndCompareDescriptorWithFile( + classDescriptor, + RecursiveDescriptorComparator.DONT_INCLUDE_METHODS_OF_OBJECT, + KotlinTestUtils.replaceExtension(source, "txt") ) } diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/serialization/builtins/AbstractBuiltInsWithJDKMembersTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/serialization/builtins/AbstractBuiltInsWithJDKMembersTest.kt index 9187408d198..1810a7dfee5 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/serialization/builtins/AbstractBuiltInsWithJDKMembersTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/serialization/builtins/AbstractBuiltInsWithJDKMembersTest.kt @@ -22,6 +22,7 @@ import org.jetbrains.kotlin.test.ConfigurationKind import org.jetbrains.kotlin.test.KotlinTestWithEnvironment import org.jetbrains.kotlin.test.TestJdkKind import org.jetbrains.kotlin.test.util.RecursiveDescriptorComparator +import org.jetbrains.kotlin.test.util.RecursiveDescriptorComparatorAdaptor import java.io.File abstract class AbstractBuiltInsWithJDKMembersTest : KotlinTestWithEnvironment() { @@ -40,7 +41,7 @@ abstract class AbstractBuiltInsWithJDKMembersTest : KotlinTestWithEnvironment() val loaded = module.packageFragmentProvider.packageFragments(packageFqName) .filterIsInstance() .single { !it.isFallback } - RecursiveDescriptorComparator.validateAndCompareDescriptorWithFile( + RecursiveDescriptorComparatorAdaptor.validateAndCompareDescriptorWithFile( loaded, configuration, File("compiler/testData/builtin-classes/$builtinVersionName/" + packageFqName.asString().replace('.', '-') + ".txt") ) diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/test/KotlinBaseTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/test/KotlinBaseTest.kt index d7b27140cef..784c899db18 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/test/KotlinBaseTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/test/KotlinBaseTest.kt @@ -8,7 +8,6 @@ package org.jetbrains.kotlin.test import com.google.common.collect.ImmutableList import com.google.common.collect.ImmutableMap import org.jetbrains.kotlin.builtins.StandardNames -import org.jetbrains.kotlin.checkers.CompilerTestLanguageVersionSettings import org.jetbrains.kotlin.checkers.ENABLE_JVM_PREVIEW import org.jetbrains.kotlin.checkers.parseLanguageVersionSettings import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/test/util/JUnit4Assertions.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/test/util/JUnit4Assertions.kt new file mode 100644 index 00000000000..921e830fe6e --- /dev/null +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/test/util/JUnit4Assertions.kt @@ -0,0 +1,50 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.util + +import org.jetbrains.kotlin.test.Assertions +import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.testFramework.KtUsefulTestCase +import org.junit.Assert +import java.io.File + +object JUnit4Assertions : Assertions() { + override fun assertEqualsToFile(expectedFile: File, actual: String, sanitizer: (String) -> String, message: () -> String) { + KotlinTestUtils.assertEqualsToFile(expectedFile, actual, sanitizer) + } + + override fun assertEquals(expected: Any?, actual: Any?, message: (() -> String)?) { + Assert.assertEquals(message?.invoke(), expected, actual) + } + + override fun assertNotEquals(expected: Any?, actual: Any?, message: (() -> String)?) { + Assert.assertNotEquals(message?.invoke(), expected, actual) + } + + override fun assertTrue(value: Boolean, message: (() -> String)?) { + Assert.assertTrue(message?.invoke(), value) + } + + override fun assertFalse(value: Boolean, message: (() -> String)?) { + Assert.assertFalse(message?.invoke(), value) + } + + override fun assertNotNull(value: Any?, message: (() -> String)?) { + Assert.assertNotNull(message?.invoke(), value) + } + + override fun assertSameElements(expected: Collection, actual: Collection, message: (() -> String)?) { + KtUsefulTestCase.assertSameElements(message?.invoke() ?: "", expected, actual) + } + + override fun assertAll(exceptions: List) { + exceptions.forEach { throw it } + } + + override fun fail(message: () -> String): Nothing { + throw AssertionError(message.invoke()) + } +} diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/test/util/RecursiveDescriptorComparatorAdaptor.java b/compiler/tests-common/tests/org/jetbrains/kotlin/test/util/RecursiveDescriptorComparatorAdaptor.java new file mode 100644 index 00000000000..7257b3140b2 --- /dev/null +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/test/util/RecursiveDescriptorComparatorAdaptor.java @@ -0,0 +1,54 @@ +/* + * 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.util; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.kotlin.descriptors.DeclarationDescriptor; +import org.jetbrains.kotlin.test.Assertions; + +import java.io.File; + +public class RecursiveDescriptorComparatorAdaptor { + private static final Assertions assertions = JUnit4Assertions.INSTANCE; + + public static void compareDescriptors( + @NotNull DeclarationDescriptor expected, + @NotNull DeclarationDescriptor actual, + @NotNull RecursiveDescriptorComparator.Configuration configuration, + @Nullable File txtFile + ) { + RecursiveDescriptorComparator.compareDescriptors(expected, actual, configuration, txtFile, assertions); + } + + public static void validateAndCompareDescriptorWithFile( + @NotNull DeclarationDescriptor actual, + @NotNull RecursiveDescriptorComparator.Configuration configuration, + @NotNull File txtFile + ) { + RecursiveDescriptorComparator.validateAndCompareDescriptorWithFile(actual, configuration, txtFile, assertions); + } + + public static void validateAndCompareDescriptors( + @NotNull DeclarationDescriptor expected, + @NotNull DeclarationDescriptor actual, + @NotNull RecursiveDescriptorComparator.Configuration configuration, + @Nullable File txtFile + ) { + RecursiveDescriptorComparator.validateAndCompareDescriptors(expected, actual, configuration, txtFile, assertions); + } +} diff --git a/compiler/tests-compiler-utils/build.gradle.kts b/compiler/tests-compiler-utils/build.gradle.kts new file mode 100644 index 00000000000..c9752ac4938 --- /dev/null +++ b/compiler/tests-compiler-utils/build.gradle.kts @@ -0,0 +1,55 @@ + +plugins { + kotlin("jvm") + id("jps-compatible") +} + +dependencies { + testCompile(kotlinStdlib("jdk8")) + testCompile(project(":kotlin-scripting-compiler")) + testCompile(project(":core:descriptors")) + testCompile(project(":core:descriptors.jvm")) + testCompile(project(":core:deserialization")) + testCompile(project(":compiler:util")) + testCompile(project(":compiler:tests-mutes")) + testCompile(project(":compiler:backend")) + testCompile(project(":compiler:ir.ir2cfg")) + testCompile(project(":compiler:frontend")) + testCompile(project(":compiler:frontend.java")) + testCompile(project(":compiler:util")) + testCompile(project(":compiler:psi")) + testCompile(project(":compiler:cli-common")) + testCompile(project(":compiler:cli")) + testCompile(project(":compiler:cli-js")) + testCompile(project(":compiler:serialization")) + testCompile(projectTests(":compiler:test-infrastructure-utils")) + testCompileOnly(intellijCoreDep()) { includeJars("intellij-core") } + + testCompile(intellijDep()) { + includeJars( + "jps-model", + "extensions", + "util", + "platform-api", + "platform-impl", + "idea", + "idea_rt", + "guava", + "trove4j", + "asm-all", + "log4j", + "jdom", + "streamex", + "bootstrap", + rootProject = rootProject + ) + isTransitive = false + } +} + +sourceSets { + "main" { none() } + "test" { projectDefault() } +} + +testsJar {} diff --git a/compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/fir/FirCfgConsistencyChecker.kt b/compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/fir/FirCfgConsistencyChecker.kt new file mode 100644 index 00000000000..09910cf81dc --- /dev/null +++ b/compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/fir/FirCfgConsistencyChecker.kt @@ -0,0 +1,67 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.fir + +import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference +import org.jetbrains.kotlin.fir.resolve.dfa.FirControlFlowGraphReferenceImpl +import org.jetbrains.kotlin.fir.resolve.dfa.cfg.CFGNode +import org.jetbrains.kotlin.fir.resolve.dfa.cfg.ControlFlowGraph +import org.jetbrains.kotlin.fir.resolve.dfa.cfg.EdgeKind +import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid +import org.jetbrains.kotlin.test.Assertions + +class FirCfgConsistencyChecker(private val assertions: Assertions) : FirVisitorVoid() { + override fun visitElement(element: FirElement) { + element.acceptChildren(this) + } + + override fun visitControlFlowGraphReference(controlFlowGraphReference: FirControlFlowGraphReference) { + val graph = (controlFlowGraphReference as? FirControlFlowGraphReferenceImpl)?.controlFlowGraph ?: return + assertions.assertEquals(ControlFlowGraph.State.Completed, graph.state) + checkConsistency(graph) + checkOrder(graph) + } + + private fun checkConsistency(graph: ControlFlowGraph) { + for (node in graph.nodes) { + for (to in node.followingNodes) { + checkEdge(node, to) + } + for (from in node.previousNodes) { + checkEdge(from, node) + } + if (node.followingNodes.isEmpty() && node.previousNodes.isEmpty()) { + throw AssertionError("Unconnected CFG node: $node") + } + } + } + + private val cfgKinds = listOf(EdgeKind.DeadForward, EdgeKind.CfgForward, EdgeKind.DeadBackward, EdgeKind.CfgBackward) + + private fun checkEdge(from: CFGNode<*>, to: CFGNode<*>) { + assertions.assertContainsElements(from.followingNodes, to) + assertions.assertContainsElements(to.previousNodes, from) + val fromKind = from.outgoingEdges.getValue(to).kind + val toKind = to.incomingEdges.getValue(from).kind + assertions.assertEquals(fromKind, toKind) + if (from.isDead && to.isDead) { + assertions.assertContainsElements(cfgKinds, toKind) + } + } + + private fun checkOrder(graph: ControlFlowGraph) { + val visited = mutableSetOf>() + for (node in graph.nodes) { + for (previousNode in node.previousNodes) { + if (previousNode.owner != graph) continue + if (!node.incomingEdges.getValue(previousNode).kind.isBack) { + assertions.assertTrue(previousNode in visited) + } + } + visited += node + } + } +} diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/fir/RenderingForDebugInfo.kt b/compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/fir/RenderingForDebugInfo.kt similarity index 100% rename from compiler/tests-common/tests/org/jetbrains/kotlin/fir/RenderingForDebugInfo.kt rename to compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/fir/RenderingForDebugInfo.kt diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/ExpectedLoadErrorsUtil.java b/compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/jvm/compiler/ExpectedLoadErrorsUtil.java similarity index 81% rename from compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/ExpectedLoadErrorsUtil.java rename to compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/jvm/compiler/ExpectedLoadErrorsUtil.java index 235a9145596..a70bd65cbe6 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/ExpectedLoadErrorsUtil.java +++ b/compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/jvm/compiler/ExpectedLoadErrorsUtil.java @@ -1,17 +1,6 @@ /* - * Copyright 2010-2015 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. + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ package org.jetbrains.kotlin.jvm.compiler; @@ -27,18 +16,17 @@ import org.jetbrains.kotlin.resolve.DescriptorUtils; import org.jetbrains.kotlin.resolve.constants.ConstantValue; import org.jetbrains.kotlin.resolve.jvm.JvmBindingContextSlices; import org.jetbrains.kotlin.resolve.scopes.MemberScope; +import org.jetbrains.kotlin.test.Assertions; import java.util.*; -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"; public static void checkForLoadErrors( @NotNull PackageViewDescriptor packageFromJava, - @NotNull BindingContext bindingContext + @NotNull BindingContext bindingContext, + @NotNull Assertions assertions ) { Map> expectedErrors = getExpectedLoadErrors(packageFromJava); Map> actualErrors = getActualLoadErrors(bindingContext); @@ -47,10 +35,10 @@ public class ExpectedLoadErrorsUtil { List actual = actualErrors.get(source); List expected = expectedErrors.get(source); - assertNotNull("Unexpected load error(s):\n" + actual + "\ncontainer:" + source, expected); - assertNotNull("Missing load error(s):\n" + expected + "\ncontainer:" + source, actual); + assertions.assertNotNull(expected, () -> "Unexpected load error(s):\n" + actual + "\ncontainer:" + source); + assertions.assertNotNull(actual, () -> "Missing load error(s):\n" + expected + "\ncontainer:" + source); - assertSameElements("Unexpected/missing load error(s)\ncontainer:" + source, actual, expected); + assertions.assertSameElements(actual, expected, () -> "Unexpected/missing load error(s)\ncontainer:" + source); } } diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/test/util/DescriptorValidator.java b/compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/test/util/DescriptorValidator.java similarity index 96% rename from compiler/tests-common/tests/org/jetbrains/kotlin/test/util/DescriptorValidator.java rename to compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/test/util/DescriptorValidator.java index b72150fd2bd..d02779d81dc 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/test/util/DescriptorValidator.java +++ b/compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/test/util/DescriptorValidator.java @@ -1,17 +1,6 @@ /* - * Copyright 2010-2015 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. + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ package org.jetbrains.kotlin.test.util; @@ -26,7 +15,6 @@ import org.jetbrains.kotlin.resolve.DescriptorUtils; import org.jetbrains.kotlin.resolve.scopes.MemberScope; import org.jetbrains.kotlin.types.KotlinType; import org.jetbrains.kotlin.types.KotlinTypeKt; -import org.junit.Assert; import java.io.PrintStream; import java.util.Collection; @@ -563,7 +551,7 @@ public class DescriptorValidator { public void done() { if (errorsFound) { - Assert.fail("Descriptor validation failed (see messages above)"); + throw new AssertionError("Descriptor validation failed (see messages above)"); } } } diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/test/util/RecursiveDescriptorComparator.java b/compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/test/util/RecursiveDescriptorComparator.java similarity index 95% rename from compiler/tests-common/tests/org/jetbrains/kotlin/test/util/RecursiveDescriptorComparator.java rename to compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/test/util/RecursiveDescriptorComparator.java index 8977f5ace0a..ee0373592a6 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/test/util/RecursiveDescriptorComparator.java +++ b/compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/test/util/RecursiveDescriptorComparator.java @@ -1,17 +1,6 @@ /* - * 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. + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ package org.jetbrains.kotlin.test.util; @@ -36,9 +25,8 @@ import org.jetbrains.kotlin.resolve.DescriptorUtils; import org.jetbrains.kotlin.resolve.MemberComparator; import org.jetbrains.kotlin.resolve.scopes.ChainedMemberScope; import org.jetbrains.kotlin.resolve.scopes.MemberScope; -import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.Assertions; import org.jetbrains.kotlin.utils.Printer; -import org.junit.Assert; import java.io.File; import java.util.ArrayList; @@ -300,49 +288,54 @@ public class RecursiveDescriptorComparator { private static void compareDescriptorWithFile( @NotNull DeclarationDescriptor actual, @NotNull Configuration configuration, - @NotNull File txtFile + @NotNull File txtFile, + @NotNull Assertions assertions ) { - doCompareDescriptors(null, actual, configuration, txtFile); + doCompareDescriptors(null, actual, configuration, txtFile, assertions); } public static void compareDescriptors( @NotNull DeclarationDescriptor expected, @NotNull DeclarationDescriptor actual, @NotNull Configuration configuration, - @Nullable File txtFile + @Nullable File txtFile, + @NotNull Assertions assertions ) { if (expected == actual) { throw new IllegalArgumentException("Don't invoke this method with expected == actual." + "Invoke compareDescriptorWithFile() instead."); } - doCompareDescriptors(expected, actual, configuration, txtFile); + doCompareDescriptors(expected, actual, configuration, txtFile, assertions); } public static void validateAndCompareDescriptorWithFile( @NotNull DeclarationDescriptor actual, @NotNull Configuration configuration, - @NotNull File txtFile + @NotNull File txtFile, + @NotNull Assertions assertions ) { DescriptorValidator.validate(configuration.validationStrategy, actual); - compareDescriptorWithFile(actual, configuration, txtFile); + compareDescriptorWithFile(actual, configuration, txtFile, assertions); } public static void validateAndCompareDescriptors( @NotNull DeclarationDescriptor expected, @NotNull DeclarationDescriptor actual, @NotNull Configuration configuration, - @Nullable File txtFile + @Nullable File txtFile, + @NotNull Assertions assertions ) { DescriptorValidator.validate(configuration.validationStrategy, expected); DescriptorValidator.validate(configuration.validationStrategy, actual); - compareDescriptors(expected, actual, configuration, txtFile); + compareDescriptors(expected, actual, configuration, txtFile, assertions); } private static void doCompareDescriptors( @Nullable DeclarationDescriptor expected, @NotNull DeclarationDescriptor actual, @NotNull Configuration configuration, - @Nullable File txtFile + @Nullable File txtFile, + @NotNull Assertions assertions ) { RecursiveDescriptorComparator comparator = new RecursiveDescriptorComparator(configuration); @@ -351,11 +344,11 @@ public class RecursiveDescriptorComparator { if (expected != null) { String expectedSerialized = comparator.serializeRecursively(expected); - Assert.assertEquals("Expected and actual descriptors differ", expectedSerialized, actualSerialized); + assertions.assertEquals(expectedSerialized, actualSerialized, () -> "Expected and actual descriptors differ"); } if (txtFile != null) { - KotlinTestUtils.assertEqualsToFile(txtFile, actualSerialized); + assertions.assertEqualsToFile(txtFile, actualSerialized, (s) -> s); } } diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/test/util/RecursiveDescriptorProcessor.java b/compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/test/util/RecursiveDescriptorProcessor.java similarity index 100% rename from compiler/tests-common/tests/org/jetbrains/kotlin/test/util/RecursiveDescriptorProcessor.java rename to compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/test/util/RecursiveDescriptorProcessor.java diff --git a/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/repl/ReplCompilerJava8Test.kt b/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/repl/ReplCompilerJava8Test.kt index c002b0c8053..96bb2719883 100644 --- a/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/repl/ReplCompilerJava8Test.kt +++ b/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/repl/ReplCompilerJava8Test.kt @@ -107,7 +107,7 @@ class ReplCompilerJava8Test : KtUsefulTestCase() { } private fun makeConfiguration() = KotlinTestUtils.newConfiguration( - ConfigurationKind.ALL, TestJdkKind.FULL_JDK, File(KotlinIntegrationTestBase.getCompilerLib(), "kotlin-stdlib.jar"), tmpdir + ConfigurationKind.ALL, TestJdkKind.FULL_JDK, File(KotlinIntegrationTestBase.getCompilerLib(), "kotlin-stdlib.jar"), tmpdir ).also { loadScriptingPlugin(it) } diff --git a/compiler/tests/org/jetbrains/kotlin/cli/jvm/KotlinCliJavaFileManagerTest.kt b/compiler/tests/org/jetbrains/kotlin/cli/jvm/KotlinCliJavaFileManagerTest.kt index 7d6b0deff2e..f9f613fedac 100644 --- a/compiler/tests/org/jetbrains/kotlin/cli/jvm/KotlinCliJavaFileManagerTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/cli/jvm/KotlinCliJavaFileManagerTest.kt @@ -186,7 +186,7 @@ class KotlinCliJavaFileManagerTest : KotlinTestWithEnvironment() { javaFilesDir = KtTestUtil.tmpDir("java-file-manager-test") val configuration = KotlinTestUtils.newConfiguration( - ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, emptyList(), listOf(javaFilesDir) + ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, emptyList(), listOf(javaFilesDir) ) return KotlinCoreEnvironment.createForTests(testRootDisposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES) diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/CompileKotlinAgainstCustomBinariesTest.kt b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/CompileKotlinAgainstCustomBinariesTest.kt index 296aa35261e..3b5c02d2a9b 100644 --- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/CompileKotlinAgainstCustomBinariesTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/CompileKotlinAgainstCustomBinariesTest.kt @@ -38,7 +38,7 @@ import org.jetbrains.kotlin.test.ConfigurationKind import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.MockLibraryUtil import org.jetbrains.kotlin.test.TestJdkKind -import org.jetbrains.kotlin.test.util.RecursiveDescriptorComparator.validateAndCompareDescriptorWithFile +import org.jetbrains.kotlin.test.util.RecursiveDescriptorComparatorAdaptor.validateAndCompareDescriptorWithFile import org.jetbrains.kotlin.utils.PathUtil import org.jetbrains.org.objectweb.asm.* import org.jetbrains.org.objectweb.asm.tree.AbstractInsnNode diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/KotlinClassFinderTest.kt b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/KotlinClassFinderTest.kt index c154a315bda..11b45706bbe 100644 --- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/KotlinClassFinderTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/KotlinClassFinderTest.kt @@ -68,9 +68,9 @@ class KotlinClassFinderTest : KotlinTestWithEnvironmentManagement() { private fun createEnvironment(tmpdir: File?): KotlinCoreEnvironment { return KotlinCoreEnvironment.createForTests( - testRootDisposable, - KotlinTestUtils.newConfiguration(ConfigurationKind.ALL, TestJdkKind.MOCK_JDK, tmpdir), - EnvironmentConfigFiles.JVM_CONFIG_FILES + testRootDisposable, + KotlinTestUtils.newConfiguration(ConfigurationKind.ALL, TestJdkKind.MOCK_JDK, tmpdir), + EnvironmentConfigFiles.JVM_CONFIG_FILES ).apply { // Activate Kotlin light class finder JvmResolveUtil.analyze(this) diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/KotlinJavacBasedClassFinderTest.kt b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/KotlinJavacBasedClassFinderTest.kt index 2ba009942a0..f81fb3ba4ba 100644 --- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/KotlinJavacBasedClassFinderTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/KotlinJavacBasedClassFinderTest.kt @@ -90,9 +90,9 @@ class KotlinJavacBasedClassFinderTest : KotlinTestWithEnvironmentManagement() { private fun createEnvironment(tmpdir: File?, files: List = emptyList()): KotlinCoreEnvironment { return KotlinCoreEnvironment.createForTests( - testRootDisposable, - KotlinTestUtils.newConfiguration(ConfigurationKind.ALL, TestJdkKind.MOCK_JDK, tmpdir), - EnvironmentConfigFiles.JVM_CONFIG_FILES + testRootDisposable, + KotlinTestUtils.newConfiguration(ConfigurationKind.ALL, TestJdkKind.MOCK_JDK, tmpdir), + EnvironmentConfigFiles.JVM_CONFIG_FILES ).apply { registerJavac(files) // Activate Kotlin light class finder diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/MemoryOptimizationsTest.kt b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/MemoryOptimizationsTest.kt index 73ae8a8ad93..6fb4e6a7e6b 100644 --- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/MemoryOptimizationsTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/MemoryOptimizationsTest.kt @@ -72,7 +72,7 @@ class MemoryOptimizationsTest : KtUsefulTestCase() { val environment = KotlinTestUtils .createEnvironmentWithJdkAndNullabilityAnnotationsFromIdea( - testRootDisposable, ConfigurationKind.ALL, TestJdkKind.FULL_JDK + testRootDisposable, ConfigurationKind.ALL, TestJdkKind.FULL_JDK ) val moduleDescriptor = JvmResolveUtil.analyze( diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/TypeQualifierAnnotationResolverTest.kt b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/TypeQualifierAnnotationResolverTest.kt index 7425678e775..f900b4a1bb3 100644 --- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/TypeQualifierAnnotationResolverTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/TypeQualifierAnnotationResolverTest.kt @@ -87,15 +87,15 @@ class TypeQualifierAnnotationResolverTest : KtUsefulTestCase() { private fun buildTypeQualifierResolverAndFindClass(className: String): Pair { val configuration = KotlinTestUtils.newConfiguration( - ConfigurationKind.ALL, TestJdkKind.FULL_JDK, - listOf( + ConfigurationKind.ALL, TestJdkKind.FULL_JDK, + listOf( KtTestUtil.getAnnotationsJar(), MockLibraryUtil.compileJavaFilesLibraryToJar( FOREIGN_ANNOTATIONS_SOURCES_PATH, "foreign-annotations" ) ), - listOf(File(TEST_DATA_PATH)) + listOf(File(TEST_DATA_PATH)) ).apply { languageVersionSettings = LanguageVersionSettingsImpl( LanguageVersion.LATEST_STABLE, ApiVersion.LATEST_STABLE, mapOf(JvmAnalysisFlags.javaTypeEnhancementState to JavaTypeEnhancementState.STRICT) diff --git a/compiler/tests/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializerTest.kt b/compiler/tests/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializerTest.kt index 6bbcf004126..f117638b03e 100644 --- a/compiler/tests/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializerTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializerTest.kt @@ -26,6 +26,7 @@ import org.jetbrains.kotlin.storage.LockBasedStorageManager import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.TestCaseWithTmpdir import org.jetbrains.kotlin.test.util.RecursiveDescriptorComparator +import org.jetbrains.kotlin.test.util.RecursiveDescriptorComparatorAdaptor import java.io.File import java.io.FileInputStream @@ -56,10 +57,10 @@ class BuiltInsSerializerTest : TestCaseWithTmpdir() { module.initialize(packageFragmentProvider) module.setDependencies(module, module.builtIns.builtInsModule) - RecursiveDescriptorComparator.validateAndCompareDescriptorWithFile( - module.getPackage(TEST_PACKAGE_FQNAME), - RecursiveDescriptorComparator.DONT_INCLUDE_METHODS_OF_OBJECT, - File(source.replace(".kt", ".txt")) + RecursiveDescriptorComparatorAdaptor.validateAndCompareDescriptorWithFile( + module.getPackage(TEST_PACKAGE_FQNAME), + RecursiveDescriptorComparator.DONT_INCLUDE_METHODS_OF_OBJECT, + File(source.replace(".kt", ".txt")) ) } diff --git a/compiler/tests/org/jetbrains/kotlin/serialization/builtins/LoadBuiltinsTest.java b/compiler/tests/org/jetbrains/kotlin/serialization/builtins/LoadBuiltinsTest.java index d1ae730779c..9a19ef042bf 100644 --- a/compiler/tests/org/jetbrains/kotlin/serialization/builtins/LoadBuiltinsTest.java +++ b/compiler/tests/org/jetbrains/kotlin/serialization/builtins/LoadBuiltinsTest.java @@ -37,7 +37,7 @@ import org.jetbrains.kotlin.storage.LockBasedStorageManager; import org.jetbrains.kotlin.test.ConfigurationKind; import org.jetbrains.kotlin.test.KotlinTestWithEnvironment; import org.jetbrains.kotlin.test.TestJdkKind; -import org.jetbrains.kotlin.test.util.RecursiveDescriptorComparator; +import org.jetbrains.kotlin.test.util.RecursiveDescriptorComparatorAdaptor; import java.io.File; import java.util.Collections; @@ -61,7 +61,7 @@ public class LoadBuiltinsTest extends KotlinTestWithEnvironment { if (fromLazyResolve instanceof LazyPackageDescriptor) { PackageFragmentDescriptor deserialized = CollectionsKt.single(PackageFragmentProviderKt.packageFragments(packageFragmentProvider, packageFqName)); - RecursiveDescriptorComparator.validateAndCompareDescriptors( + RecursiveDescriptorComparatorAdaptor.validateAndCompareDescriptors( fromLazyResolve, deserialized, AbstractBuiltInsWithJDKMembersTest.createComparatorConfiguration(), new File("compiler/testData/builtin-classes/default/" + packageFqName.asString().replace('.', '-') + ".txt") ); diff --git a/compiler/tests/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializerTest.kt b/compiler/tests/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializerTest.kt index ba115516889..3ffc7ba5933 100644 --- a/compiler/tests/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializerTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializerTest.kt @@ -39,6 +39,7 @@ import org.jetbrains.kotlin.storage.LockBasedStorageManager import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.TestCaseWithTmpdir import org.jetbrains.kotlin.test.util.RecursiveDescriptorComparator +import org.jetbrains.kotlin.test.util.RecursiveDescriptorComparatorAdaptor import org.jetbrains.kotlin.utils.JsMetadataVersion import org.jetbrains.kotlin.utils.KotlinJavascriptMetadataUtils import org.jetbrains.kotlin.utils.sure @@ -62,10 +63,10 @@ class KotlinJavascriptSerializerTest : TestCaseWithTmpdir() { serialize(configuration, metaFile) val module = deserialize(metaFile) - RecursiveDescriptorComparator.validateAndCompareDescriptorWithFile( - module.getPackage(TEST_PACKAGE_FQNAME), - RecursiveDescriptorComparator.DONT_INCLUDE_METHODS_OF_OBJECT, - File(source.replace(".kt", ".txt")) + RecursiveDescriptorComparatorAdaptor.validateAndCompareDescriptorWithFile( + module.getPackage(TEST_PACKAGE_FQNAME), + RecursiveDescriptorComparator.DONT_INCLUDE_METHODS_OF_OBJECT, + File(source.replace(".kt", ".txt")) ) } diff --git a/core/descriptors.runtime/tests/org/jetbrains/kotlin/jvm/runtime/AbstractJvmRuntimeDescriptorLoaderTest.kt b/core/descriptors.runtime/tests/org/jetbrains/kotlin/jvm/runtime/AbstractJvmRuntimeDescriptorLoaderTest.kt index 71844faf698..d86dbb8bfd7 100644 --- a/core/descriptors.runtime/tests/org/jetbrains/kotlin/jvm/runtime/AbstractJvmRuntimeDescriptorLoaderTest.kt +++ b/core/descriptors.runtime/tests/org/jetbrains/kotlin/jvm/runtime/AbstractJvmRuntimeDescriptorLoaderTest.kt @@ -34,7 +34,7 @@ import org.jetbrains.kotlin.test.* import org.jetbrains.kotlin.test.TestFiles.TestFileFactoryNoModules import org.jetbrains.kotlin.test.util.DescriptorValidator.ValidationVisitor.errorTypesForbidden import org.jetbrains.kotlin.test.util.KtTestUtil -import org.jetbrains.kotlin.test.util.RecursiveDescriptorComparator +import org.jetbrains.kotlin.test.util.RecursiveDescriptorComparatorAdaptor import org.jetbrains.kotlin.test.util.RecursiveDescriptorComparator.Configuration import org.jetbrains.kotlin.utils.Printer import org.jetbrains.kotlin.utils.sure @@ -94,7 +94,7 @@ abstract class AbstractJvmRuntimeDescriptorLoaderTest : TestCaseWithTmpdir() { val differentResultFile = KotlinTestUtils.replaceExtension(file, "runtime.txt") if (differentResultFile.exists()) { - RecursiveDescriptorComparator.validateAndCompareDescriptorWithFile(actual, comparatorConfiguration, differentResultFile) + RecursiveDescriptorComparatorAdaptor.validateAndCompareDescriptorWithFile(actual, comparatorConfiguration, differentResultFile) return } @@ -102,7 +102,7 @@ abstract class AbstractJvmRuntimeDescriptorLoaderTest : TestCaseWithTmpdir() { tmpdir, testRootDisposable, jdkKind, ConfigurationKind.ALL, true, false, false, null ).first - RecursiveDescriptorComparator.validateAndCompareDescriptors(expected, actual, comparatorConfiguration, null) + RecursiveDescriptorComparatorAdaptor.validateAndCompareDescriptors(expected, actual, comparatorConfiguration, null) } private fun DeclarationDescriptor.isJavaAnnotationConstructor() = diff --git a/idea/tests/org/jetbrains/kotlin/idea/stubs/AbstractResolveByStubTest.kt b/idea/tests/org/jetbrains/kotlin/idea/stubs/AbstractResolveByStubTest.kt index 5afaa6309f1..e0dba588134 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/stubs/AbstractResolveByStubTest.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/stubs/AbstractResolveByStubTest.kt @@ -17,6 +17,7 @@ import org.jetbrains.kotlin.psi.KtFile import org.jetbrains.kotlin.test.InTextDirectivesUtils import org.jetbrains.kotlin.test.util.DescriptorValidator.ValidationVisitor.errorTypesForbidden import org.jetbrains.kotlin.test.util.RecursiveDescriptorComparator +import org.jetbrains.kotlin.test.util.RecursiveDescriptorComparatorAdaptor import org.junit.Assert import java.io.File @@ -46,7 +47,7 @@ abstract class AbstractResolveByStubTest : KotlinLightCodeInsightFixtureTestCase val fileToCompareTo = File(FileUtil.getNameWithoutExtension(path) + ".txt") - RecursiveDescriptorComparator.validateAndCompareDescriptorWithFile( + RecursiveDescriptorComparatorAdaptor.validateAndCompareDescriptorWithFile( packageViewDescriptor, RecursiveDescriptorComparator.DONT_INCLUDE_METHODS_OF_OBJECT .filterRecursion(RecursiveDescriptorComparator.SKIP_BUILT_INS_PACKAGES) diff --git a/settings.gradle b/settings.gradle index 637afec59da..08f6a951e28 100644 --- a/settings.gradle +++ b/settings.gradle @@ -115,6 +115,7 @@ include ":benchmarks", ":compiler:cli-js-klib", ":compiler:incremental-compilation-impl", ":compiler:android-tests", + ":compiler:tests-compiler-utils", ":compiler:tests-common", ":compiler:tests-mutes", ":compiler:tests-mutes:tc-integration", From 71ffaa2d97bd38e0a04d31c371702da04cf71697 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Mon, 14 Dec 2020 16:16:46 +0300 Subject: [PATCH 115/196] [TEST] Migrate AbstractDiagnosticsTestWithJsStdLib to new test runners --- .../testsWithJsStdLib/dynamicTypes/block.kt | 2 +- .../dynamicTypes/comparisonToNull.kt | 2 +- .../dynamicTypes/destructuring.kt | 2 +- .../dynamicTypes/implicitDynamicReceiver.kt | 2 +- .../dynamicTypes/inExpression.kt | 2 +- .../dynamicTypes/indexedAccess.kt | 2 +- .../dynamicTypes/namedArguments.kt | 2 +- .../dynamicTypes/nullable.kt | 2 +- .../dynamicTypes/propertyDelegateBy.kt | 2 +- .../dynamicTypes/rangeExpression.kt | 2 +- .../dynamicTypes/spreadOperator.kt | 2 +- .../staticCallsInDynamicContext.kt | 2 +- .../export/extendingNonExportedType.kt | 8 +- .../export/unexportableTypesInSignature.kt | 24 +- .../unexportableTypesInTypeParameters.kt | 6 +- .../testsWithJsStdLib/localClassMetadata.txt | 2 +- .../module/dualModuleFromUmd.txt | 13 +- .../module/wrongCallToModule.txt | 2 +- .../module/wrongCallToNonModule.txt | 31 +- .../testsWithJsStdLib/name/illegalName.kt | 2 +- .../native/inlineExtensionToNative.kt | 2 +- .../DiagnosticsTestWithJsStdLibGenerated.java | 341 ++++++++++++------ .../handlers/DynamicCallsDumpHandler.kt | 64 ++++ .../generators/GenerateNewCompilerTests.kt | 4 + .../AbstractDiagnosticsTestWithJsStdLib.kt | 53 +++ .../jetbrains/kotlin/test/utils/FileUtils.kt | 6 + .../generators/tests/GenerateCompilerTests.kt | 4 - 27 files changed, 419 insertions(+), 167 deletions(-) rename compiler/{tests-gen/org/jetbrains/kotlin/checkers => tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners}/DiagnosticsTestWithJsStdLibGenerated.java (90%) create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/handlers/DynamicCallsDumpHandler.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractDiagnosticsTestWithJsStdLib.kt diff --git a/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/block.kt b/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/block.kt index 9ec98d4ede6..1801e2989ea 100644 --- a/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/block.kt +++ b/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/block.kt @@ -10,4 +10,4 @@ fun test() { fun dynamic(body: dynamic.() -> T): T { val topLevel = null return topLevel.body() -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/comparisonToNull.kt b/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/comparisonToNull.kt index 0cb555c90d2..71751565a1f 100644 --- a/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/comparisonToNull.kt +++ b/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/comparisonToNull.kt @@ -7,4 +7,4 @@ fun test(d: dynamic) { d["foo"] != null d.foo == null d.foo != null -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/destructuring.kt b/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/destructuring.kt index 523368b8592..2c283b169e8 100644 --- a/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/destructuring.kt +++ b/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/destructuring.kt @@ -19,4 +19,4 @@ class A { operator fun iterator(): Iterator = TODO("") } -fun bar(f: (dynamic) -> Unit): Unit = TODO("") \ No newline at end of file +fun bar(f: (dynamic) -> Unit): Unit = TODO("") diff --git a/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/implicitDynamicReceiver.kt b/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/implicitDynamicReceiver.kt index 0c82222d14b..b1701f648ed 100644 --- a/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/implicitDynamicReceiver.kt +++ b/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/implicitDynamicReceiver.kt @@ -15,4 +15,4 @@ fun dynamic.test() { v5.isDynamic() // to check that anything is resolvable foo = 1 -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/inExpression.kt b/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/inExpression.kt index 864c00b8ff5..f6dfe63925a 100644 --- a/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/inExpression.kt +++ b/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/inExpression.kt @@ -9,4 +9,4 @@ fun foo() { when (3) { !in a -> println("ok") } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/indexedAccess.kt b/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/indexedAccess.kt index 7aa077f205d..506a759936d 100644 --- a/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/indexedAccess.kt +++ b/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/indexedAccess.kt @@ -5,4 +5,4 @@ fun foo() { a[0] = 23 a[0, 1] = 42 -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/namedArguments.kt b/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/namedArguments.kt index c799a2084a0..31abe4c98b2 100644 --- a/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/namedArguments.kt +++ b/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/namedArguments.kt @@ -4,4 +4,4 @@ fun test(d: dynamic) { d.foo(1, name = "name") d.foo(1, duplicate = "", duplicate = "") -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/nullable.kt b/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/nullable.kt index b217529b22a..aeb7c4f56fe 100644 --- a/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/nullable.kt +++ b/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/nullable.kt @@ -13,4 +13,4 @@ fun foo(dn: dynamic?, d: dynamic, dnn: dynamic = TODO("not implemented") -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/spreadOperator.kt b/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/spreadOperator.kt index 14455c76030..2be0f9c449d 100644 --- a/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/spreadOperator.kt +++ b/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/spreadOperator.kt @@ -19,4 +19,4 @@ fun test(d: dynamic) { bar(*d, 23, *d) } -fun bar(vararg x: Int): Unit = TODO("$x") \ No newline at end of file +fun bar(vararg x: Int): Unit = TODO("$x") diff --git a/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/staticCallsInDynamicContext.kt b/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/staticCallsInDynamicContext.kt index 0aed9b1f66b..5a5e1a95a07 100644 --- a/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/staticCallsInDynamicContext.kt +++ b/compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/staticCallsInDynamicContext.kt @@ -71,4 +71,4 @@ class C { class WithInvoke { operator fun invoke() {} -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithJsStdLib/export/extendingNonExportedType.kt b/compiler/testData/diagnostics/testsWithJsStdLib/export/extendingNonExportedType.kt index 02c05ae0ad2..7a0064ca898 100644 --- a/compiler/testData/diagnostics/testsWithJsStdLib/export/extendingNonExportedType.kt +++ b/compiler/testData/diagnostics/testsWithJsStdLib/export/extendingNonExportedType.kt @@ -6,21 +6,21 @@ package foo open class NonExportedClass @JsExport -class ExportedClass : NonExportedClass() +class ExportedClass : NonExportedClass() interface NonExportedInterface @JsExport -class ExportedClass2 : NonExportedInterface +class ExportedClass2 : NonExportedInterface @JsExport open class ExportedGenericClass @JsExport -class ")!>ExportedClass3 : ExportedGenericClass() +class ")!>ExportedClass3 : ExportedGenericClass() @JsExport interface ExportedGenericInterface @JsExport -class ")!>ExportedClass4 : ExportedGenericInterface \ No newline at end of file +class ")!>ExportedClass4 : ExportedGenericInterface diff --git a/compiler/testData/diagnostics/testsWithJsStdLib/export/unexportableTypesInSignature.kt b/compiler/testData/diagnostics/testsWithJsStdLib/export/unexportableTypesInSignature.kt index 43040c58f74..1667a5eea3a 100644 --- a/compiler/testData/diagnostics/testsWithJsStdLib/export/unexportableTypesInSignature.kt +++ b/compiler/testData/diagnostics/testsWithJsStdLib/export/unexportableTypesInSignature.kt @@ -7,30 +7,30 @@ package foo class C @JsExport -fun foo(x: C) { +fun foo(x: C) { } -@JsExport +@JsExport fun bar() = C() -@JsExport +@JsExport val x: C = C() -@JsExport +@JsExport var x2: C get() = C() set(value) { } @JsExport class A( - val x: C, - y: C + val x: C, + y: C ) { - fun foo(x: C) = x + fun foo(x: C) = x - val x2: C = C() + val x2: C = C() - var x3: C + var x3: C get() = C() set(value) { } } @@ -40,7 +40,7 @@ fun foo2() { } @JsExport -fun foo3(x: Unit) { +fun foo3(x: Unit) { } @JsExport @@ -48,9 +48,9 @@ fun foo4(x: () -> Unit) { } @JsExport -fun foo5( Unit")!>x: (Unit) -> Unit) { +fun foo5( Unit")!>x: (Unit) -> Unit) { } @JsExport fun foo6(x: (A) -> A) { -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithJsStdLib/export/unexportableTypesInTypeParameters.kt b/compiler/testData/diagnostics/testsWithJsStdLib/export/unexportableTypesInTypeParameters.kt index 3c61dd81c6d..f6c80bbecab 100644 --- a/compiler/testData/diagnostics/testsWithJsStdLib/export/unexportableTypesInTypeParameters.kt +++ b/compiler/testData/diagnostics/testsWithJsStdLib/export/unexportableTypesInTypeParameters.kt @@ -8,10 +8,10 @@ abstract class C interface I @JsExport -fun <T : C>foo() { } +fun <T : C>foo() { } @JsExport -class A<T : C, S: I> +class A<T : C, S: I> @JsExport -interface I2<T> where T : C, T : I \ No newline at end of file +interface I2<T> where T : C, T : I diff --git a/compiler/testData/diagnostics/testsWithJsStdLib/localClassMetadata.txt b/compiler/testData/diagnostics/testsWithJsStdLib/localClassMetadata.txt index 05713b910b5..eeb8d79f136 100644 --- a/compiler/testData/diagnostics/testsWithJsStdLib/localClassMetadata.txt +++ b/compiler/testData/diagnostics/testsWithJsStdLib/localClassMetadata.txt @@ -35,8 +35,8 @@ public interface I { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - // -- Module:

-- package public fun test(): kotlin.Unit + diff --git a/compiler/testData/diagnostics/testsWithJsStdLib/module/dualModuleFromUmd.txt b/compiler/testData/diagnostics/testsWithJsStdLib/module/dualModuleFromUmd.txt index 055039202cb..85d6421e304 100644 --- a/compiler/testData/diagnostics/testsWithJsStdLib/module/dualModuleFromUmd.txt +++ b/compiler/testData/diagnostics/testsWithJsStdLib/module/dualModuleFromUmd.txt @@ -1,9 +1,6 @@ +// -- Module: -- package -package bar { - public fun box(): kotlin.Unit -} - package foo { @kotlin.js.JsModule(import = "A") public external object A { @@ -23,3 +20,11 @@ package foo { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } } + +// -- Module: -- +package + +package bar { + public fun box(): kotlin.Unit +} + diff --git a/compiler/testData/diagnostics/testsWithJsStdLib/module/wrongCallToModule.txt b/compiler/testData/diagnostics/testsWithJsStdLib/module/wrongCallToModule.txt index 134c1212b98..09f71f4e104 100644 --- a/compiler/testData/diagnostics/testsWithJsStdLib/module/wrongCallToModule.txt +++ b/compiler/testData/diagnostics/testsWithJsStdLib/module/wrongCallToModule.txt @@ -29,7 +29,6 @@ package foo { } } - // -- Module: -- package @@ -49,3 +48,4 @@ package bar { package foo { public external fun baz(): kotlin.Unit } + diff --git a/compiler/testData/diagnostics/testsWithJsStdLib/module/wrongCallToNonModule.txt b/compiler/testData/diagnostics/testsWithJsStdLib/module/wrongCallToNonModule.txt index 47320b9b0f3..b8c5d7e3ae1 100644 --- a/compiler/testData/diagnostics/testsWithJsStdLib/module/wrongCallToNonModule.txt +++ b/compiler/testData/diagnostics/testsWithJsStdLib/module/wrongCallToNonModule.txt @@ -1,18 +1,6 @@ +// -- Module: -- package -package bar { - public inline fun boo(/*0*/ x: T): kotlin.Unit - public fun box(): kotlin.Unit - - public final external class DerivedB : foo.B { - public constructor DerivedB() - public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - public final override /*1*/ /*fake_override*/ fun foo(): kotlin.Int - public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int - public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String - } -} - package foo { @kotlin.js.JsNonModule public external fun bar(): kotlin.Unit @@ -40,3 +28,20 @@ package foo { } } } + +// -- Module: -- +package + +package bar { + public inline fun boo(/*0*/ x: T): kotlin.Unit + public fun box(): kotlin.Unit + + public final external class DerivedB : foo.B { + public constructor DerivedB() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public final override /*1*/ /*fake_override*/ fun foo(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} + diff --git a/compiler/testData/diagnostics/testsWithJsStdLib/name/illegalName.kt b/compiler/testData/diagnostics/testsWithJsStdLib/name/illegalName.kt index d22f9aaa8d3..b6106c0fdab 100644 --- a/compiler/testData/diagnostics/testsWithJsStdLib/name/illegalName.kt +++ b/compiler/testData/diagnostics/testsWithJsStdLib/name/illegalName.kt @@ -22,4 +22,4 @@ val x: Int fun box(x: dynamic) { x.`foo-bar`() x.`ba-z` -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithJsStdLib/native/inlineExtensionToNative.kt b/compiler/testData/diagnostics/testsWithJsStdLib/native/inlineExtensionToNative.kt index 2a8be53e70f..fb4512bbb63 100644 --- a/compiler/testData/diagnostics/testsWithJsStdLib/native/inlineExtensionToNative.kt +++ b/compiler/testData/diagnostics/testsWithJsStdLib/native/inlineExtensionToNative.kt @@ -6,4 +6,4 @@ inline fun A.foo(x: Int): String = asDynamic().foo(x) inline operator fun A.get(x: Int): String = asDynamic()[x] -inline operator fun A.B.get(x: Int): String = asDynamic()[x] \ No newline at end of file +inline operator fun A.B.get(x: Int): String = asDynamic()[x] diff --git a/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsTestWithJsStdLibGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticsTestWithJsStdLibGenerated.java similarity index 90% rename from compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsTestWithJsStdLibGenerated.java rename to compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticsTestWithJsStdLibGenerated.java index c0b7f831644..1adc2e8c68c 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsTestWithJsStdLibGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticsTestWithJsStdLibGenerated.java @@ -3,14 +3,13 @@ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ -package org.jetbrains.kotlin.checkers; +package org.jetbrains.kotlin.test.runners; import com.intellij.testFramework.TestDataPath; -import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; -import org.jetbrains.kotlin.test.KotlinTestUtils; import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; import java.io.File; import java.util.regex.Pattern; @@ -19,1064 +18,1187 @@ import java.util.regex.Pattern; @SuppressWarnings("all") @TestMetadata("compiler/testData/diagnostics/testsWithJsStdLib") @TestDataPath("$PROJECT_ROOT") -@RunWith(JUnit3RunnerWithInners.class) public class DiagnosticsTestWithJsStdLibGenerated extends AbstractDiagnosticsTestWithJsStdLib { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + @Test public void testAllFilesPresentInTestsWithJsStdLib() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib"), Pattern.compile("^(.+)\\.kt$"), null, true); } + @Test @TestMetadata("funConstructorCallJS.kt") public void testFunConstructorCallJS() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/funConstructorCallJS.kt"); } + @Test @TestMetadata("implementingFunction.kt") public void testImplementingFunction() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/implementingFunction.kt"); } + @Test @TestMetadata("localClassMetadata.kt") public void testLocalClassMetadata() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/localClassMetadata.kt"); } + @Test @TestMetadata("noImpl.kt") public void testNoImpl() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/noImpl.kt"); } + @Test @TestMetadata("platformDependent.kt") public void testPlatformDependent() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/platformDependent.kt"); } + @Test @TestMetadata("runtimeAnnotations.kt") public void testRuntimeAnnotations() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/runtimeAnnotations.kt"); } + @Test @TestMetadata("unsafeCastFunctionOnDynamicType.kt") public void testUnsafeCastFunctionOnDynamicType() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/unsafeCastFunctionOnDynamicType.kt"); } + @Test @TestMetadata("wrongMultipleInheritance.kt") public void testWrongMultipleInheritance() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/wrongMultipleInheritance.kt"); } + @Nested @TestMetadata("compiler/testData/diagnostics/testsWithJsStdLib/classLiteral") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ClassLiteral extends AbstractDiagnosticsTestWithJsStdLib { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class ClassLiteral extends AbstractDiagnosticsTestWithJsStdLib { + @Test public void testAllFilesPresentInClassLiteral() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/classLiteral"), Pattern.compile("^(.+)\\.kt$"), null, true); } + @Test @TestMetadata("arrays_after.kt") public void testArrays_after() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/classLiteral/arrays_after.kt"); } + @Test @TestMetadata("arrays_before.kt") public void testArrays_before() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/classLiteral/arrays_before.kt"); } } + @Nested @TestMetadata("compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class DynamicTypes extends AbstractDiagnosticsTestWithJsStdLib { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class DynamicTypes extends AbstractDiagnosticsTestWithJsStdLib { + @Test public void testAllFilesPresentInDynamicTypes() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes"), Pattern.compile("^(.+)\\.kt$"), null, true); } + @Test @TestMetadata("allowedDynamicFunctionType.kt") public void testAllowedDynamicFunctionType() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/allowedDynamicFunctionType.kt"); } + @Test @TestMetadata("assignment.kt") public void testAssignment() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/assignment.kt"); } + @Test @TestMetadata("block.kt") public void testBlock() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/block.kt"); } + @Test @TestMetadata("callableReferences.kt") public void testCallableReferences() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/callableReferences.kt"); } + @Test @TestMetadata("capturedDynamic.kt") public void testCapturedDynamic() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/capturedDynamic.kt"); } + @Test @TestMetadata("capturedDynamicNI.kt") public void testCapturedDynamicNI() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/capturedDynamicNI.kt"); } + @Test @TestMetadata("classDelegateBy.kt") public void testClassDelegateBy() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/classDelegateBy.kt"); } + @Test @TestMetadata("comparisonToNull.kt") public void testComparisonToNull() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/comparisonToNull.kt"); } + @Test @TestMetadata("conditions.kt") public void testConditions() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/conditions.kt"); } + @Test @TestMetadata("conventions.kt") public void testConventions() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/conventions.kt"); } + @Test @TestMetadata("destructuring.kt") public void testDestructuring() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/destructuring.kt"); } + @Test @TestMetadata("dynamicCalls.kt") public void testDynamicCalls() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/dynamicCalls.kt"); } + @Test @TestMetadata("dynamicCallsWithLambdas.kt") public void testDynamicCallsWithLambdas() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/dynamicCallsWithLambdas.kt"); } + @Test @TestMetadata("dynamicCastTarget.kt") public void testDynamicCastTarget() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/dynamicCastTarget.kt"); } + @Test @TestMetadata("dynamicExtension.kt") public void testDynamicExtension() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/dynamicExtension.kt"); } + @Test @TestMetadata("dynamicSafeCalls.kt") public void testDynamicSafeCalls() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/dynamicSafeCalls.kt"); } + @Test @TestMetadata("dynamicVsGeneric.kt") public void testDynamicVsGeneric() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/dynamicVsGeneric.kt"); } + @Test @TestMetadata("extensionVals.kt") public void testExtensionVals() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/extensionVals.kt"); } + @Test @TestMetadata("extensionVars.kt") public void testExtensionVars() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/extensionVars.kt"); } + @Test @TestMetadata("extensions.kt") public void testExtensions() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/extensions.kt"); } + @Test @TestMetadata("extensionsToDynamic.kt") public void testExtensionsToDynamic() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/extensionsToDynamic.kt"); } + @Test @TestMetadata("implicitDynamicReceiver.kt") public void testImplicitDynamicReceiver() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/implicitDynamicReceiver.kt"); } + @Test @TestMetadata("inExpression.kt") public void testInExpression() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/inExpression.kt"); } + @Test @TestMetadata("indexedAccess.kt") public void testIndexedAccess() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/indexedAccess.kt"); } + @Test @TestMetadata("inference.kt") public void testInference() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/inference.kt"); } + @Test @TestMetadata("membersOfAny.kt") public void testMembersOfAny() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/membersOfAny.kt"); } + @Test @TestMetadata("namedArguments.kt") public void testNamedArguments() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/namedArguments.kt"); } + @Test @TestMetadata("noUnsupportedInLocals.kt") public void testNoUnsupportedInLocals() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/noUnsupportedInLocals.kt"); } + @Test @TestMetadata("nullable.kt") public void testNullable() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/nullable.kt"); } + @Test @TestMetadata("overloading.kt") public void testOverloading() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/overloading.kt"); } + @Test @TestMetadata("overloadingAmbiguity.kt") public void testOverloadingAmbiguity() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/overloadingAmbiguity.kt"); } + @Test @TestMetadata("overrides.kt") public void testOverrides() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/overrides.kt"); } + @Test @TestMetadata("propertyDelegateBy.kt") public void testPropertyDelegateBy() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/propertyDelegateBy.kt"); } + @Test @TestMetadata("protected.kt") public void testProtected() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/protected.kt"); } + @Test @TestMetadata("rangeExpression.kt") public void testRangeExpression() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/rangeExpression.kt"); } + @Test @TestMetadata("reified.kt") public void testReified() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/reified.kt"); } + @Test @TestMetadata("smartCast.kt") public void testSmartCast() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/smartCast.kt"); } + @Test @TestMetadata("spreadOperator.kt") public void testSpreadOperator() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/spreadOperator.kt"); } + @Test @TestMetadata("staticCallsInDynamicContext.kt") public void testStaticCallsInDynamicContext() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/staticCallsInDynamicContext.kt"); } + @Test @TestMetadata("staticExtensions.kt") public void testStaticExtensions() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/staticExtensions.kt"); } + @Test @TestMetadata("substitution.kt") public void testSubstitution() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/substitution.kt"); } + @Test @TestMetadata("supertypesAndBounds.kt") public void testSupertypesAndBounds() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/supertypesAndBounds.kt"); } + @Test @TestMetadata("typealiasExpandingToDynamic.kt") public void testTypealiasExpandingToDynamic() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/typealiasExpandingToDynamic.kt"); } + @Test @TestMetadata("typealiasWithAnnotatedDynamic.kt") public void testTypealiasWithAnnotatedDynamic() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/typealiasWithAnnotatedDynamic.kt"); } + @Test @TestMetadata("typealiasWithDynamic.kt") public void testTypealiasWithDynamic() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/typealiasWithDynamic.kt"); } + @Test @TestMetadata("varargs.kt") public void testVarargs() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/dynamicTypes/varargs.kt"); } } + @Nested @TestMetadata("compiler/testData/diagnostics/testsWithJsStdLib/export") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Export extends AbstractDiagnosticsTestWithJsStdLib { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class Export extends AbstractDiagnosticsTestWithJsStdLib { + @Test public void testAllFilesPresentInExport() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/export"), Pattern.compile("^(.+)\\.kt$"), null, true); } + @Test @TestMetadata("extendingNonExportedType.kt") public void testExtendingNonExportedType() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/export/extendingNonExportedType.kt"); } + @Test @TestMetadata("jsExportOnNestedDeclarations.kt") public void testJsExportOnNestedDeclarations() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/export/jsExportOnNestedDeclarations.kt"); } + @Test @TestMetadata("secondaryConstructorWithoutJsName.kt") public void testSecondaryConstructorWithoutJsName() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/export/secondaryConstructorWithoutJsName.kt"); } + @Test @TestMetadata("unexportableTypesInSignature.kt") public void testUnexportableTypesInSignature() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/export/unexportableTypesInSignature.kt"); } + @Test @TestMetadata("unexportableTypesInTypeParameters.kt") public void testUnexportableTypesInTypeParameters() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/export/unexportableTypesInTypeParameters.kt"); } + @Test @TestMetadata("wrongExportedDeclaration.kt") public void testWrongExportedDeclaration() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/export/wrongExportedDeclaration.kt"); } + @Test @TestMetadata("wrongExportedDeclarationInExportedFile.kt") public void testWrongExportedDeclarationInExportedFile() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/export/wrongExportedDeclarationInExportedFile.kt"); } } + @Nested @TestMetadata("compiler/testData/diagnostics/testsWithJsStdLib/inline") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Inline extends AbstractDiagnosticsTestWithJsStdLib { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class Inline extends AbstractDiagnosticsTestWithJsStdLib { + @Test public void testAllFilesPresentInInline() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/inline"), Pattern.compile("^(.+)\\.kt$"), null, true); } + @Test @TestMetadata("Reified.kt") public void testReified() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/inline/Reified.kt"); } } + @Nested @TestMetadata("compiler/testData/diagnostics/testsWithJsStdLib/jsCode") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class JsCode extends AbstractDiagnosticsTestWithJsStdLib { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class JsCode extends AbstractDiagnosticsTestWithJsStdLib { + @Test public void testAllFilesPresentInJsCode() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/jsCode"), Pattern.compile("^(.+)\\.kt$"), null, true); } + @Test @TestMetadata("argumentIsLiteral.kt") public void testArgumentIsLiteral() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/jsCode/argumentIsLiteral.kt"); } + @Test @TestMetadata("badAssignment.kt") public void testBadAssignment() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/jsCode/badAssignment.kt"); } + @Test @TestMetadata("deleteOperation.kt") public void testDeleteOperation() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/jsCode/deleteOperation.kt"); } + @Test @TestMetadata("error.kt") public void testError() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/jsCode/error.kt"); } + @Test @TestMetadata("noJavaScriptProduced.kt") public void testNoJavaScriptProduced() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/jsCode/noJavaScriptProduced.kt"); } + @Test @TestMetadata("warning.kt") public void testWarning() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/jsCode/warning.kt"); } } + @Nested @TestMetadata("compiler/testData/diagnostics/testsWithJsStdLib/jvmDeclarations") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class JvmDeclarations extends AbstractDiagnosticsTestWithJsStdLib { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class JvmDeclarations extends AbstractDiagnosticsTestWithJsStdLib { + @Test public void testAllFilesPresentInJvmDeclarations() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/jvmDeclarations"), Pattern.compile("^(.+)\\.kt$"), null, true); } + @Test @TestMetadata("cloneable.kt") public void testCloneable() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/jvmDeclarations/cloneable.kt"); } } + @Nested @TestMetadata("compiler/testData/diagnostics/testsWithJsStdLib/module") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Module extends AbstractDiagnosticsTestWithJsStdLib { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class Module extends AbstractDiagnosticsTestWithJsStdLib { + @Test public void testAllFilesPresentInModule() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/module"), Pattern.compile("^(.+)\\.kt$"), null, true); } + @Test @TestMetadata("dualModuleFromUmd.kt") public void testDualModuleFromUmd() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/module/dualModuleFromUmd.kt"); } + @Test @TestMetadata("incompleteReifiedArg.kt") public void testIncompleteReifiedArg() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/module/incompleteReifiedArg.kt"); } + @Test @TestMetadata("jsModuleNonExternal.kt") public void testJsModuleNonExternal() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/module/jsModuleNonExternal.kt"); } + @Test @TestMetadata("jsModuleWithoutParameters.kt") public void testJsModuleWithoutParameters() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/module/jsModuleWithoutParameters.kt"); } + @Test @TestMetadata("jsVarProhibited.kt") public void testJsVarProhibited() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/module/jsVarProhibited.kt"); } + @Test @TestMetadata("nestedProhibited.kt") public void testNestedProhibited() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/module/nestedProhibited.kt"); } + @Test @TestMetadata("prohibitedOnNonNative.kt") public void testProhibitedOnNonNative() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/module/prohibitedOnNonNative.kt"); } + @Test @TestMetadata("wrongCallToModule.kt") public void testWrongCallToModule() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/module/wrongCallToModule.kt"); } + @Test @TestMetadata("wrongCallToNonModule.kt") public void testWrongCallToNonModule() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/module/wrongCallToNonModule.kt"); } } + @Nested @TestMetadata("compiler/testData/diagnostics/testsWithJsStdLib/name") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Name extends AbstractDiagnosticsTestWithJsStdLib { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class Name extends AbstractDiagnosticsTestWithJsStdLib { + @Test public void testAllFilesPresentInName() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/name"), Pattern.compile("^(.+)\\.kt$"), null, true); } + @Test @TestMetadata("bridgeClash.kt") public void testBridgeClash() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/name/bridgeClash.kt"); } + @Test @TestMetadata("builtinClash.kt") public void testBuiltinClash() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/name/builtinClash.kt"); } + @Test @TestMetadata("classAndFunction.kt") public void testClassAndFunction() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/name/classAndFunction.kt"); } + @Test @TestMetadata("classAndTypealias.kt") public void testClassAndTypealias() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/name/classAndTypealias.kt"); } + @Test @TestMetadata("classLevelMethodAndProperty.kt") public void testClassLevelMethodAndProperty() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/name/classLevelMethodAndProperty.kt"); } + @Test @TestMetadata("conflictingNamesFromSuperclass.kt") public void testConflictingNamesFromSuperclass() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/name/conflictingNamesFromSuperclass.kt"); } + @Test @TestMetadata("declarationClash.kt") public void testDeclarationClash() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/name/declarationClash.kt"); } + @Test @TestMetadata("extensionPropertyAndMethod.kt") public void testExtensionPropertyAndMethod() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/name/extensionPropertyAndMethod.kt"); } + @Test @TestMetadata("illegalName.kt") public void testIllegalName() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/name/illegalName.kt"); } + @Test @TestMetadata("illegalPackageName.kt") public void testIllegalPackageName() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/name/illegalPackageName.kt"); } + @Test @TestMetadata("jsNameAndOverridden.kt") public void testJsNameAndOverridden() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/name/jsNameAndOverridden.kt"); } + @Test @TestMetadata("jsNameClash.kt") public void testJsNameClash() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/name/jsNameClash.kt"); } + @Test @TestMetadata("jsNameClashWithDefault.kt") public void testJsNameClashWithDefault() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/name/jsNameClashWithDefault.kt"); } + @Test @TestMetadata("jsNameMissingOnAccessors.kt") public void testJsNameMissingOnAccessors() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/name/jsNameMissingOnAccessors.kt"); } + @Test @TestMetadata("jsNameOnAccessors.kt") public void testJsNameOnAccessors() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/name/jsNameOnAccessors.kt"); } + @Test @TestMetadata("jsNameOnOverride.kt") public void testJsNameOnOverride() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/name/jsNameOnOverride.kt"); } + @Test @TestMetadata("jsNameOnPropertyAndAccessor.kt") public void testJsNameOnPropertyAndAccessor() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/name/jsNameOnPropertyAndAccessor.kt"); } + @Test @TestMetadata("jsNamePrihibitedOnPrimaryConstructor.kt") public void testJsNamePrihibitedOnPrimaryConstructor() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/name/jsNamePrihibitedOnPrimaryConstructor.kt"); } + @Test @TestMetadata("jsNameProhibitedOnExtensionProperty.kt") public void testJsNameProhibitedOnExtensionProperty() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/name/jsNameProhibitedOnExtensionProperty.kt"); } + @Test @TestMetadata("jsNameUseTargetOnProperty.kt") public void testJsNameUseTargetOnProperty() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/name/jsNameUseTargetOnProperty.kt"); } + @Test @TestMetadata("jsNameWithoutParameter.kt") public void testJsNameWithoutParameter() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/name/jsNameWithoutParameter.kt"); } + @Test @TestMetadata("methodAndMethod.kt") public void testMethodAndMethod() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/name/methodAndMethod.kt"); } + @Test @TestMetadata("nameSwapInOverride.kt") public void testNameSwapInOverride() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/name/nameSwapInOverride.kt"); } + @Test @TestMetadata("overrideOverloadedNativeFunction.kt") public void testOverrideOverloadedNativeFunction() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/name/overrideOverloadedNativeFunction.kt"); } + @Test @TestMetadata("packageAndMethod.kt") public void testPackageAndMethod() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/name/packageAndMethod.kt"); } + @Test @TestMetadata("packageAndProperty.kt") public void testPackageAndProperty() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/name/packageAndProperty.kt"); } + @Test @TestMetadata("privateJsNameClash.kt") public void testPrivateJsNameClash() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/name/privateJsNameClash.kt"); } + @Test @TestMetadata("propertyAndMethodInImplementor.kt") public void testPropertyAndMethodInImplementor() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/name/propertyAndMethodInImplementor.kt"); } + @Test @TestMetadata("propertyAndMethodInSubclass.kt") public void testPropertyAndMethodInSubclass() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/name/propertyAndMethodInSubclass.kt"); } + @Test @TestMetadata("topLevelMethodAndJsNameConstructor.kt") public void testTopLevelMethodAndJsNameConstructor() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/name/topLevelMethodAndJsNameConstructor.kt"); } + @Test @TestMetadata("topLevelMethodAndProperty.kt") public void testTopLevelMethodAndProperty() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/name/topLevelMethodAndProperty.kt"); } } + @Nested @TestMetadata("compiler/testData/diagnostics/testsWithJsStdLib/native") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Native extends AbstractDiagnosticsTestWithJsStdLib { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class Native extends AbstractDiagnosticsTestWithJsStdLib { + @Test public void testAllFilesPresentInNative() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/native"), Pattern.compile("^(.+)\\.kt$"), null, true); } + @Test @TestMetadata("anonymousInitializer.kt") public void testAnonymousInitializer() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/anonymousInitializer.kt"); } + @Test @TestMetadata("body.kt") public void testBody() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/body.kt"); } + @Test @TestMetadata("delegatedConstructorCall.kt") public void testDelegatedConstructorCall() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/delegatedConstructorCall.kt"); } + @Test @TestMetadata("delegation.kt") public void testDelegation() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/delegation.kt"); } + @Test @TestMetadata("enumEntry.kt") public void testEnumEntry() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/enumEntry.kt"); } + @Test @TestMetadata("extensionFunctionAndProperty.kt") public void testExtensionFunctionAndProperty() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/extensionFunctionAndProperty.kt"); } + @Test @TestMetadata("extensionFunctionArgumentOrReturnType.kt") public void testExtensionFunctionArgumentOrReturnType() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/extensionFunctionArgumentOrReturnType.kt"); } + @Test @TestMetadata("externalFunInterface.kt") public void testExternalFunInterface() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/externalFunInterface.kt"); } + @Test @TestMetadata("externalInterfaceNested.kt") public void testExternalInterfaceNested() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/externalInterfaceNested.kt"); } + @Test @TestMetadata("inheritance.kt") public void testInheritance() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/inheritance.kt"); } + @Test @TestMetadata("inline.kt") public void testInline() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/inline.kt"); } + @Test @TestMetadata("inlineClass.kt") public void testInlineClass() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/inlineClass.kt"); } + @Test @TestMetadata("inlineClassAsParameterOrReturnType.kt.kt") public void testInlineClassAsParameterOrReturnType_kt() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/inlineClassAsParameterOrReturnType.kt.kt"); } + @Test @TestMetadata("inlineExtensionToNative.kt") public void testInlineExtensionToNative() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/inlineExtensionToNative.kt"); } + @Test @TestMetadata("innerClass.kt") public void testInnerClass() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/innerClass.kt"); } + @Test @TestMetadata("nested.kt") public void testNested() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/nested.kt"); } + @Test @TestMetadata("nonAbstractMembersOfInterface.kt") public void testNonAbstractMembersOfInterface() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/nonAbstractMembersOfInterface.kt"); } + @Test @TestMetadata("overrideOptionalParam.kt") public void testOverrideOptionalParam() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/overrideOptionalParam.kt"); } + @Test @TestMetadata("privateMembers.kt") public void testPrivateMembers() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/privateMembers.kt"); } + @Test @TestMetadata("propertyParameter.kt") public void testPropertyParameter() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/propertyParameter.kt"); } + @Test @TestMetadata("wrongTarget.kt") public void testWrongTarget() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/wrongTarget.kt"); } + @Nested @TestMetadata("compiler/testData/diagnostics/testsWithJsStdLib/native/nativeGetter") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class NativeGetter extends AbstractDiagnosticsTestWithJsStdLib { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class NativeGetter extends AbstractDiagnosticsTestWithJsStdLib { + @Test public void testAllFilesPresentInNativeGetter() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/native/nativeGetter"), Pattern.compile("^(.+)\\.kt$"), null, true); } + @Test @TestMetadata("onLocalExtensionFun.kt") public void testOnLocalExtensionFun() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/nativeGetter/onLocalExtensionFun.kt"); } + @Test @TestMetadata("onLocalNonNativeClassMembers.kt") public void testOnLocalNonNativeClassMembers() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/nativeGetter/onLocalNonNativeClassMembers.kt"); } + @Test @TestMetadata("onLocalOtherDeclarations.kt") public void testOnLocalOtherDeclarations() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/nativeGetter/onLocalOtherDeclarations.kt"); } + @Test @TestMetadata("onNativeClassMembers.kt") public void testOnNativeClassMembers() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/nativeGetter/onNativeClassMembers.kt"); } + @Test @TestMetadata("onNestedDeclarationsInsideNativeClass.kt") public void testOnNestedDeclarationsInsideNativeClass() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/nativeGetter/onNestedDeclarationsInsideNativeClass.kt"); } + @Test @TestMetadata("onNestedDeclarationsInsideNonNativeClass.kt") public void testOnNestedDeclarationsInsideNonNativeClass() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/nativeGetter/onNestedDeclarationsInsideNonNativeClass.kt"); } + @Test @TestMetadata("onNonNativeClassMembers.kt") public void testOnNonNativeClassMembers() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/nativeGetter/onNonNativeClassMembers.kt"); } + @Test @TestMetadata("onToplevelExtensionFun.kt") public void testOnToplevelExtensionFun() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/nativeGetter/onToplevelExtensionFun.kt"); } + @Test @TestMetadata("onToplevelOtherDeclarations.kt") public void testOnToplevelOtherDeclarations() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/nativeGetter/onToplevelOtherDeclarations.kt"); } } + @Nested @TestMetadata("compiler/testData/diagnostics/testsWithJsStdLib/native/nativeInvoke") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class NativeInvoke extends AbstractDiagnosticsTestWithJsStdLib { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class NativeInvoke extends AbstractDiagnosticsTestWithJsStdLib { + @Test public void testAllFilesPresentInNativeInvoke() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/native/nativeInvoke"), Pattern.compile("^(.+)\\.kt$"), null, true); } + @Test @TestMetadata("onLocalExtensionFun.kt") public void testOnLocalExtensionFun() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/nativeInvoke/onLocalExtensionFun.kt"); } + @Test @TestMetadata("onLocalNonNativeClassMembers.kt") public void testOnLocalNonNativeClassMembers() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/nativeInvoke/onLocalNonNativeClassMembers.kt"); } + @Test @TestMetadata("onLocalOtherDeclarations.kt") public void testOnLocalOtherDeclarations() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/nativeInvoke/onLocalOtherDeclarations.kt"); } + @Test @TestMetadata("onNativeClassMembers.kt") public void testOnNativeClassMembers() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/nativeInvoke/onNativeClassMembers.kt"); } + @Test @TestMetadata("onNestedDeclarationsInsideNativeClass.kt") public void testOnNestedDeclarationsInsideNativeClass() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/nativeInvoke/onNestedDeclarationsInsideNativeClass.kt"); } + @Test @TestMetadata("onNestedDeclarationsInsideNonNativeClass.kt") public void testOnNestedDeclarationsInsideNonNativeClass() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/nativeInvoke/onNestedDeclarationsInsideNonNativeClass.kt"); } + @Test @TestMetadata("onNonNativeClassMembers.kt") public void testOnNonNativeClassMembers() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/nativeInvoke/onNonNativeClassMembers.kt"); } + @Test @TestMetadata("onToplevelExtensionFun.kt") public void testOnToplevelExtensionFun() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/nativeInvoke/onToplevelExtensionFun.kt"); } + @Test @TestMetadata("onToplevelOtherDeclarations.kt") public void testOnToplevelOtherDeclarations() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/nativeInvoke/onToplevelOtherDeclarations.kt"); } } + @Nested @TestMetadata("compiler/testData/diagnostics/testsWithJsStdLib/native/nativeSetter") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class NativeSetter extends AbstractDiagnosticsTestWithJsStdLib { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class NativeSetter extends AbstractDiagnosticsTestWithJsStdLib { + @Test public void testAllFilesPresentInNativeSetter() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/native/nativeSetter"), Pattern.compile("^(.+)\\.kt$"), null, true); } + @Test @TestMetadata("onLocalExtensionFun.kt") public void testOnLocalExtensionFun() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/nativeSetter/onLocalExtensionFun.kt"); } + @Test @TestMetadata("onLocalNonNativeClassMembers.kt") public void testOnLocalNonNativeClassMembers() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/nativeSetter/onLocalNonNativeClassMembers.kt"); } + @Test @TestMetadata("onLocalOtherDeclarations.kt") public void testOnLocalOtherDeclarations() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/nativeSetter/onLocalOtherDeclarations.kt"); } + @Test @TestMetadata("onNativeClassMembers.kt") public void testOnNativeClassMembers() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/nativeSetter/onNativeClassMembers.kt"); } + @Test @TestMetadata("onNestedDeclarationsInsideNativeClass.kt") public void testOnNestedDeclarationsInsideNativeClass() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/nativeSetter/onNestedDeclarationsInsideNativeClass.kt"); } + @Test @TestMetadata("onNestedDeclarationsInsideNonNativeClass.kt") public void testOnNestedDeclarationsInsideNonNativeClass() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/nativeSetter/onNestedDeclarationsInsideNonNativeClass.kt"); } + @Test @TestMetadata("onNonNativeClassMembers.kt") public void testOnNonNativeClassMembers() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/nativeSetter/onNonNativeClassMembers.kt"); } + @Test @TestMetadata("onToplevelExtensionFun.kt") public void testOnToplevelExtensionFun() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/nativeSetter/onToplevelExtensionFun.kt"); } + @Test @TestMetadata("onToplevelOtherDeclarations.kt") public void testOnToplevelOtherDeclarations() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/nativeSetter/onToplevelOtherDeclarations.kt"); } } + @Nested @TestMetadata("compiler/testData/diagnostics/testsWithJsStdLib/native/optionlBody") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class OptionlBody extends AbstractDiagnosticsTestWithJsStdLib { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class OptionlBody extends AbstractDiagnosticsTestWithJsStdLib { + @Test public void testAllFilesPresentInOptionlBody() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/native/optionlBody"), Pattern.compile("^(.+)\\.kt$"), null, true); } + @Test @TestMetadata("native.kt") public void testNative() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/optionlBody/native.kt"); } + @Test @TestMetadata("nativeGetter.kt") public void testNativeGetter() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/optionlBody/nativeGetter.kt"); } + @Test @TestMetadata("nativeInvoke.kt") public void testNativeInvoke() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/optionlBody/nativeInvoke.kt"); } + @Test @TestMetadata("nativeSetter.kt") public void testNativeSetter() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/optionlBody/nativeSetter.kt"); } } + @Nested @TestMetadata("compiler/testData/diagnostics/testsWithJsStdLib/native/rtti") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Rtti extends AbstractDiagnosticsTestWithJsStdLib { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class Rtti extends AbstractDiagnosticsTestWithJsStdLib { + @Test public void testAllFilesPresentInRtti() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/native/rtti"), Pattern.compile("^(.+)\\.kt$"), null, true); } + @Test @TestMetadata("castToNativeInterface.kt") public void testCastToNativeInterface() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/rtti/castToNativeInterface.kt"); } + @Test @TestMetadata("checkForNativeInterface.kt") public void testCheckForNativeInterface() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/rtti/checkForNativeInterface.kt"); } + @Test @TestMetadata("nativeInterfaceAsReifiedTypeArgument.kt") public void testNativeInterfaceAsReifiedTypeArgument() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/rtti/nativeInterfaceAsReifiedTypeArgument.kt"); } + @Test @TestMetadata("nativeInterfaceClassLiteral.kt") public void testNativeInterfaceClassLiteral() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/rtti/nativeInterfaceClassLiteral.kt"); } + @Test @TestMetadata("whenIsNativeInterface.kt") public void testWhenIsNativeInterface() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/rtti/whenIsNativeInterface.kt"); } } + @Nested @TestMetadata("compiler/testData/diagnostics/testsWithJsStdLib/native/unusedParam") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class UnusedParam extends AbstractDiagnosticsTestWithJsStdLib { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class UnusedParam extends AbstractDiagnosticsTestWithJsStdLib { + @Test public void testAllFilesPresentInUnusedParam() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/native/unusedParam"), Pattern.compile("^(.+)\\.kt$"), null, true); } + @Test @TestMetadata("native.kt") public void testNative() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/unusedParam/native.kt"); } + @Test @TestMetadata("nativeGetter.kt") public void testNativeGetter() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/unusedParam/nativeGetter.kt"); } + @Test @TestMetadata("nativeInvoke.kt") public void testNativeInvoke() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/unusedParam/nativeInvoke.kt"); } + @Test @TestMetadata("nativeSetter.kt") public void testNativeSetter() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/native/unusedParam/nativeSetter.kt"); @@ -1084,41 +1206,38 @@ public class DiagnosticsTestWithJsStdLibGenerated extends AbstractDiagnosticsTes } } + @Nested @TestMetadata("compiler/testData/diagnostics/testsWithJsStdLib/qualifier") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Qualifier extends AbstractDiagnosticsTestWithJsStdLib { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class Qualifier extends AbstractDiagnosticsTestWithJsStdLib { + @Test public void testAllFilesPresentInQualifier() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/qualifier"), Pattern.compile("^(.+)\\.kt$"), null, true); } + @Test @TestMetadata("jsQualifierNonExternal.kt") public void testJsQualifierNonExternal() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/qualifier/jsQualifierNonExternal.kt"); } + @Test @TestMetadata("wrongQualifier.kt") public void testWrongQualifier() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/qualifier/wrongQualifier.kt"); } } + @Nested @TestMetadata("compiler/testData/diagnostics/testsWithJsStdLib/reflection") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Reflection extends AbstractDiagnosticsTestWithJsStdLib { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class Reflection extends AbstractDiagnosticsTestWithJsStdLib { + @Test public void testAllFilesPresentInReflection() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJsStdLib/reflection"), Pattern.compile("^(.+)\\.kt$"), null, true); } + @Test @TestMetadata("reflectionApi.kt") public void testReflectionApi() throws Exception { runTest("compiler/testData/diagnostics/testsWithJsStdLib/reflection/reflectionApi.kt"); diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/handlers/DynamicCallsDumpHandler.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/handlers/DynamicCallsDumpHandler.kt new file mode 100644 index 00000000000..5450174adb1 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/handlers/DynamicCallsDumpHandler.kt @@ -0,0 +1,64 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.frontend.classic.handlers + +import org.jetbrains.kotlin.checkers.CheckerDebugInfoReporter +import org.jetbrains.kotlin.checkers.utils.DebugInfoUtil +import org.jetbrains.kotlin.config.LanguageFeature +import org.jetbrains.kotlin.descriptors.DeclarationDescriptor +import org.jetbrains.kotlin.test.directives.DiagnosticsDirectives +import org.jetbrains.kotlin.test.directives.model.DirectivesContainer +import org.jetbrains.kotlin.test.frontend.classic.ClassicFrontendOutputArtifact +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.TestServices +import org.jetbrains.kotlin.test.services.moduleStructure +import org.jetbrains.kotlin.test.util.RecursiveDescriptorComparator +import org.jetbrains.kotlin.test.util.RecursiveDescriptorComparator.RECURSIVE_ALL +import org.jetbrains.kotlin.test.utils.MultiModuleInfoDumper +import org.jetbrains.kotlin.test.utils.MultiModuleInfoDumperImpl +import org.jetbrains.kotlin.test.utils.withExtension + +class DynamicCallsDumpHandler(testServices: TestServices) : ClassicFrontendAnalysisHandler(testServices) { + companion object { + private const val DYNAMIC_PREFIX = ".dynamic.txt" + } + + override val directivesContainers: List + get() = listOf(DiagnosticsDirectives) + + private val dumper: MultiModuleInfoDumper = MultiModuleInfoDumperImpl(moduleHeaderTemplate = "// -- Module: <%s> --") + + override fun processModule(module: TestModule, info: ClassicFrontendOutputArtifact) { + val dynamicCallDescriptors = mutableListOf() + for (ktFile in info.ktFiles.values) { + DebugInfoUtil.markDebugAnnotations( + ktFile, + info.analysisResult.bindingContext, + CheckerDebugInfoReporter( + dynamicCallDescriptors, + markDynamicCalls = true, + debugAnnotations = mutableListOf(), + withNewInference = info.languageVersionSettings.supportsFeature(LanguageFeature.NewInference), + platform = null + ) + ) + } + val serializer = RecursiveDescriptorComparator(RECURSIVE_ALL) + val builder = dumper.builderForModule(module) + for (descriptor in dynamicCallDescriptors) { + builder.append(serializer.serializeRecursively(descriptor)) + } + } + + override fun processAfterAllModules(someAssertionWasFailed: Boolean) { + if (dumper.isEmpty()) return + val expectedFile = testServices.moduleStructure.originalTestDataFiles.first().withExtension(DYNAMIC_PREFIX) + if (expectedFile.exists()) { + val resultDump = dumper.generateResultingDump() + assertions.assertEqualsToFile(expectedFile, resultDump) + } + } +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/generators/GenerateNewCompilerTests.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/generators/GenerateNewCompilerTests.kt index b6c7372d5a3..6b2106958a1 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/generators/GenerateNewCompilerTests.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/generators/GenerateNewCompilerTests.kt @@ -26,6 +26,10 @@ fun main(args: Array) { model("diagnostics/tests", excludedPattern = excludedFirTestdataPattern) model("diagnostics/testsWithStdLib", excludedPattern = excludedFirTestdataPattern) } + + testClass { + model("diagnostics/testsWithJsStdLib") + } } testGroup("compiler/tests-common-new/tests-gen", "compiler/fir/analysis-tests/testData") { diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractDiagnosticsTestWithJsStdLib.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractDiagnosticsTestWithJsStdLib.kt new file mode 100644 index 00000000000..54f38b3542b --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractDiagnosticsTestWithJsStdLib.kt @@ -0,0 +1,53 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.runners + +import org.jetbrains.kotlin.platform.js.JsPlatforms +import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder +import org.jetbrains.kotlin.test.directives.JvmEnvironmentConfigurationDirectives +import org.jetbrains.kotlin.test.frontend.classic.ClassicFrontendFacade +import org.jetbrains.kotlin.test.frontend.classic.handlers.ClassicDiagnosticsHandler +import org.jetbrains.kotlin.test.frontend.classic.handlers.DeclarationsDumpHandler +import org.jetbrains.kotlin.test.frontend.classic.handlers.DynamicCallsDumpHandler +import org.jetbrains.kotlin.test.frontend.classic.handlers.OldNewInferenceMetaInfoProcessor +import org.jetbrains.kotlin.test.model.BackendKind +import org.jetbrains.kotlin.test.model.DependencyKind +import org.jetbrains.kotlin.test.model.FrontendKinds +import org.jetbrains.kotlin.test.services.AdditionalDiagnosticsSourceFilesProvider +import org.jetbrains.kotlin.test.services.CoroutineHelpersSourceFilesProvider +import org.jetbrains.kotlin.test.services.configuration.JsEnvironmentConfigurator + +abstract class AbstractDiagnosticsTestWithJsStdLib : AbstractKotlinCompilerTest() { + override fun TestConfigurationBuilder.configuration() { + globalDefaults { + frontend = FrontendKinds.ClassicFrontend + backend = BackendKind.NoBackend + targetPlatform = JsPlatforms.defaultJsPlatform + dependencyKind = DependencyKind.Source + } + + defaultDirectives { + +JvmEnvironmentConfigurationDirectives.USE_PSI_CLASS_FILES_READING + } + + enableMetaInfoHandler() + + useConfigurators(::JsEnvironmentConfigurator,) + + useMetaInfoProcessors(::OldNewInferenceMetaInfoProcessor) + useAdditionalSourceProviders( + ::AdditionalDiagnosticsSourceFilesProvider, + ::CoroutineHelpersSourceFilesProvider, + ) + + useFrontendFacades(::ClassicFrontendFacade) + useFrontendHandlers( + ::DeclarationsDumpHandler, + ::ClassicDiagnosticsHandler, + ::DynamicCallsDumpHandler, + ) + } +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/utils/FileUtils.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/utils/FileUtils.kt index 89e1a6442b2..3a881490d4e 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/utils/FileUtils.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/utils/FileUtils.kt @@ -26,3 +26,9 @@ val File.firTestDataFile: File } else { parentFile.resolve("${name.removeSuffix(KT)}$FIR_KT") } + +fun File.withExtension(extension: String): File { + @Suppress("NAME_SHADOWING") + val extension = extension.removePrefix(".") + return parentFile.resolve("$nameWithoutExtension.$extension") +} diff --git a/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt b/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt index 054895e8556..3e5577872e0 100644 --- a/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt +++ b/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt @@ -67,10 +67,6 @@ fun main(args: Array) { generateTestGroupSuite(args) { testGroup("compiler/tests-gen", "compiler/testData") { - testClass { - model("diagnostics/testsWithJsStdLib") - } - testClass { model("diagnostics/testsWithJsStdLibAndBackendCompilation") } From e7f8486078497daf67d9c7d78c1a80b85838f536 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Mon, 14 Dec 2020 17:33:53 +0300 Subject: [PATCH 116/196] [TEST] Migrate AbstractDiagnosticsTestWithJvmBackend to new test runners --- ...gnosticsTestWithJvmIrBackendGenerated.java | 201 +++++++++++------- ...nosticsTestWithOldJvmBackendGenerated.java | 199 ++++++++++------- .../handlers/JvmBackendDiagnosticsHandler.kt | 35 +++ .../test/directives/DiagnosticsDirectives.kt | 9 + .../handlers/ClassicDiagnosticReporter.kt | 150 +++++++++++++ .../handlers/ClassicDiagnosticsHandler.kt | 140 +----------- .../generators/GenerateNewCompilerTests.kt | 9 + .../test/runners/AbstractDiagnosticTest.kt | 3 + .../AbstractDiagnosticsTestWithJvmBackend.kt | 84 ++++++++ .../AbstractDiagnosticsTestWithJvmBackend.kt | 53 ----- .../generators/tests/GenerateCompilerTests.kt | 8 - 11 files changed, 546 insertions(+), 345 deletions(-) rename compiler/{tests-gen/org/jetbrains/kotlin/checkers => tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners}/DiagnosticsTestWithJvmIrBackendGenerated.java (88%) rename compiler/{tests-gen/org/jetbrains/kotlin/checkers => tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners}/DiagnosticsTestWithOldJvmBackendGenerated.java (88%) create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/JvmBackendDiagnosticsHandler.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/handlers/ClassicDiagnosticReporter.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractDiagnosticsTestWithJvmBackend.kt delete mode 100644 compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractDiagnosticsTestWithJvmBackend.kt diff --git a/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsTestWithJvmIrBackendGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticsTestWithJvmIrBackendGenerated.java similarity index 88% rename from compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsTestWithJvmIrBackendGenerated.java rename to compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticsTestWithJvmIrBackendGenerated.java index e830e031ba1..34721d6790f 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsTestWithJvmIrBackendGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticsTestWithJvmIrBackendGenerated.java @@ -3,581 +3,631 @@ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ -package org.jetbrains.kotlin.checkers; +package org.jetbrains.kotlin.test.runners; import com.intellij.testFramework.TestDataPath; -import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; -import org.jetbrains.kotlin.test.KotlinTestUtils; import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; import java.io.File; import java.util.regex.Pattern; -/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */ +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ @SuppressWarnings("all") @TestMetadata("compiler/testData/diagnostics/testsWithJvmBackend") @TestDataPath("$PROJECT_ROOT") -@RunWith(JUnit3RunnerWithInners.class) public class DiagnosticsTestWithJvmIrBackendGenerated extends AbstractDiagnosticsTestWithJvmIrBackend { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); - } - + @Test public void testAllFilesPresentInTestsWithJvmBackend() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } + @Test @TestMetadata("indirectInlineCycle_ir.kt") public void testIndirectInlineCycle_ir() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/indirectInlineCycle_ir.kt"); } + @Test @TestMetadata("inlineCycle_ir.kt") public void testInlineCycle_ir() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/inlineCycle_ir.kt"); } + @Test @TestMetadata("multipleBigArityFunsImplemented_ir.kt") public void testMultipleBigArityFunsImplemented_ir() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/multipleBigArityFunsImplemented_ir.kt"); } + @Test @TestMetadata("suspendInlineCycle_ir.kt") public void testSuspendInlineCycle_ir() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/suspendInlineCycle_ir.kt"); } + @Nested @TestMetadata("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class DuplicateJvmSignature extends AbstractDiagnosticsTestWithJvmIrBackend { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); - } - + public class DuplicateJvmSignature extends AbstractDiagnosticsTestWithJvmIrBackend { + @Test public void testAllFilesPresentInDuplicateJvmSignature() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } + @Test @TestMetadata("caseInProperties.kt") public void testCaseInProperties() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/caseInProperties.kt"); } + @Test @TestMetadata("changingNullabilityOfOrdinaryClassIsBinaryCompatibleChange.kt") public void testChangingNullabilityOfOrdinaryClassIsBinaryCompatibleChange() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/changingNullabilityOfOrdinaryClassIsBinaryCompatibleChange.kt"); } + @Test @TestMetadata("vararg.kt") public void testVararg() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/vararg.kt"); } + @Nested @TestMetadata("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class AccidentalOverrides extends AbstractDiagnosticsTestWithJvmIrBackend { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); - } - + public class AccidentalOverrides extends AbstractDiagnosticsTestWithJvmIrBackend { + @Test @TestMetadata("accidentalOverrideFromGrandparent.kt") public void testAccidentalOverrideFromGrandparent() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/accidentalOverrideFromGrandparent.kt"); } + @Test public void testAllFilesPresentInAccidentalOverrides() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } + @Test @TestMetadata("classFunctionOverriddenByProperty.kt") public void testClassFunctionOverriddenByProperty() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/classFunctionOverriddenByProperty.kt"); } + @Test @TestMetadata("classFunctionOverriddenByPropertyInConstructor.kt") public void testClassFunctionOverriddenByPropertyInConstructor() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/classFunctionOverriddenByPropertyInConstructor.kt"); } + @Test @TestMetadata("classFunctionOverriddenByPropertyNoGetter.kt") public void testClassFunctionOverriddenByPropertyNoGetter() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/classFunctionOverriddenByPropertyNoGetter.kt"); } + @Test @TestMetadata("classPropertyOverriddenByFunction.kt") public void testClassPropertyOverriddenByFunction() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/classPropertyOverriddenByFunction.kt"); } + @Test @TestMetadata("defaultFunction_ir.kt") public void testDefaultFunction_ir() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/defaultFunction_ir.kt"); } + @Test @TestMetadata("delegatedFunctionOverriddenByProperty_ir.kt") public void testDelegatedFunctionOverriddenByProperty_ir() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/delegatedFunctionOverriddenByProperty_ir.kt"); } + @Test @TestMetadata("genericClassFunction.kt") public void testGenericClassFunction() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/genericClassFunction.kt"); } + @Test @TestMetadata("overridesNothing_ir.kt") public void testOverridesNothing_ir() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/overridesNothing_ir.kt"); } + @Test @TestMetadata("overridesNothing_old.kt") public void testOverridesNothing_old() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/overridesNothing_old.kt"); } + @Test @TestMetadata("privateClassFunctionOverriddenByProperty.kt") public void testPrivateClassFunctionOverriddenByProperty() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/privateClassFunctionOverriddenByProperty.kt"); } + @Test @TestMetadata("traitFunctionOverriddenByPropertyNoImpl.kt") public void testTraitFunctionOverriddenByPropertyNoImpl() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/traitFunctionOverriddenByPropertyNoImpl.kt"); } + @Test @TestMetadata("traitFunctionOverriddenByProperty_ir.kt") public void testTraitFunctionOverriddenByProperty_ir() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/traitFunctionOverriddenByProperty_ir.kt"); } + @Test @TestMetadata("traitPropertyOverriddenByFunctionNoImpl.kt") public void testTraitPropertyOverriddenByFunctionNoImpl() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/traitPropertyOverriddenByFunctionNoImpl.kt"); } + @Test @TestMetadata("traitPropertyOverriddenByFunction_ir.kt") public void testTraitPropertyOverriddenByFunction_ir() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/traitPropertyOverriddenByFunction_ir.kt"); } } + @Nested @TestMetadata("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/bridges") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Bridges extends AbstractDiagnosticsTestWithJvmIrBackend { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); - } - + public class Bridges extends AbstractDiagnosticsTestWithJvmIrBackend { + @Test public void testAllFilesPresentInBridges() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/bridges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } + @Test @TestMetadata("class_ir.kt") public void testClass_ir() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/bridges/class_ir.kt"); } + @Test @TestMetadata("fakeOverrideTrait_ir.kt") public void testFakeOverrideTrait_ir() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/bridges/fakeOverrideTrait_ir.kt"); } + @Test @TestMetadata("trait_ir.kt") public void testTrait_ir() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/bridges/trait_ir.kt"); } } + @Nested @TestMetadata("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Erasure extends AbstractDiagnosticsTestWithJvmIrBackend { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); - } - + public class Erasure extends AbstractDiagnosticsTestWithJvmIrBackend { + @Test public void testAllFilesPresentInErasure() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } + @Test @TestMetadata("clashFromInterfaceAndSuperClass_ir.kt") public void testClashFromInterfaceAndSuperClass_ir() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/clashFromInterfaceAndSuperClass_ir.kt"); } + @Test @TestMetadata("collections.kt") public void testCollections() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/collections.kt"); } + @Test @TestMetadata("delegateToTwoTraits.kt") public void testDelegateToTwoTraits() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/delegateToTwoTraits.kt"); } + @Test @TestMetadata("delegationAndOwnMethod.kt") public void testDelegationAndOwnMethod() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/delegationAndOwnMethod.kt"); } + @Test @TestMetadata("delegationToTraitImplAndOwnMethod.kt") public void testDelegationToTraitImplAndOwnMethod() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/delegationToTraitImplAndOwnMethod.kt"); } + @Test @TestMetadata("extensionProperties.kt") public void testExtensionProperties() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/extensionProperties.kt"); } + @Test @TestMetadata("genericType.kt") public void testGenericType() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/genericType.kt"); } + @Test @TestMetadata("inheritFromTwoTraits_ir.kt") public void testInheritFromTwoTraits_ir() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/inheritFromTwoTraits_ir.kt"); } + @Test @TestMetadata("kotlinAndJavaCollections.kt") public void testKotlinAndJavaCollections() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/kotlinAndJavaCollections.kt"); } + @Test @TestMetadata("nullableType.kt") public void testNullableType() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/nullableType.kt"); } + @Test @TestMetadata("superTraitAndDelegationToTraitImpl_ir.kt") public void testSuperTraitAndDelegationToTraitImpl_ir() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/superTraitAndDelegationToTraitImpl_ir.kt"); } + @Test @TestMetadata("twoTraitsAndOwnFunction_ir.kt") public void testTwoTraitsAndOwnFunction_ir() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/twoTraitsAndOwnFunction_ir.kt"); } + @Test @TestMetadata("typeMappedToJava.kt") public void testTypeMappedToJava() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/typeMappedToJava.kt"); } + @Test @TestMetadata("typeParameter.kt") public void testTypeParameter() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/typeParameter.kt"); } + @Test @TestMetadata("typeParameterWithBound.kt") public void testTypeParameterWithBound() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/typeParameterWithBound.kt"); } + @Test @TestMetadata("typeParameterWithTwoBounds.kt") public void testTypeParameterWithTwoBounds() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/typeParameterWithTwoBounds.kt"); } + @Test @TestMetadata("typeParameterWithTwoBoundsInWhere.kt") public void testTypeParameterWithTwoBoundsInWhere() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/typeParameterWithTwoBoundsInWhere.kt"); } } + @Nested @TestMetadata("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/finalMembersFromBuiltIns") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class FinalMembersFromBuiltIns extends AbstractDiagnosticsTestWithJvmIrBackend { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); - } - + public class FinalMembersFromBuiltIns extends AbstractDiagnosticsTestWithJvmIrBackend { + @Test public void testAllFilesPresentInFinalMembersFromBuiltIns() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/finalMembersFromBuiltIns"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } + @Test @TestMetadata("enumMembers.kt") public void testEnumMembers() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/finalMembersFromBuiltIns/enumMembers.kt"); } + @Test @TestMetadata("waitNotifyGetClass_ir.kt") public void testWaitNotifyGetClass_ir() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/finalMembersFromBuiltIns/waitNotifyGetClass_ir.kt"); } } + @Nested @TestMetadata("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/functionAndProperty") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class FunctionAndProperty extends AbstractDiagnosticsTestWithJvmIrBackend { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); - } - + public class FunctionAndProperty extends AbstractDiagnosticsTestWithJvmIrBackend { + @Test public void testAllFilesPresentInFunctionAndProperty() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/functionAndProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } + @Test @TestMetadata("class.kt") public void testClass() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/functionAndProperty/class.kt"); } + @Test @TestMetadata("classObject.kt") public void testClassObject() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/functionAndProperty/classObject.kt"); } + @Test @TestMetadata("classPropertyInConstructor.kt") public void testClassPropertyInConstructor() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/functionAndProperty/classPropertyInConstructor.kt"); } + @Test @TestMetadata("extensionFunctionAndNormalFunction.kt") public void testExtensionFunctionAndNormalFunction() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/functionAndProperty/extensionFunctionAndNormalFunction.kt"); } + @Test @TestMetadata("extensionPropertyAndFunction.kt") public void testExtensionPropertyAndFunction() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/functionAndProperty/extensionPropertyAndFunction.kt"); } + @Test @TestMetadata("functionAndSetter.kt") public void testFunctionAndSetter() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/functionAndProperty/functionAndSetter.kt"); } + @Test @TestMetadata("functionAndVar.kt") public void testFunctionAndVar() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/functionAndProperty/functionAndVar.kt"); } + @Test @TestMetadata("localClass.kt") public void testLocalClass() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/functionAndProperty/localClass.kt"); } + @Test @TestMetadata("localClassInClass.kt") public void testLocalClassInClass() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/functionAndProperty/localClassInClass.kt"); } + @Test @TestMetadata("nestedClass.kt") public void testNestedClass() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/functionAndProperty/nestedClass.kt"); } + @Test @TestMetadata("object.kt") public void testObject() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/functionAndProperty/object.kt"); } + @Test @TestMetadata("objectExpression.kt") public void testObjectExpression() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/functionAndProperty/objectExpression.kt"); } + @Test @TestMetadata("objectExpressionInConstructor.kt") public void testObjectExpressionInConstructor() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/functionAndProperty/objectExpressionInConstructor.kt"); } + @Test @TestMetadata("privateClassPropertyNoClash.kt") public void testPrivateClassPropertyNoClash() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/functionAndProperty/privateClassPropertyNoClash.kt"); } + @Test @TestMetadata("topLevel.kt") public void testTopLevel() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/functionAndProperty/topLevel.kt"); } + @Test @TestMetadata("topLevelDifferentFiles.kt") public void testTopLevelDifferentFiles() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/functionAndProperty/topLevelDifferentFiles.kt"); } + @Test @TestMetadata("topLevelGetter.kt") public void testTopLevelGetter() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/functionAndProperty/topLevelGetter.kt"); } + @Test @TestMetadata("trait_ir.kt") public void testTrait_ir() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/functionAndProperty/trait_ir.kt"); } } + @Nested @TestMetadata("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/specialNames") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class SpecialNames extends AbstractDiagnosticsTestWithJvmIrBackend { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); - } - + public class SpecialNames extends AbstractDiagnosticsTestWithJvmIrBackend { + @Test public void testAllFilesPresentInSpecialNames() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/specialNames"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } + @Test @TestMetadata("classObjectCopiedField.kt") public void testClassObjectCopiedField() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/specialNames/classObjectCopiedField.kt"); } + @Test @TestMetadata("classObjectCopiedFieldObject_ir.kt") public void testClassObjectCopiedFieldObject_ir() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/specialNames/classObjectCopiedFieldObject_ir.kt"); } + @Test @TestMetadata("classObject_ir.kt") public void testClassObject_ir() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/specialNames/classObject_ir.kt"); } + @Test @TestMetadata("dataClassCopy.kt") public void testDataClassCopy() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/specialNames/dataClassCopy.kt"); } + @Test @TestMetadata("defaults_ir.kt") public void testDefaults_ir() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/specialNames/defaults_ir.kt"); } + @Test @TestMetadata("delegationBy_ir.kt") public void testDelegationBy_ir() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/specialNames/delegationBy_ir.kt"); } + @Test @TestMetadata("enum.kt") public void testEnum() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/specialNames/enum.kt"); } + @Test @TestMetadata("innerClassField_ir.kt") public void testInnerClassField_ir() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/specialNames/innerClassField_ir.kt"); } + @Test @TestMetadata("instance_ir.kt") public void testInstance_ir() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/specialNames/instance_ir.kt"); } + @Test @TestMetadata("propertyMetadataCache_ir.kt") public void testPropertyMetadataCache_ir() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/specialNames/propertyMetadataCache_ir.kt"); } } + @Nested @TestMetadata("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/statics") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Statics extends AbstractDiagnosticsTestWithJvmIrBackend { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); - } - + public class Statics extends AbstractDiagnosticsTestWithJvmIrBackend { + @Test public void testAllFilesPresentInStatics() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/statics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } + @Test @TestMetadata("jkjk.kt") public void testJkjk() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/statics/jkjk.kt"); } + @Test @TestMetadata("kotlinClassExtendsJavaClass.kt") public void testKotlinClassExtendsJavaClass() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/statics/kotlinClassExtendsJavaClass.kt"); } + @Test @TestMetadata("kotlinClassExtendsJavaClassExtendsJavaClass.kt") public void testKotlinClassExtendsJavaClassExtendsJavaClass() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/statics/kotlinClassExtendsJavaClassExtendsJavaClass.kt"); } + @Test @TestMetadata("kotlinClassImplementsJavaInterface.kt") public void testKotlinClassImplementsJavaInterface() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/statics/kotlinClassImplementsJavaInterface.kt"); } + @Test @TestMetadata("kotlinClassImplementsJavaInterfaceExtendsJavaInteface.kt") public void testKotlinClassImplementsJavaInterfaceExtendsJavaInteface() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/statics/kotlinClassImplementsJavaInterfaceExtendsJavaInteface.kt"); } + @Test @TestMetadata("kotlinMembersVsJavaNonVisibleStatics.kt") public void testKotlinMembersVsJavaNonVisibleStatics() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/statics/kotlinMembersVsJavaNonVisibleStatics.kt"); } } + @Nested @TestMetadata("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/synthesized") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Synthesized extends AbstractDiagnosticsTestWithJvmIrBackend { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); - } - + public class Synthesized extends AbstractDiagnosticsTestWithJvmIrBackend { + @Test public void testAllFilesPresentInSynthesized() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/synthesized"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } + @Test @TestMetadata("enumValuesValueOf.kt") public void testEnumValuesValueOf() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/synthesized/enumValuesValueOf.kt"); } } + @Nested @TestMetadata("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/traitImpl") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class TraitImpl extends AbstractDiagnosticsTestWithJvmIrBackend { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); - } - + public class TraitImpl extends AbstractDiagnosticsTestWithJvmIrBackend { + @Test public void testAllFilesPresentInTraitImpl() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/traitImpl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } + @Test @TestMetadata("defaultVsNonDefault_ir.kt") public void testDefaultVsNonDefault_ir() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/traitImpl/defaultVsNonDefault_ir.kt"); } + @Test @TestMetadata("kt43611.kt") public void testKt43611() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/traitImpl/kt43611.kt"); } + @Test @TestMetadata("oneTrait_ir.kt") public void testOneTrait_ir() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/traitImpl/oneTrait_ir.kt"); } + @Test @TestMetadata("traitFunctionOverriddenByPropertyInTrait_ir.kt") public void testTraitFunctionOverriddenByPropertyInTrait_ir() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/traitImpl/traitFunctionOverriddenByPropertyInTrait_ir.kt"); } + @Test @TestMetadata("traitPropertyOverriddenByFunctionInTrait_ir.kt") public void testTraitPropertyOverriddenByFunctionInTrait_ir() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/traitImpl/traitPropertyOverriddenByFunctionInTrait_ir.kt"); } + @Test @TestMetadata("twoTraits_ir.kt") public void testTwoTraits_ir() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/traitImpl/twoTraits_ir.kt"); @@ -585,23 +635,22 @@ public class DiagnosticsTestWithJvmIrBackendGenerated extends AbstractDiagnostic } } + @Nested @TestMetadata("compiler/testData/diagnostics/testsWithJvmBackend/valueClasses") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ValueClasses extends AbstractDiagnosticsTestWithJvmIrBackend { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_IR, testDataFilePath); - } - + public class ValueClasses extends AbstractDiagnosticsTestWithJvmIrBackend { + @Test public void testAllFilesPresentInValueClasses() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/valueClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } + @Test @TestMetadata("cloneable.kt") public void testCloneable() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/valueClasses/cloneable.kt"); } + @Test @TestMetadata("cloneable.fir.kt") public void testCloneable_fir() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/valueClasses/cloneable.fir.kt"); diff --git a/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsTestWithOldJvmBackendGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticsTestWithOldJvmBackendGenerated.java similarity index 88% rename from compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsTestWithOldJvmBackendGenerated.java rename to compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticsTestWithOldJvmBackendGenerated.java index cfd13fb6f8f..88ab881fcb9 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsTestWithOldJvmBackendGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticsTestWithOldJvmBackendGenerated.java @@ -3,571 +3,619 @@ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ -package org.jetbrains.kotlin.checkers; +package org.jetbrains.kotlin.test.runners; import com.intellij.testFramework.TestDataPath; -import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; -import org.jetbrains.kotlin.test.KotlinTestUtils; import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; import java.io.File; import java.util.regex.Pattern; -/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */ +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ @SuppressWarnings("all") @TestMetadata("compiler/testData/diagnostics/testsWithJvmBackend") @TestDataPath("$PROJECT_ROOT") -@RunWith(JUnit3RunnerWithInners.class) public class DiagnosticsTestWithOldJvmBackendGenerated extends AbstractDiagnosticsTestWithOldJvmBackend { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_OLD, testDataFilePath); - } - + @Test public void testAllFilesPresentInTestsWithJvmBackend() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_OLD, true); } + @Test @TestMetadata("indirectInlineCycle.kt") public void testIndirectInlineCycle() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/indirectInlineCycle.kt"); } + @Test @TestMetadata("inlineCycle.kt") public void testInlineCycle() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/inlineCycle.kt"); } + @Test @TestMetadata("multipleBigArityFunsImplemented.kt") public void testMultipleBigArityFunsImplemented() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/multipleBigArityFunsImplemented.kt"); } + @Test @TestMetadata("suspendInlineCycle.kt") public void testSuspendInlineCycle() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/suspendInlineCycle.kt"); } + @Nested @TestMetadata("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class DuplicateJvmSignature extends AbstractDiagnosticsTestWithOldJvmBackend { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_OLD, testDataFilePath); - } - + public class DuplicateJvmSignature extends AbstractDiagnosticsTestWithOldJvmBackend { + @Test public void testAllFilesPresentInDuplicateJvmSignature() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_OLD, true); } + @Test @TestMetadata("caseInProperties.kt") public void testCaseInProperties() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/caseInProperties.kt"); } + @Test @TestMetadata("changingNullabilityOfOrdinaryClassIsBinaryCompatibleChange.kt") public void testChangingNullabilityOfOrdinaryClassIsBinaryCompatibleChange() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/changingNullabilityOfOrdinaryClassIsBinaryCompatibleChange.kt"); } + @Test @TestMetadata("vararg.kt") public void testVararg() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/vararg.kt"); } + @Nested @TestMetadata("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class AccidentalOverrides extends AbstractDiagnosticsTestWithOldJvmBackend { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_OLD, testDataFilePath); - } - + public class AccidentalOverrides extends AbstractDiagnosticsTestWithOldJvmBackend { + @Test @TestMetadata("accidentalOverrideFromGrandparent.kt") public void testAccidentalOverrideFromGrandparent() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/accidentalOverrideFromGrandparent.kt"); } + @Test public void testAllFilesPresentInAccidentalOverrides() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_OLD, true); } + @Test @TestMetadata("classFunctionOverriddenByProperty.kt") public void testClassFunctionOverriddenByProperty() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/classFunctionOverriddenByProperty.kt"); } + @Test @TestMetadata("classFunctionOverriddenByPropertyInConstructor.kt") public void testClassFunctionOverriddenByPropertyInConstructor() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/classFunctionOverriddenByPropertyInConstructor.kt"); } + @Test @TestMetadata("classFunctionOverriddenByPropertyNoGetter.kt") public void testClassFunctionOverriddenByPropertyNoGetter() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/classFunctionOverriddenByPropertyNoGetter.kt"); } + @Test @TestMetadata("classPropertyOverriddenByFunction.kt") public void testClassPropertyOverriddenByFunction() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/classPropertyOverriddenByFunction.kt"); } + @Test @TestMetadata("defaultFunction_old.kt") public void testDefaultFunction_old() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/defaultFunction_old.kt"); } + @Test @TestMetadata("delegatedFunctionOverriddenByProperty_old.kt") public void testDelegatedFunctionOverriddenByProperty_old() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/delegatedFunctionOverriddenByProperty_old.kt"); } + @Test @TestMetadata("genericClassFunction.kt") public void testGenericClassFunction() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/genericClassFunction.kt"); } + @Test @TestMetadata("privateClassFunctionOverriddenByProperty.kt") public void testPrivateClassFunctionOverriddenByProperty() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/privateClassFunctionOverriddenByProperty.kt"); } + @Test @TestMetadata("traitFunctionOverriddenByPropertyNoImpl.kt") public void testTraitFunctionOverriddenByPropertyNoImpl() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/traitFunctionOverriddenByPropertyNoImpl.kt"); } + @Test @TestMetadata("traitFunctionOverriddenByProperty_old.kt") public void testTraitFunctionOverriddenByProperty_old() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/traitFunctionOverriddenByProperty_old.kt"); } + @Test @TestMetadata("traitPropertyOverriddenByFunctionNoImpl.kt") public void testTraitPropertyOverriddenByFunctionNoImpl() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/traitPropertyOverriddenByFunctionNoImpl.kt"); } + @Test @TestMetadata("traitPropertyOverriddenByFunction_old.kt") public void testTraitPropertyOverriddenByFunction_old() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/accidentalOverrides/traitPropertyOverriddenByFunction_old.kt"); } } + @Nested @TestMetadata("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/bridges") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Bridges extends AbstractDiagnosticsTestWithOldJvmBackend { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_OLD, testDataFilePath); - } - + public class Bridges extends AbstractDiagnosticsTestWithOldJvmBackend { + @Test public void testAllFilesPresentInBridges() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/bridges"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_OLD, true); } + @Test @TestMetadata("class_old.kt") public void testClass_old() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/bridges/class_old.kt"); } + @Test @TestMetadata("fakeOverrideTrait_old.kt") public void testFakeOverrideTrait_old() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/bridges/fakeOverrideTrait_old.kt"); } + @Test @TestMetadata("trait_old.kt") public void testTrait_old() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/bridges/trait_old.kt"); } } + @Nested @TestMetadata("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Erasure extends AbstractDiagnosticsTestWithOldJvmBackend { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_OLD, testDataFilePath); - } - + public class Erasure extends AbstractDiagnosticsTestWithOldJvmBackend { + @Test public void testAllFilesPresentInErasure() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_OLD, true); } + @Test @TestMetadata("clashFromInterfaceAndSuperClass_old.kt") public void testClashFromInterfaceAndSuperClass_old() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/clashFromInterfaceAndSuperClass_old.kt"); } + @Test @TestMetadata("collections.kt") public void testCollections() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/collections.kt"); } + @Test @TestMetadata("delegateToTwoTraits.kt") public void testDelegateToTwoTraits() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/delegateToTwoTraits.kt"); } + @Test @TestMetadata("delegationAndOwnMethod.kt") public void testDelegationAndOwnMethod() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/delegationAndOwnMethod.kt"); } + @Test @TestMetadata("delegationToTraitImplAndOwnMethod.kt") public void testDelegationToTraitImplAndOwnMethod() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/delegationToTraitImplAndOwnMethod.kt"); } + @Test @TestMetadata("extensionProperties.kt") public void testExtensionProperties() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/extensionProperties.kt"); } + @Test @TestMetadata("genericType.kt") public void testGenericType() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/genericType.kt"); } + @Test @TestMetadata("inheritFromTwoTraits_old.kt") public void testInheritFromTwoTraits_old() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/inheritFromTwoTraits_old.kt"); } + @Test @TestMetadata("kotlinAndJavaCollections.kt") public void testKotlinAndJavaCollections() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/kotlinAndJavaCollections.kt"); } + @Test @TestMetadata("nullableType.kt") public void testNullableType() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/nullableType.kt"); } + @Test @TestMetadata("superTraitAndDelegationToTraitImpl_old.kt") public void testSuperTraitAndDelegationToTraitImpl_old() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/superTraitAndDelegationToTraitImpl_old.kt"); } + @Test @TestMetadata("twoTraitsAndOwnFunction_old.kt") public void testTwoTraitsAndOwnFunction_old() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/twoTraitsAndOwnFunction_old.kt"); } + @Test @TestMetadata("typeMappedToJava.kt") public void testTypeMappedToJava() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/typeMappedToJava.kt"); } + @Test @TestMetadata("typeParameter.kt") public void testTypeParameter() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/typeParameter.kt"); } + @Test @TestMetadata("typeParameterWithBound.kt") public void testTypeParameterWithBound() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/typeParameterWithBound.kt"); } + @Test @TestMetadata("typeParameterWithTwoBounds.kt") public void testTypeParameterWithTwoBounds() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/typeParameterWithTwoBounds.kt"); } + @Test @TestMetadata("typeParameterWithTwoBoundsInWhere.kt") public void testTypeParameterWithTwoBoundsInWhere() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/erasure/typeParameterWithTwoBoundsInWhere.kt"); } } + @Nested @TestMetadata("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/finalMembersFromBuiltIns") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class FinalMembersFromBuiltIns extends AbstractDiagnosticsTestWithOldJvmBackend { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_OLD, testDataFilePath); - } - + public class FinalMembersFromBuiltIns extends AbstractDiagnosticsTestWithOldJvmBackend { + @Test public void testAllFilesPresentInFinalMembersFromBuiltIns() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/finalMembersFromBuiltIns"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_OLD, true); } + @Test @TestMetadata("enumMembers.kt") public void testEnumMembers() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/finalMembersFromBuiltIns/enumMembers.kt"); } + @Test @TestMetadata("waitNotifyGetClass_old.kt") public void testWaitNotifyGetClass_old() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/finalMembersFromBuiltIns/waitNotifyGetClass_old.kt"); } } + @Nested @TestMetadata("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/functionAndProperty") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class FunctionAndProperty extends AbstractDiagnosticsTestWithOldJvmBackend { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_OLD, testDataFilePath); - } - + public class FunctionAndProperty extends AbstractDiagnosticsTestWithOldJvmBackend { + @Test public void testAllFilesPresentInFunctionAndProperty() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/functionAndProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_OLD, true); } + @Test @TestMetadata("class.kt") public void testClass() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/functionAndProperty/class.kt"); } + @Test @TestMetadata("classObject.kt") public void testClassObject() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/functionAndProperty/classObject.kt"); } + @Test @TestMetadata("classPropertyInConstructor.kt") public void testClassPropertyInConstructor() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/functionAndProperty/classPropertyInConstructor.kt"); } + @Test @TestMetadata("extensionFunctionAndNormalFunction.kt") public void testExtensionFunctionAndNormalFunction() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/functionAndProperty/extensionFunctionAndNormalFunction.kt"); } + @Test @TestMetadata("extensionPropertyAndFunction.kt") public void testExtensionPropertyAndFunction() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/functionAndProperty/extensionPropertyAndFunction.kt"); } + @Test @TestMetadata("functionAndSetter.kt") public void testFunctionAndSetter() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/functionAndProperty/functionAndSetter.kt"); } + @Test @TestMetadata("functionAndVar.kt") public void testFunctionAndVar() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/functionAndProperty/functionAndVar.kt"); } + @Test @TestMetadata("localClass.kt") public void testLocalClass() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/functionAndProperty/localClass.kt"); } + @Test @TestMetadata("localClassInClass.kt") public void testLocalClassInClass() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/functionAndProperty/localClassInClass.kt"); } + @Test @TestMetadata("nestedClass.kt") public void testNestedClass() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/functionAndProperty/nestedClass.kt"); } + @Test @TestMetadata("object.kt") public void testObject() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/functionAndProperty/object.kt"); } + @Test @TestMetadata("objectExpression.kt") public void testObjectExpression() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/functionAndProperty/objectExpression.kt"); } + @Test @TestMetadata("objectExpressionInConstructor.kt") public void testObjectExpressionInConstructor() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/functionAndProperty/objectExpressionInConstructor.kt"); } + @Test @TestMetadata("privateClassPropertyNoClash.kt") public void testPrivateClassPropertyNoClash() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/functionAndProperty/privateClassPropertyNoClash.kt"); } + @Test @TestMetadata("topLevel.kt") public void testTopLevel() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/functionAndProperty/topLevel.kt"); } + @Test @TestMetadata("topLevelDifferentFiles.kt") public void testTopLevelDifferentFiles() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/functionAndProperty/topLevelDifferentFiles.kt"); } + @Test @TestMetadata("topLevelGetter.kt") public void testTopLevelGetter() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/functionAndProperty/topLevelGetter.kt"); } + @Test @TestMetadata("trait_old.kt") public void testTrait_old() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/functionAndProperty/trait_old.kt"); } } + @Nested @TestMetadata("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/specialNames") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class SpecialNames extends AbstractDiagnosticsTestWithOldJvmBackend { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_OLD, testDataFilePath); - } - + public class SpecialNames extends AbstractDiagnosticsTestWithOldJvmBackend { + @Test public void testAllFilesPresentInSpecialNames() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/specialNames"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_OLD, true); } + @Test @TestMetadata("classObjectCopiedField.kt") public void testClassObjectCopiedField() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/specialNames/classObjectCopiedField.kt"); } + @Test @TestMetadata("classObjectCopiedFieldObject_old.kt") public void testClassObjectCopiedFieldObject_old() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/specialNames/classObjectCopiedFieldObject_old.kt"); } + @Test @TestMetadata("classObject_old.kt") public void testClassObject_old() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/specialNames/classObject_old.kt"); } + @Test @TestMetadata("dataClassCopy.kt") public void testDataClassCopy() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/specialNames/dataClassCopy.kt"); } + @Test @TestMetadata("defaults_old.kt") public void testDefaults_old() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/specialNames/defaults_old.kt"); } + @Test @TestMetadata("delegationBy_old.kt") public void testDelegationBy_old() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/specialNames/delegationBy_old.kt"); } + @Test @TestMetadata("enum.kt") public void testEnum() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/specialNames/enum.kt"); } + @Test @TestMetadata("innerClassField_old.kt") public void testInnerClassField_old() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/specialNames/innerClassField_old.kt"); } + @Test @TestMetadata("instance_old.kt") public void testInstance_old() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/specialNames/instance_old.kt"); } + @Test @TestMetadata("propertyMetadataCache_old.kt") public void testPropertyMetadataCache_old() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/specialNames/propertyMetadataCache_old.kt"); } } + @Nested @TestMetadata("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/statics") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Statics extends AbstractDiagnosticsTestWithOldJvmBackend { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_OLD, testDataFilePath); - } - + public class Statics extends AbstractDiagnosticsTestWithOldJvmBackend { + @Test public void testAllFilesPresentInStatics() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/statics"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_OLD, true); } + @Test @TestMetadata("jkjk.kt") public void testJkjk() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/statics/jkjk.kt"); } + @Test @TestMetadata("kotlinClassExtendsJavaClass.kt") public void testKotlinClassExtendsJavaClass() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/statics/kotlinClassExtendsJavaClass.kt"); } + @Test @TestMetadata("kotlinClassExtendsJavaClassExtendsJavaClass.kt") public void testKotlinClassExtendsJavaClassExtendsJavaClass() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/statics/kotlinClassExtendsJavaClassExtendsJavaClass.kt"); } + @Test @TestMetadata("kotlinClassImplementsJavaInterface.kt") public void testKotlinClassImplementsJavaInterface() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/statics/kotlinClassImplementsJavaInterface.kt"); } + @Test @TestMetadata("kotlinClassImplementsJavaInterfaceExtendsJavaInteface.kt") public void testKotlinClassImplementsJavaInterfaceExtendsJavaInteface() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/statics/kotlinClassImplementsJavaInterfaceExtendsJavaInteface.kt"); } + @Test @TestMetadata("kotlinMembersVsJavaNonVisibleStatics.kt") public void testKotlinMembersVsJavaNonVisibleStatics() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/statics/kotlinMembersVsJavaNonVisibleStatics.kt"); } } + @Nested @TestMetadata("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/synthesized") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Synthesized extends AbstractDiagnosticsTestWithOldJvmBackend { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_OLD, testDataFilePath); - } - + public class Synthesized extends AbstractDiagnosticsTestWithOldJvmBackend { + @Test public void testAllFilesPresentInSynthesized() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/synthesized"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_OLD, true); } + @Test @TestMetadata("enumValuesValueOf.kt") public void testEnumValuesValueOf() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/synthesized/enumValuesValueOf.kt"); } } + @Nested @TestMetadata("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/traitImpl") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class TraitImpl extends AbstractDiagnosticsTestWithOldJvmBackend { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_OLD, testDataFilePath); - } - + public class TraitImpl extends AbstractDiagnosticsTestWithOldJvmBackend { + @Test public void testAllFilesPresentInTraitImpl() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/traitImpl"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_OLD, true); } + @Test @TestMetadata("defaultVsNonDefault_old.kt") public void testDefaultVsNonDefault_old() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/traitImpl/defaultVsNonDefault_old.kt"); } + @Test @TestMetadata("kt43611.kt") public void testKt43611() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/traitImpl/kt43611.kt"); } + @Test @TestMetadata("oneTrait_old.kt") public void testOneTrait_old() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/traitImpl/oneTrait_old.kt"); } + @Test @TestMetadata("traitFunctionOverriddenByPropertyInTrait_old.kt") public void testTraitFunctionOverriddenByPropertyInTrait_old() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/traitImpl/traitFunctionOverriddenByPropertyInTrait_old.kt"); } + @Test @TestMetadata("traitPropertyOverriddenByFunctionInTrait_old.kt") public void testTraitPropertyOverriddenByFunctionInTrait_old() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/traitImpl/traitPropertyOverriddenByFunctionInTrait_old.kt"); } + @Test @TestMetadata("twoTraits_old.kt") public void testTwoTraits_old() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/duplicateJvmSignature/traitImpl/twoTraits_old.kt"); @@ -575,23 +623,22 @@ public class DiagnosticsTestWithOldJvmBackendGenerated extends AbstractDiagnosti } } + @Nested @TestMetadata("compiler/testData/diagnostics/testsWithJvmBackend/valueClasses") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ValueClasses extends AbstractDiagnosticsTestWithOldJvmBackend { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_OLD, testDataFilePath); - } - + public class ValueClasses extends AbstractDiagnosticsTestWithOldJvmBackend { + @Test public void testAllFilesPresentInValueClasses() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithJvmBackend/valueClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_OLD, true); } + @Test @TestMetadata("cloneable.kt") public void testCloneable() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/valueClasses/cloneable.kt"); } + @Test @TestMetadata("cloneable.fir.kt") public void testCloneable_fir() throws Exception { runTest("compiler/testData/diagnostics/testsWithJvmBackend/valueClasses/cloneable.fir.kt"); diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/JvmBackendDiagnosticsHandler.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/JvmBackendDiagnosticsHandler.kt new file mode 100644 index 00000000000..c9969ecc23f --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/JvmBackendDiagnosticsHandler.kt @@ -0,0 +1,35 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.backend.handlers + +import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.test.frontend.classic.handlers.ClassicDiagnosticReporter +import org.jetbrains.kotlin.test.frontend.classic.handlers.withNewInferenceModeEnabled +import org.jetbrains.kotlin.test.model.BinaryArtifacts +import org.jetbrains.kotlin.test.model.FrontendKinds +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.TestServices +import org.jetbrains.kotlin.test.services.dependencyProvider + +class JvmBackendDiagnosticsHandler(testServices: TestServices) : JvmBinaryArtifactHandler(testServices) { + private val reporter = ClassicDiagnosticReporter(testServices) + + override fun processModule(module: TestModule, info: BinaryArtifacts.Jvm) { + val testFileToKtFileMap = testServices.dependencyProvider.getArtifact(module, FrontendKinds.ClassicFrontend).ktFiles + val ktFileToTestFileMap = testFileToKtFileMap.entries.map { it.value to it.key }.toMap() + val generationState = info.classFileFactory.generationState + val diagnostics = generationState.collectedExtraJvmDiagnostics.all() + val configuration = reporter.createConfiguration(module) + val withNewInferenceModeEnabled = testServices.withNewInferenceModeEnabled() + for (diagnostic in diagnostics) { + val ktFile = diagnostic.psiFile as? KtFile ?: continue + val testFile = ktFileToTestFileMap[ktFile] ?: continue + reporter.reportDiagnostic(diagnostic, module, testFile, configuration, withNewInferenceModeEnabled) + } + } + + override fun processAfterAllModules(someAssertionWasFailed: Boolean) {} +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/directives/DiagnosticsDirectives.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/directives/DiagnosticsDirectives.kt index 983511bbde4..52f043cdd35 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/directives/DiagnosticsDirectives.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/directives/DiagnosticsDirectives.kt @@ -5,6 +5,7 @@ package org.jetbrains.kotlin.test.directives +import org.jetbrains.kotlin.test.backend.handlers.JvmBackendDiagnosticsHandler import org.jetbrains.kotlin.test.directives.JvmEnvironmentConfigurationDirectives.USE_JAVAC import org.jetbrains.kotlin.test.directives.model.SimpleDirectivesContainer @@ -46,4 +47,12 @@ object DiagnosticsDirectives : SimpleDirectivesContainer() { Render debug info about dynamic calls """.trimIndent() ) + + val REPORT_JVM_DIAGNOSTICS_ON_FRONTEND by directive( + description = """ + Collect additional jvm specific diagnostics on frontend + Note that this directive is not needed if ${JvmBackendDiagnosticsHandler::class} + is enabled in test + """.trimIndent() + ) } diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/handlers/ClassicDiagnosticReporter.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/handlers/ClassicDiagnosticReporter.kt new file mode 100644 index 00000000000..6a67ae63292 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/handlers/ClassicDiagnosticReporter.kt @@ -0,0 +1,150 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.frontend.classic.handlers + +import org.jetbrains.kotlin.checkers.utils.DiagnosticsRenderingConfiguration +import org.jetbrains.kotlin.codeMetaInfo.model.CodeMetaInfo +import org.jetbrains.kotlin.codeMetaInfo.model.DiagnosticCodeMetaInfo +import org.jetbrains.kotlin.codeMetaInfo.model.ParsedCodeMetaInfo +import org.jetbrains.kotlin.config.JVMConfigurationKeys +import org.jetbrains.kotlin.config.LanguageFeature +import org.jetbrains.kotlin.diagnostics.Diagnostic +import org.jetbrains.kotlin.platform.isCommon +import org.jetbrains.kotlin.platform.js.isJs +import org.jetbrains.kotlin.platform.jvm.isJvm +import org.jetbrains.kotlin.platform.konan.isNative +import org.jetbrains.kotlin.test.directives.DiagnosticsDirectives +import org.jetbrains.kotlin.test.model.TestFile +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.* + +class ClassicDiagnosticReporter(private val testServices: TestServices) { + private val globalMetadataInfoHandler: GlobalMetadataInfoHandler + get() = testServices.globalMetadataInfoHandler + + fun createConfiguration(module: TestModule): DiagnosticsRenderingConfiguration { + return DiagnosticsRenderingConfiguration( + platform = null, + withNewInference = module.languageVersionSettings.supportsFeature(LanguageFeature.NewInference), + languageVersionSettings = module.languageVersionSettings, + skipDebugInfoDiagnostics = testServices.compilerConfigurationProvider.getCompilerConfiguration(module) + .getBoolean(JVMConfigurationKeys.IR) + ) + } + + fun reportDiagnostic( + diagnostic: Diagnostic, + module: TestModule, + file: TestFile, + configuration: DiagnosticsRenderingConfiguration, + withNewInferenceModeEnabled: Boolean + ) { + globalMetadataInfoHandler.addMetadataInfosForFile( + file, + diagnostic.toMetaInfo( + module, + file, + configuration.withNewInference, + withNewInferenceModeEnabled + ) + ) + } + + private fun Diagnostic.toMetaInfo( + module: TestModule, + file: TestFile, + newInferenceEnabled: Boolean, + withNewInferenceModeEnabled: Boolean + ): List = textRanges.map { range -> + val metaInfo = DiagnosticCodeMetaInfo(range, ClassicMetaInfoUtils.renderDiagnosticNoArgs, this) + if (withNewInferenceModeEnabled) { + metaInfo.attributes += if (newInferenceEnabled) OldNewInferenceMetaInfoProcessor.NI else OldNewInferenceMetaInfoProcessor.OI + } + if (file !in module.files) { + val targetPlatform = module.targetPlatform + metaInfo.attributes += when { + targetPlatform.isJvm() -> "JVM" + targetPlatform.isJs() -> "JS" + targetPlatform.isNative() -> "NATIVE" + targetPlatform.isCommon() -> "COMMON" + else -> error("Should not be here") + } + } + val existing = globalMetadataInfoHandler.getExistingMetaInfosForActualMetadata(file, metaInfo) + if (existing.any { it.description != null }) { + metaInfo.replaceRenderConfiguration(ClassicMetaInfoUtils.renderDiagnosticWithArgs) + } + metaInfo + } +} + +class OldNewInferenceMetaInfoProcessor(testServices: TestServices) : AdditionalMetaInfoProcessor(testServices) { + companion object { + const val OI = "OI" + const val NI = "NI" + } + + override fun processMetaInfos(module: TestModule, file: TestFile) { + /* + * Rules for OI/NI attribute: + * ┌──────────┬──────┬──────┬──────────┐ + * │ │ OI │ NI │ nothing │ <- reported + * ├──────────┼──────┼──────┼──────────┤ + * │ nothing │ both │ both │ nothing │ + * │ OI │ OI │ both │ OI │ + * │ NI │ both │ NI │ NI │ + * │ both │ both │ both │ opposite │ <- OI if NI enabled in test and vice versa + * └──────────┴──────┴──────┴──────────┘ + * ^ existed + */ + if (!testServices.withNewInferenceModeEnabled()) return + val newInferenceEnabled = module.languageVersionSettings.supportsFeature(LanguageFeature.NewInference) + val (currentFlag, otherFlag) = when (newInferenceEnabled) { + true -> NI to OI + false -> OI to NI + } + val matchedExistedInfos = mutableSetOf() + val matchedReportedInfos = mutableSetOf() + val allReportedInfos = globalMetadataInfoHandler.getReportedMetaInfosForFile(file) + for ((_, reportedInfos) in allReportedInfos.groupBy { Triple(it.start, it.end, it.tag) }) { + val existedInfos = globalMetadataInfoHandler.getExistingMetaInfosForActualMetadata(file, reportedInfos.first()) + for ((reportedInfo, existedInfo) in reportedInfos.zip(existedInfos)) { + matchedExistedInfos += existedInfo + matchedReportedInfos += reportedInfo + if (currentFlag !in reportedInfo.attributes) continue + if (currentFlag in existedInfo.attributes) continue + reportedInfo.attributes.remove(currentFlag) + } + } + + if (allReportedInfos.size != matchedReportedInfos.size) { + for (info in allReportedInfos) { + if (info !in matchedReportedInfos) { + info.attributes.remove(currentFlag) + } + } + } + + val allExistedInfos = globalMetadataInfoHandler.getExistingMetaInfosForFile(file) + if (allExistedInfos.size == matchedExistedInfos.size) return + + val newInfos = allExistedInfos.mapNotNull { + if (it in matchedExistedInfos) return@mapNotNull null + if (currentFlag in it.attributes) return@mapNotNull null + it.copy().apply { + if (otherFlag !in attributes) { + attributes += otherFlag + } + } + } + globalMetadataInfoHandler.addMetadataInfosForFile(file, newInfos) + } +} + + +fun TestServices.withNewInferenceModeEnabled(): Boolean { + return DiagnosticsDirectives.WITH_NEW_INFERENCE in moduleStructure.allDirectives +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/handlers/ClassicDiagnosticsHandler.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/handlers/ClassicDiagnosticsHandler.kt index de29d974388..6d9bd3d063b 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/handlers/ClassicDiagnosticsHandler.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/handlers/ClassicDiagnosticsHandler.kt @@ -11,18 +11,10 @@ import org.jetbrains.kotlin.asJava.getJvmSignatureDiagnostics import org.jetbrains.kotlin.checkers.diagnostics.SyntaxErrorDiagnostic import org.jetbrains.kotlin.checkers.utils.CheckerTestUtil import org.jetbrains.kotlin.checkers.utils.DiagnosticsRenderingConfiguration -import org.jetbrains.kotlin.codeMetaInfo.model.CodeMetaInfo -import org.jetbrains.kotlin.codeMetaInfo.model.DiagnosticCodeMetaInfo -import org.jetbrains.kotlin.codeMetaInfo.model.ParsedCodeMetaInfo -import org.jetbrains.kotlin.config.JVMConfigurationKeys -import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl import org.jetbrains.kotlin.diagnostics.Diagnostic import org.jetbrains.kotlin.diagnostics.Errors -import org.jetbrains.kotlin.platform.isCommon -import org.jetbrains.kotlin.platform.js.isJs import org.jetbrains.kotlin.platform.jvm.isJvm -import org.jetbrains.kotlin.platform.konan.isNative import org.jetbrains.kotlin.psi.KtDeclaration import org.jetbrains.kotlin.psi.KtFile import org.jetbrains.kotlin.resolve.AnalyzingUtils @@ -30,6 +22,7 @@ import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValueFactoryImpl import org.jetbrains.kotlin.test.directives.AdditionalFilesDirectives import org.jetbrains.kotlin.test.directives.DiagnosticsDirectives import org.jetbrains.kotlin.test.directives.DiagnosticsDirectives.MARK_DYNAMIC_CALLS +import org.jetbrains.kotlin.test.directives.DiagnosticsDirectives.REPORT_JVM_DIAGNOSTICS_ON_FRONTEND import org.jetbrains.kotlin.test.directives.LanguageSettingsDirectives import org.jetbrains.kotlin.test.directives.model.DirectivesContainer import org.jetbrains.kotlin.test.frontend.classic.ClassicFrontendOutputArtifact @@ -51,6 +44,8 @@ class ClassicDiagnosticsHandler(testServices: TestServices) : ClassicFrontendAna private val diagnosticsService: DiagnosticsService get() = testServices.diagnosticsService + private val reporter = ClassicDiagnosticReporter(testServices) + @OptIn(ExperimentalStdlibApi::class) override fun processModule(module: TestModule, info: ClassicFrontendOutputArtifact) { var allDiagnostics = info.analysisResult.bindingContext.diagnostics + computeJvmSignatureDiagnostics(info) @@ -62,42 +57,18 @@ class ClassicDiagnosticsHandler(testServices: TestServices) : ClassicFrontendAna } val diagnosticsPerFile = allDiagnostics.groupBy { it.psiFile } - val withNewInferenceModeEnabled = testServices.withNewInferenceModeEnabled() - - val configuration = DiagnosticsRenderingConfiguration( - platform = null, - withNewInference = info.languageVersionSettings.supportsFeature(LanguageFeature.NewInference), - languageVersionSettings = info.languageVersionSettings, - skipDebugInfoDiagnostics = testServices.compilerConfigurationProvider.getCompilerConfiguration(module) - .getBoolean(JVMConfigurationKeys.IR) - ) + val configuration = reporter.createConfiguration(module) for ((file, ktFile) in info.ktFiles) { val diagnostics = diagnosticsPerFile[ktFile] ?: emptyList() for (diagnostic in diagnostics) { if (!diagnostic.isValid) continue if (!diagnosticsService.shouldRenderDiagnostic(module, diagnostic.factory.name)) continue - globalMetadataInfoHandler.addMetadataInfosForFile( - file, - diagnostic.toMetaInfo( - module, - file, - configuration.withNewInference, - withNewInferenceModeEnabled - ) - ) + reporter.reportDiagnostic(diagnostic, module, file, configuration, withNewInferenceModeEnabled) } for (errorElement in AnalyzingUtils.getSyntaxErrorRanges(ktFile)) { - globalMetadataInfoHandler.addMetadataInfosForFile( - file, - SyntaxErrorDiagnostic(errorElement).toMetaInfo( - module, - file, - configuration.withNewInference, - withNewInferenceModeEnabled - ) - ) + reporter.reportDiagnostic(SyntaxErrorDiagnostic(errorElement), module, file, configuration, withNewInferenceModeEnabled) } processDebugInfoDiagnostics(configuration, module, file, ktFile, info, withNewInferenceModeEnabled) } @@ -105,6 +76,7 @@ class ClassicDiagnosticsHandler(testServices: TestServices) : ClassicFrontendAna private fun computeJvmSignatureDiagnostics(info: ClassicFrontendOutputArtifact): Set { if (testServices.moduleStructure.modules.any { !it.targetPlatform.isJvm() }) return emptySet() + if (REPORT_JVM_DIAGNOSTICS_ON_FRONTEND !in testServices.moduleStructure.allDirectives) return emptySet() val bindingContext = info.analysisResult.bindingContext val project = info.project val jvmSignatureDiagnostics = HashSet() @@ -122,32 +94,6 @@ class ClassicDiagnosticsHandler(testServices: TestServices) : ClassicFrontendAna return jvmSignatureDiagnostics } - private fun Diagnostic.toMetaInfo( - module: TestModule, - file: TestFile, - newInferenceEnabled: Boolean, - withNewInferenceModeEnabled: Boolean - ): List = textRanges.map { range -> - val metaInfo = DiagnosticCodeMetaInfo(range, ClassicMetaInfoUtils.renderDiagnosticNoArgs, this) - if (withNewInferenceModeEnabled) { - metaInfo.attributes += if (newInferenceEnabled) OldNewInferenceMetaInfoProcessor.NI else OldNewInferenceMetaInfoProcessor.OI - } - if (file !in module.files) { - val targetPlatform = module.targetPlatform - metaInfo.attributes += when { - targetPlatform.isJvm() -> "JVM" - targetPlatform.isJs() -> "JS" - targetPlatform.isNative() -> "NATIVE" - targetPlatform.isCommon() -> "COMMON" - else -> error("Should not be here") - } - } - val existing = globalMetadataInfoHandler.getExistingMetaInfosForActualMetadata(file, metaInfo) - if (existing.any { it.description != null }) { - metaInfo.replaceRenderConfiguration(ClassicMetaInfoUtils.renderDiagnosticWithArgs) - } - metaInfo - } private fun processDebugInfoDiagnostics( configuration: DiagnosticsRenderingConfiguration, @@ -175,79 +121,9 @@ class ClassicDiagnosticsHandler(testServices: TestServices) : ClassicFrontendAna ) debugAnnotations.mapNotNull { debugAnnotation -> if (!diagnosticsService.shouldRenderDiagnostic(module, debugAnnotation.diagnostic.factory.name)) return@mapNotNull null - globalMetadataInfoHandler.addMetadataInfosForFile( - file, - debugAnnotation.diagnostic.toMetaInfo(module, file, configuration.withNewInference, withNewInferenceModeEnabled) - ) + reporter.reportDiagnostic(debugAnnotation.diagnostic, module, file, configuration, withNewInferenceModeEnabled) } } override fun processAfterAllModules(someAssertionWasFailed: Boolean) {} } - -class OldNewInferenceMetaInfoProcessor(testServices: TestServices) : AdditionalMetaInfoProcessor(testServices) { - companion object { - const val OI = "OI" - const val NI = "NI" - } - - override fun processMetaInfos(module: TestModule, file: TestFile) { - /* - * Rules for OI/NI attribute: - * ┌──────────┬──────┬──────┬──────────┐ - * │ │ OI │ NI │ nothing │ <- reported - * ├──────────┼──────┼──────┼──────────┤ - * │ nothing │ both │ both │ nothing │ - * │ OI │ OI │ both │ OI │ - * │ NI │ both │ NI │ NI │ - * │ both │ both │ both │ opposite │ <- OI if NI enabled in test and vice versa - * └──────────┴──────┴──────┴──────────┘ - * ^ existed - */ - if (!testServices.withNewInferenceModeEnabled()) return - val newInferenceEnabled = module.languageVersionSettings.supportsFeature(LanguageFeature.NewInference) - val (currentFlag, otherFlag) = when (newInferenceEnabled) { - true -> NI to OI - false -> OI to NI - } - val matchedExistedInfos = mutableSetOf() - val matchedReportedInfos = mutableSetOf() - val allReportedInfos = globalMetadataInfoHandler.getReportedMetaInfosForFile(file) - for ((_, reportedInfos) in allReportedInfos.groupBy { Triple(it.start, it.end, it.tag) }) { - val existedInfos = globalMetadataInfoHandler.getExistingMetaInfosForActualMetadata(file, reportedInfos.first()) - for ((reportedInfo, existedInfo) in reportedInfos.zip(existedInfos)) { - matchedExistedInfos += existedInfo - matchedReportedInfos += reportedInfo - if (currentFlag !in reportedInfo.attributes) continue - if (currentFlag in existedInfo.attributes) continue - reportedInfo.attributes.remove(currentFlag) - } - } - - if (allReportedInfos.size != matchedReportedInfos.size) { - for (info in allReportedInfos) { - if (info !in matchedReportedInfos) { - info.attributes.remove(currentFlag) - } - } - } - - val allExistedInfos = globalMetadataInfoHandler.getExistingMetaInfosForFile(file) - if (allExistedInfos.size == matchedExistedInfos.size) return - - val newInfos = allExistedInfos.mapNotNull { - if (it in matchedExistedInfos) return@mapNotNull null - if (currentFlag in it.attributes) return@mapNotNull null - it.copy().apply { - if (otherFlag !in attributes) { - attributes += otherFlag - } - } - } - globalMetadataInfoHandler.addMetadataInfosForFile(file, newInfos) - } -} - -private fun TestServices.withNewInferenceModeEnabled(): Boolean { - return DiagnosticsDirectives.WITH_NEW_INFERENCE in moduleStructure.allDirectives -} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/generators/GenerateNewCompilerTests.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/generators/GenerateNewCompilerTests.kt index 6b2106958a1..eb9a06cde4c 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/generators/GenerateNewCompilerTests.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/generators/GenerateNewCompilerTests.kt @@ -6,6 +6,7 @@ package org.jetbrains.kotlin.test.generators import org.jetbrains.kotlin.generators.util.TestGeneratorUtil +import org.jetbrains.kotlin.test.TargetBackend import org.jetbrains.kotlin.test.runners.* fun main(args: Array) { @@ -30,6 +31,14 @@ fun main(args: Array) { testClass { model("diagnostics/testsWithJsStdLib") } + + testClass { + model("diagnostics/testsWithJvmBackend", targetBackend = TargetBackend.JVM_OLD) + } + + testClass { + model("diagnostics/testsWithJvmBackend", targetBackend = TargetBackend.JVM_IR) + } } testGroup("compiler/tests-common-new/tests-gen", "compiler/fir/analysis-tests/testData") { diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractDiagnosticTest.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractDiagnosticTest.kt index 983f75cd296..e3db8408a71 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractDiagnosticTest.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractDiagnosticTest.kt @@ -8,6 +8,8 @@ package org.jetbrains.kotlin.test.runners import org.jetbrains.kotlin.config.ExplicitApiMode import org.jetbrains.kotlin.platform.jvm.JvmPlatforms import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder +import org.jetbrains.kotlin.test.directives.DiagnosticsDirectives +import org.jetbrains.kotlin.test.directives.DiagnosticsDirectives.REPORT_JVM_DIAGNOSTICS_ON_FRONTEND import org.jetbrains.kotlin.test.directives.JvmEnvironmentConfigurationDirectives.USE_PSI_CLASS_FILES_READING import org.jetbrains.kotlin.test.directives.JvmEnvironmentConfigurationDirectives.WITH_STDLIB import org.jetbrains.kotlin.test.directives.LanguageSettingsDirectives.EXPLICIT_API_MODE @@ -36,6 +38,7 @@ abstract class AbstractDiagnosticTest : AbstractKotlinCompilerTest() { defaultDirectives { +USE_PSI_CLASS_FILES_READING + +REPORT_JVM_DIAGNOSTICS_ON_FRONTEND } enableMetaInfoHandler() diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractDiagnosticsTestWithJvmBackend.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractDiagnosticsTestWithJvmBackend.kt new file mode 100644 index 00000000000..bc2c416e36e --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractDiagnosticsTestWithJvmBackend.kt @@ -0,0 +1,84 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.runners + +import org.jetbrains.kotlin.platform.jvm.JvmPlatforms +import org.jetbrains.kotlin.test.backend.classic.ClassicJvmBackendFacade +import org.jetbrains.kotlin.test.backend.handlers.JvmBackendDiagnosticsHandler +import org.jetbrains.kotlin.test.backend.ir.JvmIrBackendFacade +import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder +import org.jetbrains.kotlin.test.directives.JvmEnvironmentConfigurationDirectives +import org.jetbrains.kotlin.test.frontend.classic.ClassicFrontend2ClassicBackendConverter +import org.jetbrains.kotlin.test.frontend.classic.ClassicFrontend2IrConverter +import org.jetbrains.kotlin.test.frontend.classic.ClassicFrontendFacade +import org.jetbrains.kotlin.test.frontend.classic.handlers.ClassicDiagnosticsHandler +import org.jetbrains.kotlin.test.frontend.classic.handlers.DeclarationsDumpHandler +import org.jetbrains.kotlin.test.frontend.classic.handlers.OldNewInferenceMetaInfoProcessor +import org.jetbrains.kotlin.test.model.BackendKind +import org.jetbrains.kotlin.test.model.BackendKinds +import org.jetbrains.kotlin.test.model.DependencyKind +import org.jetbrains.kotlin.test.model.FrontendKinds +import org.jetbrains.kotlin.test.services.AdditionalDiagnosticsSourceFilesProvider +import org.jetbrains.kotlin.test.services.CoroutineHelpersSourceFilesProvider +import org.jetbrains.kotlin.test.services.configuration.JvmEnvironmentConfigurator + +abstract class AbstractDiagnosticsTestWithJvmBackend : AbstractKotlinCompilerTest() { + abstract val targetBackendKind: BackendKind<*> + + override fun TestConfigurationBuilder.configuration() { + globalDefaults { + frontend = FrontendKinds.ClassicFrontend + backend = targetBackendKind + targetPlatform = JvmPlatforms.defaultJvmPlatform + dependencyKind = DependencyKind.Binary + } + + defaultDirectives { + +JvmEnvironmentConfigurationDirectives.USE_PSI_CLASS_FILES_READING + } + + enableMetaInfoHandler() + + useConfigurators(::JvmEnvironmentConfigurator) + + useMetaInfoProcessors(::OldNewInferenceMetaInfoProcessor) + useAdditionalSourceProviders( + ::AdditionalDiagnosticsSourceFilesProvider, + ::CoroutineHelpersSourceFilesProvider, + ) + + useFrontendFacades(::ClassicFrontendFacade) + + useFrontendHandlers( + ::DeclarationsDumpHandler, + ::ClassicDiagnosticsHandler, + ) + + useFrontend2BackendConverters( + ::ClassicFrontend2ClassicBackendConverter, + ::ClassicFrontend2IrConverter + ) + + useBackendFacades( + ::ClassicJvmBackendFacade, + ::JvmIrBackendFacade + ) + + useArtifactsHandlers( + ::JvmBackendDiagnosticsHandler + ) + } +} + +abstract class AbstractDiagnosticsTestWithOldJvmBackend : AbstractDiagnosticsTestWithJvmBackend() { + override val targetBackendKind: BackendKind<*> + get() = BackendKinds.ClassicBackend +} + +abstract class AbstractDiagnosticsTestWithJvmIrBackend : AbstractDiagnosticsTestWithJvmBackend() { + override val targetBackendKind: BackendKind<*> + get() = BackendKinds.IrBackend +} diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractDiagnosticsTestWithJvmBackend.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractDiagnosticsTestWithJvmBackend.kt deleted file mode 100644 index 6c569a66476..00000000000 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractDiagnosticsTestWithJvmBackend.kt +++ /dev/null @@ -1,53 +0,0 @@ -/* - * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. - * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. - */ - -package org.jetbrains.kotlin.checkers - -import org.jetbrains.kotlin.analyzer.AnalysisResult -import org.jetbrains.kotlin.codegen.ClassBuilderFactories -import org.jetbrains.kotlin.codegen.GenerationUtils -import org.jetbrains.kotlin.config.CompilerConfiguration -import org.jetbrains.kotlin.config.JVMConfigurationKeys -import org.jetbrains.kotlin.config.JvmTarget -import org.jetbrains.kotlin.config.LanguageVersionSettings -import org.jetbrains.kotlin.context.ModuleContext -import org.jetbrains.kotlin.psi.KtFile -import org.jetbrains.kotlin.resolve.BindingTrace - -abstract class AbstractDiagnosticsTestWithJvmBackend : AbstractDiagnosticsTest() { - - override fun analyzeModuleContents( - moduleContext: ModuleContext, - files: List, - moduleTrace: BindingTrace, - languageVersionSettings: LanguageVersionSettings, - separateModules: Boolean, - jvmTarget: JvmTarget - ): AnalysisResult { - val analysisResult = - super.analyzeModuleContents( - moduleContext, files, moduleTrace, languageVersionSettings, separateModules, jvmTarget - ) - - val generationState = - GenerationUtils.generateFiles(project, files, environment.configuration, ClassBuilderFactories.TEST, analysisResult) - - for (diagnostic in generationState.collectedExtraJvmDiagnostics.all()) { - moduleTrace.report(diagnostic) - } - return analysisResult - } - - // DO NOT use FE-based diagnostics for JVM signature conflict - override fun shouldSkipJvmSignatureDiagnostics(groupedByModule: Map>): Boolean = true -} - -abstract class AbstractDiagnosticsTestWithOldJvmBackend : AbstractDiagnosticsTestWithJvmBackend() - -abstract class AbstractDiagnosticsTestWithJvmIrBackend : AbstractDiagnosticsTestWithJvmBackend() { - override fun updateConfiguration(configuration: CompilerConfiguration) { - configuration.put(JVMConfigurationKeys.IR, true) - } -} diff --git a/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt b/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt index 3e5577872e0..2cb24bacb7f 100644 --- a/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt +++ b/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt @@ -79,14 +79,6 @@ fun main(args: Array) { model("diagnostics/testsWithJava15") } - testClass { - model("diagnostics/testsWithJvmBackend", targetBackend = TargetBackend.JVM_OLD) - } - - testClass { - model("diagnostics/testsWithJvmBackend", targetBackend = TargetBackend.JVM_IR) - } - testClass { model("multiplatform", extension = null, recursive = true, excludeParentDirs = true) } From 2aa1cb745198a9b420216e76766cb44aa1f96e82 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Mon, 14 Dec 2020 18:36:46 +0300 Subject: [PATCH 117/196] [TEST] Migrate AbstractDiagnosticsNativeTest to new test runners --- .../DiagnosticsNativeTestGenerated.java | 20 +++--- .../frontend/classic/ClassicFrontendFacade.kt | 71 +++++++++++++------ .../generators/GenerateNewCompilerTests.kt | 4 ++ .../runners/AbstractDiagnosticsNativeTest.kt | 48 +++++++++++++ .../services/CompilerConfigurationProvider.kt | 15 +++- .../FakeTopDownAnalyzerFacadeForNative.kt} | 51 +------------ .../generators/tests/GenerateCompilerTests.kt | 4 -- 7 files changed, 130 insertions(+), 83 deletions(-) rename compiler/{tests-gen/org/jetbrains/kotlin/checkers => tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners}/DiagnosticsNativeTestGenerated.java (78%) create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractDiagnosticsNativeTest.kt rename compiler/{tests-common/tests/org/jetbrains/kotlin/checkers/AbstractDiagnosticsNativeTest.kt => tests-compiler-utils/tests/org/jetbrains/kotlin/native/FakeTopDownAnalyzerFacadeForNative.kt} (58%) diff --git a/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsNativeTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticsNativeTestGenerated.java similarity index 78% rename from compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsNativeTestGenerated.java rename to compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticsNativeTestGenerated.java index ea672d9b2e1..755e934ed4c 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/checkers/DiagnosticsNativeTestGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticsNativeTestGenerated.java @@ -3,52 +3,52 @@ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ -package org.jetbrains.kotlin.checkers; +package org.jetbrains.kotlin.test.runners; import com.intellij.testFramework.TestDataPath; -import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; -import org.jetbrains.kotlin.test.KotlinTestUtils; import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; import java.io.File; import java.util.regex.Pattern; -/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */ +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ @SuppressWarnings("all") @TestMetadata("compiler/testData/diagnostics/nativeTests") @TestDataPath("$PROJECT_ROOT") -@RunWith(JUnit3RunnerWithInners.class) public class DiagnosticsNativeTestGenerated extends AbstractDiagnosticsNativeTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + @Test public void testAllFilesPresentInNativeTests() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/nativeTests"), Pattern.compile("^(.+)\\.kt$"), null, true); } + @Test @TestMetadata("sharedImmutable.kt") public void testSharedImmutable() throws Exception { runTest("compiler/testData/diagnostics/nativeTests/sharedImmutable.kt"); } + @Test @TestMetadata("threadLocal.kt") public void testThreadLocal() throws Exception { runTest("compiler/testData/diagnostics/nativeTests/threadLocal.kt"); } + @Test @TestMetadata("throws.kt") public void testThrows() throws Exception { runTest("compiler/testData/diagnostics/nativeTests/throws.kt"); } + @Test @TestMetadata("throwsClash.kt") public void testThrowsClash() throws Exception { runTest("compiler/testData/diagnostics/nativeTests/throwsClash.kt"); } + @Test @TestMetadata("topLevelSingleton.kt") public void testTopLevelSingleton() throws Exception { runTest("compiler/testData/diagnostics/nativeTests/topLevelSingleton.kt"); diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/ClassicFrontendFacade.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/ClassicFrontendFacade.kt index a15d042fdeb..2a8879be9bd 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/ClassicFrontendFacade.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/ClassicFrontendFacade.kt @@ -9,6 +9,8 @@ import com.intellij.openapi.project.Project import com.intellij.psi.search.GlobalSearchScope import org.jetbrains.kotlin.analyzer.AnalysisResult import org.jetbrains.kotlin.analyzer.common.CommonResolverForModuleFactory +import org.jetbrains.kotlin.builtins.DefaultBuiltIns +import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.builtins.jvm.JvmBuiltIns import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackagePartProvider import org.jetbrains.kotlin.cli.jvm.compiler.NoScopeRecordCliBindingTrace @@ -17,8 +19,8 @@ import org.jetbrains.kotlin.config.CompilerConfiguration import org.jetbrains.kotlin.config.JVMConfigurationKeys import org.jetbrains.kotlin.config.JVMConfigurationKeys.JVM_TARGET import org.jetbrains.kotlin.config.JvmTarget -import org.jetbrains.kotlin.config.LanguageVersionSettings import org.jetbrains.kotlin.container.get +import org.jetbrains.kotlin.context.ModuleContext import org.jetbrains.kotlin.context.ProjectContext import org.jetbrains.kotlin.context.withModule import org.jetbrains.kotlin.descriptors.impl.CompositePackageFragmentProvider @@ -31,6 +33,7 @@ import org.jetbrains.kotlin.js.analyze.TopDownAnalyzerFacadeForJS import org.jetbrains.kotlin.js.config.JsConfig import org.jetbrains.kotlin.load.java.lazy.SingleModuleClassResolver import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.native.FakeTopDownAnalyzerFacadeForNative import org.jetbrains.kotlin.platform.isCommon import org.jetbrains.kotlin.platform.js.isJs import org.jetbrains.kotlin.platform.jvm.JvmPlatforms @@ -44,6 +47,7 @@ import org.jetbrains.kotlin.resolve.jvm.JavaDescriptorResolver import org.jetbrains.kotlin.resolve.lazy.KotlinCodeAnalyzer import org.jetbrains.kotlin.resolve.lazy.declarations.FileBasedDeclarationProviderFactory import org.jetbrains.kotlin.serialization.deserialization.MetadataPartProvider +import org.jetbrains.kotlin.storage.StorageManager import org.jetbrains.kotlin.test.directives.JvmEnvironmentConfigurationDirectives import org.jetbrains.kotlin.test.model.DependencyKind import org.jetbrains.kotlin.test.model.FrontendFacade @@ -99,7 +103,6 @@ class ClassicFrontendFacade( configuration, packagePartProviderFactory, ktFiles, - languageVersionSettings, dependentDescriptors, hasCommonModules ) @@ -131,7 +134,6 @@ class ClassicFrontendFacade( configuration: CompilerConfiguration, packagePartProviderFactory: (GlobalSearchScope) -> JvmPackagePartProvider, files: List, - languageVersionSettings: LanguageVersionSettings, dependentDescriptors: List, hasCommonModules: Boolean ): AnalysisResult { @@ -147,8 +149,8 @@ class ClassicFrontendFacade( hasCommonModules ) targetPlatform.isJs() -> performJsModuleResolve(project, configuration, files, dependentDescriptors) - targetPlatform.isNative() -> TODO() - targetPlatform.isCommon() -> performCommonModuleResolve(module, files, languageVersionSettings) + targetPlatform.isNative() -> performNativeModuleResolve(module, project, files) + targetPlatform.isCommon() -> performCommonModuleResolve(module, files) else -> error("Should not be here") } } @@ -175,21 +177,12 @@ class ClassicFrontendFacade( ) } - val projectContext = ProjectContext(project, "test project context") - val storageManager = projectContext.storageManager - - val builtIns = JvmBuiltIns(storageManager, JvmBuiltIns.Kind.FROM_CLASS_LOADER) - val moduleDescriptor = ModuleDescriptorImpl(Name.special("<${module.name}>"), storageManager, builtIns, module.targetPlatform) - val dependencies = buildList { - add(moduleDescriptor) - add(moduleDescriptor.builtIns.builtInsModule) - addAll(dependentDescriptors) - } - moduleDescriptor.setDependencies(dependencies) - val moduleContentScope = GlobalSearchScope.allScope(project) val moduleClassResolver = SingleModuleClassResolver() - val moduleContext = projectContext.withModule(moduleDescriptor) + val moduleContext = createModuleContext(module, project, dependentDescriptors) { + JvmBuiltIns(it, JvmBuiltIns.Kind.FROM_CLASS_LOADER) + } + val moduleDescriptor = moduleContext.module as ModuleDescriptorImpl val jvmTarget = configuration[JVM_TARGET] ?: JvmTarget.DEFAULT val container = createContainerForLazyResolveWithJava( JvmPlatforms.jvmPlatformByTargetVersion(jvmTarget), // TODO(dsavvinov): do not pass JvmTarget around @@ -243,16 +236,32 @@ class ClassicFrontendFacade( ) } + private fun performNativeModuleResolve( + module: TestModule, + project: Project, + files: List, + ): AnalysisResult { + val moduleTrace = NoScopeRecordCliBindingTrace() + val moduleContext = createModuleContext(module, project, dependentDescriptors = emptyList()) { + DefaultBuiltIns() + } + return FakeTopDownAnalyzerFacadeForNative.analyzeFilesWithGivenTrace( + files, + moduleTrace, + moduleContext, + module.languageVersionSettings + ) + } + private fun performCommonModuleResolve( module: TestModule, files: List, - languageVersionSettings: LanguageVersionSettings, ): AnalysisResult { return CommonResolverForModuleFactory.analyzeFiles( files, Name.special("<${module.name}>"), dependOnBuiltIns = true, - languageVersionSettings, + module.languageVersionSettings, module.targetPlatform, // TODO: add dependency manager ) { _ -> @@ -260,4 +269,26 @@ class ClassicFrontendFacade( MetadataPartProvider.Empty } } + + @OptIn(ExperimentalStdlibApi::class) + private fun createModuleContext( + module: TestModule, + project: Project, + dependentDescriptors: List, + builtInsFactory: (StorageManager) -> KotlinBuiltIns, + ): ModuleContext { + val projectContext = ProjectContext(project, "test project context") + val storageManager = projectContext.storageManager + + val builtIns = builtInsFactory(storageManager) + val moduleDescriptor = ModuleDescriptorImpl(Name.special("<${module.name}>"), storageManager, builtIns, module.targetPlatform) + val dependencies = buildList { + add(moduleDescriptor) + add(moduleDescriptor.builtIns.builtInsModule) + addAll(dependentDescriptors) + } + moduleDescriptor.setDependencies(dependencies) + + return projectContext.withModule(moduleDescriptor) + } } diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/generators/GenerateNewCompilerTests.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/generators/GenerateNewCompilerTests.kt index eb9a06cde4c..a9ea608954a 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/generators/GenerateNewCompilerTests.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/generators/GenerateNewCompilerTests.kt @@ -39,6 +39,10 @@ fun main(args: Array) { testClass { model("diagnostics/testsWithJvmBackend", targetBackend = TargetBackend.JVM_IR) } + + testClass { + model("diagnostics/nativeTests") + } } testGroup("compiler/tests-common-new/tests-gen", "compiler/fir/analysis-tests/testData") { diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractDiagnosticsNativeTest.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractDiagnosticsNativeTest.kt new file mode 100644 index 00000000000..6c4167222b4 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractDiagnosticsNativeTest.kt @@ -0,0 +1,48 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.runners + +import org.jetbrains.kotlin.platform.konan.NativePlatforms +import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder +import org.jetbrains.kotlin.test.directives.JvmEnvironmentConfigurationDirectives +import org.jetbrains.kotlin.test.frontend.classic.ClassicFrontendFacade +import org.jetbrains.kotlin.test.frontend.classic.handlers.ClassicDiagnosticsHandler +import org.jetbrains.kotlin.test.frontend.classic.handlers.DeclarationsDumpHandler +import org.jetbrains.kotlin.test.frontend.classic.handlers.OldNewInferenceMetaInfoProcessor +import org.jetbrains.kotlin.test.model.BackendKind +import org.jetbrains.kotlin.test.model.DependencyKind +import org.jetbrains.kotlin.test.model.FrontendKinds +import org.jetbrains.kotlin.test.services.AdditionalDiagnosticsSourceFilesProvider +import org.jetbrains.kotlin.test.services.CoroutineHelpersSourceFilesProvider + +abstract class AbstractDiagnosticsNativeTest : AbstractKotlinCompilerTest() { + override fun TestConfigurationBuilder.configuration() { + globalDefaults { + frontend = FrontendKinds.ClassicFrontend + backend = BackendKind.NoBackend + targetPlatform = NativePlatforms.unspecifiedNativePlatform + dependencyKind = DependencyKind.Source + } + + defaultDirectives { + +JvmEnvironmentConfigurationDirectives.USE_PSI_CLASS_FILES_READING + } + + enableMetaInfoHandler() + + useMetaInfoProcessors(::OldNewInferenceMetaInfoProcessor) + useAdditionalSourceProviders( + ::AdditionalDiagnosticsSourceFilesProvider, + ::CoroutineHelpersSourceFilesProvider, + ) + + useFrontendFacades(::ClassicFrontendFacade) + useFrontendHandlers( + ::DeclarationsDumpHandler, + ::ClassicDiagnosticsHandler, + ) + } +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/CompilerConfigurationProvider.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/CompilerConfigurationProvider.kt index 360a5d48b32..cf9b0c9d140 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/CompilerConfigurationProvider.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/CompilerConfigurationProvider.kt @@ -20,6 +20,10 @@ import org.jetbrains.kotlin.config.CommonConfigurationKeys import org.jetbrains.kotlin.config.CompilerConfiguration import org.jetbrains.kotlin.config.CompilerConfigurationKey import org.jetbrains.kotlin.config.languageVersionSettings +import org.jetbrains.kotlin.platform.isCommon +import org.jetbrains.kotlin.platform.js.isJs +import org.jetbrains.kotlin.platform.jvm.isJvm +import org.jetbrains.kotlin.platform.konan.isNative import org.jetbrains.kotlin.psi.KtFile import org.jetbrains.kotlin.test.model.TestFile import org.jetbrains.kotlin.test.model.TestModule @@ -59,11 +63,20 @@ class CompilerConfigurationProviderImpl( override fun getKotlinCoreEnvironment(module: TestModule): KotlinCoreEnvironment { return cache.getOrPut(module) { + val platform = module.targetPlatform + val configFiles = when { + platform.isJvm() -> EnvironmentConfigFiles.JVM_CONFIG_FILES + platform.isJs() -> EnvironmentConfigFiles.JS_CONFIG_FILES + platform.isNative() -> EnvironmentConfigFiles.NATIVE_CONFIG_FILES + // TODO: is it correct? + platform.isCommon() -> EnvironmentConfigFiles.METADATA_CONFIG_FILES + else -> error("Unknown platform: $platform") + } val projectEnv = KotlinCoreEnvironment.createProjectEnvironmentForTests(testRootDisposable, CompilerConfiguration()) KotlinCoreEnvironment.createForTests( projectEnv, createCompilerConfiguration(module, projectEnv.project), - EnvironmentConfigFiles.JVM_CONFIG_FILES + configFiles ) } } diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractDiagnosticsNativeTest.kt b/compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/native/FakeTopDownAnalyzerFacadeForNative.kt similarity index 58% rename from compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractDiagnosticsNativeTest.kt rename to compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/native/FakeTopDownAnalyzerFacadeForNative.kt index ee98e24b0bc..1d57dffcb24 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractDiagnosticsNativeTest.kt +++ b/compiler/tests-compiler-utils/tests/org/jetbrains/kotlin/native/FakeTopDownAnalyzerFacadeForNative.kt @@ -3,12 +3,9 @@ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ -package org.jetbrains.kotlin.checkers +package org.jetbrains.kotlin.native import org.jetbrains.kotlin.analyzer.AnalysisResult -import org.jetbrains.kotlin.builtins.DefaultBuiltIns -import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles -import org.jetbrains.kotlin.config.JvmTarget import org.jetbrains.kotlin.config.LanguageVersionSettings import org.jetbrains.kotlin.container.get import org.jetbrains.kotlin.container.useInstance @@ -16,7 +13,6 @@ import org.jetbrains.kotlin.context.ModuleContext import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl import org.jetbrains.kotlin.frontend.di.configureModule import org.jetbrains.kotlin.frontend.di.configureStandardResolveComponents -import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.platform.konan.NativePlatforms import org.jetbrains.kotlin.psi.KtFile import org.jetbrains.kotlin.resolve.* @@ -24,49 +20,8 @@ import org.jetbrains.kotlin.resolve.konan.platform.NativePlatformAnalyzerService import org.jetbrains.kotlin.resolve.lazy.KotlinCodeAnalyzer import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory import org.jetbrains.kotlin.resolve.lazy.declarations.FileBasedDeclarationProviderFactory -import org.jetbrains.kotlin.storage.StorageManager -import java.util.* - -abstract class AbstractDiagnosticsNativeTest : AbstractDiagnosticsTest() { - - override fun getEnvironmentConfigFiles(): EnvironmentConfigFiles = EnvironmentConfigFiles.NATIVE_CONFIG_FILES - - override fun analyzeModuleContents( - moduleContext: ModuleContext, - files: List, - moduleTrace: BindingTrace, - languageVersionSettings: LanguageVersionSettings, - separateModules: Boolean, - jvmTarget: JvmTarget - ): AnalysisResult = FakeTopDownAnalyzerFacadeForNative.analyzeFilesWithGivenTrace( - files, - moduleTrace, - moduleContext, - languageVersionSettings - ) - - override fun shouldSkipJvmSignatureDiagnostics(groupedByModule: Map>): Boolean = true - - override fun createModule(moduleName: String, storageManager: StorageManager): ModuleDescriptorImpl = - ModuleDescriptorImpl(Name.special("<$moduleName>"), storageManager, DefaultBuiltIns()) - - override fun createSealedModule(storageManager: StorageManager): ModuleDescriptorImpl { - val module = createModule("kotlin-native-test-module", storageManager) - - val dependencies = ArrayList() - - dependencies.add(module) - dependencies.addAll(getAdditionalDependencies(module)) - dependencies.add(module.builtIns.builtInsModule) - - module.setDependencies(dependencies) - - return module - } -} - -private object FakeTopDownAnalyzerFacadeForNative { +object FakeTopDownAnalyzerFacadeForNative { fun analyzeFilesWithGivenTrace( files: Collection, trace: BindingTrace, @@ -80,7 +35,7 @@ private object FakeTopDownAnalyzerFacadeForNative { languageVersionSettings ) - analyzerForNative.analyzeDeclarations(TopDownAnalysisMode.TopLevelDeclarations, files) + analyzerForNative.analyzeDeclarations(TopDownAnalysisMode.TopLevelDeclarations, files as Collection) return AnalysisResult.success(trace.bindingContext, moduleContext.module) } } diff --git a/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt b/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt index 2cb24bacb7f..e9b03e95d04 100644 --- a/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt +++ b/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt @@ -71,10 +71,6 @@ fun main(args: Array) { model("diagnostics/testsWithJsStdLibAndBackendCompilation") } - testClass { - model("diagnostics/nativeTests") - } - testClass { model("diagnostics/testsWithJava15") } From acbc468fdde96378c5bfb844e987390864b85792 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Tue, 15 Dec 2020 10:46:58 +0300 Subject: [PATCH 118/196] [FIR] Add light tree mode to FirAnalyzerFacade --- compiler/fir/entrypoint/build.gradle.kts | 1 + .../kotlin/fir/analysis/FirAnalyzerFacade.kt | 29 +++++++++++++++---- 2 files changed, 24 insertions(+), 6 deletions(-) diff --git a/compiler/fir/entrypoint/build.gradle.kts b/compiler/fir/entrypoint/build.gradle.kts index 32db758c21c..b42e5b56867 100644 --- a/compiler/fir/entrypoint/build.gradle.kts +++ b/compiler/fir/entrypoint/build.gradle.kts @@ -8,6 +8,7 @@ dependencies { api(project(":compiler:frontend.java")) api(project(":compiler:fir:java")) api(project(":compiler:fir:raw-fir:psi2fir")) + api(project(":compiler:fir:raw-fir:light-tree2fir")) api(project(":compiler:fir:fir2ir")) api(project(":compiler:fir:checkers")) diff --git a/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/analysis/FirAnalyzerFacade.kt b/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/analysis/FirAnalyzerFacade.kt index b6146c99b48..e098d1093d7 100644 --- a/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/analysis/FirAnalyzerFacade.kt +++ b/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/analysis/FirAnalyzerFacade.kt @@ -17,6 +17,7 @@ import org.jetbrains.kotlin.fir.backend.jvm.FirJvmKotlinMangler import org.jetbrains.kotlin.fir.backend.jvm.FirJvmVisibilityConverter import org.jetbrains.kotlin.fir.builder.RawFirBuilder import org.jetbrains.kotlin.fir.declarations.FirFile +import org.jetbrains.kotlin.fir.lightTree.LightTree2Fir import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.firProvider import org.jetbrains.kotlin.fir.resolve.providers.impl.FirProviderImpl @@ -25,8 +26,15 @@ import org.jetbrains.kotlin.ir.backend.jvm.serialization.JvmManglerDesc import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl import org.jetbrains.kotlin.psi.KtFile import org.jetbrains.kotlin.psi2ir.generators.GeneratorExtensions +import java.io.File -class FirAnalyzerFacade(val session: FirSession, val languageVersionSettings: LanguageVersionSettings, val ktFiles: Collection) { +class FirAnalyzerFacade( + val session: FirSession, + val languageVersionSettings: LanguageVersionSettings, + val ktFiles: Collection = emptyList(), // may be empty if light tree mode enabled + val originalFiles: Collection = emptyList(), // may be empty if light tree mode disabled + val useLightTree: Boolean = false +) { private var firFiles: List? = null private var scopeSession: ScopeSession? = null private var collectedDiagnostics: Map>>? = null @@ -34,11 +42,20 @@ class FirAnalyzerFacade(val session: FirSession, val languageVersionSettings: La private fun buildRawFir() { if (firFiles != null) return val firProvider = (session.firProvider as FirProviderImpl) - val builder = RawFirBuilder(session, firProvider.kotlinScopeProvider) - firFiles = ktFiles.map { - val firFile = builder.buildFirFile(it) - firProvider.recordFile(firFile) - firFile + firFiles = if (useLightTree) { + val builder = LightTree2Fir(session, firProvider.kotlinScopeProvider) + originalFiles.map { + builder.buildFirFile(it).also { firFile -> + firProvider.recordFile(firFile) + } + } + } else { + val builder = RawFirBuilder(session, firProvider.kotlinScopeProvider) + ktFiles.map { + builder.buildFirFile(it).also { firFile -> + firProvider.recordFile(firFile) + } + } } } From b048296dcaad76d24468944022f47dc443185a41 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Tue, 15 Dec 2020 12:58:14 +0300 Subject: [PATCH 119/196] [FIR] Fix calculating offsets for light tree source elements --- .../kotlin/fir/lightTree/LightTree2Fir.kt | 2 +- .../fir/lightTree/converter/BaseConverter.kt | 7 +-- .../converter/DeclarationsConverter.kt | 18 +++++++- .../converter/ExpressionsConverter.kt | 43 +++++++++++-------- 4 files changed, 45 insertions(+), 25 deletions(-) diff --git a/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/LightTree2Fir.kt b/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/LightTree2Fir.kt index 4b41bd3f883..f5b1d2c7a5c 100644 --- a/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/LightTree2Fir.kt +++ b/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/LightTree2Fir.kt @@ -52,7 +52,7 @@ class LightTree2Fir( } fun buildFirFile(file: File): FirFile { - val code = FileUtil.loadFile(file, CharsetToolkit.UTF8, true).trim() + val code = FileUtil.loadFile(file, CharsetToolkit.UTF8, true) return buildFirFile(code, file.name) } diff --git a/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/converter/BaseConverter.kt b/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/converter/BaseConverter.kt index d383fb15399..d3a94e3be12 100644 --- a/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/converter/BaseConverter.kt +++ b/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/converter/BaseConverter.kt @@ -21,12 +21,13 @@ import org.jetbrains.kotlin.lexer.KtTokens.* import org.jetbrains.kotlin.name.Name import kotlin.contracts.ExperimentalContracts -open class BaseConverter( +abstract class BaseConverter( baseSession: FirSession, val tree: FlyweightCapableTreeStructure, - val offset: Int, context: Context = Context() ) : BaseFirBuilder(baseSession, context) { + abstract val offset: Int + protected val implicitType = buildImplicitTypeRef() override fun LighterASTNode.toFirSourceElement(kind: FirFakeSourceElementKind?): FirLightSourceElement { @@ -175,4 +176,4 @@ open class BaseConverter( return container } -} \ No newline at end of file +} diff --git a/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/converter/DeclarationsConverter.kt b/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/converter/DeclarationsConverter.kt index dedd0d5d0e7..7def4ad4f41 100644 --- a/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/converter/DeclarationsConverter.kt +++ b/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/converter/DeclarationsConverter.kt @@ -65,8 +65,22 @@ class DeclarationsConverter( tree: FlyweightCapableTreeStructure, offset: Int = 0, context: Context = Context() -) : BaseConverter(session, tree, offset, context) { - private val expressionConverter = ExpressionsConverter(session, stubMode, tree, this, offset + 1, context) +) : BaseConverter(session, tree, context) { + @set:PrivateForInline + override var offset: Int = offset + + @OptIn(PrivateForInline::class) + inline fun withOffset(newOffset: Int, block: () -> R): R { + val oldOffset = offset + offset = newOffset + return try { + block() + } finally { + offset = oldOffset + } + } + + private val expressionConverter = ExpressionsConverter(session, stubMode, tree, this, context) /** * [org.jetbrains.kotlin.parsing.KotlinParsing.parseFile] diff --git a/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/converter/ExpressionsConverter.kt b/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/converter/ExpressionsConverter.kt index f28ffd57073..affd7d14d44 100644 --- a/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/converter/ExpressionsConverter.kt +++ b/compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/converter/ExpressionsConverter.kt @@ -50,9 +50,10 @@ class ExpressionsConverter( private val stubMode: Boolean, tree: FlyweightCapableTreeStructure, private val declarationsConverter: DeclarationsConverter, - offset: Int, context: Context = Context() -) : BaseConverter(session, tree, offset, context) { +) : BaseConverter(session, tree, context) { + override val offset: Int + get() = declarationsConverter.offset inline fun getAsFirExpression(expression: LighterASTNode?, errorReason: String = ""): R { return expression?.let { @@ -68,8 +69,10 @@ class ExpressionsConverter( return when (expression.tokenType) { LAMBDA_EXPRESSION -> { val lambdaTree = LightTree2Fir.buildLightTreeLambdaExpression(expression.asText) - ExpressionsConverter(baseSession, stubMode, lambdaTree, declarationsConverter, offset, context) - .convertLambdaExpression(lambdaTree.root) + declarationsConverter.withOffset(offset + expression.startOffset) { + ExpressionsConverter(baseSession, stubMode, lambdaTree, declarationsConverter, context) + .convertLambdaExpression(lambdaTree.root) + } } BINARY_EXPRESSION -> convertBinaryExpression(expression) BINARY_WITH_TYPE -> convertBinaryWithTypeRHSExpression(expression) { @@ -172,22 +175,24 @@ class ExpressionsConverter( } body = if (block != null) { - declarationsConverter.convertBlockExpressionWithoutBuilding(block!!).apply { - if (statements.isEmpty()) { - statements.add( - buildReturnExpression { - source = expressionSource - this.target = target - result = buildUnitExpression { source = expressionSource } - } - ) - } - if (destructuringBlock is FirBlock) { - for ((index, statement) in destructuringBlock.statements.withIndex()) { - statements.add(index, statement) + declarationsConverter.withOffset(expressionSource.startOffset) { + declarationsConverter.convertBlockExpressionWithoutBuilding(block!!).apply { + if (statements.isEmpty()) { + statements.add( + buildReturnExpression { + source = expressionSource + this.target = target + result = buildUnitExpression { source = expressionSource } + } + ) } - } - }.build() + if (destructuringBlock is FirBlock) { + for ((index, statement) in destructuringBlock.statements.withIndex()) { + statements.add(index, statement) + } + } + }.build() + } } else { buildSingleExpressionBlock(buildErrorExpression(null, ConeSimpleDiagnostic("Lambda has no body", DiagnosticKind.Syntax))) } From 7e9deb76022095805790bbb814fed3e942478370 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Tue, 15 Dec 2020 12:58:34 +0300 Subject: [PATCH 120/196] [FIR] Fix NPE in light tree source utils --- .../analysis/diagnostics/LightTreePositioningStrategy.kt | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/LightTreePositioningStrategy.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/LightTreePositioningStrategy.kt index 1f496c79d03..5c0db8b0dea 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/LightTreePositioningStrategy.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/LightTreePositioningStrategy.kt @@ -45,10 +45,10 @@ private val DOC_AND_COMMENT_TOKENS = setOf( private fun hasSyntaxErrors(node: LighterASTNode, tree: FlyweightCapableTreeStructure): Boolean { if (node.tokenType == TokenType.ERROR_ELEMENT) return true - val childrenRef = Ref>() + val childrenRef = Ref?>() tree.getChildren(node, childrenRef) - val children = childrenRef.get() - return children.lastOrNull { + val children = childrenRef.get() ?: return false + return children.filterNotNull().lastOrNull { val tokenType = it.tokenType tokenType !is KtSingleValueToken && tokenType !in DOC_AND_COMMENT_TOKENS }?.let { hasSyntaxErrors(it, tree) } == true From 49d9b8595024d53cf7d0b8b08cce9dad01f9d457 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Tue, 15 Dec 2020 16:07:26 +0300 Subject: [PATCH 121/196] [TEST] Migrate AbstractFirDiagnosticsWithLightTreeTest to new test runners Also this commit adds AbstractTwoAttributesMetaInfoProcessor which can be used for reporting diagnostics with two attributes (OI/NI, PSI/Light tree) --- ...n.txt => recursiveNamedAnnotation.fir.txt} | 0 .../jetbrains/kotlin/test/model/Facades.kt | 4 + ...DiagnosticsWithLightTreeTestGenerated.java | 801 ++++++++++++------ .../directives/FirDiagnosticsDirectives.kt | 11 + .../handlers/ClassicDiagnosticReporter.kt | 64 +- .../test/frontend/fir/FirFrontendFacade.kt | 16 +- .../fir/handlers/FirDiagnosticsHandler.kt | 54 +- .../generators/GenerateNewCompilerTests.kt | 10 +- .../kotlin/test/impl/TestConfigurationImpl.kt | 7 +- .../test/runners/AbstractFirDiagnosticTest.kt | 22 +- .../AbstractTwoAttributesMetaInfoProcessor.kt | 76 ++ .../generators/tests/GenerateCompilerTests.kt | 5 - 12 files changed, 757 insertions(+), 313 deletions(-) rename compiler/fir/analysis-tests/testData/resolve/problems/{recursiveNamedAnnotation.txt => recursiveNamedAnnotation.fir.txt} (100%) rename compiler/{fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir => tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners}/FirDiagnosticsWithLightTreeTestGenerated.java (91%) create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/utils/AbstractTwoAttributesMetaInfoProcessor.kt diff --git a/compiler/fir/analysis-tests/testData/resolve/problems/recursiveNamedAnnotation.txt b/compiler/fir/analysis-tests/testData/resolve/problems/recursiveNamedAnnotation.fir.txt similarity index 100% rename from compiler/fir/analysis-tests/testData/resolve/problems/recursiveNamedAnnotation.txt rename to compiler/fir/analysis-tests/testData/resolve/problems/recursiveNamedAnnotation.fir.txt diff --git a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/model/Facades.kt b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/model/Facades.kt index aafed38186b..d6f075f226b 100644 --- a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/model/Facades.kt +++ b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/model/Facades.kt @@ -5,6 +5,7 @@ package org.jetbrains.kotlin.test.model +import org.jetbrains.kotlin.test.directives.model.DirectivesContainer import org.jetbrains.kotlin.test.services.ServiceRegistrationData import org.jetbrains.kotlin.test.services.TestServices @@ -16,6 +17,9 @@ abstract class AbstractTestFacade, O : ResultingArtifac open val additionalServices: List get() = emptyList() + + open val additionalDirectives: List + get() = emptyList() } abstract class FrontendFacade>( diff --git a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/FirDiagnosticsWithLightTreeTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/FirDiagnosticsWithLightTreeTestGenerated.java similarity index 91% rename from compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/FirDiagnosticsWithLightTreeTestGenerated.java rename to compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/FirDiagnosticsWithLightTreeTestGenerated.java index 0c4b52b3e1a..95c5bdf1c1a 100644 --- a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/FirDiagnosticsWithLightTreeTestGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/FirDiagnosticsWithLightTreeTestGenerated.java @@ -3,1681 +3,1940 @@ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ -package org.jetbrains.kotlin.fir; +package org.jetbrains.kotlin.test.runners; import com.intellij.testFramework.TestDataPath; -import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; -import org.jetbrains.kotlin.test.KotlinTestUtils; import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; import java.io.File; import java.util.regex.Pattern; -/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */ +/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */ @SuppressWarnings("all") @TestMetadata("compiler/fir/analysis-tests/testData/resolve") @TestDataPath("$PROJECT_ROOT") -@RunWith(JUnit3RunnerWithInners.class) public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnosticsWithLightTreeTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + @Test public void testAllFilesPresentInResolve() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } + @Test @TestMetadata("asImports.kt") public void testAsImports() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/asImports.kt"); } + @Test @TestMetadata("bareTypes.kt") public void testBareTypes() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/bareTypes.kt"); } + @Test @TestMetadata("cast.kt") public void testCast() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/cast.kt"); } + @Test @TestMetadata("companion.kt") public void testCompanion() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/companion.kt"); } + @Test @TestMetadata("companionAccessInEnum.kt") public void testCompanionAccessInEnum() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/companionAccessInEnum.kt"); } + @Test @TestMetadata("companionObjectCall.kt") public void testCompanionObjectCall() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/companionObjectCall.kt"); } + @Test @TestMetadata("companionUsesNested.kt") public void testCompanionUsesNested() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/companionUsesNested.kt"); } + @Test @TestMetadata("constantValues.kt") public void testConstantValues() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/constantValues.kt"); } + @Test @TestMetadata("copy.kt") public void testCopy() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/copy.kt"); } + @Test @TestMetadata("covariantArrayAsReceiver.kt") public void testCovariantArrayAsReceiver() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/covariantArrayAsReceiver.kt"); } + @Test @TestMetadata("defaultJavaImportHiding.kt") public void testDefaultJavaImportHiding() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/defaultJavaImportHiding.kt"); } + @Test @TestMetadata("defaultParametersInheritedToJava.kt") public void testDefaultParametersInheritedToJava() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/defaultParametersInheritedToJava.kt"); } + @Test @TestMetadata("definitelyNotNullAmbiguity.kt") public void testDefinitelyNotNullAmbiguity() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/definitelyNotNullAmbiguity.kt"); } + @Test @TestMetadata("delegatedSuperType.kt") public void testDelegatedSuperType() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/delegatedSuperType.kt"); } + @Test @TestMetadata("delegatingConstructorCall.kt") public void testDelegatingConstructorCall() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/delegatingConstructorCall.kt"); } + @Test @TestMetadata("delegatingConstructorsAndTypeAliases.kt") public void testDelegatingConstructorsAndTypeAliases() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/delegatingConstructorsAndTypeAliases.kt"); } + @Test @TestMetadata("derivedClass.kt") public void testDerivedClass() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/derivedClass.kt"); } + @Test @TestMetadata("enum.kt") public void testEnum() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/enum.kt"); } + @Test @TestMetadata("enumWithCompanion.kt") public void testEnumWithCompanion() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/enumWithCompanion.kt"); } + @Test @TestMetadata("exhaustiveWhenAndDNNType.kt") public void testExhaustiveWhenAndDNNType() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/exhaustiveWhenAndDNNType.kt"); } + @Test @TestMetadata("exhaustiveWhenAndFlexibleType.kt") public void testExhaustiveWhenAndFlexibleType() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/exhaustiveWhenAndFlexibleType.kt"); } + @Test @TestMetadata("exhaustiveness_boolean.kt") public void testExhaustiveness_boolean() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/exhaustiveness_boolean.kt"); } + @Test @TestMetadata("exhaustiveness_enum.kt") public void testExhaustiveness_enum() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/exhaustiveness_enum.kt"); } + @Test @TestMetadata("exhaustiveness_enumJava.kt") public void testExhaustiveness_enumJava() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/exhaustiveness_enumJava.kt"); } + @Test @TestMetadata("exhaustiveness_sealedClass.kt") public void testExhaustiveness_sealedClass() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/exhaustiveness_sealedClass.kt"); } + @Test @TestMetadata("exhaustiveness_sealedObject.kt") public void testExhaustiveness_sealedObject() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/exhaustiveness_sealedObject.kt"); } + @Test @TestMetadata("exhaustiveness_sealedSubClass.kt") public void testExhaustiveness_sealedSubClass() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/exhaustiveness_sealedSubClass.kt"); } + @Test @TestMetadata("extension.kt") public void testExtension() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/extension.kt"); } + @Test @TestMetadata("F.kt") public void testF() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/F.kt"); } + @Test @TestMetadata("fakeRecursiveSupertype.kt") public void testFakeRecursiveSupertype() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/fakeRecursiveSupertype.kt"); } + @Test @TestMetadata("fakeRecursiveTypealias.kt") public void testFakeRecursiveTypealias() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/fakeRecursiveTypealias.kt"); } + @Test @TestMetadata("fib.kt") public void testFib() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/fib.kt"); } + @Test @TestMetadata("flexibleCapturedType.kt") public void testFlexibleCapturedType() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/flexibleCapturedType.kt"); } + @Test @TestMetadata("ft.kt") public void testFt() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/ft.kt"); } + @Test @TestMetadata("functionTypeAlias.kt") public void testFunctionTypeAlias() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/functionTypeAlias.kt"); } + @Test @TestMetadata("functionTypes.kt") public void testFunctionTypes() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/functionTypes.kt"); } + @Test @TestMetadata("genericConstructors.kt") public void testGenericConstructors() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/genericConstructors.kt"); } + @Test @TestMetadata("genericFunctions.kt") public void testGenericFunctions() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/genericFunctions.kt"); } + @Test @TestMetadata("genericReceiverPropertyOverride.kt") public void testGenericReceiverPropertyOverride() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/genericReceiverPropertyOverride.kt"); } + @Test @TestMetadata("implicitTypeInFakeOverride.kt") public void testImplicitTypeInFakeOverride() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/implicitTypeInFakeOverride.kt"); } + @Test @TestMetadata("incorrectSuperCall.kt") public void testIncorrectSuperCall() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/incorrectSuperCall.kt"); } + @Test @TestMetadata("intersectionScope.kt") public void testIntersectionScope() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/intersectionScope.kt"); } + @Test @TestMetadata("intersectionTypes.kt") public void testIntersectionTypes() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/intersectionTypes.kt"); } + @Test @TestMetadata("invokeInWhenSubjectVariableInitializer.kt") public void testInvokeInWhenSubjectVariableInitializer() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/invokeInWhenSubjectVariableInitializer.kt"); } + @Test @TestMetadata("invokeOfLambdaWithReceiver.kt") public void testInvokeOfLambdaWithReceiver() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/invokeOfLambdaWithReceiver.kt"); } + @Test @TestMetadata("javaFieldVsAccessor.kt") public void testJavaFieldVsAccessor() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/javaFieldVsAccessor.kt"); } + @Test @TestMetadata("javaStaticScopeInheritance.kt") public void testJavaStaticScopeInheritance() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/javaStaticScopeInheritance.kt"); } + @Test @TestMetadata("kt41984.kt") public void testKt41984() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/kt41984.kt"); } + @Test @TestMetadata("kt41990.kt") public void testKt41990() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/kt41990.kt"); } + @Test @TestMetadata("labelAndReceiverForInfix.kt") public void testLabelAndReceiverForInfix() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/labelAndReceiverForInfix.kt"); } + @Test @TestMetadata("lambdaArgInScopeFunction.kt") public void testLambdaArgInScopeFunction() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/lambdaArgInScopeFunction.kt"); } + @Test @TestMetadata("lambdaInLhsOfTypeOperatorCall.kt") public void testLambdaInLhsOfTypeOperatorCall() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/lambdaInLhsOfTypeOperatorCall.kt"); } + @Test @TestMetadata("lambdaPropertyTypeInference.kt") public void testLambdaPropertyTypeInference() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/lambdaPropertyTypeInference.kt"); } + @Test @TestMetadata("localFunctionsHiding.kt") public void testLocalFunctionsHiding() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/localFunctionsHiding.kt"); } + @Test @TestMetadata("localObject.kt") public void testLocalObject() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/localObject.kt"); } + @Test @TestMetadata("nestedClass.kt") public void testNestedClass() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/nestedClass.kt"); } + @Test @TestMetadata("nestedClassContructor.kt") public void testNestedClassContructor() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/nestedClassContructor.kt"); } + @Test @TestMetadata("nestedClassNameClash.kt") public void testNestedClassNameClash() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/nestedClassNameClash.kt"); } + @Test @TestMetadata("NestedOfAliasedType.kt") public void testNestedOfAliasedType() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/NestedOfAliasedType.kt"); } + @Test @TestMetadata("nestedReturnType.kt") public void testNestedReturnType() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/nestedReturnType.kt"); } + @Test @TestMetadata("NestedSuperType.kt") public void testNestedSuperType() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/NestedSuperType.kt"); } + @Test @TestMetadata("objectInnerClass.kt") public void testObjectInnerClass() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/objectInnerClass.kt"); } + @Test @TestMetadata("offOrderMultiBoundGenericOverride.kt") public void testOffOrderMultiBoundGenericOverride() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/offOrderMultiBoundGenericOverride.kt"); } + @Test @TestMetadata("openInInterface.kt") public void testOpenInInterface() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/openInInterface.kt"); } + @Test @TestMetadata("problems2.kt") public void testProblems2() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/problems2.kt"); } + @Test @TestMetadata("propertyFromJavaPlusAssign.kt") public void testPropertyFromJavaPlusAssign() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/propertyFromJavaPlusAssign.kt"); } + @Test @TestMetadata("qualifierWithCompanion.kt") public void testQualifierWithCompanion() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/qualifierWithCompanion.kt"); } + @Test @TestMetadata("rawTypeSam.kt") public void testRawTypeSam() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/rawTypeSam.kt"); } + @Test @TestMetadata("recursiveCallOnWhenWithSealedClass.kt") public void testRecursiveCallOnWhenWithSealedClass() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/recursiveCallOnWhenWithSealedClass.kt"); } + @Test @TestMetadata("sealedClass.kt") public void testSealedClass() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/sealedClass.kt"); } + @Test @TestMetadata("simpleClass.kt") public void testSimpleClass() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/simpleClass.kt"); } + @Test @TestMetadata("simpleTypeAlias.kt") public void testSimpleTypeAlias() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/simpleTypeAlias.kt"); } + @Test @TestMetadata("spreadOperator.kt") public void testSpreadOperator() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/spreadOperator.kt"); } + @Test @TestMetadata("statusResolveForTypealiasAsSuperClass.kt") public void testStatusResolveForTypealiasAsSuperClass() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/statusResolveForTypealiasAsSuperClass.kt"); } + @Test @TestMetadata("syntheticsVsNormalProperties.kt") public void testSyntheticsVsNormalProperties() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/syntheticsVsNormalProperties.kt"); } + @Test @TestMetadata("treeSet.kt") public void testTreeSet() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/treeSet.kt"); } + @Test @TestMetadata("tryInference.kt") public void testTryInference() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/tryInference.kt"); } + @Test @TestMetadata("TwoDeclarationsInSameFile.kt") public void testTwoDeclarationsInSameFile() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/TwoDeclarationsInSameFile.kt"); } + @Test @TestMetadata("typeAliasWithGeneric.kt") public void testTypeAliasWithGeneric() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/typeAliasWithGeneric.kt"); } + @Test @TestMetadata("typeAliasWithTypeArguments.kt") public void testTypeAliasWithTypeArguments() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/typeAliasWithTypeArguments.kt"); } + @Test @TestMetadata("typeFromGetter.kt") public void testTypeFromGetter() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/typeFromGetter.kt"); } + @Test @TestMetadata("typeParameterInPropertyReceiver.kt") public void testTypeParameterInPropertyReceiver() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/typeParameterInPropertyReceiver.kt"); } + @Test @TestMetadata("typeParameterVsNested.kt") public void testTypeParameterVsNested() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/typeParameterVsNested.kt"); } + @Test @TestMetadata("typesInLocalFunctions.kt") public void testTypesInLocalFunctions() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/typesInLocalFunctions.kt"); } + @Test @TestMetadata("varargInPrimaryConstructor.kt") public void testVarargInPrimaryConstructor() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/varargInPrimaryConstructor.kt"); } + @Test @TestMetadata("whenAsReceiver.kt") public void testWhenAsReceiver() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/whenAsReceiver.kt"); } + @Test @TestMetadata("whenElse.kt") public void testWhenElse() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/whenElse.kt"); } + @Test @TestMetadata("whenExpressionType.kt") public void testWhenExpressionType() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/whenExpressionType.kt"); } + @Test @TestMetadata("whenInference.kt") public void testWhenInference() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/whenInference.kt"); } + @Nested @TestMetadata("compiler/fir/analysis-tests/testData/resolve/arguments") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Arguments extends AbstractFirDiagnosticsWithLightTreeTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class Arguments extends AbstractFirDiagnosticsWithLightTreeTest { + @Test public void testAllFilesPresentInArguments() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/arguments"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } + @Test @TestMetadata("ambiguityOnJavaOverride.kt") public void testAmbiguityOnJavaOverride() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/arguments/ambiguityOnJavaOverride.kt"); } + @Test @TestMetadata("argumentsOfAnnotations.kt") public void testArgumentsOfAnnotations() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/arguments/argumentsOfAnnotations.kt"); } + @Test @TestMetadata("argumentsOfJavaAnnotation.kt") public void testArgumentsOfJavaAnnotation() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/arguments/argumentsOfJavaAnnotation.kt"); } + @Test @TestMetadata("default.kt") public void testDefault() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/arguments/default.kt"); } + @Test @TestMetadata("defaultFromOverrides.kt") public void testDefaultFromOverrides() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/arguments/defaultFromOverrides.kt"); } + @Test @TestMetadata("definetelyNotNullForTypeParameter.kt") public void testDefinetelyNotNullForTypeParameter() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/arguments/definetelyNotNullForTypeParameter.kt"); } + @Test @TestMetadata("extensionLambdaInDefaultArgument.kt") public void testExtensionLambdaInDefaultArgument() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/arguments/extensionLambdaInDefaultArgument.kt"); } + @Test @TestMetadata("fieldPlusAssign.kt") public void testFieldPlusAssign() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/arguments/fieldPlusAssign.kt"); } + @Test @TestMetadata("incorrectFunctionalType.kt") public void testIncorrectFunctionalType() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/arguments/incorrectFunctionalType.kt"); } + @Test @TestMetadata("integerLiteralTypes.kt") public void testIntegerLiteralTypes() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/arguments/integerLiteralTypes.kt"); } + @Test @TestMetadata("invoke.kt") public void testInvoke() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/arguments/invoke.kt"); } + @Test @TestMetadata("javaAnnotationsWithArrayValue.kt") public void testJavaAnnotationsWithArrayValue() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/arguments/javaAnnotationsWithArrayValue.kt"); } + @Test @TestMetadata("javaArrayVariance.kt") public void testJavaArrayVariance() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/arguments/javaArrayVariance.kt"); } + @Test @TestMetadata("kt41940.kt") public void testKt41940() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/arguments/kt41940.kt"); } + @Test @TestMetadata("lambda.kt") public void testLambda() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/arguments/lambda.kt"); } + @Test @TestMetadata("lambdaInLambda.kt") public void testLambdaInLambda() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/arguments/lambdaInLambda.kt"); } + @Test @TestMetadata("lambdaInLambda2.kt") public void testLambdaInLambda2() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/arguments/lambdaInLambda2.kt"); } + @Test @TestMetadata("lambdaInUnresolvedCall.kt") public void testLambdaInUnresolvedCall() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/arguments/lambdaInUnresolvedCall.kt"); } + @Test @TestMetadata("namedArrayInAnnotation.kt") public void testNamedArrayInAnnotation() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/arguments/namedArrayInAnnotation.kt"); } + @Test @TestMetadata("operatorsOverLiterals.kt") public void testOperatorsOverLiterals() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/arguments/operatorsOverLiterals.kt"); } + @Test @TestMetadata("overloadByReceiver.kt") public void testOverloadByReceiver() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/arguments/overloadByReceiver.kt"); } + @Test @TestMetadata("overloadWithDefault.kt") public void testOverloadWithDefault() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/arguments/overloadWithDefault.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/arguments/simple.kt"); } + @Test @TestMetadata("stringTemplates.kt") public void testStringTemplates() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/arguments/stringTemplates.kt"); } + @Test @TestMetadata("tryInLambda.kt") public void testTryInLambda() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/arguments/tryInLambda.kt"); } + @Test @TestMetadata("untouchedReturnInIf.kt") public void testUntouchedReturnInIf() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/arguments/untouchedReturnInIf.kt"); } + @Test @TestMetadata("vararg.kt") public void testVararg() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/arguments/vararg.kt"); } + @Test @TestMetadata("varargOfLambdasWithReceiver.kt") public void testVarargOfLambdasWithReceiver() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/arguments/varargOfLambdasWithReceiver.kt"); } + @Test @TestMetadata("varargProjection.kt") public void testVarargProjection() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/arguments/varargProjection.kt"); } } + @Nested @TestMetadata("compiler/fir/analysis-tests/testData/resolve/arrays") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Arrays extends AbstractFirDiagnosticsWithLightTreeTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class Arrays extends AbstractFirDiagnosticsWithLightTreeTest { + @Test public void testAllFilesPresentInArrays() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/arrays"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } + @Test @TestMetadata("arraySet.kt") public void testArraySet() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/arrays/arraySet.kt"); } + @Test @TestMetadata("arraySetWithOperation.kt") public void testArraySetWithOperation() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/arrays/arraySetWithOperation.kt"); } } + @Nested @TestMetadata("compiler/fir/analysis-tests/testData/resolve/builtins") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Builtins extends AbstractFirDiagnosticsWithLightTreeTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class Builtins extends AbstractFirDiagnosticsWithLightTreeTest { + @Test public void testAllFilesPresentInBuiltins() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/builtins"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } + @Test @TestMetadata("lists.kt") public void testLists() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/builtins/lists.kt"); } } + @Nested @TestMetadata("compiler/fir/analysis-tests/testData/resolve/callResolution") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class CallResolution extends AbstractFirDiagnosticsWithLightTreeTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class CallResolution extends AbstractFirDiagnosticsWithLightTreeTest { + @Test public void testAllFilesPresentInCallResolution() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/callResolution"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } + @Test @TestMetadata("companionInvoke.kt") public void testCompanionInvoke() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/callResolution/companionInvoke.kt"); } + @Test @TestMetadata("companionVsSuperStatic.kt") public void testCompanionVsSuperStatic() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/callResolution/companionVsSuperStatic.kt"); } + @Test @TestMetadata("debugExpressionType.kt") public void testDebugExpressionType() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/callResolution/debugExpressionType.kt"); } + @Test @TestMetadata("debugInfoCall.kt") public void testDebugInfoCall() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/callResolution/debugInfoCall.kt"); } + @Test @TestMetadata("errorCandidates.kt") public void testErrorCandidates() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/callResolution/errorCandidates.kt"); } + @Test @TestMetadata("extensionInvokeAfterSafeCall.kt") public void testExtensionInvokeAfterSafeCall() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/callResolution/extensionInvokeAfterSafeCall.kt"); } + @Test @TestMetadata("invokeAmbiguity.kt") public void testInvokeAmbiguity() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/callResolution/invokeAmbiguity.kt"); } + @Test @TestMetadata("invokeWithReceiverAndArgument.kt") public void testInvokeWithReceiverAndArgument() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/callResolution/invokeWithReceiverAndArgument.kt"); } + @Test @TestMetadata("lambdaAsReceiver.kt") public void testLambdaAsReceiver() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/callResolution/lambdaAsReceiver.kt"); } + @Test @TestMetadata("objectInvoke.kt") public void testObjectInvoke() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/callResolution/objectInvoke.kt"); } + @Test @TestMetadata("safeCallOnTypeAlias.kt") public void testSafeCallOnTypeAlias() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/callResolution/safeCallOnTypeAlias.kt"); } + @Test @TestMetadata("superAny.kt") public void testSuperAny() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/callResolution/superAny.kt"); } + @Test @TestMetadata("syntheticPropertiesWrongImplicitReceiver.kt") public void testSyntheticPropertiesWrongImplicitReceiver() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/callResolution/syntheticPropertiesWrongImplicitReceiver.kt"); } + @Test @TestMetadata("typeAliasWithNotNullBound.kt") public void testTypeAliasWithNotNullBound() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/callResolution/typeAliasWithNotNullBound.kt"); } + @Test @TestMetadata("uselessMultipleBounds.kt") public void testUselessMultipleBounds() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/callResolution/uselessMultipleBounds.kt"); } } + @Nested @TestMetadata("compiler/fir/analysis-tests/testData/resolve/cfg") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Cfg extends AbstractFirDiagnosticsWithLightTreeTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class Cfg extends AbstractFirDiagnosticsWithLightTreeTest { + @Test public void testAllFilesPresentInCfg() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/cfg"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } + @Test @TestMetadata("annotatedLocalClass.kt") public void testAnnotatedLocalClass() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/cfg/annotatedLocalClass.kt"); } + @Test @TestMetadata("binaryOperations.kt") public void testBinaryOperations() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/cfg/binaryOperations.kt"); } + @Test @TestMetadata("booleanOperatorsWithConsts.kt") public void testBooleanOperatorsWithConsts() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/cfg/booleanOperatorsWithConsts.kt"); } + @Test @TestMetadata("complex.kt") public void testComplex() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/cfg/complex.kt"); } + @Test @TestMetadata("defaultArguments.kt") public void testDefaultArguments() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/cfg/defaultArguments.kt"); } + @Test @TestMetadata("emptyWhen.kt") public void testEmptyWhen() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/cfg/emptyWhen.kt"); } + @Test @TestMetadata("flowFromInplaceLambda.kt") public void testFlowFromInplaceLambda() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/cfg/flowFromInplaceLambda.kt"); } + @Test @TestMetadata("initBlock.kt") public void testInitBlock() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/cfg/initBlock.kt"); } + @Test @TestMetadata("initBlockAndInPlaceLambda.kt") public void testInitBlockAndInPlaceLambda() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/cfg/initBlockAndInPlaceLambda.kt"); } + @Test @TestMetadata("innerClassInAnonymousObject.kt") public void testInnerClassInAnonymousObject() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/cfg/innerClassInAnonymousObject.kt"); } + @Test @TestMetadata("inplaceLambdaInControlFlowExpressions.kt") public void testInplaceLambdaInControlFlowExpressions() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/cfg/inplaceLambdaInControlFlowExpressions.kt"); } + @Test @TestMetadata("jumps.kt") public void testJumps() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/cfg/jumps.kt"); } + @Test @TestMetadata("lambdaAsReturnOfLambda.kt") public void testLambdaAsReturnOfLambda() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/cfg/lambdaAsReturnOfLambda.kt"); } + @Test @TestMetadata("lambdaReturningObject.kt") public void testLambdaReturningObject() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/cfg/lambdaReturningObject.kt"); } + @Test @TestMetadata("lambdas.kt") public void testLambdas() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/cfg/lambdas.kt"); } + @Test @TestMetadata("localClassesWithImplicit.kt") public void testLocalClassesWithImplicit() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/cfg/localClassesWithImplicit.kt"); } + @Test @TestMetadata("loops.kt") public void testLoops() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/cfg/loops.kt"); } + @Test @TestMetadata("postponedLambdaInConstructor.kt") public void testPostponedLambdaInConstructor() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/cfg/postponedLambdaInConstructor.kt"); } + @Test @TestMetadata("postponedLambdas.kt") public void testPostponedLambdas() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/cfg/postponedLambdas.kt"); } + @Test @TestMetadata("propertiesAndInitBlocks.kt") public void testPropertiesAndInitBlocks() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/cfg/propertiesAndInitBlocks.kt"); } + @Test @TestMetadata("returnValuesFromLambda.kt") public void testReturnValuesFromLambda() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/cfg/returnValuesFromLambda.kt"); } + @Test @TestMetadata("safeCalls.kt") public void testSafeCalls() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/cfg/safeCalls.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/cfg/simple.kt"); } + @Test @TestMetadata("tryCatch.kt") public void testTryCatch() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/cfg/tryCatch.kt"); } + @Test @TestMetadata("when.kt") public void testWhen() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/cfg/when.kt"); } } + @Nested @TestMetadata("compiler/fir/analysis-tests/testData/resolve/constructors") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Constructors extends AbstractFirDiagnosticsWithLightTreeTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class Constructors extends AbstractFirDiagnosticsWithLightTreeTest { + @Test public void testAllFilesPresentInConstructors() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/constructors"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } + @Test @TestMetadata("noSuperCallInSupertypes.kt") public void testNoSuperCallInSupertypes() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/constructors/noSuperCallInSupertypes.kt"); } } + @Nested @TestMetadata("compiler/fir/analysis-tests/testData/resolve/delegates") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Delegates extends AbstractFirDiagnosticsWithLightTreeTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class Delegates extends AbstractFirDiagnosticsWithLightTreeTest { + @Test public void testAllFilesPresentInDelegates() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/delegates"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } + @Test @TestMetadata("delegateInference.kt") public void testDelegateInference() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/delegates/delegateInference.kt"); } + @Test @TestMetadata("delegateWithLambda.kt") public void testDelegateWithLambda() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/delegates/delegateWithLambda.kt"); } + @Test @TestMetadata("extensionGenericGetValue.kt") public void testExtensionGenericGetValue() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/delegates/extensionGenericGetValue.kt"); } + @Test @TestMetadata("extensionGetValueWithTypeVariableAsReceiver.kt") public void testExtensionGetValueWithTypeVariableAsReceiver() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/delegates/extensionGetValueWithTypeVariableAsReceiver.kt"); } + @Test @TestMetadata("kt41982.kt") public void testKt41982() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/delegates/kt41982.kt"); } + @Test @TestMetadata("provideDelegate.kt") public void testProvideDelegate() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/delegates/provideDelegate.kt"); } } + @Nested @TestMetadata("compiler/fir/analysis-tests/testData/resolve/diagnostics") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Diagnostics extends AbstractFirDiagnosticsWithLightTreeTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class Diagnostics extends AbstractFirDiagnosticsWithLightTreeTest { + @Test @TestMetadata("abstractSuperCall.kt") public void testAbstractSuperCall() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/abstractSuperCall.kt"); } + @Test @TestMetadata("abstractSuperCallInPresenseOfNonAbstractMethodInParent.kt") public void testAbstractSuperCallInPresenseOfNonAbstractMethodInParent() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/abstractSuperCallInPresenseOfNonAbstractMethodInParent.kt"); } + @Test public void testAllFilesPresentInDiagnostics() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/diagnostics"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } + @Test @TestMetadata("annotationArgumentKClassLiteralTypeError.kt") public void testAnnotationArgumentKClassLiteralTypeError() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationArgumentKClassLiteralTypeError.kt"); } + @Test @TestMetadata("annotationArgumentMustBeConst.kt") public void testAnnotationArgumentMustBeConst() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationArgumentMustBeConst.kt"); } + @Test @TestMetadata("annotationArgumentMustBeEnumConst.kt") public void testAnnotationArgumentMustBeEnumConst() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationArgumentMustBeEnumConst.kt"); } + @Test @TestMetadata("annotationArgumentMustBeKClassLiteral.kt") public void testAnnotationArgumentMustBeKClassLiteral() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationArgumentMustBeKClassLiteral.kt"); } + @Test @TestMetadata("annotationClassMember.kt") public void testAnnotationClassMember() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationClassMember.kt"); } + @Test @TestMetadata("anonymousObjectByDelegate.kt") public void testAnonymousObjectByDelegate() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/anonymousObjectByDelegate.kt"); } + @Test @TestMetadata("classInSupertypeForEnum.kt") public void testClassInSupertypeForEnum() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/classInSupertypeForEnum.kt"); } + @Test @TestMetadata("conflictingOverloads.kt") public void testConflictingOverloads() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/conflictingOverloads.kt"); } + @Test @TestMetadata("conflictingProjection.kt") public void testConflictingProjection() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/conflictingProjection.kt"); } + @Test @TestMetadata("constructorInInterface.kt") public void testConstructorInInterface() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/constructorInInterface.kt"); } + @Test @TestMetadata("cyclicConstructorDelegationCall.kt") public void testCyclicConstructorDelegationCall() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/cyclicConstructorDelegationCall.kt"); } + @Test @TestMetadata("delegationInInterface.kt") public void testDelegationInInterface() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/delegationInInterface.kt"); } + @Test @TestMetadata("delegationSuperCallInEnumConstructor.kt") public void testDelegationSuperCallInEnumConstructor() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/delegationSuperCallInEnumConstructor.kt"); } + @Test @TestMetadata("explicitDelegationCallRequired.kt") public void testExplicitDelegationCallRequired() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/explicitDelegationCallRequired.kt"); } + @Test @TestMetadata("inapplicableLateinitModifier.kt") public void testInapplicableLateinitModifier() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/inapplicableLateinitModifier.kt"); } + @Test @TestMetadata("incompatibleModifiers.kt") public void testIncompatibleModifiers() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/incompatibleModifiers.kt"); } + @Test @TestMetadata("infixFunctions.kt") public void testInfixFunctions() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/infixFunctions.kt"); } + @Test @TestMetadata("instanceAccessBeforeSuperCall.kt") public void testInstanceAccessBeforeSuperCall() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/instanceAccessBeforeSuperCall.kt"); } + @Test @TestMetadata("interfaceWithSuperclass.kt") public void testInterfaceWithSuperclass() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/interfaceWithSuperclass.kt"); } + @Test @TestMetadata("localAnnotationClass.kt") public void testLocalAnnotationClass() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/localAnnotationClass.kt"); } + @Test @TestMetadata("localEntitytNotAllowed.kt") public void testLocalEntitytNotAllowed() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/localEntitytNotAllowed.kt"); } + @Test @TestMetadata("manyCompanionObjects.kt") public void testManyCompanionObjects() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/manyCompanionObjects.kt"); } + @Test @TestMetadata("methodOfAnyImplementedInInterface.kt") public void testMethodOfAnyImplementedInInterface() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/methodOfAnyImplementedInInterface.kt"); } + @Test @TestMetadata("nonConstValInAnnotationArgument.kt") public void testNonConstValInAnnotationArgument() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/nonConstValInAnnotationArgument.kt"); } + @Test @TestMetadata("notASupertype.kt") public void testNotASupertype() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/notASupertype.kt"); } + @Test @TestMetadata("primaryConstructorRequiredForDataClass.kt") public void testPrimaryConstructorRequiredForDataClass() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/primaryConstructorRequiredForDataClass.kt"); } + @Test @TestMetadata("projectionsOnNonClassTypeArguments.kt") public void testProjectionsOnNonClassTypeArguments() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/projectionsOnNonClassTypeArguments.kt"); } + @Test @TestMetadata("propertyTypeMismatchOnOverride.kt") public void testPropertyTypeMismatchOnOverride() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/propertyTypeMismatchOnOverride.kt"); } + @Test @TestMetadata("qualifiedSupertypeExtendedByOtherSupertype.kt") public void testQualifiedSupertypeExtendedByOtherSupertype() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/qualifiedSupertypeExtendedByOtherSupertype.kt"); } + @Test @TestMetadata("redundantModifier.kt") public void testRedundantModifier() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/redundantModifier.kt"); } + @Test @TestMetadata("repeatedModifier.kt") public void testRepeatedModifier() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/repeatedModifier.kt"); } + @Test @TestMetadata("returnTypeMismatchOnOverride.kt") public void testReturnTypeMismatchOnOverride() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/returnTypeMismatchOnOverride.kt"); } + @Test @TestMetadata("sealedClassConstructorCall.kt") public void testSealedClassConstructorCall() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/sealedClassConstructorCall.kt"); } + @Test @TestMetadata("sealedSupertype.kt") public void testSealedSupertype() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/sealedSupertype.kt"); } + @Test @TestMetadata("someOverridesTest.kt") public void testSomeOverridesTest() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/someOverridesTest.kt"); } + @Test @TestMetadata("superCallWithDelegation.kt") public void testSuperCallWithDelegation() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/superCallWithDelegation.kt"); } + @Test @TestMetadata("superIsNotAnExpression.kt") public void testSuperIsNotAnExpression() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/superIsNotAnExpression.kt"); } + @Test @TestMetadata("superNotAvailable.kt") public void testSuperNotAvailable() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/superNotAvailable.kt"); } + @Test @TestMetadata("superclassNotAccessibleFromInterface.kt") public void testSuperclassNotAccessibleFromInterface() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/superclassNotAccessibleFromInterface.kt"); } + @Test @TestMetadata("supertypeInitializedInInterface.kt") public void testSupertypeInitializedInInterface() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/supertypeInitializedInInterface.kt"); } + @Test @TestMetadata("supertypeInitializedWithoutPrimaryConstructor.kt") public void testSupertypeInitializedWithoutPrimaryConstructor() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/supertypeInitializedWithoutPrimaryConstructor.kt"); } + @Test @TestMetadata("testIllegalAnnotationClass.kt") public void testTestIllegalAnnotationClass() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/testIllegalAnnotationClass.kt"); } + @Test @TestMetadata("typeArgumentsNotAllowed.kt") public void testTypeArgumentsNotAllowed() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/typeArgumentsNotAllowed.kt"); } + @Test @TestMetadata("typeOfAnnotationMember.kt") public void testTypeOfAnnotationMember() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/typeOfAnnotationMember.kt"); } + @Test @TestMetadata("typeParametersInEnum.kt") public void testTypeParametersInEnum() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/typeParametersInEnum.kt"); } + @Test @TestMetadata("typeParametersInObject.kt") public void testTypeParametersInObject() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/typeParametersInObject.kt"); } + @Test @TestMetadata("upperBoundViolated.kt") public void testUpperBoundViolated() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/upperBoundViolated.kt"); } + @Test @TestMetadata("valOnAnnotationParameter.kt") public void testValOnAnnotationParameter() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/diagnostics/valOnAnnotationParameter.kt"); } } + @Nested @TestMetadata("compiler/fir/analysis-tests/testData/resolve/expresssions") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Expresssions extends AbstractFirDiagnosticsWithLightTreeTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class Expresssions extends AbstractFirDiagnosticsWithLightTreeTest { + @Test @TestMetadata("access.kt") public void testAccess() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/access.kt"); } + @Test public void testAllFilesPresentInExpresssions() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/expresssions"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } + @Test @TestMetadata("annotationWithReturn.kt") public void testAnnotationWithReturn() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/annotationWithReturn.kt"); } + @Test @TestMetadata("annotations.kt") public void testAnnotations() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/annotations.kt"); } + @Test @TestMetadata("baseQualifier.kt") public void testBaseQualifier() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/baseQualifier.kt"); } + @Test @TestMetadata("blockLocalScopes.kt") public void testBlockLocalScopes() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/blockLocalScopes.kt"); } + @Test @TestMetadata("CallBasedInExpressionGenerator.kt") public void testCallBasedInExpressionGenerator() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/CallBasedInExpressionGenerator.kt"); } + @Test @TestMetadata("checkArguments.kt") public void testCheckArguments() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/checkArguments.kt"); } + @Test @TestMetadata("classifierAccessFromCompanion.kt") public void testClassifierAccessFromCompanion() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/classifierAccessFromCompanion.kt"); } + @Test @TestMetadata("companion.kt") public void testCompanion() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/companion.kt"); } + @Test @TestMetadata("companionExtension.kt") public void testCompanionExtension() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/companionExtension.kt"); } + @Test @TestMetadata("constructor.kt") public void testConstructor() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/constructor.kt"); } + @Test @TestMetadata("dispatchReceiver.kt") public void testDispatchReceiver() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/dispatchReceiver.kt"); } + @Test @TestMetadata("enumEntryUse.kt") public void testEnumEntryUse() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/enumEntryUse.kt"); } + @Test @TestMetadata("enumValues.kt") public void testEnumValues() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/enumValues.kt"); } + @Test @TestMetadata("errCallable.kt") public void testErrCallable() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/errCallable.kt"); } + @Test @TestMetadata("extensionPropertyInLambda.kt") public void testExtensionPropertyInLambda() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/extensionPropertyInLambda.kt"); } + @Test @TestMetadata("genericDecorator.kt") public void testGenericDecorator() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/genericDecorator.kt"); } + @Test @TestMetadata("genericDescriptor.kt") public void testGenericDescriptor() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/genericDescriptor.kt"); } + @Test @TestMetadata("genericDiagnostic.kt") public void testGenericDiagnostic() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/genericDiagnostic.kt"); } + @Test @TestMetadata("genericPropertyAccess.kt") public void testGenericPropertyAccess() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/genericPropertyAccess.kt"); } + @Test @TestMetadata("genericUsedInFunction.kt") public void testGenericUsedInFunction() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/genericUsedInFunction.kt"); } + @Test @TestMetadata("importedReceiver.kt") public void testImportedReceiver() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/importedReceiver.kt"); } + @Test @TestMetadata("innerQualifier.kt") public void testInnerQualifier() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/innerQualifier.kt"); } + @Test @TestMetadata("innerWithSuperCompanion.kt") public void testInnerWithSuperCompanion() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/innerWithSuperCompanion.kt"); } + @Test @TestMetadata("javaFieldCallable.kt") public void testJavaFieldCallable() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/javaFieldCallable.kt"); } + @Test @TestMetadata("lambda.kt") public void testLambda() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/lambda.kt"); } + @Test @TestMetadata("lambdaWithReceiver.kt") public void testLambdaWithReceiver() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/lambdaWithReceiver.kt"); } + @Test @TestMetadata("localClassAccessesContainingClass.kt") public void testLocalClassAccessesContainingClass() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/localClassAccessesContainingClass.kt"); } + @Test @TestMetadata("localConstructor.kt") public void testLocalConstructor() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/localConstructor.kt"); } + @Test @TestMetadata("localExtension.kt") public void testLocalExtension() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/localExtension.kt"); } + @Test @TestMetadata("localImplicitBodies.kt") public void testLocalImplicitBodies() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/localImplicitBodies.kt"); } + @Test @TestMetadata("localInnerClass.kt") public void testLocalInnerClass() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/localInnerClass.kt"); } + @Test @TestMetadata("localObjects.kt") public void testLocalObjects() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/localObjects.kt"); } + @Test @TestMetadata("localScopes.kt") public void testLocalScopes() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/localScopes.kt"); } + @Test @TestMetadata("localTypes.kt") public void testLocalTypes() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/localTypes.kt"); } + @Test @TestMetadata("localWithBooleanNot.kt") public void testLocalWithBooleanNot() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/localWithBooleanNot.kt"); } + @Test @TestMetadata("memberExtension.kt") public void testMemberExtension() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/memberExtension.kt"); } + @Test @TestMetadata("nestedConstructorCallable.kt") public void testNestedConstructorCallable() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/nestedConstructorCallable.kt"); } + @Test @TestMetadata("nestedObjects.kt") public void testNestedObjects() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/nestedObjects.kt"); } + @Test @TestMetadata("nestedVisibility.kt") public void testNestedVisibility() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/nestedVisibility.kt"); } + @Test @TestMetadata("objectOverrideCallViaImport.kt") public void testObjectOverrideCallViaImport() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/objectOverrideCallViaImport.kt"); } + @Test @TestMetadata("objectVsProperty.kt") public void testObjectVsProperty() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/objectVsProperty.kt"); } + @Test @TestMetadata("objects.kt") public void testObjects() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/objects.kt"); } + @Test @TestMetadata("outerMemberAccesses.kt") public void testOuterMemberAccesses() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/outerMemberAccesses.kt"); } + @Test @TestMetadata("outerObject.kt") public void testOuterObject() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/outerObject.kt"); } + @Test @TestMetadata("overriddenJavaGetter.kt") public void testOverriddenJavaGetter() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/overriddenJavaGetter.kt"); } + @Test @TestMetadata("privateObjectLiteral.kt") public void testPrivateObjectLiteral() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/privateObjectLiteral.kt"); } + @Test @TestMetadata("privateVisibility.kt") public void testPrivateVisibility() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/privateVisibility.kt"); } + @Test @TestMetadata("protectedVisibility.kt") public void testProtectedVisibility() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/protectedVisibility.kt"); } + @Test @TestMetadata("qualifiedExpressions.kt") public void testQualifiedExpressions() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/qualifiedExpressions.kt"); } + @Test @TestMetadata("qualifierPriority.kt") public void testQualifierPriority() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/qualifierPriority.kt"); } + @Test @TestMetadata("receiverConsistency.kt") public void testReceiverConsistency() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/receiverConsistency.kt"); } + @Test @TestMetadata("sameReceiver.kt") public void testSameReceiver() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/sameReceiver.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/simple.kt"); } + @Test @TestMetadata("syntheticInImplicitBody.kt") public void testSyntheticInImplicitBody() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/syntheticInImplicitBody.kt"); } + @Test @TestMetadata("syntheticSmartCast.kt") public void testSyntheticSmartCast() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/syntheticSmartCast.kt"); } + @Test @TestMetadata("this.kt") public void testThis() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/this.kt"); } + @Test @TestMetadata("topExtensionVsOuterMember.kt") public void testTopExtensionVsOuterMember() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/topExtensionVsOuterMember.kt"); } + @Test @TestMetadata("typeAliasConstructor.kt") public void testTypeAliasConstructor() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/typeAliasConstructor.kt"); } + @Test @TestMetadata("vararg.kt") public void testVararg() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/vararg.kt"); } + @Test @TestMetadata("when.kt") public void testWhen() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/when.kt"); } + @Nested @TestMetadata("compiler/fir/analysis-tests/testData/resolve/expresssions/inference") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Inference extends AbstractFirDiagnosticsWithLightTreeTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class Inference extends AbstractFirDiagnosticsWithLightTreeTest { + @Test public void testAllFilesPresentInInference() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/expresssions/inference"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } + @Test @TestMetadata("id.kt") public void testId() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/inference/id.kt"); } + @Test @TestMetadata("typeParameters.kt") public void testTypeParameters() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/inference/typeParameters.kt"); } + @Test @TestMetadata("typeParameters2.kt") public void testTypeParameters2() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/inference/typeParameters2.kt"); } } + @Nested @TestMetadata("compiler/fir/analysis-tests/testData/resolve/expresssions/invoke") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Invoke extends AbstractFirDiagnosticsWithLightTreeTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class Invoke extends AbstractFirDiagnosticsWithLightTreeTest { + @Test public void testAllFilesPresentInInvoke() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/expresssions/invoke"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } + @Test @TestMetadata("doubleBrackets.kt") public void testDoubleBrackets() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/doubleBrackets.kt"); } + @Test @TestMetadata("explicitReceiver.kt") public void testExplicitReceiver() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/explicitReceiver.kt"); } + @Test @TestMetadata("explicitReceiver2.kt") public void testExplicitReceiver2() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/explicitReceiver2.kt"); } + @Test @TestMetadata("extension.kt") public void testExtension() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/extension.kt"); } + @Test @TestMetadata("extensionOnObject.kt") public void testExtensionOnObject() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/extensionOnObject.kt"); } + @Test @TestMetadata("extensionSafeCall.kt") public void testExtensionSafeCall() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/extensionSafeCall.kt"); } + @Test @TestMetadata("farInvokeExtension.kt") public void testFarInvokeExtension() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/farInvokeExtension.kt"); } + @Test @TestMetadata("implicitTypeOrder.kt") public void testImplicitTypeOrder() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/implicitTypeOrder.kt"); } + @Test @TestMetadata("inBrackets.kt") public void testInBrackets() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/inBrackets.kt"); } + @Test @TestMetadata("incorrectInvokeReceiver.kt") public void testIncorrectInvokeReceiver() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/incorrectInvokeReceiver.kt"); } + @Test @TestMetadata("propertyFromParameter.kt") public void testPropertyFromParameter() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/propertyFromParameter.kt"); } + @Test @TestMetadata("propertyWithExtensionType.kt") public void testPropertyWithExtensionType() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/propertyWithExtensionType.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/simple.kt"); } + @Test @TestMetadata("threeReceivers.kt") public void testThreeReceivers() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/threeReceivers.kt"); } + @Test @TestMetadata("threeReceiversCorrect.kt") public void testThreeReceiversCorrect() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/threeReceiversCorrect.kt"); } } + @Nested @TestMetadata("compiler/fir/analysis-tests/testData/resolve/expresssions/operators") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Operators extends AbstractFirDiagnosticsWithLightTreeTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class Operators extends AbstractFirDiagnosticsWithLightTreeTest { + @Test public void testAllFilesPresentInOperators() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/expresssions/operators"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } + @Test @TestMetadata("plus.kt") public void testPlus() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/operators/plus.kt"); } + @Test @TestMetadata("plusAndPlusAssign.kt") public void testPlusAndPlusAssign() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/operators/plusAndPlusAssign.kt"); } + @Test @TestMetadata("plusAssign.kt") public void testPlusAssign() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/expresssions/operators/plusAssign.kt"); @@ -1685,930 +1944,993 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos } } + @Nested @TestMetadata("compiler/fir/analysis-tests/testData/resolve/fromBuilder") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class FromBuilder extends AbstractFirDiagnosticsWithLightTreeTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class FromBuilder extends AbstractFirDiagnosticsWithLightTreeTest { + @Test public void testAllFilesPresentInFromBuilder() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/fromBuilder"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } + @Test @TestMetadata("complexTypes.kt") public void testComplexTypes() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/fromBuilder/complexTypes.kt"); } + @Test @TestMetadata("enums.kt") public void testEnums() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/fromBuilder/enums.kt"); } + @Test @TestMetadata("noPrimaryConstructor.kt") public void testNoPrimaryConstructor() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/fromBuilder/noPrimaryConstructor.kt"); } + @Test @TestMetadata("simpleClass.kt") public void testSimpleClass() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/fromBuilder/simpleClass.kt"); } + @Test @TestMetadata("typeParameters.kt") public void testTypeParameters() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/fromBuilder/typeParameters.kt"); } } + @Nested @TestMetadata("compiler/fir/analysis-tests/testData/resolve/inference") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Inference extends AbstractFirDiagnosticsWithLightTreeTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class Inference extends AbstractFirDiagnosticsWithLightTreeTest { + @Test public void testAllFilesPresentInInference() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/inference"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } + @Test @TestMetadata("callableReferenceOnInstance.kt") public void testCallableReferenceOnInstance() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/inference/callableReferenceOnInstance.kt"); } + @Test @TestMetadata("callableReferenceToLocalClass.kt") public void testCallableReferenceToLocalClass() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/inference/callableReferenceToLocalClass.kt"); } + @Test @TestMetadata("callableReferencesAndDefaultParameters.kt") public void testCallableReferencesAndDefaultParameters() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/inference/callableReferencesAndDefaultParameters.kt"); } + @Test @TestMetadata("capturedTypeForJavaTypeParameter.kt") public void testCapturedTypeForJavaTypeParameter() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/inference/capturedTypeForJavaTypeParameter.kt"); } + @Test @TestMetadata("coercionToUnitWithEarlyReturn.kt") public void testCoercionToUnitWithEarlyReturn() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/inference/coercionToUnitWithEarlyReturn.kt"); } + @Test @TestMetadata("definitelyNotNullIntersectionType.kt") public void testDefinitelyNotNullIntersectionType() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/inference/definitelyNotNullIntersectionType.kt"); } + @Test @TestMetadata("extensionCallableReferences.kt") public void testExtensionCallableReferences() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/inference/extensionCallableReferences.kt"); } + @Test @TestMetadata("integerLiteralAsComparable.kt") public void testIntegerLiteralAsComparable() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/inference/integerLiteralAsComparable.kt"); } + @Test @TestMetadata("intersectionTypesInConstraints.kt") public void testIntersectionTypesInConstraints() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/inference/intersectionTypesInConstraints.kt"); } + @Test @TestMetadata("kt40131.kt") public void testKt40131() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/inference/kt40131.kt"); } + @Test @TestMetadata("kt41989.kt") public void testKt41989() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/inference/kt41989.kt"); } + @Test @TestMetadata("lambdaAsReturnStatementOfLambda.kt") public void testLambdaAsReturnStatementOfLambda() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/inference/lambdaAsReturnStatementOfLambda.kt"); } + @Test @TestMetadata("lambdaInElvis.kt") public void testLambdaInElvis() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/inference/lambdaInElvis.kt"); } + @Test @TestMetadata("nestedExtensionFunctionType.kt") public void testNestedExtensionFunctionType() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/inference/nestedExtensionFunctionType.kt"); } + @Test @TestMetadata("nestedLambdas.kt") public void testNestedLambdas() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/inference/nestedLambdas.kt"); } + @Test @TestMetadata("nullableIntegerLiteralType.kt") public void testNullableIntegerLiteralType() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/inference/nullableIntegerLiteralType.kt"); } + @Test @TestMetadata("receiverWithCapturedType.kt") public void testReceiverWithCapturedType() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/inference/receiverWithCapturedType.kt"); } + @Test @TestMetadata("simpleCapturedTypes.kt") public void testSimpleCapturedTypes() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/inference/simpleCapturedTypes.kt"); } + @Test @TestMetadata("typeDepthForTypeAlias.kt") public void testTypeDepthForTypeAlias() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/inference/typeDepthForTypeAlias.kt"); } } + @Nested @TestMetadata("compiler/fir/analysis-tests/testData/resolve/innerClasses") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class InnerClasses extends AbstractFirDiagnosticsWithLightTreeTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class InnerClasses extends AbstractFirDiagnosticsWithLightTreeTest { + @Test public void testAllFilesPresentInInnerClasses() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/innerClasses"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } + @Test @TestMetadata("inner.kt") public void testInner() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/innerClasses/inner.kt"); } + @Test @TestMetadata("innerTypeFromSuperClassInBody.kt") public void testInnerTypeFromSuperClassInBody() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/innerClasses/innerTypeFromSuperClassInBody.kt"); } + @Test @TestMetadata("innerTypes.kt") public void testInnerTypes() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/innerClasses/innerTypes.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/innerClasses/simple.kt"); } } + @Nested @TestMetadata("compiler/fir/analysis-tests/testData/resolve/localClasses") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class LocalClasses extends AbstractFirDiagnosticsWithLightTreeTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class LocalClasses extends AbstractFirDiagnosticsWithLightTreeTest { + @Test public void testAllFilesPresentInLocalClasses() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/localClasses"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } + @Test @TestMetadata("implicitInAnonymous.kt") public void testImplicitInAnonymous() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/localClasses/implicitInAnonymous.kt"); } + @Test @TestMetadata("implicitInLocalClasses.kt") public void testImplicitInLocalClasses() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/localClasses/implicitInLocalClasses.kt"); } + @Test @TestMetadata("typesFromSuperClasses.kt") public void testTypesFromSuperClasses() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/localClasses/typesFromSuperClasses.kt"); } } + @Nested @TestMetadata("compiler/fir/analysis-tests/testData/resolve/multifile") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Multifile extends AbstractFirDiagnosticsWithLightTreeTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class Multifile extends AbstractFirDiagnosticsWithLightTreeTest { + @Test public void testAllFilesPresentInMultifile() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/multifile"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } + @Test @TestMetadata("Annotations.kt") public void testAnnotations() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/multifile/Annotations.kt"); } + @Test @TestMetadata("ByteArray.kt") public void testByteArray() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/multifile/ByteArray.kt"); } + @Test @TestMetadata("importFromObject.kt") public void testImportFromObject() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/multifile/importFromObject.kt"); } + @Test @TestMetadata("NestedSuperType.kt") public void testNestedSuperType() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/multifile/NestedSuperType.kt"); } + @Test @TestMetadata("sealedStarImport.kt") public void testSealedStarImport() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/multifile/sealedStarImport.kt"); } + @Test @TestMetadata("simpleAliasedImport.kt") public void testSimpleAliasedImport() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/multifile/simpleAliasedImport.kt"); } + @Test @TestMetadata("simpleImport.kt") public void testSimpleImport() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/multifile/simpleImport.kt"); } + @Test @TestMetadata("simpleImportNested.kt") public void testSimpleImportNested() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/multifile/simpleImportNested.kt"); } + @Test @TestMetadata("simpleImportOuter.kt") public void testSimpleImportOuter() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/multifile/simpleImportOuter.kt"); } + @Test @TestMetadata("simpleStarImport.kt") public void testSimpleStarImport() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/multifile/simpleStarImport.kt"); } + @Test @TestMetadata("TypeAliasExpansion.kt") public void testTypeAliasExpansion() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/multifile/TypeAliasExpansion.kt"); } } + @Nested @TestMetadata("compiler/fir/analysis-tests/testData/resolve/overrides") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Overrides extends AbstractFirDiagnosticsWithLightTreeTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class Overrides extends AbstractFirDiagnosticsWithLightTreeTest { + @Test public void testAllFilesPresentInOverrides() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/overrides"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } + @Test @TestMetadata("generics.kt") public void testGenerics() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/overrides/generics.kt"); } + @Test @TestMetadata("protobufExt.kt") public void testProtobufExt() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/overrides/protobufExt.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/overrides/simple.kt"); } + @Test @TestMetadata("simpleFakeOverride.kt") public void testSimpleFakeOverride() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/overrides/simpleFakeOverride.kt"); } + @Test @TestMetadata("simpleMostSpecific.kt") public void testSimpleMostSpecific() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/overrides/simpleMostSpecific.kt"); } + @Test @TestMetadata("supertypeGenerics.kt") public void testSupertypeGenerics() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/overrides/supertypeGenerics.kt"); } + @Test @TestMetadata("supertypeGenericsComplex.kt") public void testSupertypeGenericsComplex() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/overrides/supertypeGenericsComplex.kt"); } + @Test @TestMetadata("three.kt") public void testThree() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/overrides/three.kt"); } } + @Nested @TestMetadata("compiler/fir/analysis-tests/testData/resolve/problems") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Problems extends AbstractFirDiagnosticsWithLightTreeTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class Problems extends AbstractFirDiagnosticsWithLightTreeTest { + @Test public void testAllFilesPresentInProblems() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/problems"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } + @Test @TestMetadata("compilerPhase.kt") public void testCompilerPhase() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/problems/compilerPhase.kt"); } + @Test @TestMetadata("complexLambdaWithTypeVariableAsExpectedType.kt") public void testComplexLambdaWithTypeVariableAsExpectedType() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/problems/complexLambdaWithTypeVariableAsExpectedType.kt"); } + @Test @TestMetadata("defaultParametersFromDifferentScopes.kt") public void testDefaultParametersFromDifferentScopes() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/problems/defaultParametersFromDifferentScopes.kt"); } + @Test @TestMetadata("definitelyNotNullAndOriginalType.kt") public void testDefinitelyNotNullAndOriginalType() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/problems/definitelyNotNullAndOriginalType.kt"); } + @Test @TestMetadata("flexibleTypeVarAgainstNull.kt") public void testFlexibleTypeVarAgainstNull() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/problems/flexibleTypeVarAgainstNull.kt"); } + @Test @TestMetadata("inaccessibleJavaGetter.kt") public void testInaccessibleJavaGetter() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/problems/inaccessibleJavaGetter.kt"); } + @Test @TestMetadata("innerClassHierarchy.kt") public void testInnerClassHierarchy() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/problems/innerClassHierarchy.kt"); } + @Test @TestMetadata("javaQualifier.kt") public void testJavaQualifier() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/problems/javaQualifier.kt"); } + @Test @TestMetadata("kt42346.kt") public void testKt42346() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/problems/kt42346.kt"); } + @Test @TestMetadata("multipleJavaClassesInOneFile.kt") public void testMultipleJavaClassesInOneFile() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/problems/multipleJavaClassesInOneFile.kt"); } + @Test @TestMetadata("objectDerivedFromInnerClass.kt") public void testObjectDerivedFromInnerClass() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/problems/objectDerivedFromInnerClass.kt"); } + @Test @TestMetadata("questionableSmartCast.kt") public void testQuestionableSmartCast() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/problems/questionableSmartCast.kt"); } + @Test @TestMetadata("recursiveNamedAnnotation.kt") public void testRecursiveNamedAnnotation() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/problems/recursiveNamedAnnotation.kt"); } + @Test @TestMetadata("safeCallInvoke.kt") public void testSafeCallInvoke() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/problems/safeCallInvoke.kt"); } + @Test @TestMetadata("secondaryConstructorCfg.kt") public void testSecondaryConstructorCfg() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/problems/secondaryConstructorCfg.kt"); } } + @Nested @TestMetadata("compiler/fir/analysis-tests/testData/resolve/properties") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Properties extends AbstractFirDiagnosticsWithLightTreeTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class Properties extends AbstractFirDiagnosticsWithLightTreeTest { + @Test public void testAllFilesPresentInProperties() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/properties"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } + @Test @TestMetadata("javaAccessorConversion.kt") public void testJavaAccessorConversion() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/properties/javaAccessorConversion.kt"); } + @Test @TestMetadata("javaAccessorsComplex.kt") public void testJavaAccessorsComplex() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/properties/javaAccessorsComplex.kt"); } + @Test @TestMetadata("kotlinOverridesJavaComplex.kt") public void testKotlinOverridesJavaComplex() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/properties/kotlinOverridesJavaComplex.kt"); } + @Test @TestMetadata("noBackingFieldForExtension.kt") public void testNoBackingFieldForExtension() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/properties/noBackingFieldForExtension.kt"); } + @Test @TestMetadata("noBackingFieldInProperty.kt") public void testNoBackingFieldInProperty() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/properties/noBackingFieldInProperty.kt"); } + @Test @TestMetadata("syntheticPropertiesForJavaAnnotations.kt") public void testSyntheticPropertiesForJavaAnnotations() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/properties/syntheticPropertiesForJavaAnnotations.kt"); } } + @Nested @TestMetadata("compiler/fir/analysis-tests/testData/resolve/references") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class References extends AbstractFirDiagnosticsWithLightTreeTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class References extends AbstractFirDiagnosticsWithLightTreeTest { + @Test public void testAllFilesPresentInReferences() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/references"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } + @Test @TestMetadata("integerLiteralInLhs.kt") public void testIntegerLiteralInLhs() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/references/integerLiteralInLhs.kt"); } + @Test @TestMetadata("referenceToExtension.kt") public void testReferenceToExtension() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/references/referenceToExtension.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/references/simple.kt"); } + @Test @TestMetadata("superMember.kt") public void testSuperMember() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/references/superMember.kt"); } } + @Nested @TestMetadata("compiler/fir/analysis-tests/testData/resolve/samConstructors") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class SamConstructors extends AbstractFirDiagnosticsWithLightTreeTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class SamConstructors extends AbstractFirDiagnosticsWithLightTreeTest { + @Test public void testAllFilesPresentInSamConstructors() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/samConstructors"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } + @Test @TestMetadata("genericSam.kt") public void testGenericSam() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/samConstructors/genericSam.kt"); } + @Test @TestMetadata("genericSamInferenceFromExpectType.kt") public void testGenericSamInferenceFromExpectType() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/samConstructors/genericSamInferenceFromExpectType.kt"); } + @Test @TestMetadata("kotlinSam.kt") public void testKotlinSam() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/samConstructors/kotlinSam.kt"); } + @Test @TestMetadata("realConstructorFunction.kt") public void testRealConstructorFunction() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/samConstructors/realConstructorFunction.kt"); } + @Test @TestMetadata("runnable.kt") public void testRunnable() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/samConstructors/runnable.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/samConstructors/simple.kt"); } } + @Nested @TestMetadata("compiler/fir/analysis-tests/testData/resolve/samConversions") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class SamConversions extends AbstractFirDiagnosticsWithLightTreeTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class SamConversions extends AbstractFirDiagnosticsWithLightTreeTest { + @Test public void testAllFilesPresentInSamConversions() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/samConversions"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } + @Test @TestMetadata("genericSam.kt") public void testGenericSam() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/samConversions/genericSam.kt"); } + @Test @TestMetadata("kotlinSam.kt") public void testKotlinSam() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/samConversions/kotlinSam.kt"); } + @Test @TestMetadata("notSamBecauseOfSupertype.kt") public void testNotSamBecauseOfSupertype() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/samConversions/notSamBecauseOfSupertype.kt"); } + @Test @TestMetadata("runnable.kt") public void testRunnable() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/samConversions/runnable.kt"); } + @Test @TestMetadata("samConversionInConstructorCall.kt") public void testSamConversionInConstructorCall() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/samConversions/samConversionInConstructorCall.kt"); } + @Test @TestMetadata("samSupertype.kt") public void testSamSupertype() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/samConversions/samSupertype.kt"); } + @Test @TestMetadata("samSupertypeWithOverride.kt") public void testSamSupertypeWithOverride() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/samConversions/samSupertypeWithOverride.kt"); } + @Test @TestMetadata("samWithEquals.kt") public void testSamWithEquals() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/samConversions/samWithEquals.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/samConversions/simple.kt"); } } + @Nested @TestMetadata("compiler/fir/analysis-tests/testData/resolve/smartcasts") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Smartcasts extends AbstractFirDiagnosticsWithLightTreeTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class Smartcasts extends AbstractFirDiagnosticsWithLightTreeTest { + @Test public void testAllFilesPresentInSmartcasts() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } + @Test @TestMetadata("bangbang.kt") public void testBangbang() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/bangbang.kt"); } + @Test @TestMetadata("casts.kt") public void testCasts() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/casts.kt"); } + @Test @TestMetadata("equalsAndIdentity.kt") public void testEqualsAndIdentity() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/equalsAndIdentity.kt"); } + @Test @TestMetadata("kt10240.kt") public void testKt10240() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/kt10240.kt"); } + @Test @TestMetadata("kt37327.kt") public void testKt37327() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/kt37327.kt"); } + @Test @TestMetadata("kt39000.kt") public void testKt39000() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/kt39000.kt"); } + @Test @TestMetadata("multipleCasts.kt") public void testMultipleCasts() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/multipleCasts.kt"); } + @Test @TestMetadata("nullability.kt") public void testNullability() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/nullability.kt"); } + @Test @TestMetadata("orInWhenBranch.kt") public void testOrInWhenBranch() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/orInWhenBranch.kt"); } + @Test @TestMetadata("smartCastInInit.kt") public void testSmartCastInInit() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/smartCastInInit.kt"); } + @Test @TestMetadata("smartcastToNothing.kt") public void testSmartcastToNothing() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/smartcastToNothing.kt"); } + @Nested @TestMetadata("compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Booleans extends AbstractFirDiagnosticsWithLightTreeTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class Booleans extends AbstractFirDiagnosticsWithLightTreeTest { + @Test public void testAllFilesPresentInBooleans() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } + @Test @TestMetadata("booleanOperators.kt") public void testBooleanOperators() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans/booleanOperators.kt"); } + @Test @TestMetadata("equalsToBoolean.kt") public void testEqualsToBoolean() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans/equalsToBoolean.kt"); } + @Test @TestMetadata("jumpFromRhsOfOperator.kt") public void testJumpFromRhsOfOperator() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans/jumpFromRhsOfOperator.kt"); } } + @Nested @TestMetadata("compiler/fir/analysis-tests/testData/resolve/smartcasts/boundSmartcasts") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class BoundSmartcasts extends AbstractFirDiagnosticsWithLightTreeTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class BoundSmartcasts extends AbstractFirDiagnosticsWithLightTreeTest { + @Test public void testAllFilesPresentInBoundSmartcasts() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/boundSmartcasts"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } + @Test @TestMetadata("boundSmartcasts.kt") public void testBoundSmartcasts() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/boundSmartcasts/boundSmartcasts.kt"); } + @Test @TestMetadata("boundSmartcastsInBranches.kt") public void testBoundSmartcastsInBranches() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/boundSmartcasts/boundSmartcastsInBranches.kt"); } + @Test @TestMetadata("functionCallBound.kt") public void testFunctionCallBound() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/boundSmartcasts/functionCallBound.kt"); } } + @Nested @TestMetadata("compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ControlStructures extends AbstractFirDiagnosticsWithLightTreeTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class ControlStructures extends AbstractFirDiagnosticsWithLightTreeTest { + @Test public void testAllFilesPresentInControlStructures() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } + @Test @TestMetadata("elvis.kt") public void testElvis() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/elvis.kt"); } + @Test @TestMetadata("returns.kt") public void testReturns() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/returns.kt"); } + @Test @TestMetadata("simpleIf.kt") public void testSimpleIf() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/simpleIf.kt"); } + @Test @TestMetadata("smartcastFromArgument.kt") public void testSmartcastFromArgument() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/smartcastFromArgument.kt"); } + @Test @TestMetadata("when.kt") public void testWhen() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/when.kt"); } } + @Nested @TestMetadata("compiler/fir/analysis-tests/testData/resolve/smartcasts/lambdas") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Lambdas extends AbstractFirDiagnosticsWithLightTreeTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class Lambdas extends AbstractFirDiagnosticsWithLightTreeTest { + @Test public void testAllFilesPresentInLambdas() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/lambdas"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } + @Test @TestMetadata("inPlaceLambdas.kt") public void testInPlaceLambdas() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/lambdas/inPlaceLambdas.kt"); } + @Test @TestMetadata("lambdaInWhenBranch.kt") public void testLambdaInWhenBranch() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/lambdas/lambdaInWhenBranch.kt"); } + @Test @TestMetadata("smartcastOnLambda.kt") public void testSmartcastOnLambda() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/lambdas/smartcastOnLambda.kt"); } } + @Nested @TestMetadata("compiler/fir/analysis-tests/testData/resolve/smartcasts/loops") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Loops extends AbstractFirDiagnosticsWithLightTreeTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class Loops extends AbstractFirDiagnosticsWithLightTreeTest { + @Test public void testAllFilesPresentInLoops() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/loops"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } + @Test @TestMetadata("dataFlowInfoFromWhileCondition.kt") public void testDataFlowInfoFromWhileCondition() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/loops/dataFlowInfoFromWhileCondition.kt"); } + @Test @TestMetadata("endlessLoops.kt") public void testEndlessLoops() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/loops/endlessLoops.kt"); } } + @Nested @TestMetadata("compiler/fir/analysis-tests/testData/resolve/smartcasts/problems") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Problems extends AbstractFirDiagnosticsWithLightTreeTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class Problems extends AbstractFirDiagnosticsWithLightTreeTest { + @Test public void testAllFilesPresentInProblems() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/problems"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } + @Test @TestMetadata("invoke.kt") public void testInvoke() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/problems/invoke.kt"); } } + @Nested @TestMetadata("compiler/fir/analysis-tests/testData/resolve/smartcasts/receivers") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Receivers extends AbstractFirDiagnosticsWithLightTreeTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class Receivers extends AbstractFirDiagnosticsWithLightTreeTest { + @Test public void testAllFilesPresentInReceivers() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/receivers"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } + @Test @TestMetadata("implicitReceiverAsWhenSubject.kt") public void testImplicitReceiverAsWhenSubject() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/receivers/implicitReceiverAsWhenSubject.kt"); } + @Test @TestMetadata("implicitReceivers.kt") public void testImplicitReceivers() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/receivers/implicitReceivers.kt"); } + @Test @TestMetadata("mixingImplicitAndExplicitReceivers.kt") public void testMixingImplicitAndExplicitReceivers() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/receivers/mixingImplicitAndExplicitReceivers.kt"); } + @Test @TestMetadata("thisOfExtensionProperty.kt") public void testThisOfExtensionProperty() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/receivers/thisOfExtensionProperty.kt"); } } + @Nested @TestMetadata("compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class SafeCalls extends AbstractFirDiagnosticsWithLightTreeTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class SafeCalls extends AbstractFirDiagnosticsWithLightTreeTest { + @Test public void testAllFilesPresentInSafeCalls() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } + @Test @TestMetadata("assignSafeCall.kt") public void testAssignSafeCall() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/assignSafeCall.kt"); } + @Test @TestMetadata("boundSafeCallAndIsCheck.kt") public void testBoundSafeCallAndIsCheck() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/boundSafeCallAndIsCheck.kt"); } + @Test @TestMetadata("safeCallAndEqualityToBool.kt") public void testSafeCallAndEqualityToBool() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/safeCallAndEqualityToBool.kt"); } + @Test @TestMetadata("safeCalls.kt") public void testSafeCalls() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/safeCalls.kt"); } } + @Nested @TestMetadata("compiler/fir/analysis-tests/testData/resolve/smartcasts/stability") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Stability extends AbstractFirDiagnosticsWithLightTreeTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class Stability extends AbstractFirDiagnosticsWithLightTreeTest { + @Test public void testAllFilesPresentInStability() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/stability"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } + @Test @TestMetadata("overridenOpenVal.kt") public void testOverridenOpenVal() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/stability/overridenOpenVal.kt"); } } + @Nested @TestMetadata("compiler/fir/analysis-tests/testData/resolve/smartcasts/variables") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Variables extends AbstractFirDiagnosticsWithLightTreeTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class Variables extends AbstractFirDiagnosticsWithLightTreeTest { + @Test public void testAllFilesPresentInVariables() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/smartcasts/variables"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } + @Test @TestMetadata("delayedAssignment.kt") public void testDelayedAssignment() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/variables/delayedAssignment.kt"); } + @Test @TestMetadata("smartcastAfterReassignment.kt") public void testSmartcastAfterReassignment() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/smartcasts/variables/smartcastAfterReassignment.kt"); @@ -2616,35 +2938,31 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos } } + @Nested @TestMetadata("compiler/fir/analysis-tests/testData/resolve/stdlib") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Stdlib extends AbstractFirDiagnosticsWithLightTreeTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class Stdlib extends AbstractFirDiagnosticsWithLightTreeTest { + @Test public void testAllFilesPresentInStdlib() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/stdlib"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } + @Nested @TestMetadata("compiler/fir/analysis-tests/testData/resolve/stdlib/j+k") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class J_k extends AbstractFirDiagnosticsWithLightTreeTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class J_k extends AbstractFirDiagnosticsWithLightTreeTest { + @Test public void testAllFilesPresentInJ_k() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/stdlib/j+k"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } + @Test @TestMetadata("ArrayInGenericArguments.kt") public void testArrayInGenericArguments() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/stdlib/j+k/ArrayInGenericArguments.kt"); } + @Test @TestMetadata("flexibleWildcard.kt") public void testFlexibleWildcard() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/stdlib/j+k/flexibleWildcard.kt"); @@ -2652,91 +2970,98 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos } } + @Nested @TestMetadata("compiler/fir/analysis-tests/testData/resolve/types") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Types extends AbstractFirDiagnosticsWithLightTreeTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class Types extends AbstractFirDiagnosticsWithLightTreeTest { + @Test public void testAllFilesPresentInTypes() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/types"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } + @Test @TestMetadata("bareWithSubjectTypeAlias.kt") public void testBareWithSubjectTypeAlias() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/types/bareWithSubjectTypeAlias.kt"); } + @Test @TestMetadata("capturedParametersOfInnerClasses.kt") public void testCapturedParametersOfInnerClasses() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/types/capturedParametersOfInnerClasses.kt"); } } + @Nested @TestMetadata("compiler/fir/analysis-tests/testData/resolve/visibility") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Visibility extends AbstractFirDiagnosticsWithLightTreeTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - + public class Visibility extends AbstractFirDiagnosticsWithLightTreeTest { + @Test public void testAllFilesPresentInVisibility() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/visibility"), Pattern.compile("^([^.]+)\\.kt$"), null, true); } + @Test @TestMetadata("exposedFunctionParameterType.kt") public void testExposedFunctionParameterType() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/visibility/exposedFunctionParameterType.kt"); } + @Test @TestMetadata("exposedFunctionReturnType.kt") public void testExposedFunctionReturnType() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/visibility/exposedFunctionReturnType.kt"); } + @Test @TestMetadata("exposedPropertyType.kt") public void testExposedPropertyType() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/visibility/exposedPropertyType.kt"); } + @Test @TestMetadata("exposedSupertype.kt") public void testExposedSupertype() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/visibility/exposedSupertype.kt"); } + @Test @TestMetadata("exposedTypeAlias.kt") public void testExposedTypeAlias() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/visibility/exposedTypeAlias.kt"); } + @Test @TestMetadata("exposedTypeParameters.kt") public void testExposedTypeParameters() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/visibility/exposedTypeParameters.kt"); } + @Test @TestMetadata("intersectionOverrideWithImplicitTypes.kt") public void testIntersectionOverrideWithImplicitTypes() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/visibility/intersectionOverrideWithImplicitTypes.kt"); } + @Test @TestMetadata("kotlinJavaKotlinHierarchy.kt") public void testKotlinJavaKotlinHierarchy() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/visibility/kotlinJavaKotlinHierarchy.kt"); } + @Test @TestMetadata("protectedInCompanion.kt") public void testProtectedInCompanion() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/visibility/protectedInCompanion.kt"); } + @Test @TestMetadata("singletonConstructors.kt") public void testSingletonConstructors() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/visibility/singletonConstructors.kt"); } + @Test @TestMetadata("visibilityWithOverrides.kt") public void testVisibilityWithOverrides() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/visibility/visibilityWithOverrides.kt"); diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/directives/FirDiagnosticsDirectives.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/directives/FirDiagnosticsDirectives.kt index 609cf5ba2a9..eee8d9c9544 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/directives/FirDiagnosticsDirectives.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/directives/FirDiagnosticsDirectives.kt @@ -24,4 +24,15 @@ object FirDiagnosticsDirectives : SimpleDirectivesContainer() { val FIR_IDENTICAL by directive( description = "Contents of fir test data file and FE 1.0 are identical" ) + + val USE_LIGHT_TREE by directive( + description = "Enables light tree parser instead of PSI" + ) + + val COMPARE_WITH_LIGHT_TREE by directive( + description = """ + Enable comparing diagnostics between PSI and light tree modes + For enabling light tree mode use $USE_LIGHT_TREE directive + """.trimIndent() + ) } diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/handlers/ClassicDiagnosticReporter.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/handlers/ClassicDiagnosticReporter.kt index 6a67ae63292..2cf615f2da2 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/handlers/ClassicDiagnosticReporter.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/handlers/ClassicDiagnosticReporter.kt @@ -6,9 +6,7 @@ package org.jetbrains.kotlin.test.frontend.classic.handlers import org.jetbrains.kotlin.checkers.utils.DiagnosticsRenderingConfiguration -import org.jetbrains.kotlin.codeMetaInfo.model.CodeMetaInfo import org.jetbrains.kotlin.codeMetaInfo.model.DiagnosticCodeMetaInfo -import org.jetbrains.kotlin.codeMetaInfo.model.ParsedCodeMetaInfo import org.jetbrains.kotlin.config.JVMConfigurationKeys import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.diagnostics.Diagnostic @@ -20,6 +18,7 @@ import org.jetbrains.kotlin.test.directives.DiagnosticsDirectives import org.jetbrains.kotlin.test.model.TestFile import org.jetbrains.kotlin.test.model.TestModule import org.jetbrains.kotlin.test.services.* +import org.jetbrains.kotlin.test.utils.AbstractTwoAttributesMetaInfoProcessor class ClassicDiagnosticReporter(private val testServices: TestServices) { private val globalMetadataInfoHandler: GlobalMetadataInfoHandler @@ -81,66 +80,21 @@ class ClassicDiagnosticReporter(private val testServices: TestServices) { } } -class OldNewInferenceMetaInfoProcessor(testServices: TestServices) : AdditionalMetaInfoProcessor(testServices) { +class OldNewInferenceMetaInfoProcessor(testServices: TestServices) : AbstractTwoAttributesMetaInfoProcessor(testServices) { companion object { const val OI = "OI" const val NI = "NI" } - override fun processMetaInfos(module: TestModule, file: TestFile) { - /* - * Rules for OI/NI attribute: - * ┌──────────┬──────┬──────┬──────────┐ - * │ │ OI │ NI │ nothing │ <- reported - * ├──────────┼──────┼──────┼──────────┤ - * │ nothing │ both │ both │ nothing │ - * │ OI │ OI │ both │ OI │ - * │ NI │ both │ NI │ NI │ - * │ both │ both │ both │ opposite │ <- OI if NI enabled in test and vice versa - * └──────────┴──────┴──────┴──────────┘ - * ^ existed - */ - if (!testServices.withNewInferenceModeEnabled()) return - val newInferenceEnabled = module.languageVersionSettings.supportsFeature(LanguageFeature.NewInference) - val (currentFlag, otherFlag) = when (newInferenceEnabled) { - true -> NI to OI - false -> OI to NI - } - val matchedExistedInfos = mutableSetOf() - val matchedReportedInfos = mutableSetOf() - val allReportedInfos = globalMetadataInfoHandler.getReportedMetaInfosForFile(file) - for ((_, reportedInfos) in allReportedInfos.groupBy { Triple(it.start, it.end, it.tag) }) { - val existedInfos = globalMetadataInfoHandler.getExistingMetaInfosForActualMetadata(file, reportedInfos.first()) - for ((reportedInfo, existedInfo) in reportedInfos.zip(existedInfos)) { - matchedExistedInfos += existedInfo - matchedReportedInfos += reportedInfo - if (currentFlag !in reportedInfo.attributes) continue - if (currentFlag in existedInfo.attributes) continue - reportedInfo.attributes.remove(currentFlag) - } - } + override val firstAttribute: String get() = NI + override val secondAttribute: String get() = OI - if (allReportedInfos.size != matchedReportedInfos.size) { - for (info in allReportedInfos) { - if (info !in matchedReportedInfos) { - info.attributes.remove(currentFlag) - } - } - } + override fun processorEnabled(module: TestModule): Boolean { + return DiagnosticsDirectives.WITH_NEW_INFERENCE in module.directives + } - val allExistedInfos = globalMetadataInfoHandler.getExistingMetaInfosForFile(file) - if (allExistedInfos.size == matchedExistedInfos.size) return - - val newInfos = allExistedInfos.mapNotNull { - if (it in matchedExistedInfos) return@mapNotNull null - if (currentFlag in it.attributes) return@mapNotNull null - it.copy().apply { - if (otherFlag !in attributes) { - attributes += otherFlag - } - } - } - globalMetadataInfoHandler.addMetadataInfosForFile(file, newInfos) + override fun firstAttributeEnabled(module: TestModule): Boolean { + return module.languageVersionSettings.supportsFeature(LanguageFeature.NewInference) } } diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/FirFrontendFacade.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/FirFrontendFacade.kt index 643bf466f67..7d4c1695559 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/FirFrontendFacade.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/FirFrontendFacade.kt @@ -16,8 +16,12 @@ import org.jetbrains.kotlin.fir.analysis.FirAnalyzerFacade import org.jetbrains.kotlin.fir.java.FirProjectSessionProvider import org.jetbrains.kotlin.fir.session.FirJvmModuleInfo import org.jetbrains.kotlin.fir.session.FirSessionFactory +import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.test.directives.FirDiagnosticsDirectives +import org.jetbrains.kotlin.test.directives.model.DirectivesContainer import org.jetbrains.kotlin.test.model.* import org.jetbrains.kotlin.test.services.* +import java.io.File class FirFrontendFacade( testServices: TestServices @@ -25,6 +29,9 @@ class FirFrontendFacade( override val additionalServices: List get() = listOf(service(::FirModuleInfoProvider)) + override val additionalDirectives: List + get() = listOf(FirDiagnosticsDirectives) + override fun analyze(module: TestModule): FirOutputArtifact { val moduleInfoProvider = testServices.firModuleInfoProvider val compilerConfigurationProvider = testServices.compilerConfigurationProvider @@ -34,7 +41,12 @@ class FirFrontendFacade( PsiElementFinder.EP.getPoint(project).unregisterExtension(JavaElementFinder::class.java) - val ktFiles = testServices.sourceFileProvider.getKtFilesForSourceFiles(module.files, project).values + val lightTreeEnabled = FirDiagnosticsDirectives.USE_LIGHT_TREE in module.directives + val (ktFiles, originalFiles) = if (lightTreeEnabled) { + emptyList() to module.files.filter { it.isKtFile }.map { testServices.sourceFileProvider.getRealFileForSourceFile(it) } + } else { + testServices.sourceFileProvider.getKtFilesForSourceFiles(module.files, project).values to emptyList() + } val sessionProvider = moduleInfoProvider.firSessionProvider @@ -55,7 +67,7 @@ class FirFrontendFacade( languageVersionSettings = languageVersionSettings ) - val firAnalyzerFacade = FirAnalyzerFacade(session, languageVersionSettings, ktFiles) + val firAnalyzerFacade = FirAnalyzerFacade(session, languageVersionSettings, ktFiles, originalFiles, lightTreeEnabled) val firFiles = firAnalyzerFacade.runResolution() val filesMap = firFiles.mapNotNull { firFile -> val testFile = module.files.firstOrNull { it.name == firFile.name } ?: return@mapNotNull null diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirDiagnosticsHandler.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirDiagnosticsHandler.kt index 5a9b08289b3..2d2fa173333 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirDiagnosticsHandler.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirDiagnosticsHandler.kt @@ -32,11 +32,13 @@ import org.jetbrains.kotlin.fir.visitors.FirDefaultVisitorVoid import org.jetbrains.kotlin.name.FqNameUnsafe import org.jetbrains.kotlin.resolve.AnalyzingUtils import org.jetbrains.kotlin.test.directives.DiagnosticsDirectives +import org.jetbrains.kotlin.test.directives.FirDiagnosticsDirectives import org.jetbrains.kotlin.test.directives.model.DirectivesContainer import org.jetbrains.kotlin.test.frontend.fir.FirOutputArtifact import org.jetbrains.kotlin.test.model.TestFile import org.jetbrains.kotlin.test.model.TestModule import org.jetbrains.kotlin.test.services.* +import org.jetbrains.kotlin.test.utils.AbstractTwoAttributesMetaInfoProcessor import org.jetbrains.kotlin.util.OperatorNameConventions import org.jetbrains.kotlin.utils.addIfNotNull @@ -62,6 +64,8 @@ class FirDiagnosticsHandler(testServices: TestServices) : FirAnalysisHandler(tes override fun processModule(module: TestModule, info: FirOutputArtifact) { val diagnosticsPerFile = info.firAnalyzerFacade.runCheckers() + val lightTreeComparingModeEnabled = FirDiagnosticsDirectives.COMPARE_WITH_LIGHT_TREE in module.directives + val lightTreeEnabled = FirDiagnosticsDirectives.USE_LIGHT_TREE in module.directives for (file in module.files) { val firFile = info.firFiles[file] ?: continue @@ -71,29 +75,42 @@ class FirDiagnosticsHandler(testServices: TestServices) : FirAnalysisHandler(tes // SYNTAX errors will be reported later if (diagnostic.factory == FirErrors.SYNTAX) return@mapNotNull null if (!diagnostic.isValid) return@mapNotNull null - diagnostic.toMetaInfo(file) + diagnostic.toMetaInfo(file, lightTreeEnabled, lightTreeComparingModeEnabled) } globalMetadataInfoHandler.addMetadataInfosForFile(file, diagnosticsMetadataInfos) - collectSyntaxDiagnostics(file, firFile) - collectDebugInfoDiagnostics(file, firFile) + collectSyntaxDiagnostics(file, firFile, lightTreeEnabled, lightTreeComparingModeEnabled) + collectDebugInfoDiagnostics(file, firFile, lightTreeEnabled, lightTreeComparingModeEnabled) } } - private fun FirDiagnostic<*>.toMetaInfo(file: TestFile, forceRenderArguments: Boolean = false): FirDiagnosticCodeMetaInfo { + private fun FirDiagnostic<*>.toMetaInfo( + file: TestFile, + lightTreeEnabled: Boolean, + lightTreeComparingModeEnabled: Boolean, + forceRenderArguments: Boolean = false + ): FirDiagnosticCodeMetaInfo { val metaInfo = FirDiagnosticCodeMetaInfo(this, FirMetaInfoUtils.renderDiagnosticNoArgs) val shouldRenderArguments = forceRenderArguments || globalMetadataInfoHandler.getExistingMetaInfosForActualMetadata(file, metaInfo) .any { it.description != null } if (shouldRenderArguments) { metaInfo.replaceRenderConfiguration(FirMetaInfoUtils.renderDiagnosticWithArgs) } + if (lightTreeComparingModeEnabled) { + metaInfo.attributes += if (lightTreeEnabled) PsiLightTreeMetaInfoProcessor.LT else PsiLightTreeMetaInfoProcessor.PSI + } return metaInfo } - private fun collectSyntaxDiagnostics(testFile: TestFile, firFile: FirFile) { + private fun collectSyntaxDiagnostics( + testFile: TestFile, + firFile: FirFile, + lightTreeEnabled: Boolean, + lightTreeComparingModeEnabled: Boolean + ) { // TODO: support in light tree val psiFile = firFile.psi ?: return val metaInfos = AnalyzingUtils.getSyntaxErrorRanges(psiFile).map { - FirErrors.SYNTAX.on(FirRealPsiSourceElement(it)).toMetaInfo(testFile) + FirErrors.SYNTAX.on(FirRealPsiSourceElement(it)).toMetaInfo(testFile, lightTreeEnabled, lightTreeComparingModeEnabled) } globalMetadataInfoHandler.addMetadataInfosForFile(testFile, metaInfos) } @@ -101,6 +118,8 @@ class FirDiagnosticsHandler(testServices: TestServices) : FirAnalysisHandler(tes private fun collectDebugInfoDiagnostics( testFile: TestFile, firFile: FirFile, + lightTreeEnabled: Boolean, + lightTreeComparingModeEnabled: Boolean ) { val result = mutableListOf>() val diagnosedRangesToDiagnosticNames = globalMetadataInfoHandler.getExistingMetaInfosForFile(testFile).groupBy( @@ -128,7 +147,10 @@ class FirDiagnosticsHandler(testServices: TestServices) : FirAnalysisHandler(tes super.visitFunctionCall(functionCall) } }.let(firFile::accept) - globalMetadataInfoHandler.addMetadataInfosForFile(testFile, result.map { it.toMetaInfo(testFile, forceRenderArguments = true) }) + globalMetadataInfoHandler.addMetadataInfosForFile( + testFile, + result.map { it.toMetaInfo(testFile, lightTreeEnabled, lightTreeComparingModeEnabled, forceRenderArguments = true) } + ) } fun createExpressionTypeDiagnosticIfExpected( @@ -230,3 +252,21 @@ class FirDiagnosticsHandler(testServices: TestServices) : FirAnalysisHandler(tes override fun processAfterAllModules(someAssertionWasFailed: Boolean) {} } + +class PsiLightTreeMetaInfoProcessor(testServices: TestServices) : AbstractTwoAttributesMetaInfoProcessor(testServices) { + companion object { + const val PSI = "PSI" + const val LT = "LT" // Light Tree + } + + override val firstAttribute: String get() = PSI + override val secondAttribute: String get() = LT + + override fun processorEnabled(module: TestModule): Boolean { + return FirDiagnosticsDirectives.COMPARE_WITH_LIGHT_TREE in module.directives + } + + override fun firstAttributeEnabled(module: TestModule): Boolean { + return FirDiagnosticsDirectives.USE_LIGHT_TREE !in module.directives + } +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/generators/GenerateNewCompilerTests.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/generators/GenerateNewCompilerTests.kt index a9ea608954a..113823e1fe5 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/generators/GenerateNewCompilerTests.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/generators/GenerateNewCompilerTests.kt @@ -5,7 +5,7 @@ package org.jetbrains.kotlin.test.generators -import org.jetbrains.kotlin.generators.util.TestGeneratorUtil +import org.jetbrains.kotlin.generators.util.TestGeneratorUtil.KT_WITHOUT_DOTS_IN_NAME import org.jetbrains.kotlin.test.TargetBackend import org.jetbrains.kotlin.test.runners.* @@ -47,8 +47,12 @@ fun main(args: Array) { testGroup("compiler/tests-common-new/tests-gen", "compiler/fir/analysis-tests/testData") { testClass { - model("resolve", pattern = TestGeneratorUtil.KT_WITHOUT_DOTS_IN_NAME) - model("resolveWithStdlib", pattern = TestGeneratorUtil.KT_WITHOUT_DOTS_IN_NAME) + model("resolve", pattern = KT_WITHOUT_DOTS_IN_NAME) + model("resolveWithStdlib", pattern = KT_WITHOUT_DOTS_IN_NAME) + } + + testClass { + model("resolve", pattern = KT_WITHOUT_DOTS_IN_NAME) } } } diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/impl/TestConfigurationImpl.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/impl/TestConfigurationImpl.kt index 164a0e9ca09..e82d9f6534e 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/impl/TestConfigurationImpl.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/impl/TestConfigurationImpl.kt @@ -123,7 +123,12 @@ class TestConfigurationImpl( init { testServices.apply { - this@TestConfigurationImpl.facades.values.forEach { it.values.forEach { facade -> register(facade.additionalServices) } } + this@TestConfigurationImpl.facades.values.forEach { + it.values.forEach { facade -> + register(facade.additionalServices) + allDirectives += facade.additionalDirectives + } + } } } diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractFirDiagnosticTest.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractFirDiagnosticTest.kt index f44723c4ba6..f5497d17639 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractFirDiagnosticTest.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/runners/AbstractFirDiagnosticTest.kt @@ -8,7 +8,11 @@ package org.jetbrains.kotlin.test.runners import org.jetbrains.kotlin.platform.jvm.JvmPlatforms import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder import org.jetbrains.kotlin.test.directives.FirDiagnosticsDirectives +import org.jetbrains.kotlin.test.directives.FirDiagnosticsDirectives.COMPARE_WITH_LIGHT_TREE +import org.jetbrains.kotlin.test.directives.FirDiagnosticsDirectives.FIR_DUMP +import org.jetbrains.kotlin.test.directives.FirDiagnosticsDirectives.USE_LIGHT_TREE import org.jetbrains.kotlin.test.directives.JvmEnvironmentConfigurationDirectives +import org.jetbrains.kotlin.test.directives.JvmEnvironmentConfigurationDirectives.WITH_STDLIB import org.jetbrains.kotlin.test.directives.LanguageSettingsDirectives import org.jetbrains.kotlin.test.frontend.fir.FirFailingTestSuppressor import org.jetbrains.kotlin.test.frontend.fir.FirFrontendFacade @@ -45,6 +49,8 @@ abstract class AbstractFirDiagnosticTest : AbstractKotlinCompilerTest() { ::FirCfgConsistencyHandler, ) + useMetaInfoProcessors(::PsiLightTreeMetaInfoProcessor) + forTestsMatching("compiler/testData/diagnostics/*") { useAfterAnalysisCheckers( ::FirIdenticalChecker, @@ -55,7 +61,8 @@ abstract class AbstractFirDiagnosticTest : AbstractKotlinCompilerTest() { forTestsMatching("compiler/fir/analysis-tests/testData/*") { defaultDirectives { - +FirDiagnosticsDirectives.FIR_DUMP + +FIR_DUMP + +COMPARE_WITH_LIGHT_TREE } } @@ -65,7 +72,18 @@ abstract class AbstractFirDiagnosticTest : AbstractKotlinCompilerTest() { "compiler/testData/diagnostics/tests/unsignedTypes/*" ) { defaultDirectives { - +JvmEnvironmentConfigurationDirectives.WITH_STDLIB + +WITH_STDLIB + } + } + } +} + +abstract class AbstractFirDiagnosticsWithLightTreeTest : AbstractFirDiagnosticTest() { + override fun configure(builder: TestConfigurationBuilder) { + super.configure(builder) + with(builder) { + defaultDirectives { + +USE_LIGHT_TREE } } } diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/utils/AbstractTwoAttributesMetaInfoProcessor.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/utils/AbstractTwoAttributesMetaInfoProcessor.kt new file mode 100644 index 00000000000..906b0c27a85 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/utils/AbstractTwoAttributesMetaInfoProcessor.kt @@ -0,0 +1,76 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.utils + +import org.jetbrains.kotlin.codeMetaInfo.model.CodeMetaInfo +import org.jetbrains.kotlin.codeMetaInfo.model.ParsedCodeMetaInfo +import org.jetbrains.kotlin.test.model.TestFile +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.AdditionalMetaInfoProcessor +import org.jetbrains.kotlin.test.services.TestServices + +abstract class AbstractTwoAttributesMetaInfoProcessor(testServices: TestServices) : AdditionalMetaInfoProcessor(testServices) { + protected abstract val firstAttribute: String + protected abstract val secondAttribute: String + + protected abstract fun processorEnabled(module: TestModule): Boolean + protected abstract fun firstAttributeEnabled(module: TestModule): Boolean + + override fun processMetaInfos(module: TestModule, file: TestFile) { + /* + * Rules for OI/NI attribute: + * ┌──────────┬───────┬────────┬──────────┐ + * │ │ first │ second │ nothing │ <- reported + * ├──────────┼───────┼────────┼──────────┤ + * │ nothing │ both │ both │ nothing │ + * │ first │ first │ both │ first │ + * │ second │ both │ second │ second │ + * │ both │ both │ both │ opposite │ <- first if second enabled in test and vice versa + * └──────────┴───────┴────────┴──────────┘ + * ^ existed + */ + if (!processorEnabled(module)) return + val (currentFlag, otherFlag) = when (firstAttributeEnabled(module)) { + true -> firstAttribute to secondAttribute + false -> secondAttribute to firstAttribute + } + val matchedExistedInfos = mutableSetOf() + val matchedReportedInfos = mutableSetOf() + val allReportedInfos = globalMetadataInfoHandler.getReportedMetaInfosForFile(file) + for ((_, reportedInfos) in allReportedInfos.groupBy { Triple(it.start, it.end, it.tag) }) { + val existedInfos = globalMetadataInfoHandler.getExistingMetaInfosForActualMetadata(file, reportedInfos.first()) + for ((reportedInfo, existedInfo) in reportedInfos.zip(existedInfos)) { + matchedExistedInfos += existedInfo + matchedReportedInfos += reportedInfo + if (currentFlag !in reportedInfo.attributes) continue + if (currentFlag in existedInfo.attributes) continue + reportedInfo.attributes.remove(currentFlag) + } + } + + if (allReportedInfos.size != matchedReportedInfos.size) { + for (info in allReportedInfos) { + if (info !in matchedReportedInfos) { + info.attributes.remove(currentFlag) + } + } + } + + val allExistedInfos = globalMetadataInfoHandler.getExistingMetaInfosForFile(file) + if (allExistedInfos.size == matchedExistedInfos.size) return + + val newInfos = allExistedInfos.mapNotNull { + if (it in matchedExistedInfos) return@mapNotNull null + if (currentFlag in it.attributes) return@mapNotNull null + it.copy().apply { + if (otherFlag !in attributes) { + attributes += otherFlag + } + } + } + globalMetadataInfoHandler.addMetadataInfosForFile(file, newInfos) + } +} diff --git a/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt b/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt index e9b03e95d04..8bad7ab7bbe 100644 --- a/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt +++ b/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt @@ -603,14 +603,9 @@ fun main(args: Array) { } testGroup("compiler/fir/analysis-tests/tests-gen", "compiler/fir/analysis-tests/testData") { - testClass { - model("resolve", pattern = KT_WITHOUT_DOTS_IN_NAME) - } - testClass { model("resolve", pattern = KT_WITHOUT_DOTS_IN_NAME) } - } testGroup("compiler/fir/analysis-tests/tests-gen", "compiler/testData") { From e1802fde296dbdf0de43b76eedd0819836fd012c Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Tue, 15 Dec 2020 12:58:53 +0300 Subject: [PATCH 122/196] [TD] Update test data after previous commit --- .../fir/analysis-tests/testData/resolve/F.kt | 2 +- .../testData/resolve/NestedOfAliasedType.kt | 2 +- .../testData/resolve/NestedSuperType.kt | 2 +- .../resolve/TwoDeclarationsInSameFile.kt | 2 +- .../arguments/ambiguityOnJavaOverride.kt | 2 +- .../testData/resolve/arguments/default.kt | 8 ++-- .../resolve/arguments/defaultFromOverrides.kt | 4 +- .../extensionLambdaInDefaultArgument.kt | 2 +- .../arguments/incorrectFunctionalType.kt | 2 +- .../resolve/arguments/integerLiteralTypes.kt | 8 ++-- .../testData/resolve/arguments/invoke.kt | 2 +- .../resolve/arguments/javaArrayVariance.kt | 4 +- .../testData/resolve/arguments/lambda.kt | 16 ++++---- .../resolve/arguments/lambdaInLambda.kt | 2 +- .../resolve/arguments/lambdaInLambda2.kt | 2 +- .../arguments/lambdaInUnresolvedCall.kt | 10 ++--- .../arguments/operatorsOverLiterals.kt | 38 +++++++++---------- .../resolve/arguments/overloadByReceiver.kt | 2 +- .../resolve/arguments/overloadWithDefault.kt | 2 +- .../testData/resolve/arguments/simple.kt | 14 +++---- .../resolve/arguments/stringTemplates.kt | 2 +- .../testData/resolve/arguments/tryInLambda.kt | 2 +- .../testData/resolve/arguments/vararg.kt | 8 ++-- .../resolve/arguments/varargProjection.kt | 2 +- .../testData/resolve/arrays/arraySet.kt | 2 +- .../resolve/arrays/arraySetWithOperation.kt | 2 +- .../testData/resolve/asImports.kt | 6 +-- .../testData/resolve/builtins/lists.kt | 2 +- .../resolve/callResolution/errorCandidates.kt | 8 ++-- .../invokeWithReceiverAndArgument.kt | 2 +- .../callResolution/lambdaAsReceiver.kt | 2 +- .../analysis-tests/testData/resolve/cast.kt | 2 +- .../resolve/cfg/annotatedLocalClass.kt | 2 +- .../resolve/cfg/booleanOperatorsWithConsts.kt | 2 +- .../testData/resolve/cfg/complex.kt | 2 +- .../testData/resolve/cfg/emptyWhen.kt | 2 +- .../resolve/cfg/flowFromInplaceLambda.kt | 14 +++---- .../testData/resolve/cfg/initBlock.kt | 2 +- .../resolve/cfg/initBlockAndInPlaceLambda.kt | 2 +- .../testData/resolve/cfg/jumps.kt | 4 +- .../testData/resolve/cfg/loops.kt | 2 +- .../cfg/postponedLambdaInConstructor.kt | 2 +- .../testData/resolve/cfg/postponedLambdas.kt | 2 +- .../resolve/cfg/propertiesAndInitBlocks.kt | 2 +- .../resolve/cfg/returnValuesFromLambda.kt | 2 +- .../testData/resolve/cfg/simple.kt | 2 +- .../testData/resolve/cfg/tryCatch.kt | 2 +- .../testData/resolve/cfg/when.kt | 2 +- .../testData/resolve/companion.kt | 2 +- .../testData/resolve/companionUsesNested.kt | 2 +- .../constructors/noSuperCallInSupertypes.kt | 2 +- .../analysis-tests/testData/resolve/copy.kt | 2 +- .../resolve/covariantArrayAsReceiver.kt | 2 +- .../testData/resolve/delegatedSuperType.kt | 2 +- .../resolve/delegates/delegateInference.kt | 2 +- .../resolve/delegates/delegateWithLambda.kt | 2 +- .../delegates/extensionGenericGetValue.kt | 2 +- ...nsionGetValueWithTypeVariableAsReceiver.kt | 2 +- .../resolve/delegates/provideDelegate.kt | 2 +- .../resolve/delegatingConstructorCall.kt | 10 ++--- .../delegatingConstructorsAndTypeAliases.kt | 2 +- .../testData/resolve/derivedClass.kt | 2 +- .../resolve/diagnostics/abstractSuperCall.kt | 4 +- ...llInPresenseOfNonAbstractMethodInParent.kt | 2 +- .../annotationArgumentMustBeConst.kt | 2 +- .../annotationArgumentMustBeEnumConst.kt | 2 +- .../annotationArgumentMustBeKClassLiteral.kt | 2 +- .../diagnostics/annotationClassMember.kt | 4 +- .../diagnostics/anonymousObjectByDelegate.kt | 2 +- .../diagnostics/classInSupertypeForEnum.kt | 2 +- .../diagnostics/conflictingOverloads.kt | 4 +- .../diagnostics/constructorInInterface.kt | 8 ++-- .../cyclicConstructorDelegationCall.kt | 30 +++++++-------- .../diagnostics/delegationInInterface.kt | 2 +- .../delegationSuperCallInEnumConstructor.kt | 4 +- .../explicitDelegationCallRequired.kt | 8 ++-- .../inapplicableLateinitModifier.kt | 2 +- .../diagnostics/incompatibleModifiers.kt | 2 +- .../instanceAccessBeforeSuperCall.kt | 6 +-- .../diagnostics/interfaceWithSuperclass.kt | 2 +- .../diagnostics/localAnnotationClass.kt | 4 +- .../diagnostics/localEntitytNotAllowed.kt | 10 ++--- .../diagnostics/manyCompanionObjects.kt | 14 +++---- .../methodOfAnyImplementedInInterface.kt | 2 +- .../nonConstValInAnnotationArgument.kt | 2 +- .../resolve/diagnostics/notASupertype.kt | 4 +- .../primaryConstructorRequiredForDataClass.kt | 2 +- .../propertyTypeMismatchOnOverride.kt | 2 +- ...lifiedSupertypeExtendedByOtherSupertype.kt | 2 +- .../resolve/diagnostics/redundantModifier.kt | 2 +- .../resolve/diagnostics/repeatedModifier.kt | 2 +- .../returnTypeMismatchOnOverride.kt | 4 +- .../diagnostics/sealedClassConstructorCall.kt | 2 +- .../resolve/diagnostics/sealedSupertype.kt | 6 +-- .../diagnostics/superCallWithDelegation.kt | 2 +- .../diagnostics/superIsNotAnExpression.kt | 2 +- .../resolve/diagnostics/superNotAvailable.kt | 14 +++---- .../superclassNotAccessibleFromInterface.kt | 2 +- .../supertypeInitializedInInterface.kt | 2 +- ...ypeInitializedWithoutPrimaryConstructor.kt | 2 +- .../diagnostics/testIllegalAnnotationClass.kt | 2 +- .../diagnostics/typeArgumentsNotAllowed.kt | 8 ++-- .../diagnostics/typeOfAnnotationMember.kt | 2 +- .../diagnostics/typeParametersInEnum.kt | 2 +- .../diagnostics/typeParametersInObject.kt | 16 ++++---- .../resolve/diagnostics/upperBoundViolated.kt | 2 +- .../diagnostics/valOnAnnotationParameter.kt | 4 +- .../analysis-tests/testData/resolve/enum.kt | 2 +- .../resolve/exhaustiveWhenAndDNNType.kt | 2 +- .../resolve/exhaustiveness_boolean.kt | 2 +- .../testData/resolve/exhaustiveness_enum.kt | 2 +- .../resolve/exhaustiveness_enumJava.kt | 8 ++-- .../resolve/exhaustiveness_sealedClass.kt | 2 +- .../resolve/exhaustiveness_sealedObject.kt | 2 +- .../resolve/exhaustiveness_sealedSubClass.kt | 8 ++-- .../CallBasedInExpressionGenerator.kt | 16 ++++---- .../testData/resolve/expresssions/access.kt | 6 +-- .../expresssions/annotationWithReturn.kt | 2 +- .../resolve/expresssions/annotations.kt | 2 +- .../resolve/expresssions/baseQualifier.kt | 6 +-- .../resolve/expresssions/checkArguments.kt | 2 +- .../classifierAccessFromCompanion.kt | 2 +- .../resolve/expresssions/companion.kt | 2 +- .../expresssions/companionExtension.kt | 2 +- .../resolve/expresssions/constructor.kt | 2 +- .../resolve/expresssions/dispatchReceiver.kt | 2 +- .../resolve/expresssions/enumEntryUse.kt | 4 +- .../resolve/expresssions/enumValues.kt | 2 +- .../resolve/expresssions/errCallable.kt | 2 +- .../expresssions/extensionPropertyInLambda.kt | 2 +- .../resolve/expresssions/genericDecorator.kt | 2 +- .../resolve/expresssions/genericDescriptor.kt | 2 +- .../expresssions/genericPropertyAccess.kt | 2 +- .../expresssions/genericUsedInFunction.kt | 2 +- .../resolve/expresssions/importedReceiver.kt | 2 +- .../resolve/expresssions/inference/id.kt | 2 +- .../expresssions/inference/typeParameters.kt | 4 +- .../expresssions/inference/typeParameters2.kt | 4 +- .../resolve/expresssions/innerQualifier.kt | 2 +- .../expresssions/innerWithSuperCompanion.kt | 2 +- .../expresssions/invoke/doubleBrackets.kt | 2 +- .../expresssions/invoke/explicitReceiver.kt | 2 +- .../expresssions/invoke/explicitReceiver2.kt | 2 +- .../resolve/expresssions/invoke/extension.kt | 2 +- .../expresssions/invoke/extensionOnObject.kt | 2 +- .../expresssions/invoke/farInvokeExtension.kt | 2 +- .../expresssions/invoke/implicitTypeOrder.kt | 2 +- .../resolve/expresssions/invoke/inBrackets.kt | 2 +- .../invoke/incorrectInvokeReceiver.kt | 2 +- .../invoke/propertyFromParameter.kt | 2 +- .../invoke/propertyWithExtensionType.kt | 2 +- .../resolve/expresssions/invoke/simple.kt | 2 +- .../expresssions/invoke/threeReceivers.kt | 2 +- .../resolve/expresssions/javaFieldCallable.kt | 2 +- .../expresssions/lambdaWithReceiver.kt | 2 +- .../localClassAccessesContainingClass.kt | 2 +- .../resolve/expresssions/localConstructor.kt | 2 +- .../resolve/expresssions/localExtension.kt | 2 +- .../expresssions/localImplicitBodies.kt | 2 +- .../resolve/expresssions/localInnerClass.kt | 2 +- .../resolve/expresssions/localObjects.kt | 6 +-- .../resolve/expresssions/localScopes.kt | 2 +- .../resolve/expresssions/localTypes.kt | 2 +- .../expresssions/localWithBooleanNot.kt | 2 +- .../resolve/expresssions/memberExtension.kt | 2 +- .../expresssions/nestedConstructorCallable.kt | 2 +- .../resolve/expresssions/nestedObjects.kt | 2 +- .../resolve/expresssions/nestedVisibility.kt | 12 +++--- .../objectOverrideCallViaImport.kt | 2 +- .../testData/resolve/expresssions/objects.kt | 2 +- .../resolve/expresssions/operators/plus.kt | 2 +- .../operators/plusAndPlusAssign.kt | 2 +- .../expresssions/operators/plusAssign.kt | 4 +- .../expresssions/outerMemberAccesses.kt | 2 +- .../expresssions/overriddenJavaGetter.kt | 2 +- .../expresssions/privateObjectLiteral.kt | 2 +- .../resolve/expresssions/privateVisibility.kt | 18 ++++----- .../expresssions/protectedVisibility.kt | 6 +-- .../expresssions/qualifiedExpressions.kt | 2 +- .../expresssions/receiverConsistency.kt | 6 +-- .../resolve/expresssions/sameReceiver.kt | 2 +- .../testData/resolve/expresssions/simple.kt | 2 +- .../expresssions/syntheticInImplicitBody.kt | 2 +- .../testData/resolve/expresssions/this.kt | 2 +- .../expresssions/topExtensionVsOuterMember.kt | 2 +- .../testData/resolve/expresssions/vararg.kt | 2 +- .../testData/resolve/expresssions/when.kt | 2 +- .../testData/resolve/extension.kt | 2 +- .../resolve/fakeRecursiveSupertype.kt | 2 +- .../resolve/fakeRecursiveTypealias.kt | 2 +- .../analysis-tests/testData/resolve/fib.kt | 2 +- .../resolve/fromBuilder/complexTypes.kt | 2 +- .../testData/resolve/fromBuilder/enums.kt | 8 ++-- .../fromBuilder/noPrimaryConstructor.kt | 2 +- .../resolve/fromBuilder/simpleClass.kt | 2 +- .../testData/resolve/genericFunctions.kt | 2 +- .../genericReceiverPropertyOverride.kt | 2 +- .../testData/resolve/incorrectSuperCall.kt | 2 +- .../callableReferencesAndDefaultParameters.kt | 2 +- .../coercionToUnitWithEarlyReturn.kt | 2 +- .../inference/integerLiteralAsComparable.kt | 2 +- .../inference/nestedExtensionFunctionType.kt | 2 +- .../inference/nullableIntegerLiteralType.kt | 6 +-- .../inference/receiverWithCapturedType.kt | 2 +- .../testData/resolve/innerClasses/inner.kt | 8 ++-- .../resolve/innerClasses/innerTypes.kt | 8 ++-- .../testData/resolve/innerClasses/simple.kt | 6 +-- .../testData/resolve/intersectionTypes.kt | 2 +- .../resolve/invokeOfLambdaWithReceiver.kt | 2 +- .../testData/resolve/javaFieldVsAccessor.kt | 2 +- .../testData/resolve/kt41984.kt | 2 +- .../resolve/lambdaArgInScopeFunction.kt | 6 +-- .../resolve/lambdaInLhsOfTypeOperatorCall.kt | 2 +- .../resolve/lambdaPropertyTypeInference.kt | 8 ++-- .../testData/resolve/localFunctionsHiding.kt | 2 +- .../testData/resolve/localObject.kt | 2 +- .../testData/resolve/multifile/Annotations.kt | 2 +- .../testData/resolve/multifile/ByteArray.kt | 2 +- .../resolve/multifile/NestedSuperType.kt | 2 +- .../resolve/multifile/sealedStarImport.kt | 2 +- .../resolve/multifile/simpleImportNested.kt | 2 +- .../resolve/multifile/simpleImportOuter.kt | 2 +- .../testData/resolve/nestedClassContructor.kt | 2 +- .../testData/resolve/nestedClassNameClash.kt | 2 +- .../testData/resolve/nestedReturnType.kt | 2 +- .../testData/resolve/objectInnerClass.kt | 2 +- .../offOrderMultiBoundGenericOverride.kt | 2 +- .../testData/resolve/openInInterface.kt | 2 +- .../testData/resolve/overrides/generics.kt | 2 +- .../testData/resolve/overrides/simple.kt | 2 +- .../overrides/supertypeGenericsComplex.kt | 2 +- .../testData/resolve/overrides/three.kt | 2 +- ...lexLambdaWithTypeVariableAsExpectedType.kt | 2 +- .../definitelyNotNullAndOriginalType.kt | 2 +- .../problems/inaccessibleJavaGetter.kt | 6 +-- .../resolve/problems/innerClassHierarchy.kt | 2 +- .../problems/multipleJavaClassesInOneFile.kt | 4 +- .../problems/objectDerivedFromInnerClass.kt | 4 +- .../problems/secondaryConstructorCfg.kt | 2 +- .../testData/resolve/problems2.kt | 2 +- .../syntheticPropertiesForJavaAnnotations.kt | 2 +- .../resolve/propertyFromJavaPlusAssign.kt | 2 +- .../resolve/qualifierWithCompanion.kt | 2 +- .../resolve/references/integerLiteralInLhs.kt | 2 +- .../testData/resolve/references/simple.kt | 2 +- .../resolve/references/superMember.kt | 2 +- .../genericSamInferenceFromExpectType.kt | 4 +- .../realConstructorFunction.kt | 8 ++-- .../resolve/samConversions/genericSam.kt | 4 +- .../resolve/samConversions/kotlinSam.kt | 8 ++-- .../notSamBecauseOfSupertype.kt | 8 ++-- .../testData/resolve/sealedClass.kt | 4 +- .../testData/resolve/simpleClass.kt | 2 +- .../testData/resolve/simpleTypeAlias.kt | 2 +- .../testData/resolve/smartcasts/bangbang.kt | 8 ++-- .../smartcasts/booleans/booleanOperators.kt | 14 +++---- .../smartcasts/booleans/equalsToBoolean.kt | 18 ++++----- .../booleans/jumpFromRhsOfOperator.kt | 12 +++--- .../boundSmartcasts/boundSmartcasts.kt | 6 +-- .../boundSmartcastsInBranches.kt | 2 +- .../testData/resolve/smartcasts/casts.kt | 18 ++++----- .../smartcasts/controlStructures/elvis.kt | 2 +- .../smartcasts/controlStructures/returns.kt | 12 +++--- .../smartcasts/controlStructures/simpleIf.kt | 2 +- .../smartcastFromArgument.kt | 2 +- .../smartcasts/controlStructures/when.kt | 2 +- .../resolve/smartcasts/equalsAndIdentity.kt | 10 ++--- .../testData/resolve/smartcasts/kt10240.kt | 2 +- .../testData/resolve/smartcasts/kt37327.kt | 2 +- .../testData/resolve/smartcasts/kt39000.kt | 2 +- .../smartcasts/lambdas/inPlaceLambdas.kt | 2 +- .../smartcasts/lambdas/lambdaInWhenBranch.kt | 2 +- .../smartcasts/lambdas/smartcastOnLambda.kt | 2 +- .../loops/dataFlowInfoFromWhileCondition.kt | 2 +- .../resolve/smartcasts/loops/endlessLoops.kt | 2 +- .../resolve/smartcasts/multipleCasts.kt | 2 +- .../resolve/smartcasts/nullability.kt | 36 +++++++++--------- .../resolve/smartcasts/orInWhenBranch.kt | 10 ++--- .../implicitReceiverAsWhenSubject.kt | 2 +- .../smartcasts/receivers/implicitReceivers.kt | 38 +++++++++---------- .../mixingImplicitAndExplicitReceivers.kt | 2 +- .../smartcasts/safeCalls/assignSafeCall.kt | 2 +- .../safeCalls/safeCallAndEqualityToBool.kt | 2 +- .../resolve/smartcasts/safeCalls/safeCalls.kt | 8 ++-- .../smartcasts/stability/overridenOpenVal.kt | 2 +- .../smartcasts/variables/delayedAssignment.kt | 4 +- .../variables/smartcastAfterReassignment.kt | 2 +- .../testData/resolve/spreadOperator.kt | 2 +- .../testData/resolve/treeSet.kt | 2 +- .../testData/resolve/tryInference.kt | 2 +- .../resolve/typeAliasWithTypeArguments.kt | 16 ++++---- .../testData/resolve/typeFromGetter.kt | 2 +- .../testData/resolve/typeParameterVsNested.kt | 2 +- .../types/capturedParametersOfInnerClasses.kt | 2 +- .../testData/resolve/typesInLocalFunctions.kt | 2 +- .../exposedFunctionParameterType.kt | 2 +- .../visibility/exposedFunctionReturnType.kt | 2 +- .../resolve/visibility/exposedPropertyType.kt | 6 +-- .../resolve/visibility/exposedSupertype.kt | 6 +-- .../resolve/visibility/exposedTypeAlias.kt | 6 +-- .../visibility/exposedTypeParameters.kt | 2 +- .../visibility/singletonConstructors.kt | 6 +-- .../visibility/visibilityWithOverrides.kt | 2 +- .../testData/resolve/whenAsReceiver.kt | 2 +- .../testData/resolve/whenElse.kt | 2 +- .../testData/resolve/whenInference.kt | 2 +- 306 files changed, 599 insertions(+), 599 deletions(-) diff --git a/compiler/fir/analysis-tests/testData/resolve/F.kt b/compiler/fir/analysis-tests/testData/resolve/F.kt index ea56d48e954..a95e7c700ef 100644 --- a/compiler/fir/analysis-tests/testData/resolve/F.kt +++ b/compiler/fir/analysis-tests/testData/resolve/F.kt @@ -1,4 +1,4 @@ open class A -class B : A() \ No newline at end of file +class B : A() diff --git a/compiler/fir/analysis-tests/testData/resolve/NestedOfAliasedType.kt b/compiler/fir/analysis-tests/testData/resolve/NestedOfAliasedType.kt index 2af76b328d1..2fd0590d384 100644 --- a/compiler/fir/analysis-tests/testData/resolve/NestedOfAliasedType.kt +++ b/compiler/fir/analysis-tests/testData/resolve/NestedOfAliasedType.kt @@ -6,4 +6,4 @@ typealias TA = A class B : TA() { class NestedInB : Nested() -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/NestedSuperType.kt b/compiler/fir/analysis-tests/testData/resolve/NestedSuperType.kt index ca28a0dc3dd..613c2c4de8c 100644 --- a/compiler/fir/analysis-tests/testData/resolve/NestedSuperType.kt +++ b/compiler/fir/analysis-tests/testData/resolve/NestedSuperType.kt @@ -10,4 +10,4 @@ abstract class My { class Your : My() { class NestedThree : NestedOne() -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/TwoDeclarationsInSameFile.kt b/compiler/fir/analysis-tests/testData/resolve/TwoDeclarationsInSameFile.kt index 030f50027df..fa5281064a6 100644 --- a/compiler/fir/analysis-tests/testData/resolve/TwoDeclarationsInSameFile.kt +++ b/compiler/fir/analysis-tests/testData/resolve/TwoDeclarationsInSameFile.kt @@ -3,4 +3,4 @@ package p open class A -class B : A() \ No newline at end of file +class B : A() diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/ambiguityOnJavaOverride.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/ambiguityOnJavaOverride.kt index ac36f03e9f6..616ba08d947 100644 --- a/compiler/fir/analysis-tests/testData/resolve/arguments/ambiguityOnJavaOverride.kt +++ b/compiler/fir/analysis-tests/testData/resolve/arguments/ambiguityOnJavaOverride.kt @@ -15,5 +15,5 @@ class B : A() { } fun test(b: B) { - b.foo("") + b.foo("") } diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/default.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/default.kt index bf5a1904af2..d9ac68a53ae 100644 --- a/compiler/fir/analysis-tests/testData/resolve/arguments/default.kt +++ b/compiler/fir/analysis-tests/testData/resolve/arguments/default.kt @@ -8,19 +8,19 @@ fun test() { foo(1, 2.0, true) foo(1, third = true) - foo() - foo(0, 0.0, false, "") + foo() + foo(0, 0.0, false, "") bar(1, third = true) bar(1, 2.0, true) bar(1, 2.0, true, "my") - bar(1, true) + bar(1, true) baz(1) baz(1, "my", "yours") baz(1, z = true) - baz(0, "", false) + baz(0, "", false) } diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/defaultFromOverrides.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/defaultFromOverrides.kt index 6995c3c4d61..af4ff520d6b 100644 --- a/compiler/fir/analysis-tests/testData/resolve/arguments/defaultFromOverrides.kt +++ b/compiler/fir/analysis-tests/testData/resolve/arguments/defaultFromOverrides.kt @@ -15,8 +15,8 @@ fun foo(a: A) { a.foo() a.foo(1) - a.bar() - a.bar("") + a.bar() + a.bar("") a.bar(y = 1) a.bar("", 2) } diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/extensionLambdaInDefaultArgument.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/extensionLambdaInDefaultArgument.kt index 9ecc8487742..cb6d3aa922c 100644 --- a/compiler/fir/analysis-tests/testData/resolve/arguments/extensionLambdaInDefaultArgument.kt +++ b/compiler/fir/analysis-tests/testData/resolve/arguments/extensionLambdaInDefaultArgument.kt @@ -2,4 +2,4 @@ fun test( val f: String.() -> Int = { length } ): Int { return "".f() -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/incorrectFunctionalType.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/incorrectFunctionalType.kt index 3d8b49c348c..94e5a0d0a5f 100644 --- a/compiler/fir/analysis-tests/testData/resolve/arguments/incorrectFunctionalType.kt +++ b/compiler/fir/analysis-tests/testData/resolve/arguments/incorrectFunctionalType.kt @@ -4,4 +4,4 @@ fun test() { foo { this + it } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/integerLiteralTypes.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/integerLiteralTypes.kt index 0aa726d7740..59b75b27414 100644 --- a/compiler/fir/analysis-tests/testData/resolve/arguments/integerLiteralTypes.kt +++ b/compiler/fir/analysis-tests/testData/resolve/arguments/integerLiteralTypes.kt @@ -17,9 +17,9 @@ fun test_1() { } fun test_2() { - takeInt(10000000000) + takeInt(10000000000) takeLong(10000000000) - takeByte(1000) + takeByte(1000) } fun test_3() { @@ -35,8 +35,8 @@ fun test_4() { } fun test_5() { - takeString(1) - takeString(run { 1 }) + takeString(1) + takeString(run { 1 }) } annotation class Ann(val x: Byte) diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/invoke.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/invoke.kt index c9392ab0068..523198288aa 100644 --- a/compiler/fir/analysis-tests/testData/resolve/arguments/invoke.kt +++ b/compiler/fir/analysis-tests/testData/resolve/arguments/invoke.kt @@ -6,4 +6,4 @@ class My(var x: Int) { fun copy() = My(x) } -fun testInvoke(): Int = My(13)() \ No newline at end of file +fun testInvoke(): Int = My(13)() diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/javaArrayVariance.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/javaArrayVariance.kt index 4ead42a36c3..b6916223877 100644 --- a/compiler/fir/analysis-tests/testData/resolve/arguments/javaArrayVariance.kt +++ b/compiler/fir/analysis-tests/testData/resolve/arguments/javaArrayVariance.kt @@ -13,6 +13,6 @@ fun takeOutA(array: Array) {} fun test(array: Array) { A.take(array) - takeA(array) + takeA(array) takeOutA(array) -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/lambda.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/lambda.kt index d593651712a..99f98ae6f6c 100644 --- a/compiler/fir/analysis-tests/testData/resolve/arguments/lambda.kt +++ b/compiler/fir/analysis-tests/testData/resolve/arguments/lambda.kt @@ -10,8 +10,8 @@ fun test() { foo({}) // Bad - foo(1) {} - foo(f = {}) {} + foo(1) {} + foo(f = {}) {} // OK bar(1) {} @@ -20,15 +20,15 @@ fun test() { bar(x = 1, f = {}) // Bad - bar {} - bar({}) + bar {} + bar({}) // OK baz(other = false, f = {}) baz({}, false) // Bad - baz {} - baz() {} - baz(other = false) {} -} \ No newline at end of file + baz {} + baz() {} + baz(other = false) {} +} diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/lambdaInLambda.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/lambdaInLambda.kt index 8b73579af58..4c565c751eb 100644 --- a/compiler/fir/analysis-tests/testData/resolve/arguments/lambdaInLambda.kt +++ b/compiler/fir/analysis-tests/testData/resolve/arguments/lambdaInLambda.kt @@ -20,4 +20,4 @@ fun test(ordinal: Int) { } } } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/lambdaInLambda2.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/lambdaInLambda2.kt index eb13dc322f5..f98e070fc4a 100644 --- a/compiler/fir/analysis-tests/testData/resolve/arguments/lambdaInLambda2.kt +++ b/compiler/fir/analysis-tests/testData/resolve/arguments/lambdaInLambda2.kt @@ -25,4 +25,4 @@ fun test() { val processor = AdapterProcessor( Function { method: PsiMethod? -> method?.containingClass } ) -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/lambdaInUnresolvedCall.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/lambdaInUnresolvedCall.kt index 26f6d8f3b0d..f867a56997e 100644 --- a/compiler/fir/analysis-tests/testData/resolve/arguments/lambdaInUnresolvedCall.kt +++ b/compiler/fir/analysis-tests/testData/resolve/arguments/lambdaInUnresolvedCall.kt @@ -1,14 +1,14 @@ fun materialize(): R = null!! fun test_1() { - myRun { + myRun { val x = 1 x * 2 - } + } } fun test_2() { - myRun { + myRun { materialize() - } -} \ No newline at end of file + } +} diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/operatorsOverLiterals.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/operatorsOverLiterals.kt index 5309319fed2..4e6622f6fcc 100644 --- a/compiler/fir/analysis-tests/testData/resolve/arguments/operatorsOverLiterals.kt +++ b/compiler/fir/analysis-tests/testData/resolve/arguments/operatorsOverLiterals.kt @@ -31,33 +31,33 @@ fun test_3() { fun takeByte(b: Byte) {} fun test_4() { - takeByte(1 + 1) - takeByte(1 + 127) - takeByte(1 - 1) - takeByte(-100 - 100) - takeByte(10 * 10) - takeByte(100 * 100) - taleByte(10 / 10) - takeByte(100 % 10) - takeByte(1000 % 10) - takeByte(1000 and 100) - takeByte(128 and 511) - takeByte(100 or 100) - takeByte(1000 or 0) - takeByte(511 xor 511) - takeByte(512 xor 511) + takeByte(1 + 1) + takeByte(1 + 127) + takeByte(1 - 1) + takeByte(-100 - 100) + takeByte(10 * 10) + takeByte(100 * 100) + taleByte(10 / 10) + takeByte(100 % 10) + takeByte(1000 % 10) + takeByte(1000 and 100) + takeByte(128 and 511) + takeByte(100 or 100) + takeByte(1000 or 0) + takeByte(511 xor 511) + takeByte(512 xor 511) } fun test_5() { takeByte(-1) takeByte(+1) - takeByte(1.inv()) + takeByte(1.inv()) } fun test_6() { - takeByte(run { 127 + 1 }) - takeByte(1 + run { 1 }) - takeByte(run { 1 + 1 }) + takeByte(run { 127 + 1 }) + takeByte(1 + run { 1 }) + takeByte(run { 1 + 1 }) 1 + 1 run { 1 } 1 + run { 1 } diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/overloadByReceiver.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/overloadByReceiver.kt index f8b42bbf33f..dc03b8952a4 100644 --- a/compiler/fir/analysis-tests/testData/resolve/arguments/overloadByReceiver.kt +++ b/compiler/fir/analysis-tests/testData/resolve/arguments/overloadByReceiver.kt @@ -14,4 +14,4 @@ fun takeInt(x: Int) {} fun test(d: D) { val x = d.foo() takeInt(x) -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/overloadWithDefault.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/overloadWithDefault.kt index bbe5dd311eb..617fad9626b 100644 --- a/compiler/fir/analysis-tests/testData/resolve/arguments/overloadWithDefault.kt +++ b/compiler/fir/analysis-tests/testData/resolve/arguments/overloadWithDefault.kt @@ -5,4 +5,4 @@ interface A { fun test(a: A) { a.foo { true } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/simple.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/simple.kt index c043e7a8ca1..d669fd5ef8a 100644 --- a/compiler/fir/analysis-tests/testData/resolve/arguments/simple.kt +++ b/compiler/fir/analysis-tests/testData/resolve/arguments/simple.kt @@ -7,11 +7,11 @@ fun test() { foo(1, second = 3.14, third = false, fourth = "!?") foo(third = false, second = 2.71, fourth = "?!", first = 0) - foo() - foo(0.0, false, 0, "") + foo() + foo(0.0, false, 0, "") foo(1, 2.0, third = true, "") - foo(second = 0.0, first = 0, fourth = "") - foo(first = 0.0, second = 0, third = "", fourth = false) - foo(first = 0, second = 0.0, third = false, fourth = "", first = 1) - foo(0, 0.0, false, foth = "") -} \ No newline at end of file + foo(second = 0.0, first = 0, fourth = "") + foo(first = 0.0, second = 0, third = "", fourth = false) + foo(first = 0, second = 0.0, third = false, fourth = "", first = 1) + foo(0, 0.0, false, foth = "") +} diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/stringTemplates.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/stringTemplates.kt index a863ad03614..6f8a2d62b33 100644 --- a/compiler/fir/analysis-tests/testData/resolve/arguments/stringTemplates.kt +++ b/compiler/fir/analysis-tests/testData/resolve/arguments/stringTemplates.kt @@ -4,4 +4,4 @@ fun foo(s: String) {} fun test(a: A) { foo("$a") -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/tryInLambda.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/tryInLambda.kt index 0cb52a8116b..48f800e3549 100644 --- a/compiler/fir/analysis-tests/testData/resolve/arguments/tryInLambda.kt +++ b/compiler/fir/analysis-tests/testData/resolve/arguments/tryInLambda.kt @@ -10,4 +10,4 @@ fun test() { foo() } } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/vararg.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/vararg.kt index f42aee5067d..ecafa19ebb0 100644 --- a/compiler/fir/analysis-tests/testData/resolve/arguments/vararg.kt +++ b/compiler/fir/analysis-tests/testData/resolve/arguments/vararg.kt @@ -7,11 +7,11 @@ fun test() { foo(1, "my", "yours") foo(1, *arrayOf("my", "yours")) - foo("") - foo(1, 2) + foo("") + foo(1, 2) bar(1, z = true, y = *arrayOf("my", "yours")) - bar(0, z = false, y = "", y = "other") - bar(0, "", true) + bar(0, z = false, y = "", y = "other") + bar(0, "", true) } diff --git a/compiler/fir/analysis-tests/testData/resolve/arguments/varargProjection.kt b/compiler/fir/analysis-tests/testData/resolve/arguments/varargProjection.kt index 5f7aae988c3..f51ce1bd32e 100644 --- a/compiler/fir/analysis-tests/testData/resolve/arguments/varargProjection.kt +++ b/compiler/fir/analysis-tests/testData/resolve/arguments/varargProjection.kt @@ -6,4 +6,4 @@ fun foo(vararg arg: Base) {} fun bar(base: Array, sub: Array) { foo(*base) foo(*sub) -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/arrays/arraySet.kt b/compiler/fir/analysis-tests/testData/resolve/arrays/arraySet.kt index ed31f6b10c4..7ee2af2cb3f 100644 --- a/compiler/fir/analysis-tests/testData/resolve/arrays/arraySet.kt +++ b/compiler/fir/analysis-tests/testData/resolve/arrays/arraySet.kt @@ -28,4 +28,4 @@ fun test_2(a: A) { fun test_3(a: A) { a[0] = D() // set -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/arrays/arraySetWithOperation.kt b/compiler/fir/analysis-tests/testData/resolve/arrays/arraySetWithOperation.kt index 3a96512472a..a1a92464668 100644 --- a/compiler/fir/analysis-tests/testData/resolve/arrays/arraySetWithOperation.kt +++ b/compiler/fir/analysis-tests/testData/resolve/arrays/arraySetWithOperation.kt @@ -33,4 +33,4 @@ fun test_3(a: A) { fun test_4(b: B) { b[0] += B() // unresolved -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/asImports.kt b/compiler/fir/analysis-tests/testData/resolve/asImports.kt index cf61f45b05c..33826641a61 100644 --- a/compiler/fir/analysis-tests/testData/resolve/asImports.kt +++ b/compiler/fir/analysis-tests/testData/resolve/asImports.kt @@ -11,11 +11,11 @@ class A { import foo.A as B fun test_1() { - val a = A() + val a = A() val b = B() // should be OK - val c: B = A() + val c: B = A() } fun test_2(b: B) { b.foo() -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/builtins/lists.kt b/compiler/fir/analysis-tests/testData/resolve/builtins/lists.kt index 8eb5d168b34..88229fac48d 100644 --- a/compiler/fir/analysis-tests/testData/resolve/builtins/lists.kt +++ b/compiler/fir/analysis-tests/testData/resolve/builtins/lists.kt @@ -2,4 +2,4 @@ abstract class MyStringList : List abstract class MyMutableStringList : MutableList fun List.convert(): MyStringList = this as MyStringList -fun ret(l: MutableList): MyMutableStringList = l as MyMutableStringList \ No newline at end of file +fun ret(l: MutableList): MyMutableStringList = l as MyMutableStringList diff --git a/compiler/fir/analysis-tests/testData/resolve/callResolution/errorCandidates.kt b/compiler/fir/analysis-tests/testData/resolve/callResolution/errorCandidates.kt index 6989a80856a..8ce85a18c6e 100644 --- a/compiler/fir/analysis-tests/testData/resolve/callResolution/errorCandidates.kt +++ b/compiler/fir/analysis-tests/testData/resolve/callResolution/errorCandidates.kt @@ -9,11 +9,11 @@ fun bar(x: B) {} fun test(c: C) { // Argument mapping error - foo("") + foo("") // Ambiguity - bar(c) + bar(c) // Unresolved reference - baz() -} \ No newline at end of file + baz() +} diff --git a/compiler/fir/analysis-tests/testData/resolve/callResolution/invokeWithReceiverAndArgument.kt b/compiler/fir/analysis-tests/testData/resolve/callResolution/invokeWithReceiverAndArgument.kt index 29e27786a03..56aeefc56fd 100644 --- a/compiler/fir/analysis-tests/testData/resolve/callResolution/invokeWithReceiverAndArgument.kt +++ b/compiler/fir/analysis-tests/testData/resolve/callResolution/invokeWithReceiverAndArgument.kt @@ -26,4 +26,4 @@ class Outer { } fun bar(i: Inner) {} -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/callResolution/lambdaAsReceiver.kt b/compiler/fir/analysis-tests/testData/resolve/callResolution/lambdaAsReceiver.kt index 543f908a55b..c6cc6917af0 100644 --- a/compiler/fir/analysis-tests/testData/resolve/callResolution/lambdaAsReceiver.kt +++ b/compiler/fir/analysis-tests/testData/resolve/callResolution/lambdaAsReceiver.kt @@ -9,6 +9,6 @@ fun main1() { } fun main2() { - { "" }.bar() + { "" }.bar() "".bar() } diff --git a/compiler/fir/analysis-tests/testData/resolve/cast.kt b/compiler/fir/analysis-tests/testData/resolve/cast.kt index eb1c8be7d0b..25782fdfc86 100644 --- a/compiler/fir/analysis-tests/testData/resolve/cast.kt +++ b/compiler/fir/analysis-tests/testData/resolve/cast.kt @@ -4,4 +4,4 @@ val y = 2 as Any val f = fun() = 3 as Any val g = {} val h: (String) -> Boolean = { _ -> false } -val hError = { _ -> true } \ No newline at end of file +val hError = { _ -> true } diff --git a/compiler/fir/analysis-tests/testData/resolve/cfg/annotatedLocalClass.kt b/compiler/fir/analysis-tests/testData/resolve/cfg/annotatedLocalClass.kt index 75a77b82182..794013aabe4 100644 --- a/compiler/fir/analysis-tests/testData/resolve/cfg/annotatedLocalClass.kt +++ b/compiler/fir/analysis-tests/testData/resolve/cfg/annotatedLocalClass.kt @@ -13,4 +13,4 @@ fun foo(b: Boolean) { bar() } -fun bar() {} \ No newline at end of file +fun bar() {} diff --git a/compiler/fir/analysis-tests/testData/resolve/cfg/booleanOperatorsWithConsts.kt b/compiler/fir/analysis-tests/testData/resolve/cfg/booleanOperatorsWithConsts.kt index 7d264eb9f7a..e5ba0f3a228 100644 --- a/compiler/fir/analysis-tests/testData/resolve/cfg/booleanOperatorsWithConsts.kt +++ b/compiler/fir/analysis-tests/testData/resolve/cfg/booleanOperatorsWithConsts.kt @@ -45,4 +45,4 @@ fun test_8(b: Boolean) { if (true && b) { 1 } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/cfg/complex.kt b/compiler/fir/analysis-tests/testData/resolve/cfg/complex.kt index 3da982bef9a..ec9eac70bc4 100644 --- a/compiler/fir/analysis-tests/testData/resolve/cfg/complex.kt +++ b/compiler/fir/analysis-tests/testData/resolve/cfg/complex.kt @@ -19,4 +19,4 @@ internal fun AutoCloseable?.closeFinally(cause: Throwable?) = when { inline fun List<*>.firstIsInstanceOrNull(): T? { for (element in this) if (element is T) return element return null -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/cfg/emptyWhen.kt b/compiler/fir/analysis-tests/testData/resolve/cfg/emptyWhen.kt index 31a170b91f0..13609cffc29 100644 --- a/compiler/fir/analysis-tests/testData/resolve/cfg/emptyWhen.kt +++ b/compiler/fir/analysis-tests/testData/resolve/cfg/emptyWhen.kt @@ -9,4 +9,4 @@ fun test_2(x: Int) { fun test_3(x: Int) { when (val y = x) {} -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/cfg/flowFromInplaceLambda.kt b/compiler/fir/analysis-tests/testData/resolve/cfg/flowFromInplaceLambda.kt index d965d81be19..be90f5a38d6 100644 --- a/compiler/fir/analysis-tests/testData/resolve/cfg/flowFromInplaceLambda.kt +++ b/compiler/fir/analysis-tests/testData/resolve/cfg/flowFromInplaceLambda.kt @@ -19,7 +19,7 @@ fun test_2(x: Any, y: Any) { val a = select( id( run { - y.inc() // Bad + y.inc() // Bad x as Int } ), @@ -39,14 +39,14 @@ fun test_3(x: Any, y: Any) { val a = select( id( run { - y.inc() // Bad + y.inc() // Bad x as Int materialize() } ), run { y as Int - x.inc() // Bad + x.inc() // Bad y.inc() // OK 1 } @@ -60,19 +60,19 @@ fun test_4(x: Any, y: Any) { val a = select( id( myRun { - y.inc() // Bad + y.inc() // Bad x as Int } ), y as Int, myRun { - x.inc() // Bad + x.inc() // Bad y.inc() // OK 1 } ) - takeInt(x) // Bad + takeInt(x) // Bad takeInt(y) // OK takeInt(a) // Bad } @@ -90,4 +90,4 @@ fun test_6() { } } ) -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/cfg/initBlock.kt b/compiler/fir/analysis-tests/testData/resolve/cfg/initBlock.kt index 9b01e0cfee0..53799431123 100644 --- a/compiler/fir/analysis-tests/testData/resolve/cfg/initBlock.kt +++ b/compiler/fir/analysis-tests/testData/resolve/cfg/initBlock.kt @@ -11,4 +11,4 @@ class Bar { throw Exception() val y = 2 } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/cfg/initBlockAndInPlaceLambda.kt b/compiler/fir/analysis-tests/testData/resolve/cfg/initBlockAndInPlaceLambda.kt index 41ef10d358a..06f6dffba56 100644 --- a/compiler/fir/analysis-tests/testData/resolve/cfg/initBlockAndInPlaceLambda.kt +++ b/compiler/fir/analysis-tests/testData/resolve/cfg/initBlockAndInPlaceLambda.kt @@ -11,4 +11,4 @@ class C(a: A, b: B) { C(a, it) } } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/cfg/jumps.kt b/compiler/fir/analysis-tests/testData/resolve/cfg/jumps.kt index 126031fbd59..a5dc4b78cb6 100644 --- a/compiler/fir/analysis-tests/testData/resolve/cfg/jumps.kt +++ b/compiler/fir/analysis-tests/testData/resolve/cfg/jumps.kt @@ -15,7 +15,7 @@ fun test_2(x: Int?) { } else { x } - y.inc() + y.inc() } fun test_3(x: Int?) { @@ -50,4 +50,4 @@ fun test_6() { run { return@run } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/cfg/loops.kt b/compiler/fir/analysis-tests/testData/resolve/cfg/loops.kt index f46fd20a6a4..510a2bcdc7a 100644 --- a/compiler/fir/analysis-tests/testData/resolve/cfg/loops.kt +++ b/compiler/fir/analysis-tests/testData/resolve/cfg/loops.kt @@ -65,4 +65,4 @@ fun testDoWhileFalse() { 1 } while (false) 1 -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/cfg/postponedLambdaInConstructor.kt b/compiler/fir/analysis-tests/testData/resolve/cfg/postponedLambdaInConstructor.kt index 8aaf470465e..302d1b95bf8 100644 --- a/compiler/fir/analysis-tests/testData/resolve/cfg/postponedLambdaInConstructor.kt +++ b/compiler/fir/analysis-tests/testData/resolve/cfg/postponedLambdaInConstructor.kt @@ -6,4 +6,4 @@ class B(val s: String) : A(s.let { { it } }) { fun foo() { foo() } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/cfg/postponedLambdas.kt b/compiler/fir/analysis-tests/testData/resolve/cfg/postponedLambdas.kt index 50bb00666ea..ac29eec136d 100644 --- a/compiler/fir/analysis-tests/testData/resolve/cfg/postponedLambdas.kt +++ b/compiler/fir/analysis-tests/testData/resolve/cfg/postponedLambdas.kt @@ -3,4 +3,4 @@ inline fun foo(vararg x: Any) {} fun test(a: Any, b: Any, c: Any) { foo(a, { "" }, b) -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/cfg/propertiesAndInitBlocks.kt b/compiler/fir/analysis-tests/testData/resolve/cfg/propertiesAndInitBlocks.kt index 8f9f0dd5234..31055eb1267 100644 --- a/compiler/fir/analysis-tests/testData/resolve/cfg/propertiesAndInitBlocks.kt +++ b/compiler/fir/analysis-tests/testData/resolve/cfg/propertiesAndInitBlocks.kt @@ -40,4 +40,4 @@ val x4 = try { 2 } finally { 0 -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/cfg/returnValuesFromLambda.kt b/compiler/fir/analysis-tests/testData/resolve/cfg/returnValuesFromLambda.kt index a8a716d7145..e0d1b079569 100644 --- a/compiler/fir/analysis-tests/testData/resolve/cfg/returnValuesFromLambda.kt +++ b/compiler/fir/analysis-tests/testData/resolve/cfg/returnValuesFromLambda.kt @@ -19,4 +19,4 @@ fun test_2() { fun test_3() { val x = run { return } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/cfg/simple.kt b/compiler/fir/analysis-tests/testData/resolve/cfg/simple.kt index b15a7ff84a5..b6ad6aa9b12 100644 --- a/compiler/fir/analysis-tests/testData/resolve/cfg/simple.kt +++ b/compiler/fir/analysis-tests/testData/resolve/cfg/simple.kt @@ -5,4 +5,4 @@ fun test() { val x = 1 val y = x + 1 foo() -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/cfg/tryCatch.kt b/compiler/fir/analysis-tests/testData/resolve/cfg/tryCatch.kt index 753b04f5373..3fa5da9b4a8 100644 --- a/compiler/fir/analysis-tests/testData/resolve/cfg/tryCatch.kt +++ b/compiler/fir/analysis-tests/testData/resolve/cfg/tryCatch.kt @@ -31,4 +31,4 @@ fun test_3(b: Boolean) { val y = 2 } val z = 3 -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/cfg/when.kt b/compiler/fir/analysis-tests/testData/resolve/cfg/when.kt index fc052120c6d..fe5b1fcfbb7 100644 --- a/compiler/fir/analysis-tests/testData/resolve/cfg/when.kt +++ b/compiler/fir/analysis-tests/testData/resolve/cfg/when.kt @@ -15,4 +15,4 @@ fun test_2(x: Any?) { if (x is A && x is B) { x is A } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/companion.kt b/compiler/fir/analysis-tests/testData/resolve/companion.kt index 4c6c0c970f1..03bcb9c51c7 100644 --- a/compiler/fir/analysis-tests/testData/resolve/companion.kt +++ b/compiler/fir/analysis-tests/testData/resolve/companion.kt @@ -14,4 +14,4 @@ abstract class Another { } abstract val x: InCompanion -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/companionUsesNested.kt b/compiler/fir/analysis-tests/testData/resolve/companionUsesNested.kt index af3ba0912f6..b8ab9e19eed 100644 --- a/compiler/fir/analysis-tests/testData/resolve/companionUsesNested.kt +++ b/compiler/fir/analysis-tests/testData/resolve/companionUsesNested.kt @@ -15,4 +15,4 @@ class Derived : Base() { val dd: DerivedNested = DerivedNested() } } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/constructors/noSuperCallInSupertypes.kt b/compiler/fir/analysis-tests/testData/resolve/constructors/noSuperCallInSupertypes.kt index 57224d8d01f..61f4f92d0dd 100644 --- a/compiler/fir/analysis-tests/testData/resolve/constructors/noSuperCallInSupertypes.kt +++ b/compiler/fir/analysis-tests/testData/resolve/constructors/noSuperCallInSupertypes.kt @@ -24,4 +24,4 @@ typealias DDD = C class CKt : QQQ, DDD { constructor(s: String) : super(s) -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/copy.kt b/compiler/fir/analysis-tests/testData/resolve/copy.kt index c4fe1712a7d..1c8e94975c2 100644 --- a/compiler/fir/analysis-tests/testData/resolve/copy.kt +++ b/compiler/fir/analysis-tests/testData/resolve/copy.kt @@ -5,4 +5,4 @@ fun test(some: Some) { val another = some.copy(x = 123) val same = some.copy() val different = some.copy(456, "456") -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/covariantArrayAsReceiver.kt b/compiler/fir/analysis-tests/testData/resolve/covariantArrayAsReceiver.kt index a343b108e55..15af25df94b 100644 --- a/compiler/fir/analysis-tests/testData/resolve/covariantArrayAsReceiver.kt +++ b/compiler/fir/analysis-tests/testData/resolve/covariantArrayAsReceiver.kt @@ -20,4 +20,4 @@ fun foo(element: PsiElement, usages: Array) { val adjusted = if (element is KtParameter) usages.filterNot { it.usage is KtLightMethod } else usages.toList() -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/delegatedSuperType.kt b/compiler/fir/analysis-tests/testData/resolve/delegatedSuperType.kt index 35b8e7b5702..99ab71bd47a 100644 --- a/compiler/fir/analysis-tests/testData/resolve/delegatedSuperType.kt +++ b/compiler/fir/analysis-tests/testData/resolve/delegatedSuperType.kt @@ -6,4 +6,4 @@ class B : A { override fun foo() {} } -class C(val b: B) : A by b \ No newline at end of file +class C(val b: B) : A by b diff --git a/compiler/fir/analysis-tests/testData/resolve/delegates/delegateInference.kt b/compiler/fir/analysis-tests/testData/resolve/delegates/delegateInference.kt index d4cb4c7154c..2d5c01f4b2b 100644 --- a/compiler/fir/analysis-tests/testData/resolve/delegates/delegateInference.kt +++ b/compiler/fir/analysis-tests/testData/resolve/delegates/delegateInference.kt @@ -24,4 +24,4 @@ class Test { fun test() { var x: Boolean by LocalFreezableVar(true) var y by LocalFreezableVar("") -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/delegates/delegateWithLambda.kt b/compiler/fir/analysis-tests/testData/resolve/delegates/delegateWithLambda.kt index 6f9052fd8a7..d704ff136e5 100644 --- a/compiler/fir/analysis-tests/testData/resolve/delegates/delegateWithLambda.kt +++ b/compiler/fir/analysis-tests/testData/resolve/delegates/delegateWithLambda.kt @@ -13,4 +13,4 @@ class Test { val y = getAny() as? String ?: "" y } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/delegates/extensionGenericGetValue.kt b/compiler/fir/analysis-tests/testData/resolve/delegates/extensionGenericGetValue.kt index f2a8127487f..aed7168156c 100644 --- a/compiler/fir/analysis-tests/testData/resolve/delegates/extensionGenericGetValue.kt +++ b/compiler/fir/analysis-tests/testData/resolve/delegates/extensionGenericGetValue.kt @@ -5,4 +5,4 @@ inline fun runLogged(action: () -> L): L { operator fun V.getValue(receiver: Any?, p: Any): V = runLogged { this } -val testK by runLogged { "K" } \ No newline at end of file +val testK by runLogged { "K" } diff --git a/compiler/fir/analysis-tests/testData/resolve/delegates/extensionGetValueWithTypeVariableAsReceiver.kt b/compiler/fir/analysis-tests/testData/resolve/delegates/extensionGetValueWithTypeVariableAsReceiver.kt index e23ee0e8868..4a046e9ab8b 100644 --- a/compiler/fir/analysis-tests/testData/resolve/delegates/extensionGetValueWithTypeVariableAsReceiver.kt +++ b/compiler/fir/analysis-tests/testData/resolve/delegates/extensionGetValueWithTypeVariableAsReceiver.kt @@ -5,4 +5,4 @@ inline fun runLogged(action: () -> L): L { operator fun String.getValue(receiver: Any?, p: Any): String = runLogged { this } -val testK by runLogged { "K" } \ No newline at end of file +val testK by runLogged { "K" } diff --git a/compiler/fir/analysis-tests/testData/resolve/delegates/provideDelegate.kt b/compiler/fir/analysis-tests/testData/resolve/delegates/provideDelegate.kt index 68c31000880..f493571c259 100644 --- a/compiler/fir/analysis-tests/testData/resolve/delegates/provideDelegate.kt +++ b/compiler/fir/analysis-tests/testData/resolve/delegates/provideDelegate.kt @@ -16,4 +16,4 @@ fun delegate(value: T): DelegateProvider = DelegateProvider(value) class A { val x by delegate(1) -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/delegatingConstructorCall.kt b/compiler/fir/analysis-tests/testData/resolve/delegatingConstructorCall.kt index 5d6d63eb1a1..74b8f919ea8 100644 --- a/compiler/fir/analysis-tests/testData/resolve/delegatingConstructorCall.kt +++ b/compiler/fir/analysis-tests/testData/resolve/delegatingConstructorCall.kt @@ -10,18 +10,18 @@ open class A3(x: String, y: String = "") { constructor(x: String, b: Boolean = true) : this(x, x) } -class B3_1 : A3("") +class B3_1 : A3("") class B3_2 : A3("", "asas") class B3_3 : A3("", true) -class B3_4 : A3("", Unit) +class B3_4 : A3("", Unit) open class A4(val x: Byte) -class B4 : A4( 1 + 1) +class B4 : A4( 1 + 1) open class A5 { constructor(x: Byte) constructor(x: Short) } -class B5_1 : A5(1 + 1) -class B5_2 : A5(100 * 2) +class B5_1 : A5(1 + 1) +class B5_2 : A5(100 * 2) diff --git a/compiler/fir/analysis-tests/testData/resolve/delegatingConstructorsAndTypeAliases.kt b/compiler/fir/analysis-tests/testData/resolve/delegatingConstructorsAndTypeAliases.kt index 79789e1554b..8d43415b854 100644 --- a/compiler/fir/analysis-tests/testData/resolve/delegatingConstructorsAndTypeAliases.kt +++ b/compiler/fir/analysis-tests/testData/resolve/delegatingConstructorsAndTypeAliases.kt @@ -2,4 +2,4 @@ open class Inv(x: T, r: R) typealias Alias = Inv> -class InvImpl : Alias("", Inv("", "")) \ No newline at end of file +class InvImpl : Alias("", Inv("", "")) diff --git a/compiler/fir/analysis-tests/testData/resolve/derivedClass.kt b/compiler/fir/analysis-tests/testData/resolve/derivedClass.kt index 0ef313b2750..1fd145ab255 100644 --- a/compiler/fir/analysis-tests/testData/resolve/derivedClass.kt +++ b/compiler/fir/analysis-tests/testData/resolve/derivedClass.kt @@ -2,4 +2,4 @@ open class Base(val x: T1) class Derived(x: T2) : Base(x) -fun create(x: T3) /* Derived */ = Derived(x) \ No newline at end of file +fun create(x: T3) /* Derived */ = Derived(x) diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/abstractSuperCall.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/abstractSuperCall.kt index 4c7e16469db..18abcc097c6 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/abstractSuperCall.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/abstractSuperCall.kt @@ -22,7 +22,7 @@ class B : A() { } fun g() { - super.f() + super.f() super.t() super.x @@ -32,7 +32,7 @@ class B : A() { abstract class J : A() { fun r() { - super.f() + super.f() super.t() super.x diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/abstractSuperCallInPresenseOfNonAbstractMethodInParent.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/abstractSuperCallInPresenseOfNonAbstractMethodInParent.kt index 23e7fc1dfcb..9ad38609849 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/abstractSuperCallInPresenseOfNonAbstractMethodInParent.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/abstractSuperCallInPresenseOfNonAbstractMethodInParent.kt @@ -13,5 +13,5 @@ open class B { class A : IWithToString, B() { override fun toString(): String = super.toString() // resolve to Any.toString override fun foo(): String = super.foo() // resolve to B.foo() - override fun bar(): String = super.bar() // should be an error + override fun bar(): String = super.bar() // should be an error } diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationArgumentMustBeConst.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationArgumentMustBeConst.kt index ff628194b16..86984c64a8d 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationArgumentMustBeConst.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationArgumentMustBeConst.kt @@ -28,4 +28,4 @@ class Class { ) ) @Ann3(arr) -fun test() {} \ No newline at end of file +fun test() {} diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationArgumentMustBeEnumConst.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationArgumentMustBeEnumConst.kt index 18506224a43..684f7d0029e 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationArgumentMustBeEnumConst.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationArgumentMustBeEnumConst.kt @@ -8,4 +8,4 @@ val foo = TestEnum.Foo var bar = TestEnum.Foo @Ann(foo, bar) -fun test() {} \ No newline at end of file +fun test() {} diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationArgumentMustBeKClassLiteral.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationArgumentMustBeKClassLiteral.kt index e04ed99f525..f32955807db 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationArgumentMustBeKClassLiteral.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationArgumentMustBeKClassLiteral.kt @@ -21,4 +21,4 @@ fun bar() = Foo::class bar() ] ) -fun test1() {} \ No newline at end of file +fun test1() {} diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationClassMember.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationClassMember.kt index 2e12e471c7a..99c7f132257 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationClassMember.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/annotationClassMember.kt @@ -1,7 +1,7 @@ annotation class A() { - constructor(s: Nothing?) {} + constructor(s: Nothing?) {} init {} fun foo() {} val bar: Nothing? val baz get() = Unit -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/anonymousObjectByDelegate.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/anonymousObjectByDelegate.kt index f635f85286c..dda522b47e4 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/anonymousObjectByDelegate.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/anonymousObjectByDelegate.kt @@ -14,4 +14,4 @@ fun A.test_2() { object : B by b {} } -class D(val x: String, val y: String = this.x) {} \ No newline at end of file +class D(val x: String, val y: String = this.x) {} diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/classInSupertypeForEnum.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/classInSupertypeForEnum.kt index e504994e2c4..10fe8fcbc68 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/classInSupertypeForEnum.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/classInSupertypeForEnum.kt @@ -2,4 +2,4 @@ class A interface C -enum class B : C, A(), Any() \ No newline at end of file +enum class B : C, A(), Any() diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/conflictingOverloads.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/conflictingOverloads.kt index 18944e0d232..a5e75c40091 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/conflictingOverloads.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/conflictingOverloads.kt @@ -49,7 +49,7 @@ fun lol(a: Array) {} fun mem(t: T) where T : String, T : () -> Boolean {} class M { - companion object {} + companion object {} val Companion = object : Any {} } @@ -65,4 +65,4 @@ class mest fun() {} -private fun() {} \ No newline at end of file +private fun() {} diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/constructorInInterface.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/constructorInInterface.kt index 44f0ef1703d..fed72540136 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/constructorInInterface.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/constructorInInterface.kt @@ -1,7 +1,7 @@ -interface A(val s: String) +interface A(val s: String) -interface B constructor(val s: String) +interface B constructor(val s: String) interface C { - constructor(val s: String) {} -} \ No newline at end of file + constructor(val s: String) {} +} diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/cyclicConstructorDelegationCall.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/cyclicConstructorDelegationCall.kt index 3e0bcb593bf..6af1dea3d24 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/cyclicConstructorDelegationCall.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/cyclicConstructorDelegationCall.kt @@ -2,14 +2,14 @@ class B class C class A() { - constructor(a: Int) : this("test") {} - constructor(a: String) : this(10) {} + constructor(a: Int) : this("test") {} + constructor(a: String) : this(10) {} - constructor(a: Boolean) : this('\n') {} - constructor(a: Char) : this(0.0) {} - constructor(a: Double) : this(false) {} + constructor(a: Boolean) : this('\n') {} + constructor(a: Char) : this(0.0) {} + constructor(a: Double) : this(false) {} - constructor(b: B) : this(3.14159265) {} + constructor(b: B) : this(3.14159265) {} constructor(c: C) : this() {} constructor(a: List) : this(C()) {} @@ -17,7 +17,7 @@ class A() { class D { constructor(i: Boolean) {} - constructor(i: Int) : this(3) {} + constructor(i: Int) : this(3) {} } class E { @@ -25,7 +25,7 @@ class E { // selection of the proper constructor // but a type mismatch for the first // argument - constructor(e: T, i: Int) : this(i, 10) {} + constructor(e: T, i: Int) : this(i, 10) {} } class I { @@ -33,7 +33,7 @@ class I { // selection of the proper constructor // but a type mismatch for the first // argument - constructor(e: T, i: Int) : this(i, 10) + constructor(e: T, i: Int) : this(i, 10) } class J { @@ -42,20 +42,20 @@ class J { } class F(s: String) { - constructor(i: Boolean) {} - constructor(i: Int) : this(3) {} + constructor(i: Boolean) {} + constructor(i: Int) : this(3) {} } class G(x: Int) { - constructor() {} + constructor() {} } class H(x: Int) { - constructor() + constructor() } class K(x: Int) { - constructor() : this() {} + constructor() : this() {} } class M { @@ -63,5 +63,5 @@ class M { } class U : M { - constructor() + constructor() } diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/delegationInInterface.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/delegationInInterface.kt index 07010f92307..b212a508b3c 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/delegationInInterface.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/delegationInInterface.kt @@ -6,4 +6,4 @@ interface B : A by a { val test = A() -interface C : A by test \ No newline at end of file +interface C : A by test diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/delegationSuperCallInEnumConstructor.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/delegationSuperCallInEnumConstructor.kt index 8ac7aeef381..de3e2fca1f5 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/delegationSuperCallInEnumConstructor.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/delegationSuperCallInEnumConstructor.kt @@ -1,6 +1,6 @@ enum class A { A(1), B(2), C("test"); - constructor(x: Int) : super() + constructor(x: Int) : super() constructor(t: String) : this(10) -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/explicitDelegationCallRequired.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/explicitDelegationCallRequired.kt index 467e4dd41d1..8a943818747 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/explicitDelegationCallRequired.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/explicitDelegationCallRequired.kt @@ -3,16 +3,16 @@ class A(x: Int) { } class B : A { - constructor() + constructor() constructor(z: String) : this() } class C : A(20) { - constructor() + constructor() constructor(z: String) : this() } class D() : A(20) { - constructor(x: Int) + constructor(x: Int) constructor(z: String) : this() -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/inapplicableLateinitModifier.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/inapplicableLateinitModifier.kt index 4479b9b9485..e5cdcc75457 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/inapplicableLateinitModifier.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/inapplicableLateinitModifier.kt @@ -35,4 +35,4 @@ fun rest() { lateinit var i: Int lateinit var a: A lateinit var b: B = B() -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/incompatibleModifiers.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/incompatibleModifiers.kt index f450767bb03..930e025ca9c 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/incompatibleModifiers.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/incompatibleModifiers.kt @@ -28,4 +28,4 @@ private abstract class M : K() class X { inner data class Y(val i: Int) sealed inner class Z -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/instanceAccessBeforeSuperCall.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/instanceAccessBeforeSuperCall.kt index bd69a862cac..5af0cecc5ce 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/instanceAccessBeforeSuperCall.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/instanceAccessBeforeSuperCall.kt @@ -1,5 +1,5 @@ class A { - constructor(x: Int = getSomeInt(), other: A = this, header: String = keker) {} + constructor(x: Int = getSomeInt(), other: A = this, header: String = keker) {} fun getSomeInt() = 10 var keker = "test" } @@ -7,10 +7,10 @@ class A { class B(other: B = this) class C() { - constructor(x: Int) : this({ + constructor(x: Int) : this({ val a = 10 this - }) {} + }) {} } class D { diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/interfaceWithSuperclass.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/interfaceWithSuperclass.kt index 718ea6c5312..8142f7c3420 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/interfaceWithSuperclass.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/interfaceWithSuperclass.kt @@ -5,4 +5,4 @@ interface B : A interface C class D -interface E : A(), C, D() \ No newline at end of file +interface E : A(), C, D() diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/localAnnotationClass.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/localAnnotationClass.kt index 9ee1d8fe997..ac1d02a2347 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/localAnnotationClass.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/localAnnotationClass.kt @@ -2,7 +2,7 @@ fun foo() { annotation class Ann @Ann class Local { - // There should also be NESTED_CLASS_NOT_ALLOWED report here. - annotation class Nested + // There should also be NESTED_CLASS_NOT_ALLOWED report here. + annotation class Nested } } diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/localEntitytNotAllowed.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/localEntitytNotAllowed.kt index 064c23e4eae..93261d8df5c 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/localEntitytNotAllowed.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/localEntitytNotAllowed.kt @@ -6,19 +6,19 @@ object A { interface X val a = object : Any() { - object D { + object D { object G interface Z - } + } interface Y } fun b() { - object E { + object E { object F interface M - } + } interface N @@ -28,4 +28,4 @@ object A { interface U } } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/manyCompanionObjects.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/manyCompanionObjects.kt index 165d3911fc2..0b81df7cd10 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/manyCompanionObjects.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/manyCompanionObjects.kt @@ -1,11 +1,11 @@ class A { - companion object { + companion object { - } + } - companion object { + companion object { - } + } } class B { @@ -13,7 +13,7 @@ class B { } - companion object B { + companion object B { - } -} \ No newline at end of file + } +} diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/methodOfAnyImplementedInInterface.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/methodOfAnyImplementedInInterface.kt index 44051de762b..411419ce10c 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/methodOfAnyImplementedInInterface.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/methodOfAnyImplementedInInterface.kt @@ -22,4 +22,4 @@ interface D { override operator fun toString(): String override operator fun equals(other: Any?): Boolean override operator fun hashCode(): Int -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/nonConstValInAnnotationArgument.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/nonConstValInAnnotationArgument.kt index ed82693076a..ae88b8599f9 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/nonConstValInAnnotationArgument.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/nonConstValInAnnotationArgument.kt @@ -10,4 +10,4 @@ const val cnst = 2 foo + cnst.toString() ) ) -fun test() {} \ No newline at end of file +fun test() {} diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/notASupertype.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/notASupertype.kt index 014517dd296..4e8a13c2ee7 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/notASupertype.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/notASupertype.kt @@ -4,7 +4,7 @@ class A { class B : A { fun g() { - super.f() + super.f() super.f() } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/primaryConstructorRequiredForDataClass.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/primaryConstructorRequiredForDataClass.kt index 74cf32556d9..b2792655a77 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/primaryConstructorRequiredForDataClass.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/primaryConstructorRequiredForDataClass.kt @@ -6,4 +6,4 @@ data class A {} data class C { constructor(x: Int) -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/propertyTypeMismatchOnOverride.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/propertyTypeMismatchOnOverride.kt index 1ad1c48926d..5c5c24fb52e 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/propertyTypeMismatchOnOverride.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/propertyTypeMismatchOnOverride.kt @@ -26,7 +26,7 @@ class G(val balue: E) : F(balue) { override var rest: E = balue } -class H(val balue: E) : F(balue) { +class H(val balue: E) : F(balue) { override var rest: E = balue // no report because of INAPPLICABLE_CANDIDATE } diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/qualifiedSupertypeExtendedByOtherSupertype.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/qualifiedSupertypeExtendedByOtherSupertype.kt index 946667303a7..81edcb0ef35 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/qualifiedSupertypeExtendedByOtherSupertype.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/qualifiedSupertypeExtendedByOtherSupertype.kt @@ -31,4 +31,4 @@ class Test2 : IDerived, AliasedIBase { super.bar() super.qux() } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/redundantModifier.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/redundantModifier.kt index 184d9b91e71..79f48016693 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/redundantModifier.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/redundantModifier.kt @@ -1,2 +1,2 @@ open abstract class A -abstract sealed class B \ No newline at end of file +abstract sealed class B diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/repeatedModifier.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/repeatedModifier.kt index 6095c967cc3..adbb0b1c8a3 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/repeatedModifier.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/repeatedModifier.kt @@ -14,4 +14,4 @@ enum enum class C { open class E(private private val int: Int = 5) { protected protected var double = int + 8.0 -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/returnTypeMismatchOnOverride.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/returnTypeMismatchOnOverride.kt index d5d6c933864..12775ff02b0 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/returnTypeMismatchOnOverride.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/returnTypeMismatchOnOverride.kt @@ -27,7 +27,7 @@ class G(val balue: E) : F(balue) { override fun rest(): E = balue } -class H(val balue: E) : F(balue) { +class H(val balue: E) : F(balue) { override fun rest(): E = balue // no report because of INAPPLICABLE_CANDIDATE } @@ -66,4 +66,4 @@ open class GoodDerrived : Base() { open class BadDerrived : Base() { override fun kek(): String = "test" -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/sealedClassConstructorCall.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/sealedClassConstructorCall.kt index ff7559e24dc..ae002614d51 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/sealedClassConstructorCall.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/sealedClassConstructorCall.kt @@ -1,3 +1,3 @@ sealed class A -val b = A() \ No newline at end of file +val b = A() diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/sealedSupertype.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/sealedSupertype.kt index 4bbe7624aa3..63562f91132 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/sealedSupertype.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/sealedSupertype.kt @@ -28,13 +28,13 @@ sealed class P { class K : P() -object B { +object B { class I : P() -} +} fun test() { class L : P() val a = object : P() { } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/superCallWithDelegation.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/superCallWithDelegation.kt index 3b434d4f2f4..17772e48f74 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/superCallWithDelegation.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/superCallWithDelegation.kt @@ -9,4 +9,4 @@ class C(a: A) : B(a) { // Should be resolved to delegated B.foo (no error) super.foo() } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/superIsNotAnExpression.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/superIsNotAnExpression.kt index d47496e516f..ad4f40fa5f2 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/superIsNotAnExpression.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/superIsNotAnExpression.kt @@ -4,7 +4,7 @@ class B: A() { fun act() { super() - invoke() + invoke() super { println('weird') diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/superNotAvailable.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/superNotAvailable.kt index d3767bc0fa7..1ca40411257 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/superNotAvailable.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/superNotAvailable.kt @@ -1,20 +1,20 @@ fun String.f() { - super@f.compareTo("") - super.compareTo("") + super@f.compareTo("") + super.compareTo("") } fun foo() { super - super.foo() - super.foo() + super.foo() + super.foo() } class A { fun act() { - println("Test") + println("Test") } fun String.fact() { - println("Fest") + println("Fest") } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/superclassNotAccessibleFromInterface.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/superclassNotAccessibleFromInterface.kt index 602afe19d25..f18b3dfb777 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/superclassNotAccessibleFromInterface.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/superclassNotAccessibleFromInterface.kt @@ -6,4 +6,4 @@ interface ATrait : A { override fun foo() { super.foo() } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/supertypeInitializedInInterface.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/supertypeInitializedInInterface.kt index c0c3ad4c722..2b50b9f867d 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/supertypeInitializedInInterface.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/supertypeInitializedInInterface.kt @@ -10,4 +10,4 @@ interface E : A interface F : A, B(), C, D(), Any() { -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/supertypeInitializedWithoutPrimaryConstructor.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/supertypeInitializedWithoutPrimaryConstructor.kt index 30d66077a9b..40a8a7036d4 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/supertypeInitializedWithoutPrimaryConstructor.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/supertypeInitializedWithoutPrimaryConstructor.kt @@ -8,4 +8,4 @@ class F() : C(10) class G : C(10) { constructor() : super(1) -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/testIllegalAnnotationClass.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/testIllegalAnnotationClass.kt index 20fc13b1970..2c91b6ebf20 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/testIllegalAnnotationClass.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/testIllegalAnnotationClass.kt @@ -19,4 +19,4 @@ package simulation ) class KotlinImporterComponent { class State(var directories: List = ArrayList()) -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/typeArgumentsNotAllowed.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/typeArgumentsNotAllowed.kt index 2763a3e4dd2..c01d19b07bc 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/typeArgumentsNotAllowed.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/typeArgumentsNotAllowed.kt @@ -17,11 +17,11 @@ object Best { } -val a = rest.MyClass -val b = Best.MyClass +val a = rest.MyClass +val b = Best.MyClass class B -class C<Boolean>> : B<F<Boolean>>() +class C<Boolean>> : B<F<Boolean>>() fun gest() {} @@ -31,4 +31,4 @@ fun fest() { gest() val c: ListT>>> gestT>>>() -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/typeOfAnnotationMember.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/typeOfAnnotationMember.kt index 75dc16cd3dc..85691a21134 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/typeOfAnnotationMember.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/typeOfAnnotationMember.kt @@ -20,4 +20,4 @@ annotation class Ann2( val p4: Array?, val p5: Ann1?, val p6: Enum? -) \ No newline at end of file +) diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/typeParametersInEnum.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/typeParametersInEnum.kt index 9d9a934ae47..355cca493c3 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/typeParametersInEnum.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/typeParametersInEnum.kt @@ -1,3 +1,3 @@ enum class A<B, C : B, D> -enum class B \ No newline at end of file +enum class B diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/typeParametersInObject.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/typeParametersInObject.kt index b2600d87a4f..53e38a047bc 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/typeParametersInObject.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/typeParametersInObject.kt @@ -1,15 +1,15 @@ -object A { - object B -} +object A { + object B +} class N { - companion object { + companion object { - } + } } fun test() { - object M { + object M { - } -} \ No newline at end of file + } +} diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/upperBoundViolated.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/upperBoundViolated.kt index b4fd2d58a74..d1596c5afda 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/upperBoundViolated.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/upperBoundViolated.kt @@ -45,4 +45,4 @@ val test8 = NL() class NumberPhile(x: T) val np1 = NumberPhile(10) -val np2 = NumberPhile("Test") +val np2 = NumberPhile("Test") diff --git a/compiler/fir/analysis-tests/testData/resolve/diagnostics/valOnAnnotationParameter.kt b/compiler/fir/analysis-tests/testData/resolve/diagnostics/valOnAnnotationParameter.kt index 7cc5b967fa4..03c8a353964 100644 --- a/compiler/fir/analysis-tests/testData/resolve/diagnostics/valOnAnnotationParameter.kt +++ b/compiler/fir/analysis-tests/testData/resolve/diagnostics/valOnAnnotationParameter.kt @@ -1,4 +1,4 @@ annotation class A( - var a: Int, + var a: Int, b: String -) \ No newline at end of file +) diff --git a/compiler/fir/analysis-tests/testData/resolve/enum.kt b/compiler/fir/analysis-tests/testData/resolve/enum.kt index ff83577c41e..300bdf1464a 100644 --- a/compiler/fir/analysis-tests/testData/resolve/enum.kt +++ b/compiler/fir/analysis-tests/testData/resolve/enum.kt @@ -34,4 +34,4 @@ enum class EnumClass { abstract fun foo(): Int abstract val bar: String -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/exhaustiveWhenAndDNNType.kt b/compiler/fir/analysis-tests/testData/resolve/exhaustiveWhenAndDNNType.kt index 19010ea6a55..b2fb14b0bf3 100644 --- a/compiler/fir/analysis-tests/testData/resolve/exhaustiveWhenAndDNNType.kt +++ b/compiler/fir/analysis-tests/testData/resolve/exhaustiveWhenAndDNNType.kt @@ -35,4 +35,4 @@ fun test_3() { SomeEnum.A2 -> B() } takeB(b) // should be OK -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_boolean.kt b/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_boolean.kt index 1c7013b0ba0..ca517f63c3d 100644 --- a/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_boolean.kt +++ b/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_boolean.kt @@ -22,4 +22,4 @@ fun test_2(b: Boolean?) { false -> 2 null -> 3 } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_enum.kt b/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_enum.kt index da4c4b24aa6..c502f35e046 100644 --- a/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_enum.kt +++ b/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_enum.kt @@ -53,4 +53,4 @@ fun test_3(e: Enum) { Enum.A, Enum.B -> 1 Enum.C -> 2 } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_enumJava.kt b/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_enumJava.kt index 7e428a3fb2e..ab00bc6dab8 100644 --- a/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_enumJava.kt +++ b/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_enumJava.kt @@ -10,13 +10,13 @@ fun test_1(e: JavaEnum) { val a = when (e) { JavaEnum.A -> 1 JavaEnum.B -> 2 - }.plus(0) + }.plus(0) val b = when (e) { JavaEnum.A -> 1 JavaEnum.B -> 2 is String -> 3 - }.plus(0) + }.plus(0) val c = when (e) { JavaEnum.A -> 1 @@ -35,7 +35,7 @@ fun test_2(e: JavaEnum?) { JavaEnum.A -> 1 JavaEnum.B -> 2 JavaEnum.C -> 3 - }.plus(0) + }.plus(0) val a = when (e) { JavaEnum.A -> 1 @@ -57,4 +57,4 @@ fun test_3(e: JavaEnum) { JavaEnum.A, JavaEnum.B -> 1 JavaEnum.C -> 2 }.plus(0) -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_sealedClass.kt b/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_sealedClass.kt index 8ab05066465..78547c73258 100644 --- a/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_sealedClass.kt +++ b/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_sealedClass.kt @@ -57,4 +57,4 @@ fun test_3(e: Base) { is Base.A, is Base.A.B -> 1 is C -> 2 } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_sealedObject.kt b/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_sealedObject.kt index c3752fb9187..fcf93835019 100644 --- a/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_sealedObject.kt +++ b/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_sealedObject.kt @@ -21,4 +21,4 @@ fun test_2(a: A) { C -> "" } takeString(s) -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_sealedSubClass.kt b/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_sealedSubClass.kt index 8633767fdfc..523b7eca50a 100644 --- a/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_sealedSubClass.kt +++ b/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_sealedSubClass.kt @@ -35,20 +35,20 @@ fun test_2(e: A) { val a = when (e) { is D -> 1 is E -> 2 - }.plus(0) + }.plus(0) val b = when (e) { is B -> 1 is D -> 2 is E -> 3 - }.plus(0) + }.plus(0) val c = when (e) { is B -> 1 is D -> 2 - }.plus(0) + }.plus(0) val d = when (e) { is C -> 1 - }.plus(0) + }.plus(0) } diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/CallBasedInExpressionGenerator.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/CallBasedInExpressionGenerator.kt index 1843aa9905b..7fa0c9cc927 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/CallBasedInExpressionGenerator.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/CallBasedInExpressionGenerator.kt @@ -14,27 +14,27 @@ class CallBasedInExpressionGenerator( val codegen: ExpressionCodegen, operatorReference: KtSimpleNameExpression ) : InExpressionGenerator { - private val resolvedCall = operatorReference.getResolvedCallWithAssert(codegen.bindingContext) - private val isInverted = operatorReference.getReferencedNameElementType() == KtTokens.NOT_IN + private val resolvedCall = operatorReference.getResolvedCallWithAssert(codegen.bindingContext) + private val isInverted = operatorReference.getReferencedNameElementType() == KtTokens.NOT_IN override fun generate(argument: StackValue): BranchedValue = - gen(argument).let { if (isInverted) Invert(it) else it } + gen(argument).let { if (isInverted) Invert(it) else it } private fun gen(argument: StackValue): BranchedValue = - object : BranchedValue(argument, null, argument.type, Opcodes.IFEQ) { + object : BranchedValue(argument, null, argument.type, Opcodes.IFEQ) { override fun putSelector(type: Type, kotlinType: KotlinType?, v: InstructionAdapter) { invokeFunction(v) - coerceTo(type, kotlinType, v) + coerceTo(type, kotlinType, v) } override fun condJump(jumpLabel: Label, v: InstructionAdapter, jumpIfFalse: Boolean) { invokeFunction(v) - v.visitJumpInsn(if (jumpIfFalse) Opcodes.IFEQ else Opcodes.IFNE, jumpLabel) + v.visitJumpInsn(if (jumpIfFalse) Opcodes.IFEQ else Opcodes.IFNE, jumpLabel) } private fun invokeFunction(v: InstructionAdapter) { - val result = codegen.invokeFunction(resolvedCall.call, resolvedCall, none()) - result.put(result.type, result.kotlinType, v) + val result = codegen.invokeFunction(resolvedCall.call, resolvedCall, none()) + result.put(result.type, result.kotlinType, v) } } } diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/access.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/access.kt index 43487deca83..88236e7ebc8 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/access.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/access.kt @@ -21,7 +21,7 @@ class Bar { } // NB! abc() here is resolved to member Foo.abc(), and not to extension member of Bar - fun Foo.check() = abc() + bar() + fun Foo.check() = abc() + bar() // NB! + here is resolved to member String.plus (not to extension member above) fun Foo.check2() = "" + bar() @@ -43,7 +43,7 @@ fun f() { val d = "" val c = c - abc() + abc() fun bcd() {} @@ -57,7 +57,7 @@ fun f() { dcb() } - dcb() + dcb() abc() } diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/annotationWithReturn.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/annotationWithReturn.kt index 4c6a3a5c7b7..9bdb75ab1c0 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/annotationWithReturn.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/annotationWithReturn.kt @@ -3,4 +3,4 @@ const val x = 42 -annotation class Some(val value: Int) \ No newline at end of file +annotation class Some(val value: Int) diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/annotations.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/annotations.kt index 4f4d9b5dc1e..d0e10bef1e9 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/annotations.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/annotations.kt @@ -16,4 +16,4 @@ fun foo() { } catch (t: Throwable) { 0 } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/baseQualifier.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/baseQualifier.kt index e4fb0a8d56c..cbc2599b9f9 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/baseQualifier.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/baseQualifier.kt @@ -20,6 +20,6 @@ fun test() { JavaClass.bar() val errC = BB.C - val errBarViaBB = BB.bar() - val errBarViaAA = AA.bar() -} \ No newline at end of file + val errBarViaBB = BB.bar() + val errBarViaAA = AA.bar() +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/checkArguments.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/checkArguments.kt index 862f3f6f243..05dd484ed41 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/checkArguments.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/checkArguments.kt @@ -13,4 +13,4 @@ fun foo() { val ra = bar(a) val rb = bar(b) val rc = bar(c) -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/classifierAccessFromCompanion.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/classifierAccessFromCompanion.kt index 3f73c6112e9..014b17a2021 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/classifierAccessFromCompanion.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/classifierAccessFromCompanion.kt @@ -7,4 +7,4 @@ class Factory { val f = Function val x = Function.Default } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/companion.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/companion.kt index 8bc9fa378a3..f58c33c8511 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/companion.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/companion.kt @@ -23,4 +23,4 @@ fun test() { val x = A.D val y = B.C val z = B.D -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/companionExtension.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/companionExtension.kt index 331a2640158..7a1b6473417 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/companionExtension.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/companionExtension.kt @@ -6,4 +6,4 @@ class My { fun test() { foo() } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/constructor.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/constructor.kt index e7b117928a4..fe22f0b1048 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/constructor.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/constructor.kt @@ -4,4 +4,4 @@ class C { } fun foo() = C() -fun bar() = foo().create() \ No newline at end of file +fun bar() = foo().create() diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/dispatchReceiver.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/dispatchReceiver.kt index 3a7fd610c2f..1c5a715977e 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/dispatchReceiver.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/dispatchReceiver.kt @@ -7,4 +7,4 @@ lateinit var delegate: Base fun check() = delegate.check() // Should not resolve - } \ No newline at end of file + } diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/enumEntryUse.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/enumEntryUse.kt index 8adb7774b67..e20e2c8f8e4 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/enumEntryUse.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/enumEntryUse.kt @@ -18,5 +18,5 @@ fun test() { useEnum(TestEnum.THIRD) useVararg(TestEnum.FIRST, TestEnum.SECOND) - useVararg(1, 2, 3, 4, 5) -} \ No newline at end of file + useVararg(1, 2, 3, 4, 5) +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/enumValues.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/enumValues.kt index 73fa12fc982..c82ce6a6a40 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/enumValues.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/enumValues.kt @@ -15,4 +15,4 @@ fun foo() { val first = MyEnum.valueOf("FIRST") val last = MyEnum.valueOf("LAST") -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/errCallable.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/errCallable.kt index 4ac3e2c8aa0..b637a3cbbaf 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/errCallable.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/errCallable.kt @@ -10,4 +10,4 @@ class My { fun Your.foo() { val x = ::Nested // Still should be error -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/extensionPropertyInLambda.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/extensionPropertyInLambda.kt index 198eb9cbab5..739558408e4 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/extensionPropertyInLambda.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/extensionPropertyInLambda.kt @@ -11,4 +11,4 @@ fun use(f: () -> String) {} fun test1() { use { C("abc").y } use(C("abc")::y) -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/genericDecorator.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/genericDecorator.kt index 98958c167f4..4bfa21deb37 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/genericDecorator.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/genericDecorator.kt @@ -16,4 +16,4 @@ public abstract class Decorator extends LookupElement { class MyDecorator : Decorator { override fun getLookupString(): String = delegate.lookupString -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/genericDescriptor.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/genericDescriptor.kt index 1c089007e2b..4f8e72981ba 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/genericDescriptor.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/genericDescriptor.kt @@ -38,4 +38,4 @@ fun test(call: Call, resolvedCall: ResolvedCall) { fun otherTest(call: Call<*>, resolvedCall: ResolvedCall<*>) { call.resultingDescriptor.name resolvedCall.resultingDescriptor.name -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/genericPropertyAccess.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/genericPropertyAccess.kt index 9a1cfd6472b..607833a6d85 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/genericPropertyAccess.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/genericPropertyAccess.kt @@ -4,4 +4,4 @@ abstract class Base(val x: T) { class Derived(x: T) : Base(x) { override fun foo(): T = x -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/genericUsedInFunction.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/genericUsedInFunction.kt index eac7488d220..6e3687fef46 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/genericUsedInFunction.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/genericUsedInFunction.kt @@ -6,4 +6,4 @@ fun test(arg: Generic) { val value = arg.value val foo = arg.foo() val length = foo.length + value.length -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/importedReceiver.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/importedReceiver.kt index 6b4bae77c7d..74f1a947dba 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/importedReceiver.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/importedReceiver.kt @@ -28,4 +28,4 @@ fun test() { true.gau() wat() false.watwat() -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/inference/id.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/inference/id.kt index 5a54aba8bd7..aa5b3c0cb4d 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/inference/id.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/inference/id.kt @@ -5,4 +5,4 @@ fun main() { val a = id("string") val b = id(null) val c = id(id(a)) -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/inference/typeParameters.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/inference/typeParameters.kt index e73ddbe3285..ad6516e7254 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/inference/typeParameters.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/inference/typeParameters.kt @@ -7,5 +7,5 @@ fun foo(t: T) = t fun main(fooImpl: FooImpl, bar: Bar) { val a = foo(fooImpl) - val b = foo(bar) -} \ No newline at end of file + val b = foo(bar) +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/inference/typeParameters2.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/inference/typeParameters2.kt index 931964e572c..a44c5a04324 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/inference/typeParameters2.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/inference/typeParameters2.kt @@ -6,6 +6,6 @@ fun foo(t: T) = t fun main(fooImpl: FooImpl, fooBarImpl: FooBarImpl) { - val a = foo(fooBarImpl) + val a = foo(fooBarImpl) val b = foo(fooImpl) -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/innerQualifier.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/innerQualifier.kt index ccb941f6afa..4a642b8b735 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/innerQualifier.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/innerQualifier.kt @@ -3,4 +3,4 @@ class Outer { } val x = Outer.Inner -val klass = Outer.Inner::class \ No newline at end of file +val klass = Outer.Inner::class diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/innerWithSuperCompanion.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/innerWithSuperCompanion.kt index a5ba70cba68..350fb2479e7 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/innerWithSuperCompanion.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/innerWithSuperCompanion.kt @@ -10,4 +10,4 @@ class Outer { inner class Inner : Base() { val c = codegen } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/doubleBrackets.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/doubleBrackets.kt index 2c1c336f3d3..b1054a23a14 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/doubleBrackets.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/doubleBrackets.kt @@ -1,3 +1,3 @@ fun String.k(): () -> String = { -> this } -fun test() = "hello".k()() \ No newline at end of file +fun test() = "hello".k()() diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/explicitReceiver.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/explicitReceiver.kt index 5d11ba36d9c..b883f8a2b02 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/explicitReceiver.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/explicitReceiver.kt @@ -22,4 +22,4 @@ class Bar { fun baz() { x() // Should resolve to fun x() } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/explicitReceiver2.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/explicitReceiver2.kt index d45f7fd022c..501707e377a 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/explicitReceiver2.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/explicitReceiver2.kt @@ -16,4 +16,4 @@ class Foo { val x: Bar = Bar() fun bar() = x() // Should resolve to invoke (1) -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/extension.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/extension.kt index ebe97fbd7af..72f1f3a9072 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/extension.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/extension.kt @@ -8,4 +8,4 @@ class Foo { val x = 0 fun foo() = x() // should resolve to invoke -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/extensionOnObject.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/extensionOnObject.kt index a983627d6a8..b969d1f9984 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/extensionOnObject.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/extensionOnObject.kt @@ -7,4 +7,4 @@ class Y { val x = X x.op() } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/farInvokeExtension.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/farInvokeExtension.kt index 5518db20fad..928cbaf7235 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/farInvokeExtension.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/farInvokeExtension.kt @@ -9,4 +9,4 @@ class Foo { val x = 0 fun foo() = x() // should resolve to fun x -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/implicitTypeOrder.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/implicitTypeOrder.kt index 81e849c5254..713e35a3dda 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/implicitTypeOrder.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/implicitTypeOrder.kt @@ -7,4 +7,4 @@ class A { fun create() = A() -val foo = create() \ No newline at end of file +val foo = create() diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/inBrackets.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/inBrackets.kt index 363c262ad17..27d60c91a8f 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/inBrackets.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/inBrackets.kt @@ -1,4 +1,4 @@ fun test(e: Int.() -> String) { val s = 3.e() val ss = 3.(e)() -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/incorrectInvokeReceiver.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/incorrectInvokeReceiver.kt index 26d938dd8d8..7c2478fbae3 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/incorrectInvokeReceiver.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/incorrectInvokeReceiver.kt @@ -7,4 +7,4 @@ fun sss() { // Should be resolved to top-level some, // because with local some invoke isn't applicable some() -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/propertyFromParameter.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/propertyFromParameter.kt index f49645188e6..bb1e61c9a92 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/propertyFromParameter.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/propertyFromParameter.kt @@ -1,3 +1,3 @@ class Bar(name: () -> String) { val name = name() -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/propertyWithExtensionType.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/propertyWithExtensionType.kt index e9d5bb869a8..a149327774a 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/propertyWithExtensionType.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/propertyWithExtensionType.kt @@ -7,4 +7,4 @@ fun test(a: A) { } val c = a.y val d = "".c() -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/simple.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/simple.kt index 187ebd5f683..3e33715adf4 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/simple.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/simple.kt @@ -4,4 +4,4 @@ class Simple { fun test(s: Simple) { val result = s() -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/threeReceivers.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/threeReceivers.kt index e5081adbb98..50171203e9a 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/threeReceivers.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/invoke/threeReceivers.kt @@ -17,6 +17,6 @@ class Foo { // this@Foo is dispatch receiver of foobar // Foo/foobar is dispatch receiver of invoke // this@chk is extension receiver of invoke - buz.foobar() + buz.foobar() } } diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/javaFieldCallable.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/javaFieldCallable.kt index 5435fe4042c..ef830e069ec 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/javaFieldCallable.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/javaFieldCallable.kt @@ -10,4 +10,4 @@ public class JavaClass { fun test() { val staticReference = JavaClass::staticField val nonStaticReference = JavaClass::nonStaticField -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/lambdaWithReceiver.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/lambdaWithReceiver.kt index d38dbf0d514..737e97a3f13 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/lambdaWithReceiver.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/lambdaWithReceiver.kt @@ -38,4 +38,4 @@ fun test_4() { this.inc() it.length } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/localClassAccessesContainingClass.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/localClassAccessesContainingClass.kt index a5c288b6127..10978ba49c7 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/localClassAccessesContainingClass.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/localClassAccessesContainingClass.kt @@ -8,4 +8,4 @@ class Outer { } val y = "" -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/localConstructor.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/localConstructor.kt index 2844400f9f0..3563f42d167 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/localConstructor.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/localConstructor.kt @@ -2,4 +2,4 @@ fun test() { class Local val l = Local() -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/localExtension.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/localExtension.kt index fbb385a688f..0c33cadb7f2 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/localExtension.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/localExtension.kt @@ -3,4 +3,4 @@ fun Foo.bar() {} bar() } - } \ No newline at end of file + } diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/localImplicitBodies.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/localImplicitBodies.kt index 5d937d62e08..1f41ad9eb6f 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/localImplicitBodies.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/localImplicitBodies.kt @@ -4,4 +4,4 @@ fun foo() { fun abc() = 1 } val g = x.sss() -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/localInnerClass.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/localInnerClass.kt index 05d0b6813c8..f0e9415d985 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/localInnerClass.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/localInnerClass.kt @@ -8,4 +8,4 @@ fun bar() { inner class Derived(val x: Int) : Foo } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/localObjects.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/localObjects.kt index a90af6e1282..f82f0ba51de 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/localObjects.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/localObjects.kt @@ -12,10 +12,10 @@ fun test() { } b.foo() - object B { + object B { fun foo() {} - } + } B.foo() } -val bb = B.foo() +val bb = B.foo() diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/localScopes.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/localScopes.kt index 568c3628cc5..d73e41b378a 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/localScopes.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/localScopes.kt @@ -25,4 +25,4 @@ fun test() { derived.gau() derived.baz() derived.foo() -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/localTypes.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/localTypes.kt index 725ceddcf86..ee7b0351efe 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/localTypes.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/localTypes.kt @@ -11,4 +11,4 @@ fun foo() { val Boolean.w: Char get() = ' ' fun id(arg: T): T = arg } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/localWithBooleanNot.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/localWithBooleanNot.kt index f3b9673fcce..510b26194aa 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/localWithBooleanNot.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/localWithBooleanNot.kt @@ -20,4 +20,4 @@ fun foo(): Boolean { val some = true return !some -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/memberExtension.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/memberExtension.kt index 9b4f207b9d9..8642f8fbb11 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/memberExtension.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/memberExtension.kt @@ -12,4 +12,4 @@ class Bar { fun bar(arg: Foo) { arg.foo() } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/nestedConstructorCallable.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/nestedConstructorCallable.kt index 6cb0aa1b602..d6981017de0 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/nestedConstructorCallable.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/nestedConstructorCallable.kt @@ -5,4 +5,4 @@ class A { val x = ::Nested val y = A::Nested } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/nestedObjects.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/nestedObjects.kt index 139732c1e6d..9708e898074 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/nestedObjects.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/nestedObjects.kt @@ -7,4 +7,4 @@ object A { object B val err = B.A.B -val correct = A.B.A \ No newline at end of file +val correct = A.B.A diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/nestedVisibility.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/nestedVisibility.kt index 73ed9de9800..960d7239e02 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/nestedVisibility.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/nestedVisibility.kt @@ -11,8 +11,8 @@ open class Outer { class Derived : Outer() { fun foo() { - Outer.PrivateNested() - super.PrivateInner() + Outer.PrivateNested() + super.PrivateInner() Outer.ProtectedNested() super.ProtectedInner() @@ -23,11 +23,11 @@ class Derived : Outer() { } fun foo() { - Outer.PrivateNested() - Outer().PrivateInner() + Outer.PrivateNested() + Outer().PrivateInner() - Outer.ProtectedNested() - Outer().ProtectedInner() + Outer.ProtectedNested() + Outer().ProtectedInner() Outer.PublicNested() Outer().PublicInner() diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/objectOverrideCallViaImport.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/objectOverrideCallViaImport.kt index 9462e12290d..20af0363ac0 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/objectOverrideCallViaImport.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/objectOverrideCallViaImport.kt @@ -9,4 +9,4 @@ object Derived : Base fun test() { // See KT-35730 foo() // Derived.foo is more correct here -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/objects.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/objects.kt index 0926d75e203..97345c4f1ee 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/objects.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/objects.kt @@ -3,4 +3,4 @@ object A { } fun use() = A -fun bar() = A.foo() \ No newline at end of file +fun bar() = A.foo() diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/operators/plus.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/operators/plus.kt index 10a0bb25702..87197a0c125 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/operators/plus.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/operators/plus.kt @@ -11,4 +11,4 @@ fun test_1() { fun test_2() { var f = Foo() f += Foo() -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/operators/plusAndPlusAssign.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/operators/plusAndPlusAssign.kt index c89e1843cd2..10dd9c63aab 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/operators/plusAndPlusAssign.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/operators/plusAndPlusAssign.kt @@ -6,4 +6,4 @@ class Foo { fun test() { var f = Foo() f += f -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/operators/plusAssign.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/operators/plusAssign.kt index b2084548df9..235e861ef18 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/operators/plusAssign.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/operators/plusAssign.kt @@ -7,7 +7,7 @@ class Foo { fun test_1() { val f = Foo() - f + f + f + f } fun test_2() { @@ -19,4 +19,4 @@ fun test_3(f: Foo) { f += f f += "" f += 1 -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/outerMemberAccesses.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/outerMemberAccesses.kt index 4ada07d50e5..19e65397ac2 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/outerMemberAccesses.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/outerMemberAccesses.kt @@ -42,4 +42,4 @@ class Generator(val codegen: Any) { val cc = codegen.hashCode() } } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/overriddenJavaGetter.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/overriddenJavaGetter.kt index f950fbe0355..4a60595acfa 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/overriddenJavaGetter.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/overriddenJavaGetter.kt @@ -16,4 +16,4 @@ fun test() { val d = Derived() val res1 = d.something // Should be Ok val res2 = d.getSomething() // Should be Ok -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/privateObjectLiteral.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/privateObjectLiteral.kt index 9cd32f8032f..67188d0d0fe 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/privateObjectLiteral.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/privateObjectLiteral.kt @@ -10,4 +10,4 @@ class C { } val w = z.foo() // ERROR! -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/privateVisibility.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/privateVisibility.kt index a7a9a682290..54a9235fef8 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/privateVisibility.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/privateVisibility.kt @@ -9,21 +9,21 @@ private class Private { bar() Nested() fromCompanion() - NotCompanion.foo() // hidden + NotCompanion.foo() // hidden } inner class Inner { fun foo() { bar() fromCompanion() - NotCompanion.foo() // hidden + NotCompanion.foo() // hidden } } private class Nested { fun foo() { fromCompanion() - NotCompanion.foo() // hidden + NotCompanion.foo() // hidden } } @@ -54,7 +54,7 @@ fun withLocals() { Local().baz() - Local().bar() // hidden + Local().bar() // hidden } fun test() { @@ -62,14 +62,14 @@ fun test() { Private().baz() Private().Inner() - Private().bar() // hidden - Private.Nested() // hidden - Private.fromCompanion() // hidden + Private().bar() // hidden + Private.Nested() // hidden + Private.fromCompanion() // hidden } // FILE: second.kt fun secondTest() { - foo() // hidden - Private() // hidden + foo() // hidden + Private() // hidden } diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/protectedVisibility.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/protectedVisibility.kt index f27cce779d2..537f0fd2009 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/protectedVisibility.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/protectedVisibility.kt @@ -31,7 +31,7 @@ class Derived : Protected() { fun foo() { bar() Nested().foo() - Nested().bar() // hidden + Nested().bar() // hidden fromCompanion() protectedFromCompanion() @@ -48,8 +48,8 @@ fun test() { Protected().baz() Protected().Inner() - Protected().bar() // hidden - Protected.Nested() // hidden + Protected().bar() // hidden + Protected.Nested() // hidden } open class Generic(val x: T) { diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/qualifiedExpressions.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/qualifiedExpressions.kt index 8917d08e900..9da704f0ba3 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/qualifiedExpressions.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/qualifiedExpressions.kt @@ -30,4 +30,4 @@ fun main() { C().foo() val e = a.b.E.entry val e1 = E.entry -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/receiverConsistency.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/receiverConsistency.kt index 714ba2fcbc1..86ab1c8ab94 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/receiverConsistency.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/receiverConsistency.kt @@ -6,7 +6,7 @@ class C { class Nested { fun test() { - err() + err() } } } @@ -17,5 +17,5 @@ fun test() { c.bar() val err = C() - err.foo() -} \ No newline at end of file + err.foo() +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/sameReceiver.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/sameReceiver.kt index dfdbecf2746..44116bf518d 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/sameReceiver.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/sameReceiver.kt @@ -4,4 +4,4 @@ class Foo { fun test() { bar() } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/simple.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/simple.kt index 9b1486d66f6..b6c2a77ebde 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/simple.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/simple.kt @@ -6,4 +6,4 @@ val bar = "" val n = null -val g: String? = null \ No newline at end of file +val g: String? = null diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/syntheticInImplicitBody.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/syntheticInImplicitBody.kt index 51fab0e4ff2..5fa24511973 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/syntheticInImplicitBody.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/syntheticInImplicitBody.kt @@ -12,4 +12,4 @@ class User : Owner() { fun foo() = text override fun getText() = "" -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/this.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/this.kt index 4975a819e8e..be3c84777bf 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/this.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/this.kt @@ -6,4 +6,4 @@ class Foo { fun Bar.buz() = this fun Bar.foo() = this@Foo fun Bar.foobar() = this@foobar -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/topExtensionVsOuterMember.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/topExtensionVsOuterMember.kt index 6daf0e510c1..877ef026d97 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/topExtensionVsOuterMember.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/topExtensionVsOuterMember.kt @@ -7,4 +7,4 @@ class Outer { inner class Inner { val x = foo() // Should be Int } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/vararg.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/vararg.kt index 0f3aae11065..6560aa1243c 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/vararg.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/vararg.kt @@ -5,4 +5,4 @@ fun foo() {} fun main() { foo() foo("!") -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/expresssions/when.kt b/compiler/fir/analysis-tests/testData/resolve/expresssions/when.kt index 38f66b94736..9947275b9b9 100644 --- a/compiler/fir/analysis-tests/testData/resolve/expresssions/when.kt +++ b/compiler/fir/analysis-tests/testData/resolve/expresssions/when.kt @@ -3,4 +3,4 @@ fun foo() = if (true) 1 else 0 fun bar(arg: Any?) = when (arg) { is Int -> arg as Int else -> 42 -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/extension.kt b/compiler/fir/analysis-tests/testData/resolve/extension.kt index cbe661d5b0d..83502b09540 100644 --- a/compiler/fir/analysis-tests/testData/resolve/extension.kt +++ b/compiler/fir/analysis-tests/testData/resolve/extension.kt @@ -10,4 +10,4 @@ class My { } } -fun My.foo() {} \ No newline at end of file +fun My.foo() {} diff --git a/compiler/fir/analysis-tests/testData/resolve/fakeRecursiveSupertype.kt b/compiler/fir/analysis-tests/testData/resolve/fakeRecursiveSupertype.kt index 6735d03f171..564a212f32f 100644 --- a/compiler/fir/analysis-tests/testData/resolve/fakeRecursiveSupertype.kt +++ b/compiler/fir/analysis-tests/testData/resolve/fakeRecursiveSupertype.kt @@ -4,4 +4,4 @@ class My : My() class Your : His() -class His : Your() \ No newline at end of file +class His : Your() diff --git a/compiler/fir/analysis-tests/testData/resolve/fakeRecursiveTypealias.kt b/compiler/fir/analysis-tests/testData/resolve/fakeRecursiveTypealias.kt index 7abe15c411b..66b45a20144 100644 --- a/compiler/fir/analysis-tests/testData/resolve/fakeRecursiveTypealias.kt +++ b/compiler/fir/analysis-tests/testData/resolve/fakeRecursiveTypealias.kt @@ -2,4 +2,4 @@ import incorrect.directory.Your typealias My = incorrect.directory.My -typealias Your = Your \ No newline at end of file +typealias Your = Your diff --git a/compiler/fir/analysis-tests/testData/resolve/fib.kt b/compiler/fir/analysis-tests/testData/resolve/fib.kt index d3bf182815c..0a734c9e323 100644 --- a/compiler/fir/analysis-tests/testData/resolve/fib.kt +++ b/compiler/fir/analysis-tests/testData/resolve/fib.kt @@ -8,4 +8,4 @@ fun fibIterative(n: Int): Int { prev = temp } return current -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/fromBuilder/complexTypes.kt b/compiler/fir/analysis-tests/testData/resolve/fromBuilder/complexTypes.kt index 4ff9238e2a4..7f91a4dc5db 100644 --- a/compiler/fir/analysis-tests/testData/resolve/fromBuilder/complexTypes.kt +++ b/compiler/fir/analysis-tests/testData/resolve/fromBuilder/complexTypes.kt @@ -8,4 +8,4 @@ class C { interface Test { val x: a.b.C.D, *> -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/fromBuilder/enums.kt b/compiler/fir/analysis-tests/testData/resolve/fromBuilder/enums.kt index 627ab90dfe2..0e6ac864eb4 100644 --- a/compiler/fir/analysis-tests/testData/resolve/fromBuilder/enums.kt +++ b/compiler/fir/analysis-tests/testData/resolve/fromBuilder/enums.kt @@ -9,17 +9,17 @@ enum class Order { enum class Planet(val m: Double, internal val r: Double) { MERCURY(1.0, 2.0) { override fun sayHello() { - println("Hello!!!") + println("Hello!!!") } }, VENERA(3.0, 4.0) { override fun sayHello() { - println("Ola!!!") + println("Ola!!!") } }, EARTH(5.0, 6.0) { override fun sayHello() { - println("Privet!!!") + println("Privet!!!") } }; @@ -30,4 +30,4 @@ enum class Planet(val m: Double, internal val r: Double) { companion object { const val G = 6.67e-11 } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/fromBuilder/noPrimaryConstructor.kt b/compiler/fir/analysis-tests/testData/resolve/fromBuilder/noPrimaryConstructor.kt index fbd6b4e236e..5f0a3dcd069 100644 --- a/compiler/fir/analysis-tests/testData/resolve/fromBuilder/noPrimaryConstructor.kt +++ b/compiler/fir/analysis-tests/testData/resolve/fromBuilder/noPrimaryConstructor.kt @@ -6,4 +6,4 @@ class NoPrimary { } constructor(): this("") -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/fromBuilder/simpleClass.kt b/compiler/fir/analysis-tests/testData/resolve/fromBuilder/simpleClass.kt index b35d86be327..d6e91bf884b 100644 --- a/compiler/fir/analysis-tests/testData/resolve/fromBuilder/simpleClass.kt +++ b/compiler/fir/analysis-tests/testData/resolve/fromBuilder/simpleClass.kt @@ -18,4 +18,4 @@ class SomeClass : SomeInterface { lateinit var fau: Double } -inline class InlineClass \ No newline at end of file +inline class InlineClass diff --git a/compiler/fir/analysis-tests/testData/resolve/genericFunctions.kt b/compiler/fir/analysis-tests/testData/resolve/genericFunctions.kt index a88e9c41a82..b1978fe2dbb 100644 --- a/compiler/fir/analysis-tests/testData/resolve/genericFunctions.kt +++ b/compiler/fir/analysis-tests/testData/resolve/genericFunctions.kt @@ -4,4 +4,4 @@ inline fun Any.safeAs(): T? = this as? T abstract class Summator { abstract fun plus(first: T, second: T): T -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/genericReceiverPropertyOverride.kt b/compiler/fir/analysis-tests/testData/resolve/genericReceiverPropertyOverride.kt index 74b6bed41ef..093387b3e5d 100644 --- a/compiler/fir/analysis-tests/testData/resolve/genericReceiverPropertyOverride.kt +++ b/compiler/fir/analysis-tests/testData/resolve/genericReceiverPropertyOverride.kt @@ -12,4 +12,4 @@ class C : B() { fun foo(x: Inv) { x.phasedFir } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/incorrectSuperCall.kt b/compiler/fir/analysis-tests/testData/resolve/incorrectSuperCall.kt index 923a96486fc..50c694c5335 100644 --- a/compiler/fir/analysis-tests/testData/resolve/incorrectSuperCall.kt +++ b/compiler/fir/analysis-tests/testData/resolve/incorrectSuperCall.kt @@ -15,7 +15,7 @@ class C : A, B() { override fun foo() { super.foo() - super.bar() // should be ambiguity (NB: really we should have overridden bar in C) + super.bar() // should be ambiguity (NB: really we should have overridden bar in C) super.baz() // Ok baz() // Ok diff --git a/compiler/fir/analysis-tests/testData/resolve/inference/callableReferencesAndDefaultParameters.kt b/compiler/fir/analysis-tests/testData/resolve/inference/callableReferencesAndDefaultParameters.kt index d42b9a85ddd..e52df037663 100644 --- a/compiler/fir/analysis-tests/testData/resolve/inference/callableReferencesAndDefaultParameters.kt +++ b/compiler/fir/analysis-tests/testData/resolve/inference/callableReferencesAndDefaultParameters.kt @@ -6,4 +6,4 @@ inline fun T.myLet(block: (T) -> Unit) {} fun test(a: A, s: String) { s.myLet(a::foo) -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/inference/coercionToUnitWithEarlyReturn.kt b/compiler/fir/analysis-tests/testData/resolve/inference/coercionToUnitWithEarlyReturn.kt index cde99fc41b9..1739ea41199 100644 --- a/compiler/fir/analysis-tests/testData/resolve/inference/coercionToUnitWithEarlyReturn.kt +++ b/compiler/fir/analysis-tests/testData/resolve/inference/coercionToUnitWithEarlyReturn.kt @@ -16,4 +16,4 @@ fun main(x: A?) { // lambda has a type (() -> Unit?) foo(lambda) -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/inference/integerLiteralAsComparable.kt b/compiler/fir/analysis-tests/testData/resolve/inference/integerLiteralAsComparable.kt index 59cef711f34..93f08e7d9d5 100644 --- a/compiler/fir/analysis-tests/testData/resolve/inference/integerLiteralAsComparable.kt +++ b/compiler/fir/analysis-tests/testData/resolve/inference/integerLiteralAsComparable.kt @@ -11,4 +11,4 @@ class K>(t: T) fun main() { K(0) JavaClass(0) -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/inference/nestedExtensionFunctionType.kt b/compiler/fir/analysis-tests/testData/resolve/inference/nestedExtensionFunctionType.kt index a27f1e46c48..f30007d46af 100644 --- a/compiler/fir/analysis-tests/testData/resolve/inference/nestedExtensionFunctionType.kt +++ b/compiler/fir/analysis-tests/testData/resolve/inference/nestedExtensionFunctionType.kt @@ -16,4 +16,4 @@ fun test_2(a: A, vararg zs: A.() -> Unit) { for (z in zs) { a.z() } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/inference/nullableIntegerLiteralType.kt b/compiler/fir/analysis-tests/testData/resolve/inference/nullableIntegerLiteralType.kt index 2bfbe8fa5ea..51b826f6b5a 100644 --- a/compiler/fir/analysis-tests/testData/resolve/inference/nullableIntegerLiteralType.kt +++ b/compiler/fir/analysis-tests/testData/resolve/inference/nullableIntegerLiteralType.kt @@ -4,10 +4,10 @@ fun takeInt(x: Int) {} fun test_1(b: Boolean) { val x = if (b) 1 else null - takeInt(x) + takeInt(x) } fun test_2(b: Boolean, y: Int) { val x = if (b) y else null - takeInt(x) -} \ No newline at end of file + takeInt(x) +} diff --git a/compiler/fir/analysis-tests/testData/resolve/inference/receiverWithCapturedType.kt b/compiler/fir/analysis-tests/testData/resolve/inference/receiverWithCapturedType.kt index 0a52fd88247..281eb062606 100644 --- a/compiler/fir/analysis-tests/testData/resolve/inference/receiverWithCapturedType.kt +++ b/compiler/fir/analysis-tests/testData/resolve/inference/receiverWithCapturedType.kt @@ -24,7 +24,7 @@ fun test_1_3(resolvedCall: ResolvedCall) { } fun test_2_1(resolvedCall: ResolvedCall, d: CallableDescriptor) { - val x = resolvedCall.updateD(d) // should fail + val x = resolvedCall.updateD(d) // should fail } fun test_2_2(resolvedCall: ResolvedCall, d: CallableDescriptor) { diff --git a/compiler/fir/analysis-tests/testData/resolve/innerClasses/inner.kt b/compiler/fir/analysis-tests/testData/resolve/innerClasses/inner.kt index 8e1ca1419a8..1c6aaf68ba1 100644 --- a/compiler/fir/analysis-tests/testData/resolve/innerClasses/inner.kt +++ b/compiler/fir/analysis-tests/testData/resolve/innerClasses/inner.kt @@ -23,7 +23,7 @@ class Owner { o.foo() foo() this@Owner.foo() - this.err() + this.err() } } } @@ -31,8 +31,8 @@ class Owner { fun test() { val o = Owner() o.foo() - val err = Owner.Inner() - err.baz() + val err = Owner.Inner() + err.baz() val i = o.Inner() i.gau() -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/innerClasses/innerTypes.kt b/compiler/fir/analysis-tests/testData/resolve/innerClasses/innerTypes.kt index 797f42d4a2e..8c866732348 100644 --- a/compiler/fir/analysis-tests/testData/resolve/innerClasses/innerTypes.kt +++ b/compiler/fir/analysis-tests/testData/resolve/innerClasses/innerTypes.kt @@ -12,10 +12,10 @@ val rr = Outer().Inner() val rrq = Boxed().substitute() fun check() { - accept(Outer().Inner()) // illegal - accept(Outer().Inner()) // illegal + accept(Outer().Inner()) // illegal + accept(Outer().Inner()) // illegal accept(Outer().Inner()) // ok - accept(Boxed().substitute()) // illegal + accept(Boxed().substitute()) // illegal accept(Boxed().substitute()) // ok -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/innerClasses/simple.kt b/compiler/fir/analysis-tests/testData/resolve/innerClasses/simple.kt index a42556effec..0046ca0b2b2 100644 --- a/compiler/fir/analysis-tests/testData/resolve/innerClasses/simple.kt +++ b/compiler/fir/analysis-tests/testData/resolve/innerClasses/simple.kt @@ -22,8 +22,8 @@ class Owner { } fun err() { - foo() - this.foo() + foo() + this.foo() } } } @@ -33,4 +33,4 @@ fun test() { o.foo() val n = Owner.Nested() n.baz() -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/intersectionTypes.kt b/compiler/fir/analysis-tests/testData/resolve/intersectionTypes.kt index 96ce7df60d9..961cd6bacff 100644 --- a/compiler/fir/analysis-tests/testData/resolve/intersectionTypes.kt +++ b/compiler/fir/analysis-tests/testData/resolve/intersectionTypes.kt @@ -11,4 +11,4 @@ fun test() = select(Clazz1(), Clazz2()) fun makeNull(x: T): T? = null -fun testNull() = makeNull(select(Clazz1(), Clazz2())) \ No newline at end of file +fun testNull() = makeNull(select(Clazz1(), Clazz2())) diff --git a/compiler/fir/analysis-tests/testData/resolve/invokeOfLambdaWithReceiver.kt b/compiler/fir/analysis-tests/testData/resolve/invokeOfLambdaWithReceiver.kt index 0d96614457c..e114b6e6421 100644 --- a/compiler/fir/analysis-tests/testData/resolve/invokeOfLambdaWithReceiver.kt +++ b/compiler/fir/analysis-tests/testData/resolve/invokeOfLambdaWithReceiver.kt @@ -14,4 +14,4 @@ class C { fun anotherTest(block: C.() -> Int) { block() } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/javaFieldVsAccessor.kt b/compiler/fir/analysis-tests/testData/resolve/javaFieldVsAccessor.kt index 5c568c02749..c4dba658f87 100644 --- a/compiler/fir/analysis-tests/testData/resolve/javaFieldVsAccessor.kt +++ b/compiler/fir/analysis-tests/testData/resolve/javaFieldVsAccessor.kt @@ -13,4 +13,4 @@ public class A { fun test(a: A) { val int = a.x // <- should be int val string = a.getX() -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/kt41984.kt b/compiler/fir/analysis-tests/testData/resolve/kt41984.kt index e693f6acce1..41180d7f030 100644 --- a/compiler/fir/analysis-tests/testData/resolve/kt41984.kt +++ b/compiler/fir/analysis-tests/testData/resolve/kt41984.kt @@ -26,6 +26,6 @@ open class B : A() { fun test_1(b: B, x: Int, inv: Inv) { b.take(x) - b.take(null) + b.take(null) b.takeInv(inv) } diff --git a/compiler/fir/analysis-tests/testData/resolve/lambdaArgInScopeFunction.kt b/compiler/fir/analysis-tests/testData/resolve/lambdaArgInScopeFunction.kt index af380eaa627..6cbf919f1ec 100644 --- a/compiler/fir/analysis-tests/testData/resolve/lambdaArgInScopeFunction.kt +++ b/compiler/fir/analysis-tests/testData/resolve/lambdaArgInScopeFunction.kt @@ -21,7 +21,7 @@ fun case1(kotlinClass: KotlinClass?) { {it} } - lambda.checkType { _>() } + lambda.checkType { _>() } } // TESTCASE NUMBER: 2 fun case2(kotlinClass: KotlinClass) { @@ -36,5 +36,5 @@ fun case2(kotlinClass: KotlinClass) { {it} } - lambda.checkType { _>() } -} \ No newline at end of file + lambda.checkType { _>() } +} diff --git a/compiler/fir/analysis-tests/testData/resolve/lambdaInLhsOfTypeOperatorCall.kt b/compiler/fir/analysis-tests/testData/resolve/lambdaInLhsOfTypeOperatorCall.kt index a27703b45d7..02044811550 100644 --- a/compiler/fir/analysis-tests/testData/resolve/lambdaInLhsOfTypeOperatorCall.kt +++ b/compiler/fir/analysis-tests/testData/resolve/lambdaInLhsOfTypeOperatorCall.kt @@ -14,4 +14,4 @@ fun test_2(s: String) { class B(val k: K, val v: V) -fun B.myMap(transform: (B) -> R): B = TODO() \ No newline at end of file +fun B.myMap(transform: (B) -> R): B = TODO() diff --git a/compiler/fir/analysis-tests/testData/resolve/lambdaPropertyTypeInference.kt b/compiler/fir/analysis-tests/testData/resolve/lambdaPropertyTypeInference.kt index 8bae96c5e36..03ce460d5d4 100644 --- a/compiler/fir/analysis-tests/testData/resolve/lambdaPropertyTypeInference.kt +++ b/compiler/fir/analysis-tests/testData/resolve/lambdaPropertyTypeInference.kt @@ -26,9 +26,9 @@ fun case1(javaClass: JavaClass?) { validType.checkType { _>() } //ok - invalidType.checkType { _>() } //(!!!) + invalidType.checkType { _>() } //(!!!) - Case1(javaClass).x.checkType { _>() } //(!!!) + Case1(javaClass).x.checkType { _>() } //(!!!) } class Case1(val javaClass: JavaClass?) { @@ -55,9 +55,9 @@ fun case2(kotlinClass: KotlinClass?) { validType.checkType { _>() } //ok - invalidType.checkType { _>() } //(!!!) + invalidType.checkType { _>() } //(!!!) - Case2(kotlinClass).x.checkType { _>() } //(!!!) + Case2(kotlinClass).x.checkType { _>() } //(!!!) } class Case2(val kotlinClass: KotlinClass?) { diff --git a/compiler/fir/analysis-tests/testData/resolve/localFunctionsHiding.kt b/compiler/fir/analysis-tests/testData/resolve/localFunctionsHiding.kt index 985defd6e30..e6bb627b045 100644 --- a/compiler/fir/analysis-tests/testData/resolve/localFunctionsHiding.kt +++ b/compiler/fir/analysis-tests/testData/resolve/localFunctionsHiding.kt @@ -20,4 +20,4 @@ fun test_2() { val y = 1 y.transform() -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/localObject.kt b/compiler/fir/analysis-tests/testData/resolve/localObject.kt index ff144f1d776..bdc52f69238 100644 --- a/compiler/fir/analysis-tests/testData/resolve/localObject.kt +++ b/compiler/fir/analysis-tests/testData/resolve/localObject.kt @@ -44,4 +44,4 @@ class TestProperty { } 2 } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/multifile/Annotations.kt b/compiler/fir/analysis-tests/testData/resolve/multifile/Annotations.kt index ef01d9fd690..721194e5944 100644 --- a/compiler/fir/analysis-tests/testData/resolve/multifile/Annotations.kt +++ b/compiler/fir/analysis-tests/testData/resolve/multifile/Annotations.kt @@ -43,4 +43,4 @@ class Second(val y: Char) : @WithInt(0) First() { @WithInt(24) @VeryComplex(3.14f, 6.67e-11, false, 123456789012345L, null) -typealias Third = @Simple Second \ No newline at end of file +typealias Third = @Simple Second diff --git a/compiler/fir/analysis-tests/testData/resolve/multifile/ByteArray.kt b/compiler/fir/analysis-tests/testData/resolve/multifile/ByteArray.kt index 6ff526b84b2..9fdcc9342e2 100644 --- a/compiler/fir/analysis-tests/testData/resolve/multifile/ByteArray.kt +++ b/compiler/fir/analysis-tests/testData/resolve/multifile/ByteArray.kt @@ -15,4 +15,4 @@ import test.* interface My { // Should be kotlin.ByteArray val array: ByteArray -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/multifile/NestedSuperType.kt b/compiler/fir/analysis-tests/testData/resolve/multifile/NestedSuperType.kt index b01d0b6f983..bc36c906394 100644 --- a/compiler/fir/analysis-tests/testData/resolve/multifile/NestedSuperType.kt +++ b/compiler/fir/analysis-tests/testData/resolve/multifile/NestedSuperType.kt @@ -25,4 +25,4 @@ import b.B class A : B() { class NestedInA1 : NestedInB() class NestedInA2 : NestedInC() -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/multifile/sealedStarImport.kt b/compiler/fir/analysis-tests/testData/resolve/multifile/sealedStarImport.kt index b062b6db320..4387c1c29b3 100644 --- a/compiler/fir/analysis-tests/testData/resolve/multifile/sealedStarImport.kt +++ b/compiler/fir/analysis-tests/testData/resolve/multifile/sealedStarImport.kt @@ -20,4 +20,4 @@ abstract class Factory { abstract fun createObj(): O abstract fun createExtra(): Extra -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/multifile/simpleImportNested.kt b/compiler/fir/analysis-tests/testData/resolve/multifile/simpleImportNested.kt index a5ee84d5f39..2c1053f889b 100644 --- a/compiler/fir/analysis-tests/testData/resolve/multifile/simpleImportNested.kt +++ b/compiler/fir/analysis-tests/testData/resolve/multifile/simpleImportNested.kt @@ -12,4 +12,4 @@ package b import a.MyClass.MyNested -class YourClass : MyNested() \ No newline at end of file +class YourClass : MyNested() diff --git a/compiler/fir/analysis-tests/testData/resolve/multifile/simpleImportOuter.kt b/compiler/fir/analysis-tests/testData/resolve/multifile/simpleImportOuter.kt index 877b0420088..f248ee6f7fb 100644 --- a/compiler/fir/analysis-tests/testData/resolve/multifile/simpleImportOuter.kt +++ b/compiler/fir/analysis-tests/testData/resolve/multifile/simpleImportOuter.kt @@ -12,4 +12,4 @@ package b import a.Outer -class My : Outer.Nested() \ No newline at end of file +class My : Outer.Nested() diff --git a/compiler/fir/analysis-tests/testData/resolve/nestedClassContructor.kt b/compiler/fir/analysis-tests/testData/resolve/nestedClassContructor.kt index 076512e710a..0f5bdbfd63e 100644 --- a/compiler/fir/analysis-tests/testData/resolve/nestedClassContructor.kt +++ b/compiler/fir/analysis-tests/testData/resolve/nestedClassContructor.kt @@ -17,7 +17,7 @@ class D : A.C() { val a = A() val ac = A.C() - val c = C() // shouldn't resolve + val c = C() // shouldn't resolve } } diff --git a/compiler/fir/analysis-tests/testData/resolve/nestedClassNameClash.kt b/compiler/fir/analysis-tests/testData/resolve/nestedClassNameClash.kt index b1df40b3da8..72370905cfa 100644 --- a/compiler/fir/analysis-tests/testData/resolve/nestedClassNameClash.kt +++ b/compiler/fir/analysis-tests/testData/resolve/nestedClassNameClash.kt @@ -38,4 +38,4 @@ class Foo { private fun saveResult(result: Result) {} class Result -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/nestedReturnType.kt b/compiler/fir/analysis-tests/testData/resolve/nestedReturnType.kt index 5cda845d32d..347c0ba1358 100644 --- a/compiler/fir/analysis-tests/testData/resolve/nestedReturnType.kt +++ b/compiler/fir/analysis-tests/testData/resolve/nestedReturnType.kt @@ -4,4 +4,4 @@ class Some { fun foo(): Nested { return Nested() } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/objectInnerClass.kt b/compiler/fir/analysis-tests/testData/resolve/objectInnerClass.kt index e62a32ee691..df02cad8938 100644 --- a/compiler/fir/analysis-tests/testData/resolve/objectInnerClass.kt +++ b/compiler/fir/analysis-tests/testData/resolve/objectInnerClass.kt @@ -146,4 +146,4 @@ class Case3() { } interface A {} -class B() {} \ No newline at end of file +class B() {} diff --git a/compiler/fir/analysis-tests/testData/resolve/offOrderMultiBoundGenericOverride.kt b/compiler/fir/analysis-tests/testData/resolve/offOrderMultiBoundGenericOverride.kt index e0de3d4d18c..7fca3d6ad6a 100644 --- a/compiler/fir/analysis-tests/testData/resolve/offOrderMultiBoundGenericOverride.kt +++ b/compiler/fir/analysis-tests/testData/resolve/offOrderMultiBoundGenericOverride.kt @@ -44,4 +44,4 @@ fun callJava(derived: Test.Derived, derivedRaw: Test.DerivedRaw, v: Test.I123) { fun callKotlin(derived: KDerived) { derived.foo() -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/openInInterface.kt b/compiler/fir/analysis-tests/testData/resolve/openInInterface.kt index c827bacb73a..916f320e75f 100644 --- a/compiler/fir/analysis-tests/testData/resolve/openInInterface.kt +++ b/compiler/fir/analysis-tests/testData/resolve/openInInterface.kt @@ -12,4 +12,4 @@ interface Some { set(value) { field = value } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/overrides/generics.kt b/compiler/fir/analysis-tests/testData/resolve/overrides/generics.kt index b6c7d6d1d3a..de6e5d2f399 100644 --- a/compiler/fir/analysis-tests/testData/resolve/overrides/generics.kt +++ b/compiler/fir/analysis-tests/testData/resolve/overrides/generics.kt @@ -12,4 +12,4 @@ class C : Base(), I fun f(list: List) { C().f(list) -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/overrides/simple.kt b/compiler/fir/analysis-tests/testData/resolve/overrides/simple.kt index f87bf8fb820..a956ba7e5e9 100644 --- a/compiler/fir/analysis-tests/testData/resolve/overrides/simple.kt +++ b/compiler/fir/analysis-tests/testData/resolve/overrides/simple.kt @@ -14,7 +14,7 @@ class B : A() { fun test() { foo() bar() - buz() + buz() } } diff --git a/compiler/fir/analysis-tests/testData/resolve/overrides/supertypeGenericsComplex.kt b/compiler/fir/analysis-tests/testData/resolve/overrides/supertypeGenericsComplex.kt index 5fd73df0428..b7e5ab8f445 100644 --- a/compiler/fir/analysis-tests/testData/resolve/overrides/supertypeGenericsComplex.kt +++ b/compiler/fir/analysis-tests/testData/resolve/overrides/supertypeGenericsComplex.kt @@ -10,5 +10,5 @@ class C : Base() fun f(list: MutableList, s: MutableList) { C().f(list, s) - C().f(s, list) + C().f(s, list) } diff --git a/compiler/fir/analysis-tests/testData/resolve/overrides/three.kt b/compiler/fir/analysis-tests/testData/resolve/overrides/three.kt index c904e1f9c2e..b0b95c5fd31 100644 --- a/compiler/fir/analysis-tests/testData/resolve/overrides/three.kt +++ b/compiler/fir/analysis-tests/testData/resolve/overrides/three.kt @@ -19,4 +19,4 @@ class C : B() { bar() baz() } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/problems/complexLambdaWithTypeVariableAsExpectedType.kt b/compiler/fir/analysis-tests/testData/resolve/problems/complexLambdaWithTypeVariableAsExpectedType.kt index cc1de920011..fca09a36613 100644 --- a/compiler/fir/analysis-tests/testData/resolve/problems/complexLambdaWithTypeVariableAsExpectedType.kt +++ b/compiler/fir/analysis-tests/testData/resolve/problems/complexLambdaWithTypeVariableAsExpectedType.kt @@ -3,4 +3,4 @@ fun select(x: K, y: K): K = TODO() fun test() { select(id { it.inv() }, id<(Int) -> Unit> { }) -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/problems/definitelyNotNullAndOriginalType.kt b/compiler/fir/analysis-tests/testData/resolve/problems/definitelyNotNullAndOriginalType.kt index 0230fdf919f..384164d4d76 100644 --- a/compiler/fir/analysis-tests/testData/resolve/problems/definitelyNotNullAndOriginalType.kt +++ b/compiler/fir/analysis-tests/testData/resolve/problems/definitelyNotNullAndOriginalType.kt @@ -11,5 +11,5 @@ public interface SLRUMap { // FILE: main.kt fun SLRUMap.getOrPut(value: V) { - takeV(value) + takeV(value) } diff --git a/compiler/fir/analysis-tests/testData/resolve/problems/inaccessibleJavaGetter.kt b/compiler/fir/analysis-tests/testData/resolve/problems/inaccessibleJavaGetter.kt index 1d4e92d91fb..c7645a90525 100644 --- a/compiler/fir/analysis-tests/testData/resolve/problems/inaccessibleJavaGetter.kt +++ b/compiler/fir/analysis-tests/testData/resolve/problems/inaccessibleJavaGetter.kt @@ -20,7 +20,7 @@ class WrappedPropertyDescriptor : PropertyDescriptor { fun test() { val descriptor = WrappedPropertyDescriptor() val res1 = descriptor.setter - val res2 = descriptor.getSetter() // Should be error + val res2 = descriptor.getSetter() // Should be error val res3 = descriptor.isDelegated - val res4 = descriptor.isDelegated() // Should be error -} \ No newline at end of file + val res4 = descriptor.isDelegated() // Should be error +} diff --git a/compiler/fir/analysis-tests/testData/resolve/problems/innerClassHierarchy.kt b/compiler/fir/analysis-tests/testData/resolve/problems/innerClassHierarchy.kt index 711f14d1426..d679c8e4bad 100644 --- a/compiler/fir/analysis-tests/testData/resolve/problems/innerClassHierarchy.kt +++ b/compiler/fir/analysis-tests/testData/resolve/problems/innerClassHierarchy.kt @@ -22,4 +22,4 @@ open class A(val s: String) { inner class F : E() } -fun box(): String = A("Fail").F().s \ No newline at end of file +fun box(): String = A("Fail").F().s diff --git a/compiler/fir/analysis-tests/testData/resolve/problems/multipleJavaClassesInOneFile.kt b/compiler/fir/analysis-tests/testData/resolve/problems/multipleJavaClassesInOneFile.kt index a16bfa160e3..704db700550 100644 --- a/compiler/fir/analysis-tests/testData/resolve/problems/multipleJavaClassesInOneFile.kt +++ b/compiler/fir/analysis-tests/testData/resolve/problems/multipleJavaClassesInOneFile.kt @@ -10,5 +10,5 @@ class Another {} fun test() { val some = Some() - val another = Another() -} \ No newline at end of file + val another = Another() +} diff --git a/compiler/fir/analysis-tests/testData/resolve/problems/objectDerivedFromInnerClass.kt b/compiler/fir/analysis-tests/testData/resolve/problems/objectDerivedFromInnerClass.kt index b44d753dd3d..9f0e79eaeed 100644 --- a/compiler/fir/analysis-tests/testData/resolve/problems/objectDerivedFromInnerClass.kt +++ b/compiler/fir/analysis-tests/testData/resolve/problems/objectDerivedFromInnerClass.kt @@ -1,4 +1,4 @@ class Outer { inner class Inner } fun test() { - val x = object : Outer.Inner() { } -} \ No newline at end of file + val x = object : Outer.Inner() { } +} diff --git a/compiler/fir/analysis-tests/testData/resolve/problems/secondaryConstructorCfg.kt b/compiler/fir/analysis-tests/testData/resolve/problems/secondaryConstructorCfg.kt index db5f72a53cd..c1060e44fdd 100644 --- a/compiler/fir/analysis-tests/testData/resolve/problems/secondaryConstructorCfg.kt +++ b/compiler/fir/analysis-tests/testData/resolve/problems/secondaryConstructorCfg.kt @@ -10,4 +10,4 @@ class B(p0: String) { p1 = p0.length p3 = "" } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/problems2.kt b/compiler/fir/analysis-tests/testData/resolve/problems2.kt index 7477479399d..7f27ac53f9f 100644 --- a/compiler/fir/analysis-tests/testData/resolve/problems2.kt +++ b/compiler/fir/analysis-tests/testData/resolve/problems2.kt @@ -27,4 +27,4 @@ val KonanTarget.presetName // Exhaustive when expressions give Any result type // Substitution for field declared in Java super-type does not work (KotlinStringLiteralTextEscaper.myHost) // Super is not resolved in anonymous object -// TypeParameterDescriptor.name is not resolved \ No newline at end of file +// TypeParameterDescriptor.name is not resolved diff --git a/compiler/fir/analysis-tests/testData/resolve/properties/syntheticPropertiesForJavaAnnotations.kt b/compiler/fir/analysis-tests/testData/resolve/properties/syntheticPropertiesForJavaAnnotations.kt index 30c39006a34..0c98ff8eb99 100644 --- a/compiler/fir/analysis-tests/testData/resolve/properties/syntheticPropertiesForJavaAnnotations.kt +++ b/compiler/fir/analysis-tests/testData/resolve/properties/syntheticPropertiesForJavaAnnotations.kt @@ -10,5 +10,5 @@ public @interface Ann { fun test(ann: Ann) { ann.value - ann.value() // should be an error + ann.value() // should be an error } diff --git a/compiler/fir/analysis-tests/testData/resolve/propertyFromJavaPlusAssign.kt b/compiler/fir/analysis-tests/testData/resolve/propertyFromJavaPlusAssign.kt index bd8a257c737..0c5076aecc8 100644 --- a/compiler/fir/analysis-tests/testData/resolve/propertyFromJavaPlusAssign.kt +++ b/compiler/fir/analysis-tests/testData/resolve/propertyFromJavaPlusAssign.kt @@ -19,4 +19,4 @@ public class B { fun test(b: B) { b.text += "" -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/qualifierWithCompanion.kt b/compiler/fir/analysis-tests/testData/resolve/qualifierWithCompanion.kt index a777ee49e24..102fe6387d2 100644 --- a/compiler/fir/analysis-tests/testData/resolve/qualifierWithCompanion.kt +++ b/compiler/fir/analysis-tests/testData/resolve/qualifierWithCompanion.kt @@ -16,4 +16,4 @@ fun test() { fun A.invoke() {} my.xx() -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/references/integerLiteralInLhs.kt b/compiler/fir/analysis-tests/testData/resolve/references/integerLiteralInLhs.kt index cb39869714a..72e0b814a6c 100644 --- a/compiler/fir/analysis-tests/testData/resolve/references/integerLiteralInLhs.kt +++ b/compiler/fir/analysis-tests/testData/resolve/references/integerLiteralInLhs.kt @@ -6,4 +6,4 @@ fun testRef(f: () -> Int) {} fun test() { // should resolve to Int.foo testRef(1::foo) -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/references/simple.kt b/compiler/fir/analysis-tests/testData/resolve/references/simple.kt index 01c56edc69c..0fa2c1a7555 100644 --- a/compiler/fir/analysis-tests/testData/resolve/references/simple.kt +++ b/compiler/fir/analysis-tests/testData/resolve/references/simple.kt @@ -1,3 +1,3 @@ fun foo() = 1 -fun bar() = foo() \ No newline at end of file +fun bar() = foo() diff --git a/compiler/fir/analysis-tests/testData/resolve/references/superMember.kt b/compiler/fir/analysis-tests/testData/resolve/references/superMember.kt index 1dfabd7727c..ae890509710 100644 --- a/compiler/fir/analysis-tests/testData/resolve/references/superMember.kt +++ b/compiler/fir/analysis-tests/testData/resolve/references/superMember.kt @@ -6,4 +6,4 @@ class B : A() { fun bar() { foo() } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/samConstructors/genericSamInferenceFromExpectType.kt b/compiler/fir/analysis-tests/testData/resolve/samConstructors/genericSamInferenceFromExpectType.kt index dda848e2b85..2316e66886c 100644 --- a/compiler/fir/analysis-tests/testData/resolve/samConstructors/genericSamInferenceFromExpectType.kt +++ b/compiler/fir/analysis-tests/testData/resolve/samConstructors/genericSamInferenceFromExpectType.kt @@ -18,9 +18,9 @@ fun main() { x.toInt().toString() }) - foo2(MyFunction { x: Int -> + foo2(MyFunction { x: Int -> x.toString() - }) + }) foo3( MyFunction { x -> diff --git a/compiler/fir/analysis-tests/testData/resolve/samConstructors/realConstructorFunction.kt b/compiler/fir/analysis-tests/testData/resolve/samConstructors/realConstructorFunction.kt index d2426e224ed..b3fa3fb01dc 100644 --- a/compiler/fir/analysis-tests/testData/resolve/samConstructors/realConstructorFunction.kt +++ b/compiler/fir/analysis-tests/testData/resolve/samConstructors/realConstructorFunction.kt @@ -10,13 +10,13 @@ fun foo(m: MyRunnable) {} fun MyRunnable(x: (Int) -> Boolean) = 1 fun main() { - foo(MyRunnable { x -> + foo(MyRunnable { x -> x > 1 - }) + }) - foo(MyRunnable({ it > 1 })) + foo(MyRunnable({ it > 1 })) val x = { x: Int -> x > 1 } - foo(MyRunnable(x)) + foo(MyRunnable(x)) } diff --git a/compiler/fir/analysis-tests/testData/resolve/samConversions/genericSam.kt b/compiler/fir/analysis-tests/testData/resolve/samConversions/genericSam.kt index c4eac6be67d..78977c1f58b 100644 --- a/compiler/fir/analysis-tests/testData/resolve/samConversions/genericSam.kt +++ b/compiler/fir/analysis-tests/testData/resolve/samConversions/genericSam.kt @@ -21,9 +21,9 @@ fun main() { x.toInt().toString() } - JavaUsage.foo2 { x: Int -> + JavaUsage.foo2 { x: Int -> x.toString() - } + } JavaUsage.foo3( { x -> diff --git a/compiler/fir/analysis-tests/testData/resolve/samConversions/kotlinSam.kt b/compiler/fir/analysis-tests/testData/resolve/samConversions/kotlinSam.kt index 5fb027ccb83..cca6f7e9917 100644 --- a/compiler/fir/analysis-tests/testData/resolve/samConversions/kotlinSam.kt +++ b/compiler/fir/analysis-tests/testData/resolve/samConversions/kotlinSam.kt @@ -29,11 +29,11 @@ fun main() { foo1 { x -> x > 1 } foo1(f) - foo2 { x -> x > 1 } - foo2(f) + foo2 { x -> x > 1 } + foo2(f) - foo3 { x -> x > 1 } - foo3(f) + foo3 { x -> x > 1 } + foo3(f) foo4 { x -> x > 1 } foo4(f) diff --git a/compiler/fir/analysis-tests/testData/resolve/samConversions/notSamBecauseOfSupertype.kt b/compiler/fir/analysis-tests/testData/resolve/samConversions/notSamBecauseOfSupertype.kt index 016843b8718..da5d1c5b163 100644 --- a/compiler/fir/analysis-tests/testData/resolve/samConversions/notSamBecauseOfSupertype.kt +++ b/compiler/fir/analysis-tests/testData/resolve/samConversions/notSamBecauseOfSupertype.kt @@ -18,14 +18,14 @@ public class JavaUsage { fun foo(m: MyRunnable) {} fun main() { - JavaUsage.foo { + JavaUsage.foo { x -> x > 1 - } + } - JavaUsage.foo({ it > 1 }) + JavaUsage.foo({ it > 1 }) val x = { x: Int -> x > 1 } - JavaUsage.foo(x) + JavaUsage.foo(x) } diff --git a/compiler/fir/analysis-tests/testData/resolve/sealedClass.kt b/compiler/fir/analysis-tests/testData/resolve/sealedClass.kt index 071205181ae..76cc50ceb00 100644 --- a/compiler/fir/analysis-tests/testData/resolve/sealedClass.kt +++ b/compiler/fir/analysis-tests/testData/resolve/sealedClass.kt @@ -6,5 +6,5 @@ sealed class WithPrivateConstructor private constructor(val x: Int) { private constructor() : this(42) } -object First : WithPrivateConstructor() // error -object Second : WithPrivateConstructor(0) // error +object First : WithPrivateConstructor() // error +object Second : WithPrivateConstructor(0) // error diff --git a/compiler/fir/analysis-tests/testData/resolve/simpleClass.kt b/compiler/fir/analysis-tests/testData/resolve/simpleClass.kt index 851f3c6f289..e78036d2670 100644 --- a/compiler/fir/analysis-tests/testData/resolve/simpleClass.kt +++ b/compiler/fir/analysis-tests/testData/resolve/simpleClass.kt @@ -16,4 +16,4 @@ class SomeClass : SomeInterface { set(value) {} var fau: Double -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/simpleTypeAlias.kt b/compiler/fir/analysis-tests/testData/resolve/simpleTypeAlias.kt index 00b88d1bd87..34a18758304 100644 --- a/compiler/fir/analysis-tests/testData/resolve/simpleTypeAlias.kt +++ b/compiler/fir/analysis-tests/testData/resolve/simpleTypeAlias.kt @@ -2,4 +2,4 @@ interface B typealias C = B -class D : C \ No newline at end of file +class D : C diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/bangbang.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/bangbang.kt index 6c778107ba5..b861d37433d 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/bangbang.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/bangbang.kt @@ -26,7 +26,7 @@ fun test_3(a: A?, b: Boolean) { if (b && a!!.foo()) { a.foo() // OK } - a.foo() // Bad + a.foo() // Bad } fun test_4(a: A?, b: Boolean) { @@ -38,9 +38,9 @@ fun test_4(a: A?, b: Boolean) { fun test_5(a: A?, b: Boolean) { if (b || a!!.foo()) { - a.foo() + a.foo() } - a.foo() + a.foo() } fun test_6(x: X) { @@ -49,4 +49,4 @@ fun test_6(x: X) { fun test_7(x: X?) { x!!.foo() -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans/booleanOperators.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans/booleanOperators.kt index 4f293d49cd0..e45272656a6 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans/booleanOperators.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans/booleanOperators.kt @@ -24,8 +24,8 @@ fun test_1(x: Any) { fun test_2(x: Any) { if (x is B || x is C) { x.foo() - x.bar() - x.baz() + x.bar() + x.baz() } } @@ -59,26 +59,26 @@ fun test_6(x: Any) { fun test_7(x: Any) { if (x is A || false) { // TODO: should be smartcast - x.foo() + x.foo() } } fun test_8(x: Any) { if (false || x is A) { // TODO: should be smartcast - x.foo() + x.foo() } } fun test_9(x: Any) { if (x is A || true) { - x.foo() + x.foo() } } fun test_10(x: Any) { if (true || x is A) { - x.foo() + x.foo() } } @@ -86,7 +86,7 @@ fun test_10(x: Any) { fun test_11(x: Any, b: Boolean) { if (false && x is A) { - x.foo() + x.foo() } } diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans/equalsToBoolean.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans/equalsToBoolean.kt index 045d3fa1779..97732d845cd 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans/equalsToBoolean.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans/equalsToBoolean.kt @@ -8,13 +8,13 @@ fun test_1(b: Boolean?) { if ((b == true) == true) { b.not() // OK } else { - b.not() // Bad + b.not() // Bad } } fun test_2(b: Boolean?) { if ((b == true) != true) { - b.not() // Bad + b.not() // Bad } else { b.not() // OK } @@ -22,7 +22,7 @@ fun test_2(b: Boolean?) { fun test_3(b: Boolean?) { if ((b == true) == false) { - b.not() // Bad + b.not() // Bad } else { b.not() // OK } @@ -32,13 +32,13 @@ fun test_4(b: Boolean?) { if ((b == true) != false) { b.not() // OK } else { - b.not() // Bad + b.not() // Bad } } fun test_5(b: Boolean?) { if ((b != true) == true) { - b.not() // Bad + b.not() // Bad } else { b.not() // OK } @@ -48,7 +48,7 @@ fun test_6(b: Boolean?) { if ((b != true) != true) { b.not() // OK } else { - b.not() // Bad + b.not() // Bad } } @@ -56,14 +56,14 @@ fun test_7(b: Boolean?) { if ((b != true) == false) { b.not() // OK } else { - b.not() // Bad + b.not() // Bad } } fun test_8(b: Boolean?) { if ((b != true) != false) { - b.not() // Bad + b.not() // Bad } else { b.not() // OK } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans/jumpFromRhsOfOperator.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans/jumpFromRhsOfOperator.kt index b425f917c26..be91a791bed 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans/jumpFromRhsOfOperator.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/booleans/jumpFromRhsOfOperator.kt @@ -34,24 +34,24 @@ fun test_4(a: A?) { fun test_5(a: A?) { a == null || throw Exception() - a.foo() + a.foo() } fun teat_6(a: A?) { a != null && throw Exception() - a.foo() + a.foo() } fun test_7(a: A?) { if (a == null || throw Exception()) { - a.foo() + a.foo() } - a.foo() + a.foo() } fun test_8(a: A?) { if (a != null && throw Exception()) { - a.foo() + a.foo() } - a.foo() + a.foo() } diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/boundSmartcasts/boundSmartcasts.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/boundSmartcasts/boundSmartcasts.kt index 2642e666098..f6e34990a98 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/boundSmartcasts/boundSmartcasts.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/boundSmartcasts/boundSmartcasts.kt @@ -30,7 +30,7 @@ fun test_3(x: Any, y: Any) { } z = y if (y is B) { - z.foo() + z.foo() z.bar() } } @@ -40,7 +40,7 @@ fun test_4(y: Any) { x as Int x.inc() x = y - x.inc() + x.inc() if (y is A) { x.foo() y.foo() @@ -75,4 +75,4 @@ fun test_7(d1: D, d2: D) { a.foo() // should be OK b as B b.bar() // should be OK -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/boundSmartcasts/boundSmartcastsInBranches.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/boundSmartcasts/boundSmartcastsInBranches.kt index 33e8f4b3cb4..88992851c5c 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/boundSmartcasts/boundSmartcastsInBranches.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/boundSmartcasts/boundSmartcastsInBranches.kt @@ -118,4 +118,4 @@ fun test_7() { y.length // Bad z.length // OK } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/casts.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/casts.kt index 75224175da3..dfb08e48fb6 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/casts.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/casts.kt @@ -15,31 +15,31 @@ fun test_3(b: Boolean, x: Any?) { if (b && x as Boolean) { x.not() } - x.not() + x.not() if (b && x as Boolean == true) { x.not() } - x.not() + x.not() if (b || x as Boolean) { - x.not() + x.not() } - x.not() + x.not() } fun test_4(b: Any) { if (b as? Boolean != null) { b.not() } else { - b.not() + b.not() } - b.not() + b.not() if (b as? Boolean == null) { - b.not() + b.not() } else { b.not() } - b.not() -} \ No newline at end of file + b.not() +} diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/elvis.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/elvis.kt index cdcbaa5f77c..8891abd774d 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/elvis.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/elvis.kt @@ -14,4 +14,4 @@ fun test2(a: Any?, b: Any?): String { if (b !is String) return "" if (a !is String?) return "" return a ?: b -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/returns.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/returns.kt index 71d27f73d39..58f167ec50d 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/returns.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/returns.kt @@ -36,8 +36,8 @@ fun test_2(x: Any) { else -> return } x.foo() - x.bar() - x.baz() + x.bar() + x.baz() } fun test_3(x: Any) { @@ -45,9 +45,9 @@ fun test_3(x: Any) { x is B -> x.bar() x is C -> x.baz() } - x.foo() - x.bar() - x.baz() + x.foo() + x.bar() + x.baz() } fun runHigherOrder(f: () -> T): T = f() @@ -60,4 +60,4 @@ fun test_4(a: Any?) { runHigherOrder { s.length // Should be OK } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/simpleIf.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/simpleIf.kt index bbe6b2244b2..04653ca4545 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/simpleIf.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/simpleIf.kt @@ -23,4 +23,4 @@ fun test_3(x: Any) { x.inc() } } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/smartcastFromArgument.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/smartcastFromArgument.kt index 07d628f7306..3ce26ed8eea 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/smartcastFromArgument.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/smartcastFromArgument.kt @@ -9,4 +9,4 @@ fun test(a: Any) { if (takeA(a as? A ?: return)) { a.foo() } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/when.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/when.kt index b5a9a67bab0..a5e84e1accd 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/when.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/controlStructures/when.kt @@ -89,4 +89,4 @@ fun test_4(x: Any) { 1 -> x.inc() } x.inc() -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/equalsAndIdentity.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/equalsAndIdentity.kt index 18289e801d8..e54a97ef7fd 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/equalsAndIdentity.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/equalsAndIdentity.kt @@ -16,12 +16,12 @@ fun test_1(x: A, y: A?) { fun test_2(x: A?, y: A?) { if (x == y) { - x.foo() - y.foo() + x.foo() + y.foo() } if (x === y) { - x.foo() - y.foo() + x.foo() + y.foo() } } @@ -35,4 +35,4 @@ fun test_3(x: A?, y: A?) { x.foo() y.foo() } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/kt10240.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/kt10240.kt index afaf177ac05..4a2b7373d0f 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/kt10240.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/kt10240.kt @@ -33,4 +33,4 @@ fun d() { koko = null } } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/kt37327.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/kt37327.kt index dd476fa0e59..dcf4cbfcec8 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/kt37327.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/kt37327.kt @@ -11,4 +11,4 @@ fun Q.foo() { when (this) { is B -> x // unresolved } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/kt39000.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/kt39000.kt index f2a6e828f2f..f314cbcdf87 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/kt39000.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/kt39000.kt @@ -9,4 +9,4 @@ fun main(a: A) { if (a === X) { foo(a) } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/lambdas/inPlaceLambdas.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/lambdas/inPlaceLambdas.kt index 311e0c240e4..abc7a141b50 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/lambdas/inPlaceLambdas.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/lambdas/inPlaceLambdas.kt @@ -30,4 +30,4 @@ fun test_3(x: Any?) { } x.bar() } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/lambdas/lambdaInWhenBranch.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/lambdas/lambdaInWhenBranch.kt index 7c551a3deeb..908142c83af 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/lambdas/lambdaInWhenBranch.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/lambdas/lambdaInWhenBranch.kt @@ -20,4 +20,4 @@ private fun foo(p: Sealed) { is SubClass1 -> p.t is SubClass2 -> "2" }.length // should be resolved, but when is not considered as sealed because type of p is not a sealed class -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/lambdas/smartcastOnLambda.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/lambdas/smartcastOnLambda.kt index 0ee6af5b03c..c8d3d037e35 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/lambdas/smartcastOnLambda.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/lambdas/smartcastOnLambda.kt @@ -3,4 +3,4 @@ fun test(func: (() -> Unit)?) { if (func != null) { func() } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/loops/dataFlowInfoFromWhileCondition.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/loops/dataFlowInfoFromWhileCondition.kt index fe66111c930..7008375bcb0 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/loops/dataFlowInfoFromWhileCondition.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/loops/dataFlowInfoFromWhileCondition.kt @@ -10,4 +10,4 @@ fun test() { while (a is B || a is C) { a.foo() } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/loops/endlessLoops.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/loops/endlessLoops.kt index 1776f00f971..bc94abdb650 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/loops/endlessLoops.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/loops/endlessLoops.kt @@ -44,7 +44,7 @@ fun test_4(x: Any, b: Boolean) { } break } - x.foo() // No smartcast + x.foo() // No smartcast } fun test_5(x: Any, b: Boolean) { diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/multipleCasts.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/multipleCasts.kt index d264337c942..c9b0b837694 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/multipleCasts.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/multipleCasts.kt @@ -26,4 +26,4 @@ fun test_1() { a.foo() b.foo() } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/nullability.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/nullability.kt index 35b4d6f8b97..a0f9eb98439 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/nullability.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/nullability.kt @@ -39,18 +39,18 @@ fun test_1(x: A?) { if (x != null) { x.foo() } else { - x.foo() + x.foo() } - x.foo() + x.foo() } fun test_2(x: A?) { if (x == null) { - x.foo() + x.foo() } else { x.foo() } - x.foo() + x.foo() } fun test_3(x: A?) { @@ -83,8 +83,8 @@ fun test_6(q: Q?) { fun test_7(q: Q?) { if (q?.fdata()?.fs()?.inc() != null) { q.fdata() // good - q.fdata().fs() // bad - q.fdata().fs().inc() // bad + q.fdata().fs() // bad + q.fdata().fs().inc() // bad } } @@ -98,44 +98,44 @@ fun test_9(a: Int, b: Int?) { if (a == b) { b.inc() } - b.inc() + b.inc() if (a === b) { b.inc() } - b.inc() + b.inc() if (b == a) { b.inc() } - b.inc() + b.inc() if (b === a) { b.inc() } - b.inc() + b.inc() } fun test_10(a: Int?, b: Int?) { if (a == b) { - b.inc() + b.inc() } - b.inc() + b.inc() if (a === b) { - b.inc() + b.inc() } - b.inc() + b.inc() if (b == a) { - b.inc() + b.inc() } - b.inc() + b.inc() if (b === a) { - b.inc() + b.inc() } - b.inc() + b.inc() } fun test_11(q: QImpl?, q2: QImpl) { diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/orInWhenBranch.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/orInWhenBranch.kt index c681c1b2959..9b2ad3bab6f 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/orInWhenBranch.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/orInWhenBranch.kt @@ -4,24 +4,24 @@ fun String.foo() {} fun test_1(a: Any?) { when (a) { - is String, is Any -> a.foo() // Should be Bad + is String, is Any -> a.foo() // Should be Bad } } fun test_2(a: Any?) { if (a is String || a is Any) { - a.foo() // Should be Bad + a.foo() // Should be Bad } } fun test_3(a: Any?, b: Boolean) { when (a) { - is String, b -> a.foo() // Should be Bad + is String, b -> a.foo() // Should be Bad } } fun test_4(a: Any?, b: Boolean) { if (a is String || b) { - a.foo() // Should be Bad + a.foo() // Should be Bad } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/receivers/implicitReceiverAsWhenSubject.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/receivers/implicitReceiverAsWhenSubject.kt index a06e2fa03a1..6fc7ae837a3 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/receivers/implicitReceiverAsWhenSubject.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/receivers/implicitReceiverAsWhenSubject.kt @@ -15,4 +15,4 @@ fun Any.test_2(): Int = when (val x = this) { length } else -> 0 -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/receivers/implicitReceivers.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/receivers/implicitReceivers.kt index 23e50af2cc2..f13a9b24ca5 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/receivers/implicitReceivers.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/receivers/implicitReceivers.kt @@ -14,23 +14,23 @@ fun Any?.test_1() { this.foo() foo() } else { - this.foo() - foo() + this.foo() + foo() } - this.foo() - foo() + this.foo() + foo() } fun Any?.test_2() { if (this !is A) { - this.foo() - foo() + this.foo() + foo() } else { this.foo() foo() } - this.foo() - foo() + this.foo() + foo() } fun test_3(a: Any, b: Any, c: Any) { @@ -49,13 +49,13 @@ fun test_3(a: Any, b: Any, c: Any) { fun Any?.test_4() { if (this !is A) { - this.foo() - foo() - this.bar() - bar() + this.foo() + foo() + this.bar() + bar() } else if (this !is B) { - this.bar() - bar() + this.bar() + bar() this.foo() foo() } else { @@ -64,10 +64,10 @@ fun Any?.test_4() { this.bar() bar() } - this.foo() - foo() - this.bar() - bar() + this.foo() + foo() + this.bar() + bar() } fun Any.test_5(): Int = when { @@ -81,4 +81,4 @@ fun Any.test_6() { size this as String length -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/receivers/mixingImplicitAndExplicitReceivers.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/receivers/mixingImplicitAndExplicitReceivers.kt index 025700d52e9..ca70aec69ce 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/receivers/mixingImplicitAndExplicitReceivers.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/receivers/mixingImplicitAndExplicitReceivers.kt @@ -11,4 +11,4 @@ class Wrapper(val s: String?) { } } -fun takeString(s: String) {} \ No newline at end of file +fun takeString(s: String) {} diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/assignSafeCall.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/assignSafeCall.kt index f0cefdea95a..2ab10f63a19 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/assignSafeCall.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/assignSafeCall.kt @@ -57,4 +57,4 @@ fun test_2(a: B?) { val a = x as? B ?: return a.foo() // Should be OK x.foo() // Should be OK -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/safeCallAndEqualityToBool.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/safeCallAndEqualityToBool.kt index 741000c7541..293db6f24d0 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/safeCallAndEqualityToBool.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/safeCallAndEqualityToBool.kt @@ -31,4 +31,4 @@ fun test_4(s: String?) { } else { s.length // Should be OK } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/safeCalls.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/safeCalls.kt index 51413298fbf..455c59ab709 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/safeCalls.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/safeCalls/safeCalls.kt @@ -22,17 +22,17 @@ fun test_3(x: Any) { (x as? A)?.bar(x)?.foo(x.bool())?.let { x.bool() } - x.bool() + x.bool() } fun test_4(x: A?) { x?.id()?.bool() - x.id() + x.id() } fun Any?.boo(b: Boolean) {} fun test_5(x: A?) { x?.let { return }?.boo(x.bool()) - x.id() -} \ No newline at end of file + x.id() +} diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/stability/overridenOpenVal.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/stability/overridenOpenVal.kt index 8742262e919..98b6ef64964 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/stability/overridenOpenVal.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/stability/overridenOpenVal.kt @@ -13,4 +13,4 @@ fun test_2(b: B) { if (b.x is String) { b.x.length } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/variables/delayedAssignment.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/variables/delayedAssignment.kt index 6bf18a7dd07..c911291afd8 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/variables/delayedAssignment.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/variables/delayedAssignment.kt @@ -11,5 +11,5 @@ fun test(b: Boolean) { } else { a = null } - a.foo() -} \ No newline at end of file + a.foo() +} diff --git a/compiler/fir/analysis-tests/testData/resolve/smartcasts/variables/smartcastAfterReassignment.kt b/compiler/fir/analysis-tests/testData/resolve/smartcasts/variables/smartcastAfterReassignment.kt index b24f2f6b05d..056a5620c9c 100644 --- a/compiler/fir/analysis-tests/testData/resolve/smartcasts/variables/smartcastAfterReassignment.kt +++ b/compiler/fir/analysis-tests/testData/resolve/smartcasts/variables/smartcastAfterReassignment.kt @@ -19,4 +19,4 @@ fun test_3() { x.length x = null x.length -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/spreadOperator.kt b/compiler/fir/analysis-tests/testData/resolve/spreadOperator.kt index df9adc970ad..ca85a5cc842 100644 --- a/compiler/fir/analysis-tests/testData/resolve/spreadOperator.kt +++ b/compiler/fir/analysis-tests/testData/resolve/spreadOperator.kt @@ -25,4 +25,4 @@ fun testFromJava() { val values = Utils.getStrings() val list = myListOf(*values) takeStrings(list) -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/treeSet.kt b/compiler/fir/analysis-tests/testData/resolve/treeSet.kt index 06a7a6516b1..695882645ec 100644 --- a/compiler/fir/analysis-tests/testData/resolve/treeSet.kt +++ b/compiler/fir/analysis-tests/testData/resolve/treeSet.kt @@ -1,3 +1,3 @@ import java.util.* -val x: SortedSet = TreeSet() \ No newline at end of file +val x: SortedSet = TreeSet() diff --git a/compiler/fir/analysis-tests/testData/resolve/tryInference.kt b/compiler/fir/analysis-tests/testData/resolve/tryInference.kt index e6d14b02757..4ee09058718 100644 --- a/compiler/fir/analysis-tests/testData/resolve/tryInference.kt +++ b/compiler/fir/analysis-tests/testData/resolve/tryInference.kt @@ -14,4 +14,4 @@ fun test() { materialize() // Should be an errror } ) -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/typeAliasWithTypeArguments.kt b/compiler/fir/analysis-tests/testData/resolve/typeAliasWithTypeArguments.kt index baaee1fb118..065f9741152 100644 --- a/compiler/fir/analysis-tests/testData/resolve/typeAliasWithTypeArguments.kt +++ b/compiler/fir/analysis-tests/testData/resolve/typeAliasWithTypeArguments.kt @@ -10,10 +10,10 @@ interface C { fun baz() } -interface Inv() { +interface Inv() { fun k(): K fun t(): T -} +} typealias Inv0 = Inv typealias Inv1 = Inv @@ -42,7 +42,7 @@ fun test_2(inv: Inv2) { fun test_3(inv: Inv3) { inv.k().foo() - inv.t().bar() + inv.t().bar() inv.t().baz() } @@ -74,21 +74,21 @@ typealias Invariant1 = Invariant fun test_5(a: A, in1: In1, in2: In1, in3: In1) { in1.take(a) in2.take(a) - in3.take(a) + in3.take(a) } fun test_6(a: A, out1: Out1, out2: Out1, out3: Out1) { out1.value().foo() - out2.value().foo() + out2.value().foo() out3.value().foo() } fun test_7(a: A, inv1: Invariant1, inv2: Invariant1, inv3: Invariant1) { inv1.value().foo() - inv2.value().foo() + inv2.value().foo() inv3.value().foo() inv1.take(a) inv2.take(a) - inv3.take(a) -} \ No newline at end of file + inv3.take(a) +} diff --git a/compiler/fir/analysis-tests/testData/resolve/typeFromGetter.kt b/compiler/fir/analysis-tests/testData/resolve/typeFromGetter.kt index 035f9be3c88..b796778f5bf 100644 --- a/compiler/fir/analysis-tests/testData/resolve/typeFromGetter.kt +++ b/compiler/fir/analysis-tests/testData/resolve/typeFromGetter.kt @@ -9,4 +9,4 @@ val w: Int get(): Int = 1 interface Some { val bar: Int get() = 1 -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/typeParameterVsNested.kt b/compiler/fir/analysis-tests/testData/resolve/typeParameterVsNested.kt index e1a220fb529..5181ec7b24e 100644 --- a/compiler/fir/analysis-tests/testData/resolve/typeParameterVsNested.kt +++ b/compiler/fir/analysis-tests/testData/resolve/typeParameterVsNested.kt @@ -13,7 +13,7 @@ abstract class My { abstract val z: test.My.T - class Some : T() + class Some : T() } abstract class Your : T diff --git a/compiler/fir/analysis-tests/testData/resolve/types/capturedParametersOfInnerClasses.kt b/compiler/fir/analysis-tests/testData/resolve/types/capturedParametersOfInnerClasses.kt index f78eb42830c..a6e88678f95 100644 --- a/compiler/fir/analysis-tests/testData/resolve/types/capturedParametersOfInnerClasses.kt +++ b/compiler/fir/analysis-tests/testData/resolve/types/capturedParametersOfInnerClasses.kt @@ -10,4 +10,4 @@ class A { fun foo(c: A.B.C) {} -fun foo(c: A.B.C) {} \ No newline at end of file +fun foo(c: A.B.C) {} diff --git a/compiler/fir/analysis-tests/testData/resolve/typesInLocalFunctions.kt b/compiler/fir/analysis-tests/testData/resolve/typesInLocalFunctions.kt index 943cf93e42d..2dbee247b04 100644 --- a/compiler/fir/analysis-tests/testData/resolve/typesInLocalFunctions.kt +++ b/compiler/fir/analysis-tests/testData/resolve/typesInLocalFunctions.kt @@ -7,4 +7,4 @@ fun foo(): () -> Boolean { } else { return { true } } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/visibility/exposedFunctionParameterType.kt b/compiler/fir/analysis-tests/testData/resolve/visibility/exposedFunctionParameterType.kt index 8e80e8fcbe6..b7581351fc1 100644 --- a/compiler/fir/analysis-tests/testData/resolve/visibility/exposedFunctionParameterType.kt +++ b/compiler/fir/analysis-tests/testData/resolve/visibility/exposedFunctionParameterType.kt @@ -6,4 +6,4 @@ class B { fun foo(value: A.AInner) { } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/visibility/exposedFunctionReturnType.kt b/compiler/fir/analysis-tests/testData/resolve/visibility/exposedFunctionReturnType.kt index 58c4c104ae8..49c79e79ccd 100644 --- a/compiler/fir/analysis-tests/testData/resolve/visibility/exposedFunctionReturnType.kt +++ b/compiler/fir/analysis-tests/testData/resolve/visibility/exposedFunctionReturnType.kt @@ -5,7 +5,7 @@ class A { } abstract class B { - fun foo(str: String): A.InnerA + fun foo(str: String): A.InnerA } private enum class Some { diff --git a/compiler/fir/analysis-tests/testData/resolve/visibility/exposedPropertyType.kt b/compiler/fir/analysis-tests/testData/resolve/visibility/exposedPropertyType.kt index b464599d35a..e3aef127280 100644 --- a/compiler/fir/analysis-tests/testData/resolve/visibility/exposedPropertyType.kt +++ b/compiler/fir/analysis-tests/testData/resolve/visibility/exposedPropertyType.kt @@ -17,7 +17,7 @@ class Property { var var1: String var var2: String var var3: Int - var var4: A.AInnerPrivate + var var4: A.AInnerPrivate var var5: A.AInnerPublic - var var6: A.AInnerProtectedEnum -} \ No newline at end of file + var var6: A.AInnerProtectedEnum +} diff --git a/compiler/fir/analysis-tests/testData/resolve/visibility/exposedSupertype.kt b/compiler/fir/analysis-tests/testData/resolve/visibility/exposedSupertype.kt index 7fc4f2897e9..168e52b8dfc 100644 --- a/compiler/fir/analysis-tests/testData/resolve/visibility/exposedSupertype.kt +++ b/compiler/fir/analysis-tests/testData/resolve/visibility/exposedSupertype.kt @@ -38,7 +38,7 @@ interface E { } -class Test2 : A.APublicI, B.BInner() { +class Test2 : A.APublicI, B.BInner() { } @@ -50,7 +50,7 @@ class Test4 : E, A.AProtectedI { } -class Test5 : C.CPublicI, B.BInner() { +class Test5 : C.CPublicI, B.BInner() { } @@ -60,4 +60,4 @@ class Test6 : E, C.CPublic { class Test7 : D.PublicButProtected { -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/visibility/exposedTypeAlias.kt b/compiler/fir/analysis-tests/testData/resolve/visibility/exposedTypeAlias.kt index 4296207e024..9c51b28bf8c 100644 --- a/compiler/fir/analysis-tests/testData/resolve/visibility/exposedTypeAlias.kt +++ b/compiler/fir/analysis-tests/testData/resolve/visibility/exposedTypeAlias.kt @@ -2,7 +2,7 @@ class A { private inner class Inner } class B { - typealias AInner = A.Inner + typealias AInner = A.Inner inner class Inner } @@ -10,9 +10,9 @@ class C { typealias BInner = B.Inner } -typealias AInner0 = A.Inner +typealias AInner0 = A.Inner typealias BInner0 = B.Inner private typealias MyString = String -fun foo(): MyString = "" \ No newline at end of file +fun foo(): MyString = "" diff --git a/compiler/fir/analysis-tests/testData/resolve/visibility/exposedTypeParameters.kt b/compiler/fir/analysis-tests/testData/resolve/visibility/exposedTypeParameters.kt index aac91cbe755..eda6bd86bc6 100644 --- a/compiler/fir/analysis-tests/testData/resolve/visibility/exposedTypeParameters.kt +++ b/compiler/fir/analysis-tests/testData/resolve/visibility/exposedTypeParameters.kt @@ -32,4 +32,4 @@ public class Container : C { } // invalid, A is private, B is internal, D is protected -public interface Test8A, P: B, F: C, N: C.D, M: E> \ No newline at end of file +public interface Test8A, P: B, F: C, N: C.D, M: E> diff --git a/compiler/fir/analysis-tests/testData/resolve/visibility/singletonConstructors.kt b/compiler/fir/analysis-tests/testData/resolve/visibility/singletonConstructors.kt index 51a43a129e8..5fc9f86fa4d 100644 --- a/compiler/fir/analysis-tests/testData/resolve/visibility/singletonConstructors.kt +++ b/compiler/fir/analysis-tests/testData/resolve/visibility/singletonConstructors.kt @@ -2,12 +2,12 @@ class A { companion object Comp {} fun foo() { - Comp() + Comp() } } object B { - private val x = B() + private val x = B() } class D { @@ -26,6 +26,6 @@ enum class E { }; fun foo() { - X() + X() } } diff --git a/compiler/fir/analysis-tests/testData/resolve/visibility/visibilityWithOverrides.kt b/compiler/fir/analysis-tests/testData/resolve/visibility/visibilityWithOverrides.kt index 9e5875af43c..768d1052b24 100644 --- a/compiler/fir/analysis-tests/testData/resolve/visibility/visibilityWithOverrides.kt +++ b/compiler/fir/analysis-tests/testData/resolve/visibility/visibilityWithOverrides.kt @@ -19,5 +19,5 @@ abstract class A { // FILE: main.kt fun test(b: B): String { - return b foo "hello" // should be an error + return b foo "hello" // should be an error } diff --git a/compiler/fir/analysis-tests/testData/resolve/whenAsReceiver.kt b/compiler/fir/analysis-tests/testData/resolve/whenAsReceiver.kt index f6078dd1139..caf0dccad90 100644 --- a/compiler/fir/analysis-tests/testData/resolve/whenAsReceiver.kt +++ b/compiler/fir/analysis-tests/testData/resolve/whenAsReceiver.kt @@ -9,4 +9,4 @@ fun foo(b: Boolean, a: Int) { }?.also { 1 } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/whenElse.kt b/compiler/fir/analysis-tests/testData/resolve/whenElse.kt index 82295985eea..d217e230760 100644 --- a/compiler/fir/analysis-tests/testData/resolve/whenElse.kt +++ b/compiler/fir/analysis-tests/testData/resolve/whenElse.kt @@ -53,4 +53,4 @@ fun case3() { A.A1 -> B() //should be INCOMPATIBLE_TYPES A.A2 -> B() //should be INCOMPATIBLE_TYPES } -} \ No newline at end of file +} diff --git a/compiler/fir/analysis-tests/testData/resolve/whenInference.kt b/compiler/fir/analysis-tests/testData/resolve/whenInference.kt index 5cf6db722d0..9dfd1cd2988 100644 --- a/compiler/fir/analysis-tests/testData/resolve/whenInference.kt +++ b/compiler/fir/analysis-tests/testData/resolve/whenInference.kt @@ -6,4 +6,4 @@ fun takeA(a: A) {} fun test() { takeA(if(true) materialize() else materialize()) -} \ No newline at end of file +} From 4ed2651c1f01c1144f5ca87f9c2e945d1275ad95 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Tue, 15 Dec 2020 13:14:46 +0300 Subject: [PATCH 123/196] [CMI] Rename platforms to attributes in some forgotten places --- .../org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoParser.kt | 6 +++--- .../AbstractCodeMetaInfoRenderConfiguration.kt | 4 ++-- .../DiagnosticCodeMetaInfoRenderConfiguration.kt | 2 +- .../test/frontend/fir/handlers/FirDiagnosticCodeMetaInfo.kt | 2 +- 4 files changed, 7 insertions(+), 7 deletions(-) diff --git a/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoParser.kt b/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoParser.kt index 9b3f7925d25..d56f7e627c0 100644 --- a/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoParser.kt +++ b/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/codeMetaInfo/CodeMetaInfoParser.kt @@ -15,7 +15,7 @@ object CodeMetaInfoParser { /* * ([\S&&[^,(){}]]+) -- tag, allowing all non-space characters except bracers and curly bracers - * ([{](.*?)[}])? -- list of platforms + * ([{](.*?)[}])? -- list of attributes * (\("(.*?)"\))? -- arguments of meta info * (, )? -- possible separator between different infos */ @@ -60,14 +60,14 @@ object CodeMetaInfoParser { val allMetaInfos = openingMatchResult.groups[2]!!.value tagRegex.findAll(allMetaInfos).map { it.groups }.forEach { val tag = it[1]!!.value - val platforms = it[3]?.value?.split(";") ?: emptyList() + val attributes = it[3]?.value?.split(";") ?: emptyList() val description = it[5]?.value result.add( ParsedCodeMetaInfo( openingMatchResult.range.first, closingMatchResult.range.first, - platforms.toMutableList(), + attributes.toMutableList(), tag, description ) diff --git a/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/codeMetaInfo/renderConfigurations/AbstractCodeMetaInfoRenderConfiguration.kt b/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/codeMetaInfo/renderConfigurations/AbstractCodeMetaInfoRenderConfiguration.kt index 5135ddf25af..1867150a652 100644 --- a/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/codeMetaInfo/renderConfigurations/AbstractCodeMetaInfoRenderConfiguration.kt +++ b/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/codeMetaInfo/renderConfigurations/AbstractCodeMetaInfoRenderConfiguration.kt @@ -10,7 +10,7 @@ import org.jetbrains.kotlin.codeMetaInfo.model.CodeMetaInfo abstract class AbstractCodeMetaInfoRenderConfiguration(var renderParams: Boolean = true) { private val clickOrPressRegex = "Click or press (.*)to navigate".toRegex() // We have different hotkeys on different platforms - open fun asString(codeMetaInfo: CodeMetaInfo): String = codeMetaInfo.tag + getPlatformsString(codeMetaInfo) + open fun asString(codeMetaInfo: CodeMetaInfo): String = codeMetaInfo.tag + getAttributesString(codeMetaInfo) open fun getAdditionalParams(codeMetaInfo: CodeMetaInfo) = "" @@ -31,7 +31,7 @@ abstract class AbstractCodeMetaInfoRenderConfiguration(var renderParams: Boolean return sanitizedText } - protected fun getPlatformsString(codeMetaInfo: CodeMetaInfo): String { + protected fun getAttributesString(codeMetaInfo: CodeMetaInfo): String { if (codeMetaInfo.attributes.isEmpty()) return "" return "{${codeMetaInfo.attributes.joinToString(";")}}" } diff --git a/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/codeMetaInfo/renderConfigurations/DiagnosticCodeMetaInfoRenderConfiguration.kt b/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/codeMetaInfo/renderConfigurations/DiagnosticCodeMetaInfoRenderConfiguration.kt index 6357a18f5cd..0218108e750 100644 --- a/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/codeMetaInfo/renderConfigurations/DiagnosticCodeMetaInfoRenderConfiguration.kt +++ b/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/codeMetaInfo/renderConfigurations/DiagnosticCodeMetaInfoRenderConfiguration.kt @@ -21,7 +21,7 @@ open class DiagnosticCodeMetaInfoRenderConfiguration( override fun asString(codeMetaInfo: CodeMetaInfo): String { if (codeMetaInfo !is DiagnosticCodeMetaInfo) return "" return (getTag(codeMetaInfo) - + getPlatformsString(codeMetaInfo) + + getAttributesString(codeMetaInfo) + getParamsString(codeMetaInfo)) .replace(crossPlatformLineBreak, "") } diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirDiagnosticCodeMetaInfo.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirDiagnosticCodeMetaInfo.kt index fbb6af8262d..5042b2d400b 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirDiagnosticCodeMetaInfo.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirDiagnosticCodeMetaInfo.kt @@ -62,7 +62,7 @@ class FirDiagnosticCodeMetaRenderConfiguration( override fun asString(codeMetaInfo: CodeMetaInfo): String { if (codeMetaInfo !is FirDiagnosticCodeMetaInfo) return "" return (getTag(codeMetaInfo) - + getPlatformsString(codeMetaInfo) + + getAttributesString(codeMetaInfo) + getParamsString(codeMetaInfo)) .replace(crossPlatformLineBreak, "") } From 019cb1485e1c485b16e4563fb567d6f53fa8971c Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Tue, 15 Dec 2020 13:25:23 +0300 Subject: [PATCH 124/196] [TEST] Extract language feature regex pattern to :test-infrastructure-utils --- .../tests/org/jetbrains/kotlin/test/util/Patterns.kt | 10 ++++++++++ .../test/builders/LanguageVersionSettingsBuilder.kt | 6 ++---- .../checkers/CompilerTestLanguageVersionSettings.kt | 6 ++---- 3 files changed, 14 insertions(+), 8 deletions(-) create mode 100644 compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/util/Patterns.kt diff --git a/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/util/Patterns.kt b/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/util/Patterns.kt new file mode 100644 index 00000000000..0c28a4f45c4 --- /dev/null +++ b/compiler/test-infrastructure-utils/tests/org/jetbrains/kotlin/test/util/Patterns.kt @@ -0,0 +1,10 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.test.util + +import java.util.regex.Pattern + +val LANGUAGE_FEATURE_PATTERN: Pattern = Pattern.compile("""(\+|-|warn:)(\w+)\s*""") diff --git a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/builders/LanguageVersionSettingsBuilder.kt b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/builders/LanguageVersionSettingsBuilder.kt index bb7f2d5fcd2..873a284b96a 100644 --- a/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/builders/LanguageVersionSettingsBuilder.kt +++ b/compiler/test-infrastructure/tests/org/jetbrains/kotlin/test/builders/LanguageVersionSettingsBuilder.kt @@ -10,14 +10,12 @@ import org.jetbrains.kotlin.test.directives.LanguageSettingsDirectives import org.jetbrains.kotlin.test.directives.model.RegisteredDirectives import org.jetbrains.kotlin.test.directives.model.singleOrZeroValue import org.jetbrains.kotlin.test.services.DefaultsDsl +import org.jetbrains.kotlin.test.util.LANGUAGE_FEATURE_PATTERN import org.jetbrains.kotlin.utils.addToStdlib.runIf -import java.util.regex.Pattern @DefaultsDsl class LanguageVersionSettingsBuilder { companion object { - private val languageFeaturePattern = Pattern.compile("""(\+|-|warn:)(\w+)\s*""") - fun fromExistingSettings(builder: LanguageVersionSettingsBuilder): LanguageVersionSettingsBuilder { return LanguageVersionSettingsBuilder().apply { languageVersion = builder.languageVersion @@ -79,7 +77,7 @@ class LanguageVersionSettingsBuilder { } private fun parseLanguageFeature(featureString: String) { - val matcher = languageFeaturePattern.matcher(featureString) + val matcher = LANGUAGE_FEATURE_PATTERN.matcher(featureString) if (!matcher.find()) { error( """Wrong syntax in the '// !${LanguageSettingsDirectives.LANGUAGE.name}: ...' directive: diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/CompilerTestLanguageVersionSettings.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/CompilerTestLanguageVersionSettings.kt index b3611f27d18..a571a54daaf 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/CompilerTestLanguageVersionSettings.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/CompilerTestLanguageVersionSettings.kt @@ -9,9 +9,9 @@ import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment import org.jetbrains.kotlin.config.* import org.jetbrains.kotlin.test.Directives import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.util.LANGUAGE_FEATURE_PATTERN import org.junit.Assert import java.io.File -import java.util.regex.Pattern const val LANGUAGE_DIRECTIVE = "LANGUAGE" const val API_VERSION_DIRECTIVE = "API_VERSION" @@ -117,10 +117,8 @@ fun setupLanguageVersionSettingsForCompilerTests(originalFileText: String, envir private fun analysisFlag(flag: AnalysisFlag, value: @kotlin.internal.NoInfer T?): Pair, T>? = value?.let(flag::to) -private val languagePattern = Pattern.compile("(\\+|\\-|warn:)(\\w+)\\s*") - private fun collectLanguageFeatureMap(directives: String): Map { - val matcher = languagePattern.matcher(directives) + val matcher = LANGUAGE_FEATURE_PATTERN.matcher(directives) if (!matcher.find()) { Assert.fail( "Wrong syntax in the '// !$LANGUAGE_DIRECTIVE: ...' directive:\n" + From 416f17e5ece0c96788855b5e2e64e4d576a2839c Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Wed, 16 Dec 2020 10:38:10 +0300 Subject: [PATCH 125/196] [TEST] Drop remaining tests of experimental coroutines --- .../release/coroutineContext.fir.kt | 8 -- .../coroutines/release/coroutineContext.kt | 8 -- ...nguageVersionIsNotEqualToApiVersion.fir.kt | 38 -------- .../languageVersionIsNotEqualToApiVersion.kt | 38 -------- .../restrictSuspension/outerYield_1_2.fir.kt | 94 ------------------- .../restrictSuspension/outerYield_1_2.kt | 94 ------------------- .../suspendCoroutineUnavailableWithNewAPI.kt | 16 ---- ...spendCoroutineUnavailableWithOldAPI.fir.kt | 14 --- .../suspendCoroutineUnavailableWithOldAPI.kt | 14 --- .../nothingTypedSuspendFunction_1_2.kt | 10 -- .../nothingTypedSuspendFunction_1_2.txt | 3 - .../test/runners/DiagnosticTestGenerated.java | 36 ------- ...irOldFrontendDiagnosticsTestGenerated.java | 36 ------- 13 files changed, 409 deletions(-) delete mode 100644 compiler/testData/diagnostics/testsWithStdLib/coroutines/release/coroutineContext.fir.kt delete mode 100644 compiler/testData/diagnostics/testsWithStdLib/coroutines/release/coroutineContext.kt delete mode 100644 compiler/testData/diagnostics/testsWithStdLib/coroutines/release/languageVersionIsNotEqualToApiVersion.fir.kt delete mode 100644 compiler/testData/diagnostics/testsWithStdLib/coroutines/release/languageVersionIsNotEqualToApiVersion.kt delete mode 100644 compiler/testData/diagnostics/testsWithStdLib/coroutines/restrictSuspension/outerYield_1_2.fir.kt delete mode 100644 compiler/testData/diagnostics/testsWithStdLib/coroutines/restrictSuspension/outerYield_1_2.kt delete mode 100644 compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendCoroutineUnavailableWithNewAPI.kt delete mode 100644 compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendCoroutineUnavailableWithOldAPI.fir.kt delete mode 100644 compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendCoroutineUnavailableWithOldAPI.kt delete mode 100644 compiler/testData/diagnostics/testsWithStdLib/coroutines/tailCalls/nothingTypedSuspendFunction_1_2.kt delete mode 100644 compiler/testData/diagnostics/testsWithStdLib/coroutines/tailCalls/nothingTypedSuspendFunction_1_2.txt diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/release/coroutineContext.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/release/coroutineContext.fir.kt deleted file mode 100644 index 63667e6256c..00000000000 --- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/release/coroutineContext.fir.kt +++ /dev/null @@ -1,8 +0,0 @@ -// !LANGUAGE: +ReleaseCoroutines -// SKIP_TXT - -import kotlin.coroutines.experimental.coroutineContext - -suspend fun test() { - coroutineContext -} diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/release/coroutineContext.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/release/coroutineContext.kt deleted file mode 100644 index 76f47275c19..00000000000 --- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/release/coroutineContext.kt +++ /dev/null @@ -1,8 +0,0 @@ -// !LANGUAGE: +ReleaseCoroutines -// SKIP_TXT - -import kotlin.coroutines.experimental.coroutineContext - -suspend fun test() { - coroutineContext -} diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/release/languageVersionIsNotEqualToApiVersion.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/release/languageVersionIsNotEqualToApiVersion.fir.kt deleted file mode 100644 index 9d872adc72a..00000000000 --- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/release/languageVersionIsNotEqualToApiVersion.fir.kt +++ /dev/null @@ -1,38 +0,0 @@ -// !API_VERSION: 1.2 -// !DIAGNOSTICS: -UNUSED_PARAMETER -// !LANGUAGE: +ReleaseCoroutines -// !WITH_NEW_INFERENCE -// SKIP_TXT - -suspend fun dummy() {} - -// TODO: Forbid -fun builder(c: suspend () -> Unit) {} - -suspend fun test1() { - kotlin.coroutines.coroutineContext - - kotlin.coroutines.experimental.coroutineContext - - suspend {}() - - dummy() - - val c: suspend () -> Unit = {} - c() - - builder {} -} - -fun test2() { - kotlin.coroutines.experimental.buildSequence { - yield(1) - } - kotlin.sequences.buildSequence { - yield(1) - } -} - -suspend fun test3(): Unit = kotlin.coroutines.experimental.suspendCoroutine { _ -> Unit } - -suspend fun test4(): Unit = kotlin.coroutines.suspendCoroutine { _ -> Unit } diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/release/languageVersionIsNotEqualToApiVersion.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/release/languageVersionIsNotEqualToApiVersion.kt deleted file mode 100644 index 88e8f78ee0a..00000000000 --- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/release/languageVersionIsNotEqualToApiVersion.kt +++ /dev/null @@ -1,38 +0,0 @@ -// !API_VERSION: 1.2 -// !DIAGNOSTICS: -UNUSED_PARAMETER -// !LANGUAGE: +ReleaseCoroutines -// !WITH_NEW_INFERENCE -// SKIP_TXT - -suspend fun dummy() {} - -// TODO: Forbid -fun builder(c: suspend () -> Unit) {} - -suspend fun test1() { - kotlin.coroutines.coroutineContext - - kotlin.coroutines.experimental.coroutineContext - - suspend {}() - - dummy() - - val c: suspend () -> Unit = {} - c() - - builder {} -} - -fun test2() { - kotlin.coroutines.experimental.buildSequence { - yield(1) - } - kotlin.sequences.buildSequence { - yield(1) - } -} - -suspend fun test3(): Unit = kotlin.coroutines.experimental.suspendCoroutine { _ -> Unit } - -suspend fun test4(): Unit = kotlin.coroutines.suspendCoroutine { _ -> Unit } diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/restrictSuspension/outerYield_1_2.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/restrictSuspension/outerYield_1_2.fir.kt deleted file mode 100644 index cb9c725dd29..00000000000 --- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/restrictSuspension/outerYield_1_2.fir.kt +++ /dev/null @@ -1,94 +0,0 @@ -// !LANGUAGE: -ReleaseCoroutines -ExperimentalBuilderInference -// !DIAGNOSTICS: -EXPERIMENTAL_FEATURE_WARNING -// !WITH_NEW_INFERENCE -// SKIP_TXT - -@kotlin.coroutines.experimental.RestrictsSuspension -class RestrictedController { - suspend fun yield(x: T) {} - - suspend fun anotherYield(x: T) { - yield(x) - this.yield(x) - - yield2(x) - this.yield2(x) - - with(this) { - yield(x) - this@with.yield(x) - - yield2(x) - this@with.yield2(x) - } - } -} - -fun buildSequence(c: suspend RestrictedController.() -> Unit) {} -suspend fun RestrictedController.yield2(x: T) {} - -fun test() { - buildSequence a@{ - buildSequence b@{ - yield(1) - yield2(1) - this@b.yield(1) - this@b.yield2(1) - - this@a.yield(2) // Should be error - this@a.yield2(2) // Should be error - - with(this) { - yield(3) - this@with.yield(3) - - yield2(3) - this@with.yield2(3) - } - } - } - - buildSequence { - buildSequence { - yield("a") - yield2("a") - this.yield("b") - this.yield2("b") - - yield(1) // Should be error - yield2(1) // Should be error - - with(this) { - yield("") - this@with.yield("") - - yield2("") - this@with.yield2("") - } - } - } - - buildSequence a@{ - yield(1) - yield2(1) - buildSequence { - yield("") - yield2("") - this@a.yield(1) - this@a.yield2(1) - - with(this) { - yield("") - this@with.yield("") - - yield2("") - this@with.yield2("") - } - } - } - - buildSequence { - yield("") - RestrictedController().yield("1") - } -} diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/restrictSuspension/outerYield_1_2.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/restrictSuspension/outerYield_1_2.kt deleted file mode 100644 index d57a7f75988..00000000000 --- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/restrictSuspension/outerYield_1_2.kt +++ /dev/null @@ -1,94 +0,0 @@ -// !LANGUAGE: -ReleaseCoroutines -ExperimentalBuilderInference -// !DIAGNOSTICS: -EXPERIMENTAL_FEATURE_WARNING -// !WITH_NEW_INFERENCE -// SKIP_TXT - -@kotlin.coroutines.experimental.RestrictsSuspension -class RestrictedController { - suspend fun yield(x: T) {} - - suspend fun anotherYield(x: T) { - yield(x) - this.yield(x) - - yield2(x) - this.yield2(x) - - with(this) { - yield(x) - this@with.yield(x) - - yield2(x) - this@with.yield2(x) - } - } -} - -fun buildSequence(c: suspend RestrictedController.() -> Unit) {} -suspend fun RestrictedController.yield2(x: T) {} - -fun test() { - buildSequence a@{ - buildSequence b@{ - yield(1) - yield2(1) - this@b.yield(1) - this@b.yield2(1) - - this@a.yield(2) // Should be error - this@a.yield2(2) // Should be error - - with(this) { - yield(3) - this@with.yield(3) - - yield2(3) - this@with.yield2(3) - } - } - } - - buildSequence { - buildSequence { - yield("a") - yield2("a") - this.yield("b") - this.yield2("b") - - yield(1) // Should be error - yield2(1) // Should be error - - with(this) { - yield("") - this@with.yield("") - - yield2("") - this@with.yield2("") - } - } - } - - buildSequence a@{ - yield(1) - yield2(1) - buildSequence { - yield("") - yield2("") - this@a.yield(1) - this@a.yield2(1) - - with(this) { - yield("") - this@with.yield("") - - yield2("") - this@with.yield2("") - } - } - } - - buildSequence { - yield("") - RestrictedController().yield("1") - } -} diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendCoroutineUnavailableWithNewAPI.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendCoroutineUnavailableWithNewAPI.kt deleted file mode 100644 index 2e262aa0861..00000000000 --- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendCoroutineUnavailableWithNewAPI.kt +++ /dev/null @@ -1,16 +0,0 @@ -// FIR_IDENTICAL -// !API_VERSION: 1.1 -// !LANGUAGE: +Coroutines -ReleaseCoroutines -// SKIP_TXT - -import kotlin.coroutines.experimental.* -import kotlin.coroutines.experimental.intrinsics.* - -suspend fun foo(): Unit = suspendCoroutine { - it.resume(Unit) -} - -suspend fun bar(): Unit = suspendCoroutineOrReturn { - it.resume(Unit) - COROUTINE_SUSPENDED -} diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendCoroutineUnavailableWithOldAPI.fir.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendCoroutineUnavailableWithOldAPI.fir.kt deleted file mode 100644 index a7f1c382a1f..00000000000 --- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendCoroutineUnavailableWithOldAPI.fir.kt +++ /dev/null @@ -1,14 +0,0 @@ -// !API_VERSION: 1.0 -// SKIP_TXT - -import kotlin.coroutines.experimental.* -import kotlin.coroutines.experimental.intrinsics.* - -suspend fun foo(): Unit = suspendCoroutine { - it.resume(Unit) -} - -suspend fun bar(): Unit = suspendCoroutineUninterceptedOrReturn { - it.resume(Unit) - COROUTINE_SUSPENDED -} diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendCoroutineUnavailableWithOldAPI.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendCoroutineUnavailableWithOldAPI.kt deleted file mode 100644 index 88f8c40b79e..00000000000 --- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendCoroutineUnavailableWithOldAPI.kt +++ /dev/null @@ -1,14 +0,0 @@ -// !API_VERSION: 1.0 -// SKIP_TXT - -import kotlin.coroutines.experimental.* -import kotlin.coroutines.experimental.intrinsics.* - -suspend fun foo(): Unit = suspendCoroutine { - it.resume(Unit) -} - -suspend fun bar(): Unit = suspendCoroutineUninterceptedOrReturn { - it.resume(Unit) - COROUTINE_SUSPENDED -} diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/tailCalls/nothingTypedSuspendFunction_1_2.kt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/tailCalls/nothingTypedSuspendFunction_1_2.kt deleted file mode 100644 index 33258efbc9d..00000000000 --- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/tailCalls/nothingTypedSuspendFunction_1_2.kt +++ /dev/null @@ -1,10 +0,0 @@ -// FIR_IDENTICAL -// !DIAGNOSTICS: -DEPRECATION -// Tail calls are not allowed to be Nothing typed. See KT-15051 -import kotlin.coroutines.experimental.* -import kotlin.coroutines.experimental.intrinsics.* - -suspend fun suspendLogAndThrow(exception: Throwable): Nothing = suspendCoroutineUninterceptedOrReturn { c -> - c.resumeWithException(exception) - COROUTINE_SUSPENDED -} diff --git a/compiler/testData/diagnostics/testsWithStdLib/coroutines/tailCalls/nothingTypedSuspendFunction_1_2.txt b/compiler/testData/diagnostics/testsWithStdLib/coroutines/tailCalls/nothingTypedSuspendFunction_1_2.txt deleted file mode 100644 index 662ae2a6501..00000000000 --- a/compiler/testData/diagnostics/testsWithStdLib/coroutines/tailCalls/nothingTypedSuspendFunction_1_2.txt +++ /dev/null @@ -1,3 +0,0 @@ -package - -public suspend fun suspendLogAndThrow(/*0*/ exception: kotlin.Throwable): kotlin.Nothing diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java index 6d07fe643a5..6e09f40619a 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java @@ -32427,18 +32427,6 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendCoroutineOrReturn_1_2.kt"); } - @Test - @TestMetadata("suspendCoroutineUnavailableWithNewAPI.kt") - public void testSuspendCoroutineUnavailableWithNewAPI() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendCoroutineUnavailableWithNewAPI.kt"); - } - - @Test - @TestMetadata("suspendCoroutineUnavailableWithOldAPI.kt") - public void testSuspendCoroutineUnavailableWithOldAPI() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendCoroutineUnavailableWithOldAPI.kt"); - } - @Test @TestMetadata("suspendCovarianJavaOverride.kt") public void testSuspendCovarianJavaOverride() throws Exception { @@ -33006,18 +32994,6 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines/release"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } - @Test - @TestMetadata("coroutineContext.kt") - public void testCoroutineContext() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/release/coroutineContext.kt"); - } - - @Test - @TestMetadata("languageVersionIsNotEqualToApiVersion.kt") - public void testLanguageVersionIsNotEqualToApiVersion() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/release/languageVersionIsNotEqualToApiVersion.kt"); - } - @Test @TestMetadata("suspend.kt") public void testSuspend() throws Exception { @@ -33058,12 +33034,6 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/restrictSuspension/notRelatedFun.kt"); } - @Test - @TestMetadata("outerYield_1_2.kt") - public void testOuterYield_1_2() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/restrictSuspension/outerYield_1_2.kt"); - } - @Test @TestMetadata("outerYield_1_3.kt") public void testOuterYield_1_3() throws Exception { @@ -33204,12 +33174,6 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/tailCalls/localFunctions.kt"); } - @Test - @TestMetadata("nothingTypedSuspendFunction_1_2.kt") - public void testNothingTypedSuspendFunction_1_2() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/tailCalls/nothingTypedSuspendFunction_1_2.kt"); - } - @Test @TestMetadata("nothingTypedSuspendFunction_1_3.kt") public void testNothingTypedSuspendFunction_1_3() throws Exception { diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java index 33db9111fc8..2df1ed4ac7a 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java @@ -32331,18 +32331,6 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendCoroutineOrReturn_1_2.kt"); } - @Test - @TestMetadata("suspendCoroutineUnavailableWithNewAPI.kt") - public void testSuspendCoroutineUnavailableWithNewAPI() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendCoroutineUnavailableWithNewAPI.kt"); - } - - @Test - @TestMetadata("suspendCoroutineUnavailableWithOldAPI.kt") - public void testSuspendCoroutineUnavailableWithOldAPI() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/suspendCoroutineUnavailableWithOldAPI.kt"); - } - @Test @TestMetadata("suspendCovarianJavaOverride.kt") public void testSuspendCovarianJavaOverride() throws Exception { @@ -32910,18 +32898,6 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/coroutines/release"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); } - @Test - @TestMetadata("coroutineContext.kt") - public void testCoroutineContext() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/release/coroutineContext.kt"); - } - - @Test - @TestMetadata("languageVersionIsNotEqualToApiVersion.kt") - public void testLanguageVersionIsNotEqualToApiVersion() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/release/languageVersionIsNotEqualToApiVersion.kt"); - } - @Test @TestMetadata("suspend.kt") public void testSuspend() throws Exception { @@ -32962,12 +32938,6 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/restrictSuspension/notRelatedFun.kt"); } - @Test - @TestMetadata("outerYield_1_2.kt") - public void testOuterYield_1_2() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/restrictSuspension/outerYield_1_2.kt"); - } - @Test @TestMetadata("outerYield_1_3.kt") public void testOuterYield_1_3() throws Exception { @@ -33108,12 +33078,6 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/tailCalls/localFunctions.kt"); } - @Test - @TestMetadata("nothingTypedSuspendFunction_1_2.kt") - public void testNothingTypedSuspendFunction_1_2() throws Exception { - runTest("compiler/testData/diagnostics/testsWithStdLib/coroutines/tailCalls/nothingTypedSuspendFunction_1_2.kt"); - } - @Test @TestMetadata("nothingTypedSuspendFunction_1_3.kt") public void testNothingTypedSuspendFunction_1_3() throws Exception { From e7c4121e6785d1ac4cd7633066b4662ea3a23248 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Wed, 16 Dec 2020 11:17:01 +0300 Subject: [PATCH 126/196] [TEST] Add muting tests with .fail file for js box tests --- .../jetbrains/kotlin/js/test/BasicBoxTest.kt | 18 ++++++++++++++++-- 1 file changed, 16 insertions(+), 2 deletions(-) diff --git a/js/js.tests/test/org/jetbrains/kotlin/js/test/BasicBoxTest.kt b/js/js.tests/test/org/jetbrains/kotlin/js/test/BasicBoxTest.kt index 8360f5f456e..82c87d9937a 100644 --- a/js/js.tests/test/org/jetbrains/kotlin/js/test/BasicBoxTest.kt +++ b/js/js.tests/test/org/jetbrains/kotlin/js/test/BasicBoxTest.kt @@ -11,6 +11,7 @@ import com.intellij.openapi.util.text.StringUtil import com.intellij.openapi.vfs.StandardFileSystems import com.intellij.openapi.vfs.VirtualFileManager import com.intellij.psi.PsiManager +import com.intellij.testFramework.assertEqualsToFile import junit.framework.TestCase import org.jetbrains.kotlin.checkers.CompilerTestLanguageVersionSettings import org.jetbrains.kotlin.checkers.parseLanguageVersionSettings @@ -97,11 +98,24 @@ abstract class BasicBoxTest( protected open val testChecker get() = if (runTestInNashorn) NashornJsTestChecker else V8JsTestChecker fun doTest(filePath: String) { - doTest(filePath, "OK", MainCallParameters.noCall()) + doTestWithIgnoringByFailFile(filePath, coroutinesPackage = "") } fun doTestWithCoroutinesPackageReplacement(filePath: String, coroutinesPackage: String) { - doTest(filePath, "OK", MainCallParameters.noCall(), coroutinesPackage) + doTestWithIgnoringByFailFile(filePath, coroutinesPackage) + } + + fun doTestWithIgnoringByFailFile(filePath: String, coroutinesPackage: String) { + val failFile = File("$filePath.fail") + try { + doTest(filePath, "OK", MainCallParameters.noCall(), coroutinesPackage) + } catch (e: Throwable) { + if (failFile.exists()) { + KotlinTestUtils.assertEqualsToFile(failFile, e.message ?: "") + } else { + throw e + } + } } open fun doTest(filePath: String, expectedResult: String, mainCallParameters: MainCallParameters, coroutinesPackage: String = "") { From f2fa36f9cb2540760533016d0f89fda508afa2b6 Mon Sep 17 00:00:00 2001 From: Vladimir Dolzhenko Date: Wed, 16 Dec 2020 20:59:34 +0100 Subject: [PATCH 127/196] Split modules scan based if facedSettings can affect api/lang level of module ^KTIJ-249 Fixed Original commit: d280fb1fe466ef7b6ef7559067032033bedefd6e --- .../ui/KotlinConfigurationCheckerService.kt | 36 ++++++++++++++----- 1 file changed, 28 insertions(+), 8 deletions(-) diff --git a/idea/idea-jvm/src/org/jetbrains/kotlin/idea/configuration/ui/KotlinConfigurationCheckerService.kt b/idea/idea-jvm/src/org/jetbrains/kotlin/idea/configuration/ui/KotlinConfigurationCheckerService.kt index d3e17be07aa..14abf04fd10 100644 --- a/idea/idea-jvm/src/org/jetbrains/kotlin/idea/configuration/ui/KotlinConfigurationCheckerService.kt +++ b/idea/idea-jvm/src/org/jetbrains/kotlin/idea/configuration/ui/KotlinConfigurationCheckerService.kt @@ -20,6 +20,7 @@ import com.intellij.notification.NotificationDisplayType import com.intellij.notification.NotificationsConfiguration import com.intellij.openapi.application.runReadAction import com.intellij.openapi.externalSystem.service.project.manage.ProjectDataImportListener +import com.intellij.openapi.module.Module import com.intellij.openapi.progress.ProgressIndicator import com.intellij.openapi.progress.ProgressManager import com.intellij.openapi.progress.Task @@ -27,8 +28,10 @@ import com.intellij.openapi.project.Project import com.intellij.openapi.startup.StartupActivity import com.intellij.psi.search.FileTypeIndex import com.intellij.psi.search.GlobalSearchScope +import org.jetbrains.kotlin.config.KotlinFacetSettingsProvider import org.jetbrains.kotlin.idea.KotlinFileType import org.jetbrains.kotlin.idea.KotlinJvmBundle +import org.jetbrains.kotlin.idea.compiler.configuration.Kotlin2JvmCompilerArgumentsHolder import org.jetbrains.kotlin.idea.configuration.notifyOutdatedBundledCompilerIfNecessary import org.jetbrains.kotlin.idea.configuration.ui.notifications.notifyKotlinStyleUpdateIfNeeded import org.jetbrains.kotlin.idea.project.getAndCacheLanguageLevelByDependencies @@ -74,16 +77,33 @@ class KotlinConfigurationCheckerService(val project: Project) { val totalModules = modules.size - for ((index, module) in modules.withIndex()) { - indicator.fraction = index * 1.0 / totalModules + project.runReadActionInSmartMode { + val facetSettingsProvider = KotlinFacetSettingsProvider.getInstance(project) ?: return@runReadActionInSmartMode - val anyKotlinFileInModule = project.runReadActionInSmartMode { - !project.isDisposed && !module.isDisposed - && FileTypeIndex.containsFileOfType(KotlinFileType.INSTANCE, module.getModuleScope(true)) + var referenceModuleWithUseProjectSettings: Module? = null + val filteredModules = modules.withIndex().filter { + indicator.checkCanceled() + indicator.fraction = (it.index / (2.0 * totalModules)) + val facetSettings = facetSettingsProvider.getInitializedSettings(it.value) + val useProjectSettings = facetSettings.useProjectSettings + if (useProjectSettings) { + referenceModuleWithUseProjectSettings = it.value + } + !useProjectSettings } - if (anyKotlinFileInModule) { - indicator.text2 = KotlinJvmBundle.message("configure.kotlin.language.settings.0.module", module.name) - runReadAction { + + referenceModuleWithUseProjectSettings?.getAndCacheLanguageLevelByDependencies() + + for ((index, module) in filteredModules) { + indicator.checkCanceled() + indicator.fraction = 0.5 + (index / (2.0 * filteredModules.size)) + + val anyKotlinFileInModule = + !project.isDisposed && !module.isDisposed + && FileTypeIndex.containsFileOfType(KotlinFileType.INSTANCE, module.getModuleScope(true)) + + if (anyKotlinFileInModule) { + indicator.text2 = KotlinJvmBundle.message("configure.kotlin.language.settings.0.module", module.name) module.getAndCacheLanguageLevelByDependencies() } } From 8974d31bb8b3529968029961f2a23357e563c1ac Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Thu, 17 Dec 2020 00:33:10 +0300 Subject: [PATCH 128/196] [TEST] Fix problem with line separator on windows --- .../kotlin/test/services/impl/ModuleStructureExtractorImpl.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/impl/ModuleStructureExtractorImpl.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/impl/ModuleStructureExtractorImpl.kt index 3842cf57d23..e2724ea52a7 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/impl/ModuleStructureExtractorImpl.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/impl/ModuleStructureExtractorImpl.kt @@ -257,7 +257,7 @@ class ModuleStructureExtractorImpl( filesOfCurrentModule.add( TestFile( relativePath = filename, - originalContent = linesOfCurrentFile.joinToString(separator = System.lineSeparator(), postfix = System.lineSeparator()), + originalContent = linesOfCurrentFile.joinToString(separator = "\n", postfix = "\n"), originalFile = currentTestDataFile, startLineNumberInOriginalFile = startLineNumberOfCurrentFile, isAdditional = false From f597343d822110d255b784080cf8d43bc6613216 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Thu, 17 Dec 2020 00:33:17 +0300 Subject: [PATCH 129/196] [TEST] Fix testdata --- .../annotations/jvmStatic/privateCompanionObject.kt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/privateCompanionObject.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/privateCompanionObject.kt index 7a809f942eb..da777684ae4 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/privateCompanionObject.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmStatic/privateCompanionObject.kt @@ -1,5 +1,5 @@ -// Issue: KT-25114 // FIR_IDENTICAL +// Issue: KT-25114 // !DIAGNOSTICS: -UNUSED_PARAMETER class WithPrivateCompanion { @@ -27,4 +27,4 @@ class WithPrivateCompanion { @JvmStatic fun staticFunction() {} } -} \ No newline at end of file +} From 03693e3d5a75505d4afde41ec3ecfad95518989c Mon Sep 17 00:00:00 2001 From: Igor Chevdar Date: Mon, 16 Nov 2020 20:45:48 +0500 Subject: [PATCH 130/196] [klib] Optimized away some Files.exists() --- .../kotlin/library/SearchPathResolver.kt | 6 ++++-- .../kotlin/library/impl/KotlinLibraryImpl.kt | 15 ++++++++------- 2 files changed, 12 insertions(+), 9 deletions(-) diff --git a/compiler/util-klib/src/org/jetbrains/kotlin/library/SearchPathResolver.kt b/compiler/util-klib/src/org/jetbrains/kotlin/library/SearchPathResolver.kt index d82138c6964..2b83dec7ee0 100644 --- a/compiler/util-klib/src/org/jetbrains/kotlin/library/SearchPathResolver.kt +++ b/compiler/util-klib/src/org/jetbrains/kotlin/library/SearchPathResolver.kt @@ -54,8 +54,10 @@ abstract class KotlinLibrarySearchPathResolver( (listOf(currentDirHead) + repoRoots + listOf(localHead, distHead, distPlatformHead)).filterNotNull() } + private val files: Set by lazy { searchRoots.flatMap { it.listFilesOrEmpty }.map { it.absolutePath }.toSet() } + private fun found(candidate: File): File? { - fun check(file: File): Boolean = file.exists + fun check(file: File): Boolean = files.contains(file.absolutePath) || file.exists val noSuffix = File(candidate.path.removeSuffixIfPresent(KLIB_FILE_EXTENSION_WITH_DOT)) val withSuffix = File(candidate.path.suffixIfNot(KLIB_FILE_EXTENSION_WITH_DOT)) @@ -292,4 +294,4 @@ class CompilerSingleFileKlibResolveAllowingIrProvidersStrategy( SingleKlibComponentResolver( libraryFile.absolutePath, logger, knownIrProviders ).resolve(libraryFile.absolutePath) -} \ No newline at end of file +} diff --git a/compiler/util-klib/src/org/jetbrains/kotlin/library/impl/KotlinLibraryImpl.kt b/compiler/util-klib/src/org/jetbrains/kotlin/library/impl/KotlinLibraryImpl.kt index cb1f37e905e..ed38e7e9599 100644 --- a/compiler/util-klib/src/org/jetbrains/kotlin/library/impl/KotlinLibraryImpl.kt +++ b/compiler/util-klib/src/org/jetbrains/kotlin/library/impl/KotlinLibraryImpl.kt @@ -28,20 +28,21 @@ open class BaseKotlinLibraryImpl( override val libraryFile get() = access.klib override val libraryName: String by lazy { access.inPlace { it.libraryName } } - override val componentList: List by lazy { - access.inPlace { - it.libDir.listFiles + private val componentListAndHasPre14Manifest by lazy { + access.inPlace { layout -> + val listFiles = layout.libDir.listFiles + listFiles .filter { it.isDirectory } .filter { it.listFiles.map { it.name }.contains(KLIB_MANIFEST_FILE_NAME) } - .map { it.name } + .map { it.name } to listFiles.any { it.absolutePath == layout.pre_1_4_manifest.absolutePath } } } + override val componentList: List get() = componentListAndHasPre14Manifest.first + override fun toString() = "$libraryName[default=$isDefault]" - override val has_pre_1_4_manifest: Boolean by lazy { - access.inPlace { it.pre_1_4_manifest.exists } - } + override val has_pre_1_4_manifest: Boolean get() = componentListAndHasPre14Manifest.second override val manifestProperties: Properties by lazy { access.inPlace { it.manifestFile.loadProperties() } From be688356c96e7227489d0ab581d40d3cbbf4a32c Mon Sep 17 00:00:00 2001 From: Igor Chevdar Date: Wed, 16 Dec 2020 18:39:09 +0500 Subject: [PATCH 131/196] [IR] Fixed bug with thread unsafety There is no need in a singleton here --- .../src/org/jetbrains/kotlin/backend/common/ir/IrUtils.kt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/IrUtils.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/IrUtils.kt index 49487090bcd..9ea06bc92a7 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/IrUtils.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/IrUtils.kt @@ -466,7 +466,7 @@ val IrFunction.allParametersCount: Int // This is essentially the same as FakeOverrideBuilder, // but it bypasses SymbolTable. // TODO: merge it with FakeOverrideBuilder. -private object FakeOverrideBuilderForLowerings : FakeOverrideBuilderStrategy() { +private class FakeOverrideBuilderForLowerings : FakeOverrideBuilderStrategy() { override fun linkFunctionFakeOverride(declaration: IrFakeOverrideFunction) { declaration.acquireSymbol(IrSimpleFunctionSymbolImpl(WrappedSimpleFunctionDescriptor())) @@ -491,7 +491,7 @@ private object FakeOverrideBuilderForLowerings : FakeOverrideBuilderStrategy() { } fun IrClass.addFakeOverrides(irBuiltIns: IrBuiltIns, implementedMembers: List = emptyList()) { - IrOverridingUtil(irBuiltIns, FakeOverrideBuilderForLowerings) + IrOverridingUtil(irBuiltIns, FakeOverrideBuilderForLowerings()) .buildFakeOverridesForClassUsingOverriddenSymbols(this, implementedMembers) .forEach { addChild(it) } } From 43c04dfd08626da1ab3076ce6c58d335dd42cdb0 Mon Sep 17 00:00:00 2001 From: Ilya Gorbunov Date: Mon, 14 Dec 2020 18:41:14 +0300 Subject: [PATCH 132/196] [Wasm] Publish stdlib: remove separate project --- libraries/stdlib/wasm/build.gradle.kts | 38 ++++++++++++++++++- .../stdlib/wasm/publish/build.gradle.kts | 11 ------ settings.gradle | 2 - 3 files changed, 37 insertions(+), 14 deletions(-) delete mode 100644 libraries/stdlib/wasm/publish/build.gradle.kts diff --git a/libraries/stdlib/wasm/build.gradle.kts b/libraries/stdlib/wasm/build.gradle.kts index 5de782a3139..03bd4ea877d 100644 --- a/libraries/stdlib/wasm/build.gradle.kts +++ b/libraries/stdlib/wasm/build.gradle.kts @@ -1,9 +1,12 @@ import org.jetbrains.kotlin.gradle.dsl.KotlinCompile plugins { + `maven-publish` kotlin("multiplatform") } +description = "Kotlin Standard Library for experimental WebAssembly platform" + val unimplementedNativeBuiltIns = (file("$rootDir/core/builtins/native/kotlin/").list().toSortedSet() - file("$rootDir/libraries/stdlib/wasm/builtins/kotlin/").list()) .map { "core/builtins/native/kotlin/$it" } @@ -83,4 +86,37 @@ tasks.named("compileKotlinJs") { (this as KotlinCompile<*>).kotlinOptions.freeCompilerArgs += "-Xir-module-name=kotlin" dependsOn(commonMainSources) dependsOn(builtInsSources) -} \ No newline at end of file +} + +val runtimeElements by configurations.creating {} +val apiElements by configurations.creating {} + +publish { + pom.packaging = "klib" + artifact(tasks.named("jsJar")) { + extension = "klib" + } +} + +afterEvaluate { + // cleanup default publications + // TODO: remove after mpp plugin allows avoiding their creation at all, KT-29273 + publishing { + publications.removeAll { it.name != "Main" } + } + + tasks.withType { + if (publication.name != "Main") this.enabled = false + } + + tasks.named("publish") { + doFirst { + publishing.publications { + if (singleOrNull()?.name != "Main") { + throw GradleException("kotlin-stdlib-wasm should have only one publication, found $size: ${joinToString { it.name }}") + } + } + } + } +} + diff --git a/libraries/stdlib/wasm/publish/build.gradle.kts b/libraries/stdlib/wasm/publish/build.gradle.kts deleted file mode 100644 index 0480de65bc9..00000000000 --- a/libraries/stdlib/wasm/publish/build.gradle.kts +++ /dev/null @@ -1,11 +0,0 @@ -description = "Kotlin Standard Library for experimental WebAssembly platform" - -// Using separate project to publish a single klib from multiplatform build - -publish { - artifactId = "kotlin-stdlib-wasm" - pom.packaging = "klib" - artifact(tasks.getByPath(":kotlin-stdlib-wasm:jsJar")) { - extension = "klib" - } -} diff --git a/settings.gradle b/settings.gradle index 08f6a951e28..01a97906baa 100644 --- a/settings.gradle +++ b/settings.gradle @@ -405,7 +405,6 @@ if (buildProperties.inJpsBuildIdeaSync) { ":kotlin-stdlib-js-ir", ":kotlin-stdlib-js-ir-minimal-for-test", ":kotlin-stdlib-wasm", - ":kotlin-stdlib-wasm-publish", ":kotlin-stdlib-jdk7", ":kotlin-stdlib-jdk8", ":kotlin-stdlib:samples", @@ -424,7 +423,6 @@ if (buildProperties.inJpsBuildIdeaSync) { project(':kotlin-stdlib-js').projectDir = "$rootDir/libraries/stdlib/js-v1" as File project(':kotlin-stdlib-js-ir').projectDir = "$rootDir/libraries/stdlib/js-ir" as File project(':kotlin-stdlib-wasm').projectDir = "$rootDir/libraries/stdlib/wasm" as File - project(':kotlin-stdlib-wasm-publish').projectDir = "$rootDir/libraries/stdlib/wasm/publish" as File project(':kotlin-stdlib-js-ir-minimal-for-test').projectDir = "$rootDir/libraries/stdlib/js-ir-minimal-for-test" as File project(':kotlin-stdlib-jdk7').projectDir = "$rootDir/libraries/stdlib/jdk7" as File project(':kotlin-stdlib-jdk8').projectDir = "$rootDir/libraries/stdlib/jdk8" as File From 88a0fe7ec19363fec03fd84163a4cc704d2967aa Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Thu, 19 Nov 2020 17:31:48 +0300 Subject: [PATCH 133/196] Make a longer description for Kotlin Android plugin Try to overcome `Plugin description must not be generic, please elaborate.` from the Gradle plugin portal. --- libraries/tools/kotlin-gradle-plugin/build.gradle.kts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libraries/tools/kotlin-gradle-plugin/build.gradle.kts b/libraries/tools/kotlin-gradle-plugin/build.gradle.kts index df29e83b625..6be5e333150 100644 --- a/libraries/tools/kotlin-gradle-plugin/build.gradle.kts +++ b/libraries/tools/kotlin-gradle-plugin/build.gradle.kts @@ -190,7 +190,7 @@ pluginBundle { create( name = "kotlinAndroidPlugin", id = "org.jetbrains.kotlin.android", - display = "Android" + display = "Kotlin Android plugin" ) create( name = "kotlinAndroidExtensionsPlugin", From efc7ab5023798c447ecc14488bedb4980660bfdf Mon Sep 17 00:00:00 2001 From: Andrei Klunnyi Date: Thu, 17 Dec 2020 19:01:49 +0100 Subject: [PATCH 134/196] KTIJ-664 [SealedClassInheritorsProvider]: test fixes --- idea/testData/checker/WhenNonExhaustive.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/idea/testData/checker/WhenNonExhaustive.kt b/idea/testData/checker/WhenNonExhaustive.kt index 35683853d4a..f14534fed71 100644 --- a/idea/testData/checker/WhenNonExhaustive.kt +++ b/idea/testData/checker/WhenNonExhaustive.kt @@ -49,7 +49,7 @@ sealed class Variant { object Another : Variant() } -fun nonExhaustiveSealed(v: Variant) = when(v) { +fun nonExhaustiveSealed(v: Variant) = when(v) { Variant.Singleton -> false } From 27ebb6c946b7ed20efd46793441d291a864a8ab4 Mon Sep 17 00:00:00 2001 From: Andrei Klunnyi Date: Thu, 17 Dec 2020 15:45:28 +0100 Subject: [PATCH 135/196] KTIJ-650 [Code completion]: test framework fix This commit fixes test infrastructure issue. Usage of "COMPILER_ARGUMENTS" test-data-instruction resulted in side effect. Test cases following the one that used it got broken LanguageVersionSetting - LanguageFeature.MultiPlatformProjects escaped, languageVersion could be wrong. Why it happened KotlinProjectDescriptorWithFacet defines default values of (language-version, isMultiplatform) settings for the test-case. The values themselves are stored in KotlinFacetSettings and passed there only once. After every test-case (if it uses "COMPILER_ARGUMENTS") infrastructure calls KotlinLightCodeInsightFixtureTestCaseKt#rollbackCompilerOptions which resets mentioned values (among others) in KotlinFacetSettings. Instances of KotlinProjectDescriptorWithFacet are reused hence facet settings remained reset. --- .../test/AbstractKeywordCompletionTest.kt | 6 ++--- .../test/KotlinProjectDescriptorWithFacet.kt | 22 ++++++++++++++----- 2 files changed, 20 insertions(+), 8 deletions(-) diff --git a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/AbstractKeywordCompletionTest.kt b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/AbstractKeywordCompletionTest.kt index 321bef33521..2111c99ed0b 100644 --- a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/AbstractKeywordCompletionTest.kt +++ b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/AbstractKeywordCompletionTest.kt @@ -23,9 +23,9 @@ abstract class AbstractKeywordCompletionTest : KotlinFixtureCompletionBaseTestCa } override fun getProjectDescriptor(): KotlinLightProjectDescriptor = when { - "LangLevel10" in fileName() -> KotlinProjectDescriptorWithFacet.KOTLIN_10 - "LangLevel11" in fileName() -> KotlinProjectDescriptorWithFacet.KOTLIN_11 - else -> KotlinProjectDescriptorWithFacet.KOTLIN_STABLE_WITH_MULTIPLATFORM + "LangLevel10" in fileName() -> KotlinProjectDescriptorWithFacet.KOTLIN_10.apply { replicateToFacetSettings() } + "LangLevel11" in fileName() -> KotlinProjectDescriptorWithFacet.KOTLIN_11.apply { replicateToFacetSettings() } + else -> KotlinProjectDescriptorWithFacet.KOTLIN_STABLE_WITH_MULTIPLATFORM.apply { replicateToFacetSettings() } } override fun defaultInvocationCount() = 1 diff --git a/idea/idea-test-framework/test/org/jetbrains/kotlin/idea/test/KotlinProjectDescriptorWithFacet.kt b/idea/idea-test-framework/test/org/jetbrains/kotlin/idea/test/KotlinProjectDescriptorWithFacet.kt index c7d83284686..0eca6dd6eac 100644 --- a/idea/idea-test-framework/test/org/jetbrains/kotlin/idea/test/KotlinProjectDescriptorWithFacet.kt +++ b/idea/idea-test-framework/test/org/jetbrains/kotlin/idea/test/KotlinProjectDescriptorWithFacet.kt @@ -30,13 +30,25 @@ class KotlinProjectDescriptorWithFacet( private val languageVersion: LanguageVersion, private val multiPlatform: Boolean = false ) : KotlinLightProjectDescriptor() { + + private var facetConfig: KotlinFacetConfiguration? = null + override fun configureModule(module: Module, model: ModifiableRootModel, contentEntry: ContentEntry) { configureKotlinFacet(module) { - settings.languageLevel = languageVersion - if (multiPlatform) { - settings.compilerSettings = CompilerSettings().apply { - additionalArguments += " -Xmulti-platform" - } + facetConfig = this + toFacetConfig(this) + } + } + + fun replicateToFacetSettings() { + facetConfig?.let { toFacetConfig(it) } + } + + private fun toFacetConfig(configuration: KotlinFacetConfiguration) { + configuration.settings.languageLevel = languageVersion + if (multiPlatform) { + configuration.settings.compilerSettings = CompilerSettings().apply { + additionalArguments += " -Xmulti-platform" } } } From 3eb0745b58f1c35834e361d112c5a5b1053edc66 Mon Sep 17 00:00:00 2001 From: Andrei Klunnyi Date: Thu, 17 Dec 2020 15:46:17 +0100 Subject: [PATCH 136/196] KTIJ-650 [Code completion]: "sealed interface" is for 1.5+ only --- .../org/jetbrains/kotlin/idea/completion/KeywordCompletion.kt | 2 ++ idea/idea-completion/testData/keywords/AfterClassProperty.kt | 2 ++ idea/idea-completion/testData/keywords/AfterClasses.kt | 2 ++ .../testData/keywords/AfterClasses_LangLevel10.kt | 2 -- .../testData/keywords/AfterClasses_LangLevel11.kt | 2 -- idea/idea-completion/testData/keywords/AfterFuns.kt | 2 ++ .../testData/keywords/GlobalPropertyAccessors.kt | 2 ++ .../idea-completion/testData/keywords/InAnnotationClassScope.kt | 2 ++ idea/idea-completion/testData/keywords/InClassBeforeFun.kt | 2 ++ idea/idea-completion/testData/keywords/InClassScope.kt | 2 ++ idea/idea-completion/testData/keywords/InEnumScope2.kt | 2 ++ idea/idea-completion/testData/keywords/InInterfaceScope.kt | 2 ++ idea/idea-completion/testData/keywords/InObjectScope.kt | 2 ++ .../idea-completion/testData/keywords/InTopScopeAfterPackage.kt | 2 ++ idea/idea-completion/testData/keywords/PropertyAccessors.kt | 2 ++ idea/idea-completion/testData/keywords/PropertyAccessors2.kt | 2 ++ idea/idea-completion/testData/keywords/PropertySetter.kt | 2 ++ idea/idea-completion/testData/keywords/SealedWithName.kt | 2 ++ idea/idea-completion/testData/keywords/SealedWithoutName.kt | 2 ++ idea/idea-completion/testData/keywords/TopScope.kt | 2 ++ idea/idea-completion/testData/keywords/TopScope3-.kt | 2 ++ idea/idea-completion/testData/keywords/topScope2.kt | 2 ++ 22 files changed, 40 insertions(+), 4 deletions(-) diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KeywordCompletion.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KeywordCompletion.kt index 9317092d4fe..3e5c75b2491 100644 --- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KeywordCompletion.kt +++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KeywordCompletion.kt @@ -122,11 +122,13 @@ object KeywordCompletion { fun complete(position: PsiElement, prefixMatcher: PrefixMatcher, isJvmModule: Boolean, consumer: (LookupElement) -> Unit) { if (!GENERAL_FILTER.isAcceptable(position, position)) return + val sealedInterfacesEnabled = position.languageVersionSettings.supportsFeature(LanguageFeature.SealedInterfaces) val parserFilter = buildFilter(position) for (keywordToken in ALL_KEYWORDS) { val nextKeywords = keywordToken.getNextPossibleKeywords(position) ?: setOf(null) nextKeywords.forEach { + if (keywordToken == SEALED_KEYWORD && it == INTERFACE_KEYWORD && !sealedInterfacesEnabled) return@forEach handleCompoundKeyword(position, keywordToken, it, isJvmModule, prefixMatcher, parserFilter, consumer) } } diff --git a/idea/idea-completion/testData/keywords/AfterClassProperty.kt b/idea/idea-completion/testData/keywords/AfterClassProperty.kt index 788cee4e10a..cb2c81431a1 100644 --- a/idea/idea-completion/testData/keywords/AfterClassProperty.kt +++ b/idea/idea-completion/testData/keywords/AfterClassProperty.kt @@ -1,3 +1,5 @@ +// COMPILER_ARGUMENTS: -XXLanguage:+SealedInterfaces -XXLanguage:+MultiPlatformProjects + class MouseMovedEventArgs { public val X : Int = 0 diff --git a/idea/idea-completion/testData/keywords/AfterClasses.kt b/idea/idea-completion/testData/keywords/AfterClasses.kt index 6d16b266393..9a68457c1bc 100644 --- a/idea/idea-completion/testData/keywords/AfterClasses.kt +++ b/idea/idea-completion/testData/keywords/AfterClasses.kt @@ -1,3 +1,5 @@ +// COMPILER_ARGUMENTS: -XXLanguage:+SealedInterfaces -XXLanguage:+MultiPlatformProjects + class A { fun foo() { bar() diff --git a/idea/idea-completion/testData/keywords/AfterClasses_LangLevel10.kt b/idea/idea-completion/testData/keywords/AfterClasses_LangLevel10.kt index d6dd4d72438..17727796838 100644 --- a/idea/idea-completion/testData/keywords/AfterClasses_LangLevel10.kt +++ b/idea/idea-completion/testData/keywords/AfterClasses_LangLevel10.kt @@ -33,8 +33,6 @@ class B { // EXIST: infix // EXIST: sealed class // EXIST: sealed class AfterClasses_LangLevel10 -// EXIST: sealed interface AfterClasses_LangLevel10 -// EXIST: sealed interface // EXIST: data class // EXIST: { "lookupString":"data class", "itemText":"data class", "tailText":" AfterClasses_LangLevel10(...)", "attributes":"bold" } // EXIST: inline diff --git a/idea/idea-completion/testData/keywords/AfterClasses_LangLevel11.kt b/idea/idea-completion/testData/keywords/AfterClasses_LangLevel11.kt index 7263e242a82..24bbfe25aad 100644 --- a/idea/idea-completion/testData/keywords/AfterClasses_LangLevel11.kt +++ b/idea/idea-completion/testData/keywords/AfterClasses_LangLevel11.kt @@ -33,8 +33,6 @@ class B { // EXIST: infix // EXIST: sealed class // EXIST: sealed class AfterClasses_LangLevel11 -// EXIST: sealed interface AfterClasses_LangLevel11 -// EXIST: sealed interface // EXIST: data class // EXIST: { "lookupString":"data class", "itemText":"data class", "tailText":" AfterClasses_LangLevel11(...)", "attributes":"bold" } // EXIST: inline diff --git a/idea/idea-completion/testData/keywords/AfterFuns.kt b/idea/idea-completion/testData/keywords/AfterFuns.kt index 3f915220f47..6b35b3680da 100644 --- a/idea/idea-completion/testData/keywords/AfterFuns.kt +++ b/idea/idea-completion/testData/keywords/AfterFuns.kt @@ -1,3 +1,5 @@ +// COMPILER_ARGUMENTS: -XXLanguage:+SealedInterfaces -XXLanguage:+MultiPlatformProjects + class A { fun foo() { bar() diff --git a/idea/idea-completion/testData/keywords/GlobalPropertyAccessors.kt b/idea/idea-completion/testData/keywords/GlobalPropertyAccessors.kt index ab7873fa77e..fe02a7cc9c2 100644 --- a/idea/idea-completion/testData/keywords/GlobalPropertyAccessors.kt +++ b/idea/idea-completion/testData/keywords/GlobalPropertyAccessors.kt @@ -1,3 +1,5 @@ +// COMPILER_ARGUMENTS: -XXLanguage:+SealedInterfaces -XXLanguage:+MultiPlatformProjects + fun foo() { bar() } diff --git a/idea/idea-completion/testData/keywords/InAnnotationClassScope.kt b/idea/idea-completion/testData/keywords/InAnnotationClassScope.kt index cc49effaff9..35d9db37c7f 100644 --- a/idea/idea-completion/testData/keywords/InAnnotationClassScope.kt +++ b/idea/idea-completion/testData/keywords/InAnnotationClassScope.kt @@ -1,3 +1,5 @@ +// COMPILER_ARGUMENTS: -XXLanguage:+SealedInterfaces -XXLanguage:+MultiPlatformProjects + annotation class Test { } diff --git a/idea/idea-completion/testData/keywords/InClassBeforeFun.kt b/idea/idea-completion/testData/keywords/InClassBeforeFun.kt index ebc5751c42d..27161fe28ae 100644 --- a/idea/idea-completion/testData/keywords/InClassBeforeFun.kt +++ b/idea/idea-completion/testData/keywords/InClassBeforeFun.kt @@ -1,3 +1,5 @@ +// COMPILER_ARGUMENTS: -XXLanguage:+SealedInterfaces -XXLanguage:+MultiPlatformProjects + public class Test { diff --git a/idea/idea-completion/testData/keywords/InClassScope.kt b/idea/idea-completion/testData/keywords/InClassScope.kt index de5a03acfe6..863eb38b6ca 100644 --- a/idea/idea-completion/testData/keywords/InClassScope.kt +++ b/idea/idea-completion/testData/keywords/InClassScope.kt @@ -1,3 +1,5 @@ +// COMPILER_ARGUMENTS: -XXLanguage:+SealedInterfaces -XXLanguage:+MultiPlatformProjects + class TestClass { } diff --git a/idea/idea-completion/testData/keywords/InEnumScope2.kt b/idea/idea-completion/testData/keywords/InEnumScope2.kt index 2251838ea0f..f21931454f6 100644 --- a/idea/idea-completion/testData/keywords/InEnumScope2.kt +++ b/idea/idea-completion/testData/keywords/InEnumScope2.kt @@ -1,3 +1,5 @@ +// COMPILER_ARGUMENTS: -XXLanguage:+SealedInterfaces -XXLanguage:+MultiPlatformProjects + enum class Test { ; diff --git a/idea/idea-completion/testData/keywords/InInterfaceScope.kt b/idea/idea-completion/testData/keywords/InInterfaceScope.kt index 11689d4e8de..b553f51cdb0 100644 --- a/idea/idea-completion/testData/keywords/InInterfaceScope.kt +++ b/idea/idea-completion/testData/keywords/InInterfaceScope.kt @@ -1,3 +1,5 @@ +// COMPILER_ARGUMENTS: -XXLanguage:+SealedInterfaces -XXLanguage:+MultiPlatformProjects + interface Test { } diff --git a/idea/idea-completion/testData/keywords/InObjectScope.kt b/idea/idea-completion/testData/keywords/InObjectScope.kt index 8f8fc86717b..291e5607b94 100644 --- a/idea/idea-completion/testData/keywords/InObjectScope.kt +++ b/idea/idea-completion/testData/keywords/InObjectScope.kt @@ -1,3 +1,5 @@ +// COMPILER_ARGUMENTS: -XXLanguage:+SealedInterfaces -XXLanguage:+MultiPlatformProjects + object Test { } diff --git a/idea/idea-completion/testData/keywords/InTopScopeAfterPackage.kt b/idea/idea-completion/testData/keywords/InTopScopeAfterPackage.kt index 282b0c8d8df..e3c85bb5a96 100644 --- a/idea/idea-completion/testData/keywords/InTopScopeAfterPackage.kt +++ b/idea/idea-completion/testData/keywords/InTopScopeAfterPackage.kt @@ -1,3 +1,5 @@ +// COMPILER_ARGUMENTS: -XXLanguage:+SealedInterfaces -XXLanguage:+MultiPlatformProjects + package Test diff --git a/idea/idea-completion/testData/keywords/PropertyAccessors.kt b/idea/idea-completion/testData/keywords/PropertyAccessors.kt index 8a6e6ace135..f52b8114536 100644 --- a/idea/idea-completion/testData/keywords/PropertyAccessors.kt +++ b/idea/idea-completion/testData/keywords/PropertyAccessors.kt @@ -1,3 +1,5 @@ +// COMPILER_ARGUMENTS: -XXLanguage:+SealedInterfaces -XXLanguage:+MultiPlatformProjects + class Some { var a : Int diff --git a/idea/idea-completion/testData/keywords/PropertyAccessors2.kt b/idea/idea-completion/testData/keywords/PropertyAccessors2.kt index 269f3f45e15..31e4eb9ae7f 100644 --- a/idea/idea-completion/testData/keywords/PropertyAccessors2.kt +++ b/idea/idea-completion/testData/keywords/PropertyAccessors2.kt @@ -1,3 +1,5 @@ +// COMPILER_ARGUMENTS: -XXLanguage:+SealedInterfaces -XXLanguage:+MultiPlatformProjects + class Some { var a : Int = 1 diff --git a/idea/idea-completion/testData/keywords/PropertySetter.kt b/idea/idea-completion/testData/keywords/PropertySetter.kt index f950db00539..fc6e6b730b2 100644 --- a/idea/idea-completion/testData/keywords/PropertySetter.kt +++ b/idea/idea-completion/testData/keywords/PropertySetter.kt @@ -1,3 +1,5 @@ +// COMPILER_ARGUMENTS: -XXLanguage:+SealedInterfaces -XXLanguage:+MultiPlatformProjects + class Some { var a : Int get() = 0 diff --git a/idea/idea-completion/testData/keywords/SealedWithName.kt b/idea/idea-completion/testData/keywords/SealedWithName.kt index 345a354e786..5487c20aaab 100644 --- a/idea/idea-completion/testData/keywords/SealedWithName.kt +++ b/idea/idea-completion/testData/keywords/SealedWithName.kt @@ -1,3 +1,5 @@ +// COMPILER_ARGUMENTS: -XXLanguage:+SealedInterfaces -XXLanguage:+MultiPlatformProjects + seal // EXIST: "sealed class SealedWithName" // EXIST: "sealed interface SealedWithName" diff --git a/idea/idea-completion/testData/keywords/SealedWithoutName.kt b/idea/idea-completion/testData/keywords/SealedWithoutName.kt index de4abff9998..8bef92d7f4e 100644 --- a/idea/idea-completion/testData/keywords/SealedWithoutName.kt +++ b/idea/idea-completion/testData/keywords/SealedWithoutName.kt @@ -1,3 +1,5 @@ +// COMPILER_ARGUMENTS: -XXLanguage:+SealedInterfaces -XXLanguage:+MultiPlatformProjects + class OuterClass { seal } diff --git a/idea/idea-completion/testData/keywords/TopScope.kt b/idea/idea-completion/testData/keywords/TopScope.kt index 47b03855278..6b8ea73b427 100644 --- a/idea/idea-completion/testData/keywords/TopScope.kt +++ b/idea/idea-completion/testData/keywords/TopScope.kt @@ -1,3 +1,5 @@ +// COMPILER_ARGUMENTS: -XXLanguage:+SealedInterfaces -XXLanguage:+MultiPlatformProjects + // EXIST: abstract diff --git a/idea/idea-completion/testData/keywords/TopScope3-.kt b/idea/idea-completion/testData/keywords/TopScope3-.kt index 63e8eaf6465..fd56753c3b5 100644 --- a/idea/idea-completion/testData/keywords/TopScope3-.kt +++ b/idea/idea-completion/testData/keywords/TopScope3-.kt @@ -1,3 +1,5 @@ +// COMPILER_ARGUMENTS: -XXLanguage:+SealedInterfaces -XXLanguage:+MultiPlatformProjects + // EXIST: abstract diff --git a/idea/idea-completion/testData/keywords/topScope2.kt b/idea/idea-completion/testData/keywords/topScope2.kt index 63e8eaf6465..fd56753c3b5 100644 --- a/idea/idea-completion/testData/keywords/topScope2.kt +++ b/idea/idea-completion/testData/keywords/topScope2.kt @@ -1,3 +1,5 @@ +// COMPILER_ARGUMENTS: -XXLanguage:+SealedInterfaces -XXLanguage:+MultiPlatformProjects + // EXIST: abstract From 4f96f9d6a17a9fe44575792131680106ab04ca64 Mon Sep 17 00:00:00 2001 From: Shagen Ogandzhanian Date: Fri, 18 Dec 2020 01:54:01 +0100 Subject: [PATCH 137/196] [JS IR] Initialize enum fields before accessing them in companion object see https://youtrack.jetbrains.com/issue/KT-43901 --- .../ir/FirBlackBoxCodegenTestGenerated.java | 5 +++ .../ir/backend/js/lower/EnumClassLowering.kt | 26 ++++++++------ .../lower/InvokeStaticInitializersLowering.kt | 5 ++- .../box/enum/companionAccessingEnumValue.kt | 35 +++++++++++++++++++ .../codegen/BlackBoxCodegenTestGenerated.java | 5 +++ .../LightAnalysisModeTestGenerated.java | 5 +++ .../ir/IrBlackBoxCodegenTestGenerated.java | 5 +++ .../IrJsCodegenBoxES6TestGenerated.java | 5 +++ .../IrJsCodegenBoxTestGenerated.java | 5 +++ .../semantics/JsCodegenBoxTestGenerated.java | 5 +++ .../IrCodegenBoxWasmTestGenerated.java | 5 +++ 11 files changed, 92 insertions(+), 14 deletions(-) create mode 100644 compiler/testData/codegen/box/enum/companionAccessingEnumValue.kt diff --git a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/codegen/ir/FirBlackBoxCodegenTestGenerated.java b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/codegen/ir/FirBlackBoxCodegenTestGenerated.java index 623d2da523c..ea15af2113a 100644 --- a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/codegen/ir/FirBlackBoxCodegenTestGenerated.java +++ b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/codegen/ir/FirBlackBoxCodegenTestGenerated.java @@ -11090,6 +11090,11 @@ public class FirBlackBoxCodegenTestGenerated extends AbstractFirBlackBoxCodegenT runTest("compiler/testData/codegen/box/enum/classForEnumEntry.kt"); } + @TestMetadata("companionAccessingEnumValue.kt") + public void testCompanionAccessingEnumValue() throws Exception { + runTest("compiler/testData/codegen/box/enum/companionAccessingEnumValue.kt"); + } + @TestMetadata("companionObjectInEnum.kt") public void testCompanionObjectInEnum() throws Exception { runTest("compiler/testData/codegen/box/enum/companionObjectInEnum.kt"); diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/EnumClassLowering.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/EnumClassLowering.kt index ba5e2abb355..014d66d10c8 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/EnumClassLowering.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/EnumClassLowering.kt @@ -47,7 +47,7 @@ class EnumUsageLowering(val context: JsCommonBackendContext) : BodyLoweringPass } private fun lowerEnumEntry(enumEntry: IrEnumEntry) = - enumEntry.getInstanceFun!!.run { JsIrBuilder.buildCall(symbol) } + JsIrBuilder.buildCall(enumEntry.getInstanceFun!!.symbol) } @@ -168,7 +168,7 @@ class EnumClassConstructorBodyTransformer(val context: JsCommonBackendContext) : if (container is IrConstructor) { - if (irClass.goodEnum) { + if (irClass.isInstantiableEnum) { // Pass new parameters to delegating constructor calls lowerEnumConstructorsBody(container) } @@ -278,9 +278,6 @@ class EnumClassConstructorBodyTransformer(val context: JsCommonBackendContext) : //------------------------------------------------------- -private val IrClass.goodEnum: Boolean - get() = isEnumClass && !isExpect && !isEffectivelyExternal() - class EnumEntryInstancesLowering(val context: JsCommonBackendContext) : DeclarationTransformer { private var IrEnumEntry.correspondingField by context.mapping.enumEntryToCorrespondingField @@ -288,7 +285,7 @@ class EnumEntryInstancesLowering(val context: JsCommonBackendContext) : Declarat override fun transformFlat(declaration: IrDeclaration): List? { if (declaration is IrEnumEntry) { val irClass = declaration.parentAsClass - if (irClass.goodEnum) { + if (irClass.isInstantiableEnum) { // Create instance variable for each enum entry initialized with `null` return listOf(declaration, createEnumEntryInstanceVariable(irClass, declaration)) } @@ -322,7 +319,7 @@ class EnumEntryInstancesBodyLowering(val context: JsCommonBackendContext) : Body if (container is IrConstructor && container.constructedClass.kind == ClassKind.ENUM_ENTRY) { val entryClass = container.constructedClass val enum = entryClass.parentAsClass - if (enum.goodEnum) { + if (enum.isInstantiableEnum) { val entry = enum.declarations.filterIsInstance().find { it.correspondingClass === entryClass }!! //In ES6 using `this` before superCall is unavailable, so @@ -344,7 +341,7 @@ class EnumClassCreateInitializerLowering(val context: JsCommonBackendContext) : private var IrClass.initEntryInstancesFun: IrSimpleFunction? by context.mapping.enumClassToInitEntryInstancesFun override fun transformFlat(declaration: IrDeclaration): List? { - if (declaration is IrClass && declaration.goodEnum) { + if (declaration is IrClass && declaration.isInstantiableEnum) { // Create boolean flag that indicates if entry instances were initialized. val entryInstancesInitializedVar = createEntryInstancesInitializedVar(declaration) @@ -394,6 +391,10 @@ class EnumClassCreateInitializerLowering(val context: JsCommonBackendContext) : +irSetField(null, instanceField, entry.initializerExpression!!.expression.deepCopyWithSymbols(it)) } } + + irClass.companionObject()?.let { companionObject -> + +irGetObjectValue(companionObject.defaultType, companionObject.symbol) + } }.statements } } @@ -402,12 +403,12 @@ class EnumClassCreateInitializerLowering(val context: JsCommonBackendContext) : class EnumEntryCreateGetInstancesFunsLowering(val context: JsCommonBackendContext) : DeclarationTransformer { private var IrEnumEntry.correspondingField by context.mapping.enumEntryToCorrespondingField - private var IrClass.initEntryInstancesFun: IrSimpleFunction? by context.mapping.enumClassToInitEntryInstancesFun + private val IrClass.initEntryInstancesFun: IrSimpleFunction? by context.mapping.enumClassToInitEntryInstancesFun override fun transformFlat(declaration: IrDeclaration): List? { if (declaration is IrEnumEntry) { val irClass = declaration.parentAsClass - if (irClass.goodEnum) { + if (irClass.isInstantiableEnum) { // Create entry instance getters. These are used to lower `IrGetEnumValue`. val entryGetInstanceFun = createGetEntryInstanceFun(irClass, declaration, irClass.initEntryInstancesFun!!) @@ -445,6 +446,9 @@ class EnumEntryCreateGetInstancesFunsLowering(val context: JsCommonBackendContex } } +private val IrClass.isInstantiableEnum: Boolean + get() = isEnumClass && !isExpect && !isEffectivelyExternal() + class EnumSyntheticFunctionsLowering(val context: JsCommonBackendContext) : DeclarationTransformer { private var IrEnumEntry.getInstanceFun by context.mapping.enumEntryToGetInstanceFun @@ -454,7 +458,7 @@ class EnumSyntheticFunctionsLowering(val context: JsCommonBackendContext) : Decl (declaration.body as? IrSyntheticBody)?.let { body -> val kind = body.kind - declaration.parents.filterIsInstance().firstOrNull { it.goodEnum }?.let { irClass -> + declaration.parents.filterIsInstance().firstOrNull { it.isInstantiableEnum }?.let { irClass -> declaration.body = context.irFactory.createBlockBody(UNDEFINED_OFFSET, UNDEFINED_OFFSET) { statements += when (kind) { IrSyntheticBodyKind.ENUM_VALUES -> createEnumValuesBody(declaration, irClass) diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/InvokeStaticInitializersLowering.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/InvokeStaticInitializersLowering.kt index 688a5965729..298305656a7 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/InvokeStaticInitializersLowering.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/lower/InvokeStaticInitializersLowering.kt @@ -12,13 +12,12 @@ import org.jetbrains.kotlin.ir.declarations.IrDeclaration import org.jetbrains.kotlin.ir.expressions.IrBody import org.jetbrains.kotlin.ir.expressions.IrStatementContainer import org.jetbrains.kotlin.ir.expressions.impl.IrCallImpl -import org.jetbrains.kotlin.ir.util.companionObject -import org.jetbrains.kotlin.ir.util.constructedClass -import org.jetbrains.kotlin.ir.util.isEffectivelyExternal +import org.jetbrains.kotlin.ir.util.* class InvokeStaticInitializersLowering(val context: JsIrBackendContext) : BodyLoweringPass { override fun lower(irBody: IrBody, container: IrDeclaration) { if (container !is IrConstructor) return + if (container?.parentClassOrNull?.isEnumClass == true) return val irClass = container.constructedClass if (irClass.isEffectivelyExternal()) { diff --git a/compiler/testData/codegen/box/enum/companionAccessingEnumValue.kt b/compiler/testData/codegen/box/enum/companionAccessingEnumValue.kt new file mode 100644 index 00000000000..ea358a6d4da --- /dev/null +++ b/compiler/testData/codegen/box/enum/companionAccessingEnumValue.kt @@ -0,0 +1,35 @@ +private var logs = "" + +enum class Foo(val text: String) { + FOO("foo"), + BAR("bar"), + PING("foo"); + + init { + logs += "${text}A;" + } + + companion object { + init { + logs += "StatA;" + } + val first = values()[0] + init { + logs += "Stat${first.text};" + } + } + + init { + logs += "${text}B;" + } +} + +fun box(): String { + Foo.FOO + + if (Foo.first !== Foo.FOO) return "FAIL 0: ${Foo.first}" + + if (logs != "fooA;fooB;barA;barB;fooA;fooB;StatA;Statfoo;") return "FAIL 1: ${logs}" + + return "OK" +} \ No newline at end of file diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java index a06f0587e26..86566d0a845 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java @@ -11090,6 +11090,11 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { runTest("compiler/testData/codegen/box/enum/classForEnumEntry.kt"); } + @TestMetadata("companionAccessingEnumValue.kt") + public void testCompanionAccessingEnumValue() throws Exception { + runTest("compiler/testData/codegen/box/enum/companionAccessingEnumValue.kt"); + } + @TestMetadata("companionObjectInEnum.kt") public void testCompanionObjectInEnum() throws Exception { runTest("compiler/testData/codegen/box/enum/companionObjectInEnum.kt"); diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java index d99b2c153c9..d68bdc6c5c5 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java @@ -11090,6 +11090,11 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes runTest("compiler/testData/codegen/box/enum/classForEnumEntry.kt"); } + @TestMetadata("companionAccessingEnumValue.kt") + public void testCompanionAccessingEnumValue() throws Exception { + runTest("compiler/testData/codegen/box/enum/companionAccessingEnumValue.kt"); + } + @TestMetadata("companionObjectInEnum.kt") public void testCompanionObjectInEnum() throws Exception { runTest("compiler/testData/codegen/box/enum/companionObjectInEnum.kt"); diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java index bf252f8b44a..749b7f10298 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java @@ -11090,6 +11090,11 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes runTest("compiler/testData/codegen/box/enum/classForEnumEntry.kt"); } + @TestMetadata("companionAccessingEnumValue.kt") + public void testCompanionAccessingEnumValue() throws Exception { + runTest("compiler/testData/codegen/box/enum/companionAccessingEnumValue.kt"); + } + @TestMetadata("companionObjectInEnum.kt") public void testCompanionObjectInEnum() throws Exception { runTest("compiler/testData/codegen/box/enum/companionObjectInEnum.kt"); diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/es6/semantics/IrJsCodegenBoxES6TestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/es6/semantics/IrJsCodegenBoxES6TestGenerated.java index b8a38136f6b..250ada97c5f 100644 --- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/es6/semantics/IrJsCodegenBoxES6TestGenerated.java +++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/es6/semantics/IrJsCodegenBoxES6TestGenerated.java @@ -9495,6 +9495,11 @@ public class IrJsCodegenBoxES6TestGenerated extends AbstractIrJsCodegenBoxES6Tes runTest("compiler/testData/codegen/box/enum/asReturnExpression.kt"); } + @TestMetadata("companionAccessingEnumValue.kt") + public void testCompanionAccessingEnumValue() throws Exception { + runTest("compiler/testData/codegen/box/enum/companionAccessingEnumValue.kt"); + } + @TestMetadata("companionObjectInEnum.kt") public void testCompanionObjectInEnum() throws Exception { runTest("compiler/testData/codegen/box/enum/companionObjectInEnum.kt"); diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/semantics/IrJsCodegenBoxTestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/semantics/IrJsCodegenBoxTestGenerated.java index ca1f06642fd..1afba166ad5 100644 --- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/semantics/IrJsCodegenBoxTestGenerated.java +++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/ir/semantics/IrJsCodegenBoxTestGenerated.java @@ -9495,6 +9495,11 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { runTest("compiler/testData/codegen/box/enum/asReturnExpression.kt"); } + @TestMetadata("companionAccessingEnumValue.kt") + public void testCompanionAccessingEnumValue() throws Exception { + runTest("compiler/testData/codegen/box/enum/companionAccessingEnumValue.kt"); + } + @TestMetadata("companionObjectInEnum.kt") public void testCompanionObjectInEnum() throws Exception { runTest("compiler/testData/codegen/box/enum/companionObjectInEnum.kt"); diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java index ddc4f01c978..4fe28af80a4 100644 --- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java +++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java @@ -9495,6 +9495,11 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { runTest("compiler/testData/codegen/box/enum/asReturnExpression.kt"); } + @TestMetadata("companionAccessingEnumValue.kt") + public void testCompanionAccessingEnumValue() throws Exception { + runTest("compiler/testData/codegen/box/enum/companionAccessingEnumValue.kt"); + } + @TestMetadata("companionObjectInEnum.kt") public void testCompanionObjectInEnum() throws Exception { runTest("compiler/testData/codegen/box/enum/companionObjectInEnum.kt"); diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/wasm/semantics/IrCodegenBoxWasmTestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/wasm/semantics/IrCodegenBoxWasmTestGenerated.java index 4461339f686..217848da792 100644 --- a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/wasm/semantics/IrCodegenBoxWasmTestGenerated.java +++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/wasm/semantics/IrCodegenBoxWasmTestGenerated.java @@ -4594,6 +4594,11 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest runTest("compiler/testData/codegen/box/enum/asReturnExpression.kt"); } + @TestMetadata("companionAccessingEnumValue.kt") + public void testCompanionAccessingEnumValue() throws Exception { + runTest("compiler/testData/codegen/box/enum/companionAccessingEnumValue.kt"); + } + @TestMetadata("companionObjectInEnum.kt") public void testCompanionObjectInEnum() throws Exception { runTest("compiler/testData/codegen/box/enum/companionObjectInEnum.kt"); From d907c48d9ce378425f4a664a68ac0715fc2b3c08 Mon Sep 17 00:00:00 2001 From: Mikhail Glukhikh Date: Thu, 17 Dec 2020 13:04:12 +0300 Subject: [PATCH 138/196] Allow KtEnumEntry...RefExpression.referencedElement be nullable This commit fixes KNPE provoked by RemoveExplicitTypeArgumentsIntention #KT-29735 Fixed --- .../psi/KtEnumEntrySuperclassReferenceExpression.kt | 10 +++++----- .../inspectionData/expected.xml | 10 ++++++++++ .../intentions/removeExplicitTypeArguments/kt29735.kt | 5 +++++ .../removeExplicitTypeArguments/kt29735.kt.after | 5 +++++ .../kotlin/idea/intentions/IntentionTestGenerated.java | 5 +++++ 5 files changed, 30 insertions(+), 5 deletions(-) create mode 100644 idea/testData/intentions/removeExplicitTypeArguments/kt29735.kt create mode 100644 idea/testData/intentions/removeExplicitTypeArguments/kt29735.kt.after diff --git a/compiler/psi/src/org/jetbrains/kotlin/psi/KtEnumEntrySuperclassReferenceExpression.kt b/compiler/psi/src/org/jetbrains/kotlin/psi/KtEnumEntrySuperclassReferenceExpression.kt index 69fff055ca0..1bc70ecc8b8 100644 --- a/compiler/psi/src/org/jetbrains/kotlin/psi/KtEnumEntrySuperclassReferenceExpression.kt +++ b/compiler/psi/src/org/jetbrains/kotlin/psi/KtEnumEntrySuperclassReferenceExpression.kt @@ -36,8 +36,8 @@ class KtEnumEntrySuperclassReferenceExpression : super(stub, KtStubElementTypes.ENUM_ENTRY_SUPERCLASS_REFERENCE_EXPRESSION) // It is the owner enum class (not an enum entry but the whole enum) - private val referencedElement: KtClass - get() = calcReferencedElement()!! + private val referencedElement: KtClass? + get() = calcReferencedElement() private fun calcReferencedElement(): KtClass? { val owner = this.getStrictParentOfType() @@ -54,15 +54,15 @@ class KtEnumEntrySuperclassReferenceExpression : } override fun getReferencedNameAsName(): Name { - return referencedElement.name?.let { Name.identifier(it) } ?: SpecialNames.NO_NAME_PROVIDED + return referencedElement?.name?.let { Name.identifier(it) } ?: SpecialNames.NO_NAME_PROVIDED } override fun getReferencedNameElement(): PsiElement { - return referencedElement + return referencedElement!! } override fun getIdentifier(): PsiElement? { - return referencedElement.nameIdentifier + return referencedElement?.nameIdentifier } override fun getReferencedNameElementType(): IElementType { diff --git a/idea/testData/intentions/removeExplicitTypeArguments/inspectionData/expected.xml b/idea/testData/intentions/removeExplicitTypeArguments/inspectionData/expected.xml index 069d6819617..6fae53e378b 100644 --- a/idea/testData/intentions/removeExplicitTypeArguments/inspectionData/expected.xml +++ b/idea/testData/intentions/removeExplicitTypeArguments/inspectionData/expected.xml @@ -223,4 +223,14 @@ Unnecessary type argument Remove explicit type arguments + + + kt29735.kt + 4 + light_idea_test_case + kt29735 + + Unnecessary type argument + Remove explicit type arguments + \ No newline at end of file diff --git a/idea/testData/intentions/removeExplicitTypeArguments/kt29735.kt b/idea/testData/intentions/removeExplicitTypeArguments/kt29735.kt new file mode 100644 index 00000000000..bf428cbd618 --- /dev/null +++ b/idea/testData/intentions/removeExplicitTypeArguments/kt29735.kt @@ -0,0 +1,5 @@ +// WITH_RUNTIME + +enum class A(val strings: List) { + B(listOfing>("")) +} \ No newline at end of file diff --git a/idea/testData/intentions/removeExplicitTypeArguments/kt29735.kt.after b/idea/testData/intentions/removeExplicitTypeArguments/kt29735.kt.after new file mode 100644 index 00000000000..e4a665da99f --- /dev/null +++ b/idea/testData/intentions/removeExplicitTypeArguments/kt29735.kt.after @@ -0,0 +1,5 @@ +// WITH_RUNTIME + +enum class A(val strings: List) { + B(listOf("")) +} \ No newline at end of file diff --git a/idea/tests/org/jetbrains/kotlin/idea/intentions/IntentionTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/intentions/IntentionTestGenerated.java index ffc098cf01e..e13e89a46ad 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/intentions/IntentionTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/intentions/IntentionTestGenerated.java @@ -14492,6 +14492,11 @@ public class IntentionTestGenerated extends AbstractIntentionTest { runTest("idea/testData/intentions/removeExplicitTypeArguments/insideOtherCall.kt"); } + @TestMetadata("kt29735.kt") + public void testKt29735() throws Exception { + runTest("idea/testData/intentions/removeExplicitTypeArguments/kt29735.kt"); + } + @TestMetadata("kt31441.kt") public void testKt31441() throws Exception { runTest("idea/testData/intentions/removeExplicitTypeArguments/kt31441.kt"); From 44c6ec2c449d8237bb78207e8dd6ea4dc20c0cc0 Mon Sep 17 00:00:00 2001 From: Jinseong Jeon Date: Tue, 1 Dec 2020 15:23:16 -0800 Subject: [PATCH 139/196] FIR checker: make unused checker handle invoke properly #KT-43688 Fixed --- .../extendedCheckers/unused/invoke.kt | 5 ++++ .../extendedCheckers/unused/invoke.txt | 12 ++++++++++ .../ExtendedFirDiagnosticsTestGenerated.java | 5 ++++ ...WithLightTreeDiagnosticsTestGenerated.java | 5 ++++ .../checkers/extended/UnusedChecker.kt | 24 ++++++++++++++++++- 5 files changed, 50 insertions(+), 1 deletion(-) create mode 100644 compiler/fir/analysis-tests/testData/extendedCheckers/unused/invoke.kt create mode 100644 compiler/fir/analysis-tests/testData/extendedCheckers/unused/invoke.txt diff --git a/compiler/fir/analysis-tests/testData/extendedCheckers/unused/invoke.kt b/compiler/fir/analysis-tests/testData/extendedCheckers/unused/invoke.kt new file mode 100644 index 00000000000..96764751f64 --- /dev/null +++ b/compiler/fir/analysis-tests/testData/extendedCheckers/unused/invoke.kt @@ -0,0 +1,5 @@ +fun foo(): Int { + val x = fun() = 4 + val y = fun() = 2 + return 10 * x() + y() +} diff --git a/compiler/fir/analysis-tests/testData/extendedCheckers/unused/invoke.txt b/compiler/fir/analysis-tests/testData/extendedCheckers/unused/invoke.txt new file mode 100644 index 00000000000..cf32a300edb --- /dev/null +++ b/compiler/fir/analysis-tests/testData/extendedCheckers/unused/invoke.txt @@ -0,0 +1,12 @@ +FILE: invoke.kt + public final fun foo(): R|kotlin/Int| { + lval x: R|() -> kotlin/Int| = fun (): R|kotlin/Int| { + ^ Int(4) + } + + lval y: R|() -> kotlin/Int| = fun (): R|kotlin/Int| { + ^ Int(2) + } + + ^foo Int(10).R|kotlin/Int.times|(R|/x|.R|SubstitutionOverride|()).R|kotlin/Int.plus|(R|/y|.R|SubstitutionOverride|()) + } diff --git a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/ExtendedFirDiagnosticsTestGenerated.java b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/ExtendedFirDiagnosticsTestGenerated.java index e61136729ac..d1d2c85606e 100644 --- a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/ExtendedFirDiagnosticsTestGenerated.java +++ b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/ExtendedFirDiagnosticsTestGenerated.java @@ -330,6 +330,11 @@ public class ExtendedFirDiagnosticsTestGenerated extends AbstractExtendedFirDiag runTest("compiler/fir/analysis-tests/testData/extendedCheckers/unused/classProperty.kt"); } + @TestMetadata("invoke.kt") + public void testInvoke() throws Exception { + runTest("compiler/fir/analysis-tests/testData/extendedCheckers/unused/invoke.kt"); + } + @TestMetadata("lambda.kt") public void testLambda() throws Exception { runTest("compiler/fir/analysis-tests/testData/extendedCheckers/unused/lambda.kt"); diff --git a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/ExtendedFirWithLightTreeDiagnosticsTestGenerated.java b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/ExtendedFirWithLightTreeDiagnosticsTestGenerated.java index faec62595f6..09565f356d5 100644 --- a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/ExtendedFirWithLightTreeDiagnosticsTestGenerated.java +++ b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/fir/ExtendedFirWithLightTreeDiagnosticsTestGenerated.java @@ -330,6 +330,11 @@ public class ExtendedFirWithLightTreeDiagnosticsTestGenerated extends AbstractEx runTest("compiler/fir/analysis-tests/testData/extendedCheckers/unused/classProperty.kt"); } + @TestMetadata("invoke.kt") + public void testInvoke() throws Exception { + runTest("compiler/fir/analysis-tests/testData/extendedCheckers/unused/invoke.kt"); + } + @TestMetadata("lambda.kt") public void testLambda() throws Exception { runTest("compiler/fir/analysis-tests/testData/extendedCheckers/unused/lambda.kt"); diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/UnusedChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/UnusedChecker.kt index 1008992cc57..2b54d48eb3f 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/UnusedChecker.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/extended/UnusedChecker.kt @@ -10,6 +10,7 @@ import kotlinx.collections.immutable.persistentMapOf import org.jetbrains.kotlin.KtNodeTypes import org.jetbrains.kotlin.fir.FirAnnotationContainer import org.jetbrains.kotlin.fir.FirFakeSourceElementKind +import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.FirSymbolOwner import org.jetbrains.kotlin.fir.analysis.cfa.* import org.jetbrains.kotlin.fir.analysis.checkers.cfa.FirControlFlowChecker @@ -23,7 +24,10 @@ import org.jetbrains.kotlin.fir.expressions.FirFunctionCall import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccess import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference import org.jetbrains.kotlin.fir.resolve.dfa.cfg.* +import org.jetbrains.kotlin.fir.resolve.inference.isFunctionalType +import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol +import org.jetbrains.kotlin.fir.types.coneType object UnusedChecker : FirControlFlowChecker() { override fun analyze(graph: ControlFlowGraph, reporter: DiagnosticReporter, checkerContext: CheckerContext) { @@ -34,7 +38,7 @@ object UnusedChecker : FirControlFlowChecker() { val properties = LocalPropertyCollector.collect(graph) if (properties.isEmpty()) return - val data = ValueWritesWithoutReading(properties).getData(graph) + val data = ValueWritesWithoutReading(checkerContext.session, properties).getData(graph) graph.traverse(TraverseDirection.Backward, CfaVisitor(data, reporter)) } @@ -151,6 +155,7 @@ object UnusedChecker : FirControlFlowChecker() { } private class ValueWritesWithoutReading( + private val session: FirSession, private val localProperties: Set ) : ControlFlowGraphVisitor>>() { fun getData(graph: ControlFlowGraph): Map, PathAwareVariableStatusInfo> { @@ -265,6 +270,23 @@ object UnusedChecker : FirControlFlowChecker() { return update(dataForNode, *symbols) { status } } + override fun visitFunctionCallNode( + node: FunctionCallNode, + data: Collection> + ): PathAwareVariableStatusInfo { + val dataForNode = visitNode(node, data) + val reference = node.fir.calleeReference as? FirResolvedNamedReference ?: return dataForNode + val functionSymbol = reference.resolvedSymbol as? FirFunctionSymbol<*> ?: return dataForNode + val symbol = if (functionSymbol.callableId.callableName.identifier == "invoke") { + localProperties.find { it.fir.name == reference.name && it.fir.returnTypeRef.coneType.isFunctionalType(session) } + } else null + symbol ?: return dataForNode + + val status = VariableStatus.READ + status.isRead = true + return update(dataForNode, symbol) { status } + } + private fun update( pathAwareInfo: PathAwareVariableStatusInfo, vararg symbols: FirPropertySymbol, From 46084316829f4bc4c7b3b44f86274d3b7fd8fb89 Mon Sep 17 00:00:00 2001 From: Jinseong Jeon Date: Thu, 17 Dec 2020 15:38:45 -0800 Subject: [PATCH 140/196] FIR2IR: correct base symbols of fake overrides for delegated member #KT-43984 Fixed --- .../generators/FakeOverrideGenerator.kt | 18 +++++++-------- ...ackBoxAgainstJavaCodegenTestGenerated.java | 5 +++++ .../interfaces/defaultMethod.kt | 22 +++++++++++++++++++ ...ackBoxAgainstJavaCodegenTestGenerated.java | 5 +++++ ...ackBoxAgainstJavaCodegenTestGenerated.java | 5 +++++ 5 files changed, 46 insertions(+), 9 deletions(-) create mode 100644 compiler/testData/codegen/boxAgainstJava/interfaces/defaultMethod.kt diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/FakeOverrideGenerator.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/FakeOverrideGenerator.kt index c6241de9f4d..ee506407f4a 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/FakeOverrideGenerator.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/FakeOverrideGenerator.kt @@ -10,11 +10,9 @@ import org.jetbrains.kotlin.fir.* import org.jetbrains.kotlin.fir.backend.* import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.resolve.defaultType -import org.jetbrains.kotlin.fir.scopes.FirTypeScope -import org.jetbrains.kotlin.fir.scopes.getDirectOverriddenFunctions -import org.jetbrains.kotlin.fir.scopes.getDirectOverriddenProperties +import org.jetbrains.kotlin.fir.scopes.* import org.jetbrains.kotlin.fir.scopes.impl.FirFakeOverrideGenerator -import org.jetbrains.kotlin.fir.scopes.unsubstitutedScope +import org.jetbrains.kotlin.fir.scopes.impl.delegatedWrapperData import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol @@ -194,11 +192,13 @@ class FakeOverrideGenerator( ): List { if (symbol.fir.origin != FirDeclarationOrigin.IntersectionOverride) return listOf(basedSymbol) return scope.directOverridden(symbol).map { - @Suppress("UNCHECKED_CAST") - if (it.fir.isSubstitutionOverride && it.dispatchReceiverClassOrNull() == containingClass) - it.originalForSubstitutionOverride!! - else - it + when { + it.fir.isSubstitutionOverride && it.dispatchReceiverClassOrNull() == containingClass -> + it.originalForSubstitutionOverride!! + it.fir.origin == FirDeclarationOrigin.Delegated -> + it.fir.delegatedWrapperData?.wrapped?.symbol!! as S + else -> it + } } } diff --git a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/codegen/ir/FirBlackBoxAgainstJavaCodegenTestGenerated.java b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/codegen/ir/FirBlackBoxAgainstJavaCodegenTestGenerated.java index 24bc905559e..c6a091b2d3b 100644 --- a/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/codegen/ir/FirBlackBoxAgainstJavaCodegenTestGenerated.java +++ b/compiler/fir/fir2ir/tests-gen/org/jetbrains/kotlin/codegen/ir/FirBlackBoxAgainstJavaCodegenTestGenerated.java @@ -425,6 +425,11 @@ public class FirBlackBoxAgainstJavaCodegenTestGenerated extends AbstractFirBlack KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/interfaces"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } + @TestMetadata("defaultMethod.kt") + public void testDefaultMethod() throws Exception { + runTest("compiler/testData/codegen/boxAgainstJava/interfaces/defaultMethod.kt"); + } + @TestMetadata("inheritJavaInterface.kt") public void testInheritJavaInterface() throws Exception { runTest("compiler/testData/codegen/boxAgainstJava/interfaces/inheritJavaInterface.kt"); diff --git a/compiler/testData/codegen/boxAgainstJava/interfaces/defaultMethod.kt b/compiler/testData/codegen/boxAgainstJava/interfaces/defaultMethod.kt new file mode 100644 index 00000000000..3e103e584c5 --- /dev/null +++ b/compiler/testData/codegen/boxAgainstJava/interfaces/defaultMethod.kt @@ -0,0 +1,22 @@ +// JVM_TARGET: 1.8 + +// FILE: A.java + +public interface A { + default String getMessage() { + return "OK"; + } +} + +// FILE: 1.kt + +interface I : A + +class B : A + +open class C(a : A) : I, A by a + +fun box(): String { + val a = B() + return C(a).message +} diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/BlackBoxAgainstJavaCodegenTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/BlackBoxAgainstJavaCodegenTestGenerated.java index 34d34562a2f..889ec77bc21 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/BlackBoxAgainstJavaCodegenTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/BlackBoxAgainstJavaCodegenTestGenerated.java @@ -424,6 +424,11 @@ public class BlackBoxAgainstJavaCodegenTestGenerated extends AbstractBlackBoxAga KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/interfaces"), Pattern.compile("^(.+)\\.kt$"), null, true); } + @TestMetadata("defaultMethod.kt") + public void testDefaultMethod() throws Exception { + runTest("compiler/testData/codegen/boxAgainstJava/interfaces/defaultMethod.kt"); + } + @TestMetadata("inheritJavaInterface.kt") public void testInheritJavaInterface() throws Exception { runTest("compiler/testData/codegen/boxAgainstJava/interfaces/inheritJavaInterface.kt"); diff --git a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrBlackBoxAgainstJavaCodegenTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrBlackBoxAgainstJavaCodegenTestGenerated.java index e748f3b8cc6..4b6b6073967 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrBlackBoxAgainstJavaCodegenTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/codegen/ir/IrBlackBoxAgainstJavaCodegenTestGenerated.java @@ -425,6 +425,11 @@ public class IrBlackBoxAgainstJavaCodegenTestGenerated extends AbstractIrBlackBo KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxAgainstJava/interfaces"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_IR, true); } + @TestMetadata("defaultMethod.kt") + public void testDefaultMethod() throws Exception { + runTest("compiler/testData/codegen/boxAgainstJava/interfaces/defaultMethod.kt"); + } + @TestMetadata("inheritJavaInterface.kt") public void testInheritJavaInterface() throws Exception { runTest("compiler/testData/codegen/boxAgainstJava/interfaces/inheritJavaInterface.kt"); From fe0c25693d29124bbe237b76692a1d79e15244aa Mon Sep 17 00:00:00 2001 From: Jinseong Jeon Date: Wed, 16 Dec 2020 14:22:02 -0800 Subject: [PATCH 141/196] FIR2IR: do not convert @ExtensionFunctionType twice --- .../kotlin/fir/backend/Fir2IrBuiltIns.kt | 7 -- .../kotlin/fir/backend/Fir2IrTypeConverter.kt | 4 +- .../ir/irText/classes/initValInLambda.fir.txt | 2 +- ...mbdaInDataClassDefaultParameter.fir.kt.txt | 8 +- .../lambdaInDataClassDefaultParameter.fir.txt | 40 +++--- .../parameters/lambdas.fir.kt.txt | 2 +- .../declarations/parameters/lambdas.fir.txt | 8 +- .../adaptedExtensionFunctions.fir.kt.txt | 2 +- .../adaptedExtensionFunctions.fir.txt | 10 +- .../expressions/extFunInvokeAsFun.fir.kt.txt | 7 -- .../expressions/extFunInvokeAsFun.fir.txt | 17 --- .../irText/expressions/extFunInvokeAsFun.kt | 1 + .../expressions/extFunSafeInvoke.fir.kt.txt | 9 -- .../expressions/extFunSafeInvoke.fir.txt | 22 ---- .../ir/irText/expressions/extFunSafeInvoke.kt | 1 + .../ir/irText/expressions/kt37570.fir.txt | 2 +- .../sam/samConversionToGeneric.fir.kt.txt | 4 +- .../sam/samConversionToGeneric.fir.txt | 14 +-- ...ConversionOnArbitraryExpression.fir.kt.txt | 28 ++--- ...endConversionOnArbitraryExpression.fir.txt | 116 +++++++++--------- .../variableAsFunctionCall.fir.kt.txt | 2 +- .../variableAsFunctionCall.fir.txt | 8 +- .../irText/firProblems/AllCandidates.fir.txt | 2 +- .../typeVariableAfterBuildMap.fir.txt | 2 +- .../ir/irText/lambdas/extensionLambda.fir.txt | 2 +- .../lambdas/multipleImplicitReceivers.fir.txt | 6 +- .../ir/irText/stubs/builtinMap.fir.txt | 2 +- .../castsInsideCoroutineInference.fir.kt.txt | 14 +-- .../castsInsideCoroutineInference.fir.txt | 56 ++++----- 29 files changed, 168 insertions(+), 230 deletions(-) delete mode 100644 compiler/testData/ir/irText/expressions/extFunInvokeAsFun.fir.kt.txt delete mode 100644 compiler/testData/ir/irText/expressions/extFunInvokeAsFun.fir.txt delete mode 100644 compiler/testData/ir/irText/expressions/extFunSafeInvoke.fir.kt.txt delete mode 100644 compiler/testData/ir/irText/expressions/extFunSafeInvoke.fir.txt diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrBuiltIns.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrBuiltIns.kt index a9cd66793e4..81c951dd015 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrBuiltIns.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrBuiltIns.kt @@ -23,13 +23,6 @@ class Fir2IrBuiltIns( provider?.initComponents(components) } - private val extensionFunctionTypeAnnotationSymbol by lazy { - annotationSymbolById(CompilerConeAttributes.ExtensionFunctionType.ANNOTATION_CLASS_ID) - } - - internal fun extensionFunctionTypeAnnotationConstructorCall(): IrConstructorCall = - extensionFunctionTypeAnnotationSymbol!!.toConstructorCall() - private val enhancedNullabilityAnnotationSymbol by lazy { annotationSymbolById(CompilerConeAttributes.EnhancedNullability.ANNOTATION_CLASS_ID) } diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrTypeConverter.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrTypeConverter.kt index aaadc1ca71e..dd8028efa84 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrTypeConverter.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrTypeConverter.kt @@ -88,9 +88,7 @@ class Fir2IrTypeConverter( val firSymbol = this.lookupTag.toSymbol(session) ?: return createErrorType() firSymbol.toSymbol(session, classifierStorage, typeContext) } - val typeAnnotations: MutableList = - if (!isExtensionFunctionType) mutableListOf() - else mutableListOf(builtIns.extensionFunctionTypeAnnotationConstructorCall()) + val typeAnnotations: MutableList = mutableListOf() typeAnnotations += with(annotationGenerator) { annotations.toIrAnnotations() } if (hasEnhancedNullability) { builtIns.enhancedNullabilityAnnotationConstructorCall()?.let { diff --git a/compiler/testData/ir/irText/classes/initValInLambda.fir.txt b/compiler/testData/ir/irText/classes/initValInLambda.fir.txt index 17a083eaa50..c6efa0dc7d8 100644 --- a/compiler/testData/ir/irText/classes/initValInLambda.fir.txt +++ b/compiler/testData/ir/irText/classes/initValInLambda.fir.txt @@ -16,7 +16,7 @@ FILE fqName: fileName:/initValInLambda.kt receiver: GET_VAR ': .TestInitValInLambdaCalledOnce declared in .TestInitValInLambdaCalledOnce.' type=.TestInitValInLambdaCalledOnce origin=null ANONYMOUS_INITIALIZER isStatic=false BLOCK_BODY - CALL 'public final fun run (block: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1): R of kotlin.run [inline] declared in kotlin' type=kotlin.Unit origin=null + CALL 'public final fun run (block: @[ExtensionFunctionType] kotlin.Function1): R of kotlin.run [inline] declared in kotlin' type=kotlin.Unit origin=null : kotlin.Int : kotlin.Unit $receiver: CONST Int type=kotlin.Int value=1 diff --git a/compiler/testData/ir/irText/classes/lambdaInDataClassDefaultParameter.fir.kt.txt b/compiler/testData/ir/irText/classes/lambdaInDataClassDefaultParameter.fir.kt.txt index 726406607bb..22448fd726c 100644 --- a/compiler/testData/ir/irText/classes/lambdaInDataClassDefaultParameter.fir.kt.txt +++ b/compiler/testData/ir/irText/classes/lambdaInDataClassDefaultParameter.fir.kt.txt @@ -1,5 +1,5 @@ data class A { - constructor(runA: @ExtensionFunctionType @ExtensionFunctionType Function2 = local fun A.(it: String) { + constructor(runA: @ExtensionFunctionType Function2 = local fun A.(it: String) { return Unit } ) /* primary */ { @@ -8,15 +8,15 @@ data class A { } - val runA: @ExtensionFunctionType @ExtensionFunctionType Function2 + val runA: @ExtensionFunctionType Function2 field = runA get - fun component1(): @ExtensionFunctionType @ExtensionFunctionType Function2 { + fun component1(): @ExtensionFunctionType Function2 { return .#runA } - fun copy(runA: @ExtensionFunctionType @ExtensionFunctionType Function2 = .#runA): A { + fun copy(runA: @ExtensionFunctionType Function2 = .#runA): A { return A(runA = runA) } diff --git a/compiler/testData/ir/irText/classes/lambdaInDataClassDefaultParameter.fir.txt b/compiler/testData/ir/irText/classes/lambdaInDataClassDefaultParameter.fir.txt index 4180b5b498f..921be13b44b 100644 --- a/compiler/testData/ir/irText/classes/lambdaInDataClassDefaultParameter.fir.txt +++ b/compiler/testData/ir/irText/classes/lambdaInDataClassDefaultParameter.fir.txt @@ -1,8 +1,8 @@ FILE fqName: fileName:/lambdaInDataClassDefaultParameter.kt CLASS CLASS name:A modality:FINAL visibility:public [data] superTypes:[kotlin.Any] $this: VALUE_PARAMETER INSTANCE_RECEIVER name: type:.A - CONSTRUCTOR visibility:public <> (runA:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit>) returnType:.A [primary] - VALUE_PARAMETER name:runA index:0 type:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit> + CONSTRUCTOR visibility:public <> (runA:@[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit>) returnType:.A [primary] + VALUE_PARAMETER name:runA index:0 type:@[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit> EXPRESSION_BODY FUN_EXPR type=kotlin.Function2<.A, kotlin.String, kotlin.Unit> origin=LAMBDA FUN LOCAL_FUNCTION_FOR_LAMBDA name: visibility:local modality:FINAL <> ($receiver:.A, it:kotlin.String) returnType:kotlin.Unit @@ -15,32 +15,32 @@ FILE fqName: fileName:/lambdaInDataClassDefaultParameter.kt DELEGATING_CONSTRUCTOR_CALL 'public constructor () [primary] declared in kotlin.Any' INSTANCE_INITIALIZER_CALL classDescriptor='CLASS CLASS name:A modality:FINAL visibility:public [data] superTypes:[kotlin.Any]' PROPERTY name:runA visibility:public modality:FINAL [val] - FIELD PROPERTY_BACKING_FIELD name:runA type:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit> visibility:private [final] + FIELD PROPERTY_BACKING_FIELD name:runA type:@[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit> visibility:private [final] EXPRESSION_BODY - GET_VAR 'runA: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit> declared in .A.' type=@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit> origin=INITIALIZE_PROPERTY_FROM_PARAMETER - FUN DEFAULT_PROPERTY_ACCESSOR name: visibility:public modality:FINAL <> ($this:.A) returnType:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit> + GET_VAR 'runA: @[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit> declared in .A.' type=@[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit> origin=INITIALIZE_PROPERTY_FROM_PARAMETER + FUN DEFAULT_PROPERTY_ACCESSOR name: visibility:public modality:FINAL <> ($this:.A) returnType:@[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit> correspondingProperty: PROPERTY name:runA visibility:public modality:FINAL [val] $this: VALUE_PARAMETER name: type:.A BLOCK_BODY - RETURN type=kotlin.Nothing from='public final fun (): @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit> declared in .A' - GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:runA type:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit> visibility:private [final]' type=@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit> origin=null + RETURN type=kotlin.Nothing from='public final fun (): @[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit> declared in .A' + GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:runA type:@[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit> visibility:private [final]' type=@[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit> origin=null receiver: GET_VAR ': .A declared in .A.' type=.A origin=null - FUN name:component1 visibility:public modality:FINAL <> ($this:.A) returnType:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit> + FUN name:component1 visibility:public modality:FINAL <> ($this:.A) returnType:@[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit> $this: VALUE_PARAMETER name: type:.A BLOCK_BODY - RETURN type=kotlin.Nothing from='public final fun component1 (): @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit> declared in .A' - GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:runA type:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit> visibility:private [final]' type=@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit> origin=null + RETURN type=kotlin.Nothing from='public final fun component1 (): @[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit> declared in .A' + GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:runA type:@[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit> visibility:private [final]' type=@[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit> origin=null receiver: GET_VAR ': .A declared in .A.component1' type=.A origin=null - FUN name:copy visibility:public modality:FINAL <> ($this:.A, runA:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit>) returnType:.A + FUN name:copy visibility:public modality:FINAL <> ($this:.A, runA:@[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit>) returnType:.A $this: VALUE_PARAMETER name: type:.A - VALUE_PARAMETER name:runA index:0 type:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit> + VALUE_PARAMETER name:runA index:0 type:@[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit> EXPRESSION_BODY - GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:runA type:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit> visibility:private [final]' type=@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit> origin=null + GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:runA type:@[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit> visibility:private [final]' type=@[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit> origin=null receiver: GET_VAR ': .A declared in .A.copy' type=.A origin=null BLOCK_BODY - RETURN type=kotlin.Nothing from='public final fun copy (runA: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit>): .A declared in .A' - CONSTRUCTOR_CALL 'public constructor (runA: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit>) [primary] declared in .A' type=.A origin=null - runA: GET_VAR 'runA: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit> declared in .A.copy' type=@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit> origin=null + RETURN type=kotlin.Nothing from='public final fun copy (runA: @[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit>): .A declared in .A' + CONSTRUCTOR_CALL 'public constructor (runA: @[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit>) [primary] declared in .A' type=.A origin=null + runA: GET_VAR 'runA: @[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit> declared in .A.copy' type=@[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit> origin=null FUN GENERATED_DATA_CLASS_MEMBER name:equals visibility:public modality:OPEN <> ($this:.A, other:kotlin.Any?) returnType:kotlin.Boolean overridden: public open fun equals (other: kotlin.Any?): kotlin.Boolean [operator] declared in kotlin.Any @@ -67,9 +67,9 @@ FILE fqName: fileName:/lambdaInDataClassDefaultParameter.kt BRANCH if: CALL 'public final fun not (): kotlin.Boolean [operator] declared in kotlin.Boolean' type=kotlin.Boolean origin=EXCLEQ $this: CALL 'public final fun EQEQ (arg0: kotlin.Any?, arg1: kotlin.Any?): kotlin.Boolean declared in kotlin.internal.ir' type=kotlin.Boolean origin=EXCLEQ - arg0: GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:runA type:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit> visibility:private [final]' type=@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit> origin=null + arg0: GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:runA type:@[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit> visibility:private [final]' type=@[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit> origin=null receiver: GET_VAR ': .A declared in .A.equals' type=.A origin=null - arg1: GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:runA type:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit> visibility:private [final]' type=@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit> origin=null + arg1: GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:runA type:@[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit> visibility:private [final]' type=@[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit> origin=null receiver: GET_VAR 'val tmp_0: .A [val] declared in .A.equals' type=.A origin=null then: RETURN type=kotlin.Nothing from='public open fun equals (other: kotlin.Any?): kotlin.Boolean declared in .A' CONST Boolean type=kotlin.Boolean value=false @@ -82,7 +82,7 @@ FILE fqName: fileName:/lambdaInDataClassDefaultParameter.kt BLOCK_BODY RETURN type=kotlin.Nothing from='public open fun hashCode (): kotlin.Int declared in .A' CALL 'public open fun hashCode (): kotlin.Int declared in kotlin.Any' type=kotlin.Int origin=null - $this: GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:runA type:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit> visibility:private [final]' type=@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit> origin=null + $this: GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:runA type:@[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit> visibility:private [final]' type=@[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit> origin=null receiver: GET_VAR ': .A declared in .A.hashCode' type=.A origin=null FUN GENERATED_DATA_CLASS_MEMBER name:toString visibility:public modality:OPEN <> ($this:.A) returnType:kotlin.String overridden: @@ -93,7 +93,7 @@ FILE fqName: fileName:/lambdaInDataClassDefaultParameter.kt STRING_CONCATENATION type=kotlin.String CONST String type=kotlin.String value="A(" CONST String type=kotlin.String value="runA=" - GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:runA type:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit> visibility:private [final]' type=@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit> origin=null + GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:runA type:@[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit> visibility:private [final]' type=@[ExtensionFunctionType] kotlin.Function2<.A, kotlin.String, kotlin.Unit> origin=null receiver: GET_VAR ': .A declared in .A.toString' type=.A origin=null CONST String type=kotlin.String value=")" CLASS CLASS name:B modality:FINAL visibility:public [data] superTypes:[kotlin.Any] diff --git a/compiler/testData/ir/irText/declarations/parameters/lambdas.fir.kt.txt b/compiler/testData/ir/irText/declarations/parameters/lambdas.fir.kt.txt index e097d10a472..3947169f441 100644 --- a/compiler/testData/ir/irText/declarations/parameters/lambdas.fir.kt.txt +++ b/compiler/testData/ir/irText/declarations/parameters/lambdas.fir.kt.txt @@ -5,7 +5,7 @@ val test1: Function1 get -val test2: @ExtensionFunctionType @ExtensionFunctionType Function2 +val test2: @ExtensionFunctionType Function2 field = local fun Any.(it: Any): Int { return it.hashCode() } diff --git a/compiler/testData/ir/irText/declarations/parameters/lambdas.fir.txt b/compiler/testData/ir/irText/declarations/parameters/lambdas.fir.txt index 4e81fb31a3d..f8322c87f07 100644 --- a/compiler/testData/ir/irText/declarations/parameters/lambdas.fir.txt +++ b/compiler/testData/ir/irText/declarations/parameters/lambdas.fir.txt @@ -14,7 +14,7 @@ FILE fqName: fileName:/lambdas.kt RETURN type=kotlin.Nothing from='public final fun (): kotlin.Function1 declared in ' GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:test1 type:kotlin.Function1 visibility:private [final,static]' type=kotlin.Function1 origin=null PROPERTY name:test2 visibility:public modality:FINAL [val] - FIELD PROPERTY_BACKING_FIELD name:test2 type:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function2 visibility:private [final,static] + FIELD PROPERTY_BACKING_FIELD name:test2 type:@[ExtensionFunctionType] kotlin.Function2 visibility:private [final,static] EXPRESSION_BODY FUN_EXPR type=kotlin.Function2 origin=LAMBDA FUN LOCAL_FUNCTION_FOR_LAMBDA name: visibility:local modality:FINAL <> ($receiver:kotlin.Any, it:kotlin.Any) returnType:kotlin.Int @@ -24,11 +24,11 @@ FILE fqName: fileName:/lambdas.kt RETURN type=kotlin.Nothing from='local final fun (it: kotlin.Any): kotlin.Int declared in .test2' CALL 'public open fun hashCode (): kotlin.Int declared in kotlin.Any' type=kotlin.Int origin=null $this: GET_VAR 'it: kotlin.Any declared in .test2.' type=kotlin.Any origin=null - FUN DEFAULT_PROPERTY_ACCESSOR name: visibility:public modality:FINAL <> () returnType:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function2 + FUN DEFAULT_PROPERTY_ACCESSOR name: visibility:public modality:FINAL <> () returnType:@[ExtensionFunctionType] kotlin.Function2 correspondingProperty: PROPERTY name:test2 visibility:public modality:FINAL [val] BLOCK_BODY - RETURN type=kotlin.Nothing from='public final fun (): @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function2 declared in ' - GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:test2 type:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function2 visibility:private [final,static]' type=@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function2 origin=null + RETURN type=kotlin.Nothing from='public final fun (): @[ExtensionFunctionType] kotlin.Function2 declared in ' + GET_FIELD 'FIELD PROPERTY_BACKING_FIELD name:test2 type:@[ExtensionFunctionType] kotlin.Function2 visibility:private [final,static]' type=@[ExtensionFunctionType] kotlin.Function2 origin=null PROPERTY name:test3 visibility:public modality:FINAL [val] FIELD PROPERTY_BACKING_FIELD name:test3 type:kotlin.Function2 visibility:private [final,static] EXPRESSION_BODY diff --git a/compiler/testData/ir/irText/expressions/callableReferences/adaptedExtensionFunctions.fir.kt.txt b/compiler/testData/ir/irText/expressions/callableReferences/adaptedExtensionFunctions.fir.kt.txt index 801dd51fa50..0dd8e57a20b 100644 --- a/compiler/testData/ir/irText/expressions/callableReferences/adaptedExtensionFunctions.fir.kt.txt +++ b/compiler/testData/ir/irText/expressions/callableReferences/adaptedExtensionFunctions.fir.kt.txt @@ -1,4 +1,4 @@ -fun use(f: @ExtensionFunctionType @ExtensionFunctionType Function2) { +fun use(f: @ExtensionFunctionType Function2) { } class C { diff --git a/compiler/testData/ir/irText/expressions/callableReferences/adaptedExtensionFunctions.fir.txt b/compiler/testData/ir/irText/expressions/callableReferences/adaptedExtensionFunctions.fir.txt index 16809547e9a..7cacf363154 100644 --- a/compiler/testData/ir/irText/expressions/callableReferences/adaptedExtensionFunctions.fir.txt +++ b/compiler/testData/ir/irText/expressions/callableReferences/adaptedExtensionFunctions.fir.txt @@ -1,6 +1,6 @@ FILE fqName: fileName:/adaptedExtensionFunctions.kt - FUN name:use visibility:public modality:FINAL <> (f:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function2<.C, kotlin.Int, kotlin.Unit>) returnType:kotlin.Unit - VALUE_PARAMETER name:f index:0 type:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function2<.C, kotlin.Int, kotlin.Unit> + FUN name:use visibility:public modality:FINAL <> (f:@[ExtensionFunctionType] kotlin.Function2<.C, kotlin.Int, kotlin.Unit>) returnType:kotlin.Unit + VALUE_PARAMETER name:f index:0 type:@[ExtensionFunctionType] kotlin.Function2<.C, kotlin.Int, kotlin.Unit> BLOCK_BODY CLASS CLASS name:C modality:FINAL visibility:public superTypes:[kotlin.Any] $this: VALUE_PARAMETER INSTANCE_RECEIVER name: type:.C @@ -43,13 +43,13 @@ FILE fqName: fileName:/adaptedExtensionFunctions.kt BLOCK_BODY FUN name:testExtensionVararg visibility:public modality:FINAL <> () returnType:kotlin.Unit BLOCK_BODY - CALL 'public final fun use (f: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function2<.C, kotlin.Int, kotlin.Unit>): kotlin.Unit declared in ' type=kotlin.Unit origin=null + CALL 'public final fun use (f: @[ExtensionFunctionType] kotlin.Function2<.C, kotlin.Int, kotlin.Unit>): kotlin.Unit declared in ' type=kotlin.Unit origin=null f: FUNCTION_REFERENCE 'public final fun extensionVararg (i: kotlin.Int, vararg s: kotlin.String): kotlin.Unit declared in ' type=kotlin.reflect.KFunction2<.C, kotlin.Int, kotlin.Unit> origin=null reflectionTarget= FUN name:testExtensionDefault visibility:public modality:FINAL <> () returnType:kotlin.Unit BLOCK_BODY - CALL 'public final fun use (f: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function2<.C, kotlin.Int, kotlin.Unit>): kotlin.Unit declared in ' type=kotlin.Unit origin=null + CALL 'public final fun use (f: @[ExtensionFunctionType] kotlin.Function2<.C, kotlin.Int, kotlin.Unit>): kotlin.Unit declared in ' type=kotlin.Unit origin=null f: FUNCTION_REFERENCE 'public final fun extensionDefault (i: kotlin.Int, s: kotlin.String): kotlin.Unit declared in ' type=kotlin.reflect.KFunction2<.C, kotlin.Int, kotlin.Unit> origin=null reflectionTarget= FUN name:testExtensionBoth visibility:public modality:FINAL <> () returnType:kotlin.Unit BLOCK_BODY - CALL 'public final fun use (f: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function2<.C, kotlin.Int, kotlin.Unit>): kotlin.Unit declared in ' type=kotlin.Unit origin=null + CALL 'public final fun use (f: @[ExtensionFunctionType] kotlin.Function2<.C, kotlin.Int, kotlin.Unit>): kotlin.Unit declared in ' type=kotlin.Unit origin=null f: FUNCTION_REFERENCE 'public final fun extensionBoth (i: kotlin.Int, s: kotlin.String, vararg t: kotlin.String): kotlin.Unit declared in ' type=kotlin.reflect.KFunction2<.C, kotlin.Int, kotlin.Unit> origin=null reflectionTarget= diff --git a/compiler/testData/ir/irText/expressions/extFunInvokeAsFun.fir.kt.txt b/compiler/testData/ir/irText/expressions/extFunInvokeAsFun.fir.kt.txt deleted file mode 100644 index de1341623b5..00000000000 --- a/compiler/testData/ir/irText/expressions/extFunInvokeAsFun.fir.kt.txt +++ /dev/null @@ -1,7 +0,0 @@ -fun with1(receiver: Any?, block: @ExtensionFunctionType @ExtensionFunctionType Function1) { - return block.invoke(p1 = receiver) -} - -fun with2(receiver: Any?, block: @ExtensionFunctionType @ExtensionFunctionType Function1) { - return block.invoke(p1 = receiver) -} diff --git a/compiler/testData/ir/irText/expressions/extFunInvokeAsFun.fir.txt b/compiler/testData/ir/irText/expressions/extFunInvokeAsFun.fir.txt deleted file mode 100644 index 13ced496642..00000000000 --- a/compiler/testData/ir/irText/expressions/extFunInvokeAsFun.fir.txt +++ /dev/null @@ -1,17 +0,0 @@ -FILE fqName: fileName:/extFunInvokeAsFun.kt - FUN name:with1 visibility:public modality:FINAL <> (receiver:kotlin.Any?, block:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1) returnType:kotlin.Unit - VALUE_PARAMETER name:receiver index:0 type:kotlin.Any? - VALUE_PARAMETER name:block index:1 type:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1 - BLOCK_BODY - RETURN type=kotlin.Nothing from='public final fun with1 (receiver: kotlin.Any?, block: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1): kotlin.Unit declared in ' - CALL 'public abstract fun invoke (p1: P1 of kotlin.Function1): R of kotlin.Function1 [operator] declared in kotlin.Function1' type=kotlin.Unit origin=INVOKE - $this: GET_VAR 'block: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1 declared in .with1' type=@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1 origin=VARIABLE_AS_FUNCTION - p1: GET_VAR 'receiver: kotlin.Any? declared in .with1' type=kotlin.Any? origin=null - FUN name:with2 visibility:public modality:FINAL <> (receiver:kotlin.Any?, block:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1) returnType:kotlin.Unit - VALUE_PARAMETER name:receiver index:0 type:kotlin.Any? - VALUE_PARAMETER name:block index:1 type:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1 - BLOCK_BODY - RETURN type=kotlin.Nothing from='public final fun with2 (receiver: kotlin.Any?, block: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1): kotlin.Unit declared in ' - CALL 'public abstract fun invoke (p1: P1 of kotlin.Function1): R of kotlin.Function1 [operator] declared in kotlin.Function1' type=kotlin.Unit origin=INVOKE - $this: GET_VAR 'block: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1 declared in .with2' type=@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1 origin=VARIABLE_AS_FUNCTION - p1: GET_VAR 'receiver: kotlin.Any? declared in .with2' type=kotlin.Any? origin=null diff --git a/compiler/testData/ir/irText/expressions/extFunInvokeAsFun.kt b/compiler/testData/ir/irText/expressions/extFunInvokeAsFun.kt index 983bcfae575..3cd68aee830 100644 --- a/compiler/testData/ir/irText/expressions/extFunInvokeAsFun.kt +++ b/compiler/testData/ir/irText/expressions/extFunInvokeAsFun.kt @@ -1,3 +1,4 @@ +// FIR_IDENTICAL // !DUMP_DEPENDENCIES fun with1(receiver: Any?, block: Any?.() -> Unit) = block(receiver) diff --git a/compiler/testData/ir/irText/expressions/extFunSafeInvoke.fir.kt.txt b/compiler/testData/ir/irText/expressions/extFunSafeInvoke.fir.kt.txt deleted file mode 100644 index dff7557aa76..00000000000 --- a/compiler/testData/ir/irText/expressions/extFunSafeInvoke.fir.kt.txt +++ /dev/null @@ -1,9 +0,0 @@ -fun test(receiver: Any?, fn: @ExtensionFunctionType @ExtensionFunctionType Function3): Unit? { - return { // BLOCK - val tmp0_safe_receiver: Any? = receiver - when { - EQEQ(arg0 = tmp0_safe_receiver, arg1 = null) -> null - else -> fn.invoke(p1 = tmp0_safe_receiver, p2 = 42, p3 = "Hello") - } - } -} diff --git a/compiler/testData/ir/irText/expressions/extFunSafeInvoke.fir.txt b/compiler/testData/ir/irText/expressions/extFunSafeInvoke.fir.txt deleted file mode 100644 index 60d3941c3c4..00000000000 --- a/compiler/testData/ir/irText/expressions/extFunSafeInvoke.fir.txt +++ /dev/null @@ -1,22 +0,0 @@ -FILE fqName: fileName:/extFunSafeInvoke.kt - FUN name:test visibility:public modality:FINAL <> (receiver:kotlin.Any?, fn:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function3) returnType:kotlin.Unit? - VALUE_PARAMETER name:receiver index:0 type:kotlin.Any? - VALUE_PARAMETER name:fn index:1 type:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function3 - BLOCK_BODY - RETURN type=kotlin.Nothing from='public final fun test (receiver: kotlin.Any?, fn: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function3): kotlin.Unit? declared in ' - BLOCK type=kotlin.Unit? origin=SAFE_CALL - VAR IR_TEMPORARY_VARIABLE name:tmp_0 type:kotlin.Any? [val] - GET_VAR 'receiver: kotlin.Any? declared in .test' type=kotlin.Any? origin=null - WHEN type=kotlin.Unit? origin=null - BRANCH - if: CALL 'public final fun EQEQ (arg0: kotlin.Any?, arg1: kotlin.Any?): kotlin.Boolean declared in kotlin.internal.ir' type=kotlin.Boolean origin=EQEQ - arg0: GET_VAR 'val tmp_0: kotlin.Any? [val] declared in .test' type=kotlin.Any? origin=null - arg1: CONST Null type=kotlin.Nothing? value=null - then: CONST Null type=kotlin.Nothing? value=null - BRANCH - if: CONST Boolean type=kotlin.Boolean value=true - then: CALL 'public abstract fun invoke (p1: P1 of kotlin.Function3, p2: P2 of kotlin.Function3, p3: P3 of kotlin.Function3): R of kotlin.Function3 [operator] declared in kotlin.Function3' type=kotlin.Unit origin=INVOKE - $this: GET_VAR 'fn: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function3 declared in .test' type=@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function3 origin=VARIABLE_AS_FUNCTION - p1: GET_VAR 'val tmp_0: kotlin.Any? [val] declared in .test' type=kotlin.Any? origin=null - p2: CONST Int type=kotlin.Int value=42 - p3: CONST String type=kotlin.String value="Hello" diff --git a/compiler/testData/ir/irText/expressions/extFunSafeInvoke.kt b/compiler/testData/ir/irText/expressions/extFunSafeInvoke.kt index 6a13282dde7..d8fa490cd1c 100644 --- a/compiler/testData/ir/irText/expressions/extFunSafeInvoke.kt +++ b/compiler/testData/ir/irText/expressions/extFunSafeInvoke.kt @@ -1,2 +1,3 @@ +// FIR_IDENTICAL fun test(receiver: Any?, fn: Any.(Int, String) -> Unit) = receiver?.fn(42, "Hello") \ No newline at end of file diff --git a/compiler/testData/ir/irText/expressions/kt37570.fir.txt b/compiler/testData/ir/irText/expressions/kt37570.fir.txt index f85315f8871..16424ad49d3 100644 --- a/compiler/testData/ir/irText/expressions/kt37570.fir.txt +++ b/compiler/testData/ir/irText/expressions/kt37570.fir.txt @@ -21,7 +21,7 @@ FILE fqName: fileName:/kt37570.kt ANONYMOUS_INITIALIZER isStatic=false BLOCK_BODY TYPE_OP type=kotlin.Unit origin=IMPLICIT_COERCION_TO_UNIT typeOperand=kotlin.Unit - CALL 'public final fun apply (block: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1): T of kotlin.apply [inline] declared in kotlin' type=kotlin.String origin=null + CALL 'public final fun apply (block: @[ExtensionFunctionType] kotlin.Function1): T of kotlin.apply [inline] declared in kotlin' type=kotlin.String origin=null : kotlin.String $receiver: CALL 'public final fun a (): kotlin.String declared in ' type=kotlin.String origin=null block: FUN_EXPR type=kotlin.Function1 origin=LAMBDA diff --git a/compiler/testData/ir/irText/expressions/sam/samConversionToGeneric.fir.kt.txt b/compiler/testData/ir/irText/expressions/sam/samConversionToGeneric.fir.kt.txt index d0245f2b431..a81462a07eb 100644 --- a/compiler/testData/ir/irText/expressions/sam/samConversionToGeneric.fir.kt.txt +++ b/compiler/testData/ir/irText/expressions/sam/samConversionToGeneric.fir.kt.txt @@ -38,11 +38,11 @@ fun test7(a: Any) { bar(j = a /*as Function1 */ /*-> J? */) } -fun test8(efn: @ExtensionFunctionType @ExtensionFunctionType Function1): J { +fun test8(efn: @ExtensionFunctionType Function1): J { return efn /*-> J */ } -fun test9(efn: @ExtensionFunctionType @ExtensionFunctionType Function1) { +fun test9(efn: @ExtensionFunctionType Function1) { bar(j = efn /*-> J? */) } diff --git a/compiler/testData/ir/irText/expressions/sam/samConversionToGeneric.fir.txt b/compiler/testData/ir/irText/expressions/sam/samConversionToGeneric.fir.txt index e956025229a..f42df5fa5fd 100644 --- a/compiler/testData/ir/irText/expressions/sam/samConversionToGeneric.fir.txt +++ b/compiler/testData/ir/irText/expressions/sam/samConversionToGeneric.fir.txt @@ -72,19 +72,19 @@ FILE fqName: fileName:/samConversionToGeneric.kt j: TYPE_OP type=.J.H.bar?>? origin=SAM_CONVERSION typeOperand=.J.H.bar?>? TYPE_OP type=kotlin.Function1.test7, T of .test7> origin=IMPLICIT_CAST typeOperand=kotlin.Function1.test7, T of .test7> GET_VAR 'a: kotlin.Any declared in .test7' type=kotlin.Any origin=null - FUN name:test8 visibility:public modality:FINAL <> (efn:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1) returnType:.J - VALUE_PARAMETER name:efn index:0 type:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1 + FUN name:test8 visibility:public modality:FINAL <> (efn:@[ExtensionFunctionType] kotlin.Function1) returnType:.J + VALUE_PARAMETER name:efn index:0 type:@[ExtensionFunctionType] kotlin.Function1 BLOCK_BODY - RETURN type=kotlin.Nothing from='public final fun test8 (efn: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1): .J declared in ' + RETURN type=kotlin.Nothing from='public final fun test8 (efn: @[ExtensionFunctionType] kotlin.Function1): .J declared in ' TYPE_OP type=.J origin=SAM_CONVERSION typeOperand=.J - GET_VAR 'efn: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1 declared in .test8' type=@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1 origin=null - FUN name:test9 visibility:public modality:FINAL <> (efn:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1) returnType:kotlin.Unit - VALUE_PARAMETER name:efn index:0 type:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1 + GET_VAR 'efn: @[ExtensionFunctionType] kotlin.Function1 declared in .test8' type=@[ExtensionFunctionType] kotlin.Function1 origin=null + FUN name:test9 visibility:public modality:FINAL <> (efn:@[ExtensionFunctionType] kotlin.Function1) returnType:kotlin.Unit + VALUE_PARAMETER name:efn index:0 type:@[ExtensionFunctionType] kotlin.Function1 BLOCK_BODY CALL 'public open fun bar (j: .J.H.bar?>?): kotlin.Unit declared in .H' type=kotlin.Unit origin=null : kotlin.String? j: TYPE_OP type=.J.H.bar?>? origin=SAM_CONVERSION typeOperand=.J.H.bar?>? - GET_VAR 'efn: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1 declared in .test9' type=@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1 origin=null + GET_VAR 'efn: @[ExtensionFunctionType] kotlin.Function1 declared in .test9' type=@[ExtensionFunctionType] kotlin.Function1 origin=null FUN name:test10 visibility:public modality:FINAL <> (fn:kotlin.Function1) returnType:kotlin.Unit VALUE_PARAMETER name:fn index:0 type:kotlin.Function1 BLOCK_BODY diff --git a/compiler/testData/ir/irText/expressions/suspendConversionOnArbitraryExpression.fir.kt.txt b/compiler/testData/ir/irText/expressions/suspendConversionOnArbitraryExpression.fir.kt.txt index 58f8cee23af..d3aea965056 100644 --- a/compiler/testData/ir/irText/expressions/suspendConversionOnArbitraryExpression.fir.kt.txt +++ b/compiler/testData/ir/irText/expressions/suspendConversionOnArbitraryExpression.fir.kt.txt @@ -1,7 +1,7 @@ fun useSuspend(sfn: SuspendFunction0) { } -fun useSuspendExt(sfn: @ExtensionFunctionType @ExtensionFunctionType SuspendFunction1) { +fun useSuspendExt(sfn: @ExtensionFunctionType SuspendFunction1) { } fun useSuspendArg(sfn: SuspendFunction1) { @@ -10,7 +10,7 @@ fun useSuspendArg(sfn: SuspendFunction1) { fun useSuspendArgT(sfn: SuspendFunction1) { } -fun useSuspendExtT(sfn: @ExtensionFunctionType @ExtensionFunctionType SuspendFunction1) { +fun useSuspendExtT(sfn: @ExtensionFunctionType SuspendFunction1) { } fun produceFun(): Function0 { @@ -40,9 +40,9 @@ fun testSimpleNonVal() { }) } -fun testExtAsExt(fn: @ExtensionFunctionType @ExtensionFunctionType Function1) { +fun testExtAsExt(fn: @ExtensionFunctionType Function1) { useSuspendExt(sfn = { // BLOCK - local suspend fun @ExtensionFunctionType @ExtensionFunctionType Function1.suspendConversion(p0: Int) { + local suspend fun @ExtensionFunctionType Function1.suspendConversion(p0: Int) { callee.invoke(p1 = p0) } @@ -50,9 +50,9 @@ fun testExtAsExt(fn: @ExtensionFunctionType @ExtensionFunctionType Function1) { +fun testExtAsSimple(fn: @ExtensionFunctionType Function1) { useSuspendArg(sfn = { // BLOCK - local suspend fun @ExtensionFunctionType @ExtensionFunctionType Function1.suspendConversion(p0: Int) { + local suspend fun @ExtensionFunctionType Function1.suspendConversion(p0: Int) { callee.invoke(p1 = p0) } @@ -90,9 +90,9 @@ fun testSimpleAsExtT(fn: Function1) { }) } -fun testExtAsSimpleT(fn: @ExtensionFunctionType @ExtensionFunctionType Function1) { +fun testExtAsSimpleT(fn: @ExtensionFunctionType Function1) { useSuspendArgT(sfn = { // BLOCK - local suspend fun @ExtensionFunctionType @ExtensionFunctionType Function1.suspendConversion(p0: T) { + local suspend fun @ExtensionFunctionType Function1.suspendConversion(p0: T) { callee.invoke(p1 = p0) } @@ -100,9 +100,9 @@ fun testExtAsSimpleT(fn: @ExtensionFunctionType @ExtensionFunctionType Function1 }) } -fun testExtAsExtT(fn: @ExtensionFunctionType @ExtensionFunctionType Function1) { +fun testExtAsExtT(fn: @ExtensionFunctionType Function1) { useSuspendExtT(sfn = { // BLOCK - local suspend fun @ExtensionFunctionType @ExtensionFunctionType Function1.suspendConversion(p0: T) { + local suspend fun @ExtensionFunctionType Function1.suspendConversion(p0: T) { callee.invoke(p1 = p0) } @@ -130,9 +130,9 @@ fun testSimpleSAsExtT(fn: Function1) { }) } -fun testExtSAsSimpleT(fn: @ExtensionFunctionType @ExtensionFunctionType Function1) { +fun testExtSAsSimpleT(fn: @ExtensionFunctionType Function1) { useSuspendArgT(sfn = { // BLOCK - local suspend fun @ExtensionFunctionType @ExtensionFunctionType Function1.suspendConversion(p0: T) { + local suspend fun @ExtensionFunctionType Function1.suspendConversion(p0: T) { callee.invoke(p1 = p0) } @@ -140,9 +140,9 @@ fun testExtSAsSimpleT(fn: @ExtensionFunctionType @ExtensionFunctionTy }) } -fun testExtSAsExtT(fn: @ExtensionFunctionType @ExtensionFunctionType Function1) { +fun testExtSAsExtT(fn: @ExtensionFunctionType Function1) { useSuspendExtT(sfn = { // BLOCK - local suspend fun @ExtensionFunctionType @ExtensionFunctionType Function1.suspendConversion(p0: T) { + local suspend fun @ExtensionFunctionType Function1.suspendConversion(p0: T) { callee.invoke(p1 = p0) } diff --git a/compiler/testData/ir/irText/expressions/suspendConversionOnArbitraryExpression.fir.txt b/compiler/testData/ir/irText/expressions/suspendConversionOnArbitraryExpression.fir.txt index e80e8af23f0..09cebecbb93 100644 --- a/compiler/testData/ir/irText/expressions/suspendConversionOnArbitraryExpression.fir.txt +++ b/compiler/testData/ir/irText/expressions/suspendConversionOnArbitraryExpression.fir.txt @@ -2,8 +2,8 @@ FILE fqName: fileName:/suspendConversionOnArbitraryExpression.kt FUN name:useSuspend visibility:public modality:FINAL <> (sfn:kotlin.coroutines.SuspendFunction0) returnType:kotlin.Unit VALUE_PARAMETER name:sfn index:0 type:kotlin.coroutines.SuspendFunction0 BLOCK_BODY - FUN name:useSuspendExt visibility:public modality:FINAL <> (sfn:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1) returnType:kotlin.Unit - VALUE_PARAMETER name:sfn index:0 type:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1 + FUN name:useSuspendExt visibility:public modality:FINAL <> (sfn:@[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1) returnType:kotlin.Unit + VALUE_PARAMETER name:sfn index:0 type:@[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1 BLOCK_BODY FUN name:useSuspendArg visibility:public modality:FINAL <> (sfn:kotlin.coroutines.SuspendFunction1) returnType:kotlin.Unit VALUE_PARAMETER name:sfn index:0 type:kotlin.coroutines.SuspendFunction1 @@ -12,9 +12,9 @@ FILE fqName: fileName:/suspendConversionOnArbitraryExpression.kt TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] VALUE_PARAMETER name:sfn index:0 type:kotlin.coroutines.SuspendFunction1.useSuspendArgT, kotlin.Unit> BLOCK_BODY - FUN name:useSuspendExtT visibility:public modality:FINAL (sfn:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1.useSuspendExtT, kotlin.Unit>) returnType:kotlin.Unit + FUN name:useSuspendExtT visibility:public modality:FINAL (sfn:@[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1.useSuspendExtT, kotlin.Unit>) returnType:kotlin.Unit TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] - VALUE_PARAMETER name:sfn index:0 type:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1.useSuspendExtT, kotlin.Unit> + VALUE_PARAMETER name:sfn index:0 type:@[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1.useSuspendExtT, kotlin.Unit> BLOCK_BODY FUN name:produceFun visibility:public modality:FINAL <> () returnType:kotlin.Function0 BLOCK_BODY @@ -47,39 +47,39 @@ FILE fqName: fileName:/suspendConversionOnArbitraryExpression.kt $this: GET_VAR 'callee: kotlin.Function0 declared in .testSimpleNonVal.suspendConversion' type=kotlin.Function0 origin=null FUNCTION_REFERENCE 'local final fun suspendConversion (): kotlin.Unit [suspend] declared in .testSimpleNonVal' type=kotlin.coroutines.SuspendFunction0 origin=SUSPEND_CONVERSION reflectionTarget=null $receiver: CALL 'public final fun produceFun (): kotlin.Function0 declared in ' type=kotlin.Function0 origin=null - FUN name:testExtAsExt visibility:public modality:FINAL <> (fn:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1) returnType:kotlin.Unit - VALUE_PARAMETER name:fn index:0 type:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1 + FUN name:testExtAsExt visibility:public modality:FINAL <> (fn:@[ExtensionFunctionType] kotlin.Function1) returnType:kotlin.Unit + VALUE_PARAMETER name:fn index:0 type:@[ExtensionFunctionType] kotlin.Function1 BLOCK_BODY - CALL 'public final fun useSuspendExt (sfn: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1): kotlin.Unit declared in ' type=kotlin.Unit origin=null - sfn: BLOCK type=@[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1 origin=SUSPEND_CONVERSION - FUN ADAPTER_FOR_SUSPEND_CONVERSION name:suspendConversion visibility:local modality:FINAL <> ($receiver:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1, p0:kotlin.Int) returnType:kotlin.Unit [suspend] - $receiver: VALUE_PARAMETER ADAPTER_PARAMETER_FOR_SUSPEND_CONVERSION name:callee type:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1 + CALL 'public final fun useSuspendExt (sfn: @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1): kotlin.Unit declared in ' type=kotlin.Unit origin=null + sfn: BLOCK type=kotlin.coroutines.SuspendFunction1 origin=SUSPEND_CONVERSION + FUN ADAPTER_FOR_SUSPEND_CONVERSION name:suspendConversion visibility:local modality:FINAL <> ($receiver:@[ExtensionFunctionType] kotlin.Function1, p0:kotlin.Int) returnType:kotlin.Unit [suspend] + $receiver: VALUE_PARAMETER ADAPTER_PARAMETER_FOR_SUSPEND_CONVERSION name:callee type:@[ExtensionFunctionType] kotlin.Function1 VALUE_PARAMETER ADAPTER_PARAMETER_FOR_SUSPEND_CONVERSION name:p0 index:0 type:kotlin.Int BLOCK_BODY CALL 'public abstract fun invoke (p1: P1 of kotlin.Function1): R of kotlin.Function1 [operator] declared in kotlin.Function1' type=kotlin.Unit origin=null - $this: GET_VAR 'callee: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1 declared in .testExtAsExt.suspendConversion' type=@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1 origin=null + $this: GET_VAR 'callee: @[ExtensionFunctionType] kotlin.Function1 declared in .testExtAsExt.suspendConversion' type=@[ExtensionFunctionType] kotlin.Function1 origin=null p1: GET_VAR 'p0: kotlin.Int declared in .testExtAsExt.suspendConversion' type=kotlin.Int origin=null - FUNCTION_REFERENCE 'local final fun suspendConversion (p0: kotlin.Int): kotlin.Unit [suspend] declared in .testExtAsExt' type=@[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1 origin=SUSPEND_CONVERSION reflectionTarget=null - $receiver: GET_VAR 'fn: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1 declared in .testExtAsExt' type=@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1 origin=null - FUN name:testExtAsSimple visibility:public modality:FINAL <> (fn:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1) returnType:kotlin.Unit - VALUE_PARAMETER name:fn index:0 type:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1 + FUNCTION_REFERENCE 'local final fun suspendConversion (p0: kotlin.Int): kotlin.Unit [suspend] declared in .testExtAsExt' type=kotlin.coroutines.SuspendFunction1 origin=SUSPEND_CONVERSION reflectionTarget=null + $receiver: GET_VAR 'fn: @[ExtensionFunctionType] kotlin.Function1 declared in .testExtAsExt' type=@[ExtensionFunctionType] kotlin.Function1 origin=null + FUN name:testExtAsSimple visibility:public modality:FINAL <> (fn:@[ExtensionFunctionType] kotlin.Function1) returnType:kotlin.Unit + VALUE_PARAMETER name:fn index:0 type:@[ExtensionFunctionType] kotlin.Function1 BLOCK_BODY CALL 'public final fun useSuspendArg (sfn: kotlin.coroutines.SuspendFunction1): kotlin.Unit declared in ' type=kotlin.Unit origin=null sfn: BLOCK type=kotlin.coroutines.SuspendFunction1 origin=SUSPEND_CONVERSION - FUN ADAPTER_FOR_SUSPEND_CONVERSION name:suspendConversion visibility:local modality:FINAL <> ($receiver:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1, p0:kotlin.Int) returnType:kotlin.Unit [suspend] - $receiver: VALUE_PARAMETER ADAPTER_PARAMETER_FOR_SUSPEND_CONVERSION name:callee type:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1 + FUN ADAPTER_FOR_SUSPEND_CONVERSION name:suspendConversion visibility:local modality:FINAL <> ($receiver:@[ExtensionFunctionType] kotlin.Function1, p0:kotlin.Int) returnType:kotlin.Unit [suspend] + $receiver: VALUE_PARAMETER ADAPTER_PARAMETER_FOR_SUSPEND_CONVERSION name:callee type:@[ExtensionFunctionType] kotlin.Function1 VALUE_PARAMETER ADAPTER_PARAMETER_FOR_SUSPEND_CONVERSION name:p0 index:0 type:kotlin.Int BLOCK_BODY CALL 'public abstract fun invoke (p1: P1 of kotlin.Function1): R of kotlin.Function1 [operator] declared in kotlin.Function1' type=kotlin.Unit origin=null - $this: GET_VAR 'callee: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1 declared in .testExtAsSimple.suspendConversion' type=@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1 origin=null + $this: GET_VAR 'callee: @[ExtensionFunctionType] kotlin.Function1 declared in .testExtAsSimple.suspendConversion' type=@[ExtensionFunctionType] kotlin.Function1 origin=null p1: GET_VAR 'p0: kotlin.Int declared in .testExtAsSimple.suspendConversion' type=kotlin.Int origin=null FUNCTION_REFERENCE 'local final fun suspendConversion (p0: kotlin.Int): kotlin.Unit [suspend] declared in .testExtAsSimple' type=kotlin.coroutines.SuspendFunction1 origin=SUSPEND_CONVERSION reflectionTarget=null - $receiver: GET_VAR 'fn: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1 declared in .testExtAsSimple' type=@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1 origin=null + $receiver: GET_VAR 'fn: @[ExtensionFunctionType] kotlin.Function1 declared in .testExtAsSimple' type=@[ExtensionFunctionType] kotlin.Function1 origin=null FUN name:testSimpleAsExt visibility:public modality:FINAL <> (fn:kotlin.Function1) returnType:kotlin.Unit VALUE_PARAMETER name:fn index:0 type:kotlin.Function1 BLOCK_BODY - CALL 'public final fun useSuspendExt (sfn: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1): kotlin.Unit declared in ' type=kotlin.Unit origin=null - sfn: BLOCK type=@[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1 origin=SUSPEND_CONVERSION + CALL 'public final fun useSuspendExt (sfn: @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1): kotlin.Unit declared in ' type=kotlin.Unit origin=null + sfn: BLOCK type=kotlin.coroutines.SuspendFunction1 origin=SUSPEND_CONVERSION FUN ADAPTER_FOR_SUSPEND_CONVERSION name:suspendConversion visibility:local modality:FINAL <> ($receiver:kotlin.Function1, p0:kotlin.Int) returnType:kotlin.Unit [suspend] $receiver: VALUE_PARAMETER ADAPTER_PARAMETER_FOR_SUSPEND_CONVERSION name:callee type:kotlin.Function1 VALUE_PARAMETER ADAPTER_PARAMETER_FOR_SUSPEND_CONVERSION name:p0 index:0 type:kotlin.Int @@ -87,7 +87,7 @@ FILE fqName: fileName:/suspendConversionOnArbitraryExpression.kt CALL 'public abstract fun invoke (p1: P1 of kotlin.Function1): R of kotlin.Function1 [operator] declared in kotlin.Function1' type=kotlin.Unit origin=null $this: GET_VAR 'callee: kotlin.Function1 declared in .testSimpleAsExt.suspendConversion' type=kotlin.Function1 origin=null p1: GET_VAR 'p0: kotlin.Int declared in .testSimpleAsExt.suspendConversion' type=kotlin.Int origin=null - FUNCTION_REFERENCE 'local final fun suspendConversion (p0: kotlin.Int): kotlin.Unit [suspend] declared in .testSimpleAsExt' type=@[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1 origin=SUSPEND_CONVERSION reflectionTarget=null + FUNCTION_REFERENCE 'local final fun suspendConversion (p0: kotlin.Int): kotlin.Unit [suspend] declared in .testSimpleAsExt' type=kotlin.coroutines.SuspendFunction1 origin=SUSPEND_CONVERSION reflectionTarget=null $receiver: GET_VAR 'fn: kotlin.Function1 declared in .testSimpleAsExt' type=kotlin.Function1 origin=null FUN name:testSimpleAsSimpleT visibility:public modality:FINAL <> (fn:kotlin.Function1) returnType:kotlin.Unit VALUE_PARAMETER name:fn index:0 type:kotlin.Function1 @@ -107,9 +107,9 @@ FILE fqName: fileName:/suspendConversionOnArbitraryExpression.kt FUN name:testSimpleAsExtT visibility:public modality:FINAL <> (fn:kotlin.Function1) returnType:kotlin.Unit VALUE_PARAMETER name:fn index:0 type:kotlin.Function1 BLOCK_BODY - CALL 'public final fun useSuspendExtT (sfn: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1.useSuspendExtT, kotlin.Unit>): kotlin.Unit declared in ' type=kotlin.Unit origin=null + CALL 'public final fun useSuspendExtT (sfn: @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1.useSuspendExtT, kotlin.Unit>): kotlin.Unit declared in ' type=kotlin.Unit origin=null : kotlin.Int - sfn: BLOCK type=@[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1.useSuspendExtT, kotlin.Unit> origin=SUSPEND_CONVERSION + sfn: BLOCK type=kotlin.coroutines.SuspendFunction1.useSuspendExtT, kotlin.Unit> origin=SUSPEND_CONVERSION FUN ADAPTER_FOR_SUSPEND_CONVERSION name:suspendConversion visibility:local modality:FINAL <> ($receiver:kotlin.Function1, p0:T of .useSuspendExtT) returnType:kotlin.Unit [suspend] $receiver: VALUE_PARAMETER ADAPTER_PARAMETER_FOR_SUSPEND_CONVERSION name:callee type:kotlin.Function1 VALUE_PARAMETER ADAPTER_PARAMETER_FOR_SUSPEND_CONVERSION name:p0 index:0 type:T of .useSuspendExtT @@ -117,38 +117,38 @@ FILE fqName: fileName:/suspendConversionOnArbitraryExpression.kt CALL 'public abstract fun invoke (p1: P1 of kotlin.Function1): R of kotlin.Function1 [operator] declared in kotlin.Function1' type=kotlin.Unit origin=null $this: GET_VAR 'callee: kotlin.Function1 declared in .testSimpleAsExtT.suspendConversion' type=kotlin.Function1 origin=null p1: GET_VAR 'p0: T of .useSuspendExtT declared in .testSimpleAsExtT.suspendConversion' type=T of .useSuspendExtT origin=null - FUNCTION_REFERENCE 'local final fun suspendConversion (p0: T of .useSuspendExtT): kotlin.Unit [suspend] declared in .testSimpleAsExtT' type=@[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1.useSuspendExtT, kotlin.Unit> origin=SUSPEND_CONVERSION reflectionTarget=null + FUNCTION_REFERENCE 'local final fun suspendConversion (p0: T of .useSuspendExtT): kotlin.Unit [suspend] declared in .testSimpleAsExtT' type=kotlin.coroutines.SuspendFunction1.useSuspendExtT, kotlin.Unit> origin=SUSPEND_CONVERSION reflectionTarget=null $receiver: GET_VAR 'fn: kotlin.Function1 declared in .testSimpleAsExtT' type=kotlin.Function1 origin=null - FUN name:testExtAsSimpleT visibility:public modality:FINAL <> (fn:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1) returnType:kotlin.Unit - VALUE_PARAMETER name:fn index:0 type:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1 + FUN name:testExtAsSimpleT visibility:public modality:FINAL <> (fn:@[ExtensionFunctionType] kotlin.Function1) returnType:kotlin.Unit + VALUE_PARAMETER name:fn index:0 type:@[ExtensionFunctionType] kotlin.Function1 BLOCK_BODY CALL 'public final fun useSuspendArgT (sfn: kotlin.coroutines.SuspendFunction1.useSuspendArgT, kotlin.Unit>): kotlin.Unit declared in ' type=kotlin.Unit origin=null : kotlin.Int sfn: BLOCK type=kotlin.coroutines.SuspendFunction1.useSuspendArgT, kotlin.Unit> origin=SUSPEND_CONVERSION - FUN ADAPTER_FOR_SUSPEND_CONVERSION name:suspendConversion visibility:local modality:FINAL <> ($receiver:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1, p0:T of .useSuspendArgT) returnType:kotlin.Unit [suspend] - $receiver: VALUE_PARAMETER ADAPTER_PARAMETER_FOR_SUSPEND_CONVERSION name:callee type:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1 + FUN ADAPTER_FOR_SUSPEND_CONVERSION name:suspendConversion visibility:local modality:FINAL <> ($receiver:@[ExtensionFunctionType] kotlin.Function1, p0:T of .useSuspendArgT) returnType:kotlin.Unit [suspend] + $receiver: VALUE_PARAMETER ADAPTER_PARAMETER_FOR_SUSPEND_CONVERSION name:callee type:@[ExtensionFunctionType] kotlin.Function1 VALUE_PARAMETER ADAPTER_PARAMETER_FOR_SUSPEND_CONVERSION name:p0 index:0 type:T of .useSuspendArgT BLOCK_BODY CALL 'public abstract fun invoke (p1: P1 of kotlin.Function1): R of kotlin.Function1 [operator] declared in kotlin.Function1' type=kotlin.Unit origin=null - $this: GET_VAR 'callee: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1 declared in .testExtAsSimpleT.suspendConversion' type=@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1 origin=null + $this: GET_VAR 'callee: @[ExtensionFunctionType] kotlin.Function1 declared in .testExtAsSimpleT.suspendConversion' type=@[ExtensionFunctionType] kotlin.Function1 origin=null p1: GET_VAR 'p0: T of .useSuspendArgT declared in .testExtAsSimpleT.suspendConversion' type=T of .useSuspendArgT origin=null FUNCTION_REFERENCE 'local final fun suspendConversion (p0: T of .useSuspendArgT): kotlin.Unit [suspend] declared in .testExtAsSimpleT' type=kotlin.coroutines.SuspendFunction1.useSuspendArgT, kotlin.Unit> origin=SUSPEND_CONVERSION reflectionTarget=null - $receiver: GET_VAR 'fn: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1 declared in .testExtAsSimpleT' type=@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1 origin=null - FUN name:testExtAsExtT visibility:public modality:FINAL <> (fn:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1) returnType:kotlin.Unit - VALUE_PARAMETER name:fn index:0 type:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1 + $receiver: GET_VAR 'fn: @[ExtensionFunctionType] kotlin.Function1 declared in .testExtAsSimpleT' type=@[ExtensionFunctionType] kotlin.Function1 origin=null + FUN name:testExtAsExtT visibility:public modality:FINAL <> (fn:@[ExtensionFunctionType] kotlin.Function1) returnType:kotlin.Unit + VALUE_PARAMETER name:fn index:0 type:@[ExtensionFunctionType] kotlin.Function1 BLOCK_BODY - CALL 'public final fun useSuspendExtT (sfn: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1.useSuspendExtT, kotlin.Unit>): kotlin.Unit declared in ' type=kotlin.Unit origin=null + CALL 'public final fun useSuspendExtT (sfn: @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1.useSuspendExtT, kotlin.Unit>): kotlin.Unit declared in ' type=kotlin.Unit origin=null : kotlin.Int - sfn: BLOCK type=@[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1.useSuspendExtT, kotlin.Unit> origin=SUSPEND_CONVERSION - FUN ADAPTER_FOR_SUSPEND_CONVERSION name:suspendConversion visibility:local modality:FINAL <> ($receiver:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1, p0:T of .useSuspendExtT) returnType:kotlin.Unit [suspend] - $receiver: VALUE_PARAMETER ADAPTER_PARAMETER_FOR_SUSPEND_CONVERSION name:callee type:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1 + sfn: BLOCK type=kotlin.coroutines.SuspendFunction1.useSuspendExtT, kotlin.Unit> origin=SUSPEND_CONVERSION + FUN ADAPTER_FOR_SUSPEND_CONVERSION name:suspendConversion visibility:local modality:FINAL <> ($receiver:@[ExtensionFunctionType] kotlin.Function1, p0:T of .useSuspendExtT) returnType:kotlin.Unit [suspend] + $receiver: VALUE_PARAMETER ADAPTER_PARAMETER_FOR_SUSPEND_CONVERSION name:callee type:@[ExtensionFunctionType] kotlin.Function1 VALUE_PARAMETER ADAPTER_PARAMETER_FOR_SUSPEND_CONVERSION name:p0 index:0 type:T of .useSuspendExtT BLOCK_BODY CALL 'public abstract fun invoke (p1: P1 of kotlin.Function1): R of kotlin.Function1 [operator] declared in kotlin.Function1' type=kotlin.Unit origin=null - $this: GET_VAR 'callee: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1 declared in .testExtAsExtT.suspendConversion' type=@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1 origin=null + $this: GET_VAR 'callee: @[ExtensionFunctionType] kotlin.Function1 declared in .testExtAsExtT.suspendConversion' type=@[ExtensionFunctionType] kotlin.Function1 origin=null p1: GET_VAR 'p0: T of .useSuspendExtT declared in .testExtAsExtT.suspendConversion' type=T of .useSuspendExtT origin=null - FUNCTION_REFERENCE 'local final fun suspendConversion (p0: T of .useSuspendExtT): kotlin.Unit [suspend] declared in .testExtAsExtT' type=@[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1.useSuspendExtT, kotlin.Unit> origin=SUSPEND_CONVERSION reflectionTarget=null - $receiver: GET_VAR 'fn: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1 declared in .testExtAsExtT' type=@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1 origin=null + FUNCTION_REFERENCE 'local final fun suspendConversion (p0: T of .useSuspendExtT): kotlin.Unit [suspend] declared in .testExtAsExtT' type=kotlin.coroutines.SuspendFunction1.useSuspendExtT, kotlin.Unit> origin=SUSPEND_CONVERSION reflectionTarget=null + $receiver: GET_VAR 'fn: @[ExtensionFunctionType] kotlin.Function1 declared in .testExtAsExtT' type=@[ExtensionFunctionType] kotlin.Function1 origin=null FUN name:testSimpleSAsSimpleT visibility:public modality:FINAL (fn:kotlin.Function1.testSimpleSAsSimpleT, kotlin.Unit>) returnType:kotlin.Unit TYPE_PARAMETER name:S index:0 variance: superTypes:[kotlin.Any?] VALUE_PARAMETER name:fn index:0 type:kotlin.Function1.testSimpleSAsSimpleT, kotlin.Unit> @@ -169,9 +169,9 @@ FILE fqName: fileName:/suspendConversionOnArbitraryExpression.kt TYPE_PARAMETER name:S index:0 variance: superTypes:[kotlin.Any?] VALUE_PARAMETER name:fn index:0 type:kotlin.Function1.testSimpleSAsExtT, kotlin.Unit> BLOCK_BODY - CALL 'public final fun useSuspendExtT (sfn: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1.useSuspendExtT, kotlin.Unit>): kotlin.Unit declared in ' type=kotlin.Unit origin=null + CALL 'public final fun useSuspendExtT (sfn: @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1.useSuspendExtT, kotlin.Unit>): kotlin.Unit declared in ' type=kotlin.Unit origin=null : S of .testSimpleSAsExtT - sfn: BLOCK type=@[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1.useSuspendExtT, kotlin.Unit> origin=SUSPEND_CONVERSION + sfn: BLOCK type=kotlin.coroutines.SuspendFunction1.useSuspendExtT, kotlin.Unit> origin=SUSPEND_CONVERSION FUN ADAPTER_FOR_SUSPEND_CONVERSION name:suspendConversion visibility:local modality:FINAL <> ($receiver:kotlin.Function1.testSimpleSAsExtT, kotlin.Unit>, p0:T of .useSuspendExtT) returnType:kotlin.Unit [suspend] $receiver: VALUE_PARAMETER ADAPTER_PARAMETER_FOR_SUSPEND_CONVERSION name:callee type:kotlin.Function1.testSimpleSAsExtT, kotlin.Unit> VALUE_PARAMETER ADAPTER_PARAMETER_FOR_SUSPEND_CONVERSION name:p0 index:0 type:T of .useSuspendExtT @@ -179,40 +179,40 @@ FILE fqName: fileName:/suspendConversionOnArbitraryExpression.kt CALL 'public abstract fun invoke (p1: P1 of kotlin.Function1): R of kotlin.Function1 [operator] declared in kotlin.Function1' type=kotlin.Unit origin=null $this: GET_VAR 'callee: kotlin.Function1.testSimpleSAsExtT, kotlin.Unit> declared in .testSimpleSAsExtT.suspendConversion' type=kotlin.Function1.testSimpleSAsExtT, kotlin.Unit> origin=null p1: GET_VAR 'p0: T of .useSuspendExtT declared in .testSimpleSAsExtT.suspendConversion' type=T of .useSuspendExtT origin=null - FUNCTION_REFERENCE 'local final fun suspendConversion (p0: T of .useSuspendExtT): kotlin.Unit [suspend] declared in .testSimpleSAsExtT' type=@[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1.useSuspendExtT, kotlin.Unit> origin=SUSPEND_CONVERSION reflectionTarget=null + FUNCTION_REFERENCE 'local final fun suspendConversion (p0: T of .useSuspendExtT): kotlin.Unit [suspend] declared in .testSimpleSAsExtT' type=kotlin.coroutines.SuspendFunction1.useSuspendExtT, kotlin.Unit> origin=SUSPEND_CONVERSION reflectionTarget=null $receiver: GET_VAR 'fn: kotlin.Function1.testSimpleSAsExtT, kotlin.Unit> declared in .testSimpleSAsExtT' type=kotlin.Function1.testSimpleSAsExtT, kotlin.Unit> origin=null - FUN name:testExtSAsSimpleT visibility:public modality:FINAL (fn:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1.testExtSAsSimpleT, kotlin.Unit>) returnType:kotlin.Unit + FUN name:testExtSAsSimpleT visibility:public modality:FINAL (fn:@[ExtensionFunctionType] kotlin.Function1.testExtSAsSimpleT, kotlin.Unit>) returnType:kotlin.Unit TYPE_PARAMETER name:S index:0 variance: superTypes:[kotlin.Any?] - VALUE_PARAMETER name:fn index:0 type:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1.testExtSAsSimpleT, kotlin.Unit> + VALUE_PARAMETER name:fn index:0 type:@[ExtensionFunctionType] kotlin.Function1.testExtSAsSimpleT, kotlin.Unit> BLOCK_BODY CALL 'public final fun useSuspendArgT (sfn: kotlin.coroutines.SuspendFunction1.useSuspendArgT, kotlin.Unit>): kotlin.Unit declared in ' type=kotlin.Unit origin=null : S of .testExtSAsSimpleT sfn: BLOCK type=kotlin.coroutines.SuspendFunction1.useSuspendArgT, kotlin.Unit> origin=SUSPEND_CONVERSION - FUN ADAPTER_FOR_SUSPEND_CONVERSION name:suspendConversion visibility:local modality:FINAL <> ($receiver:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1.testExtSAsSimpleT, kotlin.Unit>, p0:T of .useSuspendArgT) returnType:kotlin.Unit [suspend] - $receiver: VALUE_PARAMETER ADAPTER_PARAMETER_FOR_SUSPEND_CONVERSION name:callee type:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1.testExtSAsSimpleT, kotlin.Unit> + FUN ADAPTER_FOR_SUSPEND_CONVERSION name:suspendConversion visibility:local modality:FINAL <> ($receiver:@[ExtensionFunctionType] kotlin.Function1.testExtSAsSimpleT, kotlin.Unit>, p0:T of .useSuspendArgT) returnType:kotlin.Unit [suspend] + $receiver: VALUE_PARAMETER ADAPTER_PARAMETER_FOR_SUSPEND_CONVERSION name:callee type:@[ExtensionFunctionType] kotlin.Function1.testExtSAsSimpleT, kotlin.Unit> VALUE_PARAMETER ADAPTER_PARAMETER_FOR_SUSPEND_CONVERSION name:p0 index:0 type:T of .useSuspendArgT BLOCK_BODY CALL 'public abstract fun invoke (p1: P1 of kotlin.Function1): R of kotlin.Function1 [operator] declared in kotlin.Function1' type=kotlin.Unit origin=null - $this: GET_VAR 'callee: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1.testExtSAsSimpleT, kotlin.Unit> declared in .testExtSAsSimpleT.suspendConversion' type=@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1.testExtSAsSimpleT, kotlin.Unit> origin=null + $this: GET_VAR 'callee: @[ExtensionFunctionType] kotlin.Function1.testExtSAsSimpleT, kotlin.Unit> declared in .testExtSAsSimpleT.suspendConversion' type=@[ExtensionFunctionType] kotlin.Function1.testExtSAsSimpleT, kotlin.Unit> origin=null p1: GET_VAR 'p0: T of .useSuspendArgT declared in .testExtSAsSimpleT.suspendConversion' type=T of .useSuspendArgT origin=null FUNCTION_REFERENCE 'local final fun suspendConversion (p0: T of .useSuspendArgT): kotlin.Unit [suspend] declared in .testExtSAsSimpleT' type=kotlin.coroutines.SuspendFunction1.useSuspendArgT, kotlin.Unit> origin=SUSPEND_CONVERSION reflectionTarget=null - $receiver: GET_VAR 'fn: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1.testExtSAsSimpleT, kotlin.Unit> declared in .testExtSAsSimpleT' type=@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1.testExtSAsSimpleT, kotlin.Unit> origin=null - FUN name:testExtSAsExtT visibility:public modality:FINAL (fn:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1.testExtSAsExtT, kotlin.Unit>) returnType:kotlin.Unit + $receiver: GET_VAR 'fn: @[ExtensionFunctionType] kotlin.Function1.testExtSAsSimpleT, kotlin.Unit> declared in .testExtSAsSimpleT' type=@[ExtensionFunctionType] kotlin.Function1.testExtSAsSimpleT, kotlin.Unit> origin=null + FUN name:testExtSAsExtT visibility:public modality:FINAL (fn:@[ExtensionFunctionType] kotlin.Function1.testExtSAsExtT, kotlin.Unit>) returnType:kotlin.Unit TYPE_PARAMETER name:S index:0 variance: superTypes:[kotlin.Any?] - VALUE_PARAMETER name:fn index:0 type:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1.testExtSAsExtT, kotlin.Unit> + VALUE_PARAMETER name:fn index:0 type:@[ExtensionFunctionType] kotlin.Function1.testExtSAsExtT, kotlin.Unit> BLOCK_BODY - CALL 'public final fun useSuspendExtT (sfn: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1.useSuspendExtT, kotlin.Unit>): kotlin.Unit declared in ' type=kotlin.Unit origin=null + CALL 'public final fun useSuspendExtT (sfn: @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1.useSuspendExtT, kotlin.Unit>): kotlin.Unit declared in ' type=kotlin.Unit origin=null : S of .testExtSAsExtT - sfn: BLOCK type=@[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1.useSuspendExtT, kotlin.Unit> origin=SUSPEND_CONVERSION - FUN ADAPTER_FOR_SUSPEND_CONVERSION name:suspendConversion visibility:local modality:FINAL <> ($receiver:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1.testExtSAsExtT, kotlin.Unit>, p0:T of .useSuspendExtT) returnType:kotlin.Unit [suspend] - $receiver: VALUE_PARAMETER ADAPTER_PARAMETER_FOR_SUSPEND_CONVERSION name:callee type:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1.testExtSAsExtT, kotlin.Unit> + sfn: BLOCK type=kotlin.coroutines.SuspendFunction1.useSuspendExtT, kotlin.Unit> origin=SUSPEND_CONVERSION + FUN ADAPTER_FOR_SUSPEND_CONVERSION name:suspendConversion visibility:local modality:FINAL <> ($receiver:@[ExtensionFunctionType] kotlin.Function1.testExtSAsExtT, kotlin.Unit>, p0:T of .useSuspendExtT) returnType:kotlin.Unit [suspend] + $receiver: VALUE_PARAMETER ADAPTER_PARAMETER_FOR_SUSPEND_CONVERSION name:callee type:@[ExtensionFunctionType] kotlin.Function1.testExtSAsExtT, kotlin.Unit> VALUE_PARAMETER ADAPTER_PARAMETER_FOR_SUSPEND_CONVERSION name:p0 index:0 type:T of .useSuspendExtT BLOCK_BODY CALL 'public abstract fun invoke (p1: P1 of kotlin.Function1): R of kotlin.Function1 [operator] declared in kotlin.Function1' type=kotlin.Unit origin=null - $this: GET_VAR 'callee: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1.testExtSAsExtT, kotlin.Unit> declared in .testExtSAsExtT.suspendConversion' type=@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1.testExtSAsExtT, kotlin.Unit> origin=null + $this: GET_VAR 'callee: @[ExtensionFunctionType] kotlin.Function1.testExtSAsExtT, kotlin.Unit> declared in .testExtSAsExtT.suspendConversion' type=@[ExtensionFunctionType] kotlin.Function1.testExtSAsExtT, kotlin.Unit> origin=null p1: GET_VAR 'p0: T of .useSuspendExtT declared in .testExtSAsExtT.suspendConversion' type=T of .useSuspendExtT origin=null - FUNCTION_REFERENCE 'local final fun suspendConversion (p0: T of .useSuspendExtT): kotlin.Unit [suspend] declared in .testExtSAsExtT' type=@[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1.useSuspendExtT, kotlin.Unit> origin=SUSPEND_CONVERSION reflectionTarget=null - $receiver: GET_VAR 'fn: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1.testExtSAsExtT, kotlin.Unit> declared in .testExtSAsExtT' type=@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1.testExtSAsExtT, kotlin.Unit> origin=null + FUNCTION_REFERENCE 'local final fun suspendConversion (p0: T of .useSuspendExtT): kotlin.Unit [suspend] declared in .testExtSAsExtT' type=kotlin.coroutines.SuspendFunction1.useSuspendExtT, kotlin.Unit> origin=SUSPEND_CONVERSION reflectionTarget=null + $receiver: GET_VAR 'fn: @[ExtensionFunctionType] kotlin.Function1.testExtSAsExtT, kotlin.Unit> declared in .testExtSAsExtT' type=@[ExtensionFunctionType] kotlin.Function1.testExtSAsExtT, kotlin.Unit> origin=null FUN name:testSmartCastWithSuspendConversion visibility:public modality:FINAL <> (a:kotlin.Any) returnType:kotlin.Unit VALUE_PARAMETER name:a index:0 type:kotlin.Any BLOCK_BODY diff --git a/compiler/testData/ir/irText/expressions/variableAsFunctionCall.fir.kt.txt b/compiler/testData/ir/irText/expressions/variableAsFunctionCall.fir.kt.txt index ec434a2a7e0..d26d3800122 100644 --- a/compiler/testData/ir/irText/expressions/variableAsFunctionCall.fir.kt.txt +++ b/compiler/testData/ir/irText/expressions/variableAsFunctionCall.fir.kt.txt @@ -9,7 +9,7 @@ fun test1(f: Function0) { return f.invoke() } -fun test2(f: @ExtensionFunctionType @ExtensionFunctionType Function1) { +fun test2(f: @ExtensionFunctionType Function1) { return f.invoke(p1 = "hello") } diff --git a/compiler/testData/ir/irText/expressions/variableAsFunctionCall.fir.txt b/compiler/testData/ir/irText/expressions/variableAsFunctionCall.fir.txt index 2e60d30775d..7ba641b6e3a 100644 --- a/compiler/testData/ir/irText/expressions/variableAsFunctionCall.fir.txt +++ b/compiler/testData/ir/irText/expressions/variableAsFunctionCall.fir.txt @@ -14,12 +14,12 @@ FILE fqName: fileName:/variableAsFunctionCall.kt RETURN type=kotlin.Nothing from='public final fun test1 (f: kotlin.Function0): kotlin.Unit declared in ' CALL 'public abstract fun invoke (): R of kotlin.Function0 [operator] declared in kotlin.Function0' type=kotlin.Unit origin=INVOKE $this: GET_VAR 'f: kotlin.Function0 declared in .test1' type=kotlin.Function0 origin=VARIABLE_AS_FUNCTION - FUN name:test2 visibility:public modality:FINAL <> (f:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1) returnType:kotlin.Unit - VALUE_PARAMETER name:f index:0 type:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1 + FUN name:test2 visibility:public modality:FINAL <> (f:@[ExtensionFunctionType] kotlin.Function1) returnType:kotlin.Unit + VALUE_PARAMETER name:f index:0 type:@[ExtensionFunctionType] kotlin.Function1 BLOCK_BODY - RETURN type=kotlin.Nothing from='public final fun test2 (f: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1): kotlin.Unit declared in ' + RETURN type=kotlin.Nothing from='public final fun test2 (f: @[ExtensionFunctionType] kotlin.Function1): kotlin.Unit declared in ' CALL 'public abstract fun invoke (p1: P1 of kotlin.Function1): R of kotlin.Function1 [operator] declared in kotlin.Function1' type=kotlin.Unit origin=INVOKE - $this: GET_VAR 'f: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1 declared in .test2' type=@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1 origin=VARIABLE_AS_FUNCTION + $this: GET_VAR 'f: @[ExtensionFunctionType] kotlin.Function1 declared in .test2' type=@[ExtensionFunctionType] kotlin.Function1 origin=VARIABLE_AS_FUNCTION p1: CONST String type=kotlin.String value="hello" FUN name:test3 visibility:public modality:FINAL <> () returnType:kotlin.String BLOCK_BODY diff --git a/compiler/testData/ir/irText/firProblems/AllCandidates.fir.txt b/compiler/testData/ir/irText/firProblems/AllCandidates.fir.txt index f0afc80228e..a9652095e84 100644 --- a/compiler/testData/ir/irText/firProblems/AllCandidates.fir.txt +++ b/compiler/testData/ir/irText/firProblems/AllCandidates.fir.txt @@ -55,7 +55,7 @@ FILE fqName: fileName:/AllCandidates.kt VALUE_PARAMETER name:allCandidates index:0 type:kotlin.collections.Collection<.MyCandidate> BLOCK_BODY RETURN type=kotlin.Nothing from='private final fun allCandidatesResult (allCandidates: kotlin.collections.Collection<.MyCandidate>): .OverloadResolutionResultsImpl.allCandidatesResult?>? declared in ' - CALL 'public final fun apply (block: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1): T of kotlin.apply [inline] declared in kotlin' type=.OverloadResolutionResultsImpl.allCandidatesResult?>? origin=null + CALL 'public final fun apply (block: @[ExtensionFunctionType] kotlin.Function1): T of kotlin.apply [inline] declared in kotlin' type=.OverloadResolutionResultsImpl.allCandidatesResult?>? origin=null : .OverloadResolutionResultsImpl.allCandidatesResult?>? $receiver: CALL 'public open fun nameNotFound (): .OverloadResolutionResultsImpl.OverloadResolutionResultsImpl.nameNotFound?>? declared in .OverloadResolutionResultsImpl' type=.OverloadResolutionResultsImpl.allCandidatesResult?>? origin=null : A of .allCandidatesResult? diff --git a/compiler/testData/ir/irText/firProblems/typeVariableAfterBuildMap.fir.txt b/compiler/testData/ir/irText/firProblems/typeVariableAfterBuildMap.fir.txt index c4ed0731a15..1534070b987 100644 --- a/compiler/testData/ir/irText/firProblems/typeVariableAfterBuildMap.fir.txt +++ b/compiler/testData/ir/irText/firProblems/typeVariableAfterBuildMap.fir.txt @@ -545,7 +545,7 @@ FILE fqName: fileName:/typeVariableAfterBuildMap.kt PROPERTY name:ORDERED_VISIBILITIES visibility:private modality:FINAL [val] FIELD PROPERTY_BACKING_FIELD name:ORDERED_VISIBILITIES type:kotlin.collections.Map<.Visibility, kotlin.Int> visibility:private [final] EXPRESSION_BODY - CALL 'public final fun buildMap (builderAction: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1, kotlin.Unit>): kotlin.collections.Map [inline] declared in kotlin.collections' type=kotlin.collections.Map<.Visibility, kotlin.Int> origin=null + CALL 'public final fun buildMap (builderAction: @[ExtensionFunctionType] kotlin.Function1, kotlin.Unit>): kotlin.collections.Map [inline] declared in kotlin.collections' type=kotlin.collections.Map<.Visibility, kotlin.Int> origin=null : .Visibility : kotlin.Int builderAction: FUN_EXPR type=kotlin.Function1.Visibility, kotlin.Int>, kotlin.Unit> origin=LAMBDA diff --git a/compiler/testData/ir/irText/lambdas/extensionLambda.fir.txt b/compiler/testData/ir/irText/lambdas/extensionLambda.fir.txt index a57a2b134fe..56bbb873c5c 100644 --- a/compiler/testData/ir/irText/lambdas/extensionLambda.fir.txt +++ b/compiler/testData/ir/irText/lambdas/extensionLambda.fir.txt @@ -2,7 +2,7 @@ FILE fqName: fileName:/extensionLambda.kt FUN name:test1 visibility:public modality:FINAL <> () returnType:kotlin.Int BLOCK_BODY RETURN type=kotlin.Nothing from='public final fun test1 (): kotlin.Int declared in ' - CALL 'public final fun run (block: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1): R of kotlin.run [inline] declared in kotlin' type=kotlin.Int origin=null + CALL 'public final fun run (block: @[ExtensionFunctionType] kotlin.Function1): R of kotlin.run [inline] declared in kotlin' type=kotlin.Int origin=null : kotlin.String : kotlin.Int $receiver: CONST String type=kotlin.String value="42" diff --git a/compiler/testData/ir/irText/lambdas/multipleImplicitReceivers.fir.txt b/compiler/testData/ir/irText/lambdas/multipleImplicitReceivers.fir.txt index ed4c93f35a2..7e81e71b4c3 100644 --- a/compiler/testData/ir/irText/lambdas/multipleImplicitReceivers.fir.txt +++ b/compiler/testData/ir/irText/lambdas/multipleImplicitReceivers.fir.txt @@ -86,7 +86,7 @@ FILE fqName: fileName:/multipleImplicitReceivers.kt VALUE_PARAMETER name:invokeImpl index:1 type:.IInvoke BLOCK_BODY TYPE_OP type=kotlin.Unit origin=IMPLICIT_COERCION_TO_UNIT typeOperand=kotlin.Unit - CALL 'public final fun with (receiver: T of kotlin.with, block: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1): R of kotlin.with [inline] declared in kotlin' type=kotlin.Int origin=null + CALL 'public final fun with (receiver: T of kotlin.with, block: @[ExtensionFunctionType] kotlin.Function1): R of kotlin.with [inline] declared in kotlin' type=kotlin.Int origin=null : .A : kotlin.Int receiver: GET_OBJECT 'CLASS OBJECT name:A modality:FINAL visibility:public superTypes:[kotlin.Any]' type=.A @@ -95,7 +95,7 @@ FILE fqName: fileName:/multipleImplicitReceivers.kt $receiver: VALUE_PARAMETER name: type:.A BLOCK_BODY RETURN type=kotlin.Nothing from='local final fun (): kotlin.Int declared in .test' - CALL 'public final fun with (receiver: T of kotlin.with, block: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1): R of kotlin.with [inline] declared in kotlin' type=kotlin.Int origin=null + CALL 'public final fun with (receiver: T of kotlin.with, block: @[ExtensionFunctionType] kotlin.Function1): R of kotlin.with [inline] declared in kotlin' type=kotlin.Int origin=null : .IFoo : kotlin.Int receiver: GET_VAR 'fooImpl: .IFoo declared in .test' type=.IFoo origin=null @@ -104,7 +104,7 @@ FILE fqName: fileName:/multipleImplicitReceivers.kt $receiver: VALUE_PARAMETER name: type:.IFoo BLOCK_BODY RETURN type=kotlin.Nothing from='local final fun (): kotlin.Int declared in .test.' - CALL 'public final fun with (receiver: T of kotlin.with, block: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1): R of kotlin.with [inline] declared in kotlin' type=kotlin.Int origin=null + CALL 'public final fun with (receiver: T of kotlin.with, block: @[ExtensionFunctionType] kotlin.Function1): R of kotlin.with [inline] declared in kotlin' type=kotlin.Int origin=null : .IInvoke : kotlin.Int receiver: GET_VAR 'invokeImpl: .IInvoke declared in .test' type=.IInvoke origin=null diff --git a/compiler/testData/ir/irText/stubs/builtinMap.fir.txt b/compiler/testData/ir/irText/stubs/builtinMap.fir.txt index 2df3708de14..6ec62b253cb 100644 --- a/compiler/testData/ir/irText/stubs/builtinMap.fir.txt +++ b/compiler/testData/ir/irText/stubs/builtinMap.fir.txt @@ -16,7 +16,7 @@ FILE fqName: fileName:/builtinMap.kt pair: GET_VAR 'pair: kotlin.Pair.plus, V1 of .plus> declared in .plus' type=kotlin.Pair.plus, V1 of .plus> origin=null BRANCH if: CONST Boolean type=kotlin.Boolean value=true - then: CALL 'public final fun apply (block: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.Function1): T of kotlin.apply [inline] declared in kotlin' type=java.util.LinkedHashMap.plus?, V1 of .plus?> origin=null + then: CALL 'public final fun apply (block: @[ExtensionFunctionType] kotlin.Function1): T of kotlin.apply [inline] declared in kotlin' type=java.util.LinkedHashMap.plus?, V1 of .plus?> origin=null : java.util.LinkedHashMap.plus?, V1 of .plus?> $receiver: CONSTRUCTOR_CALL 'public constructor (p0: kotlin.collections.Map?) declared in java.util.LinkedHashMap' type=java.util.LinkedHashMap.plus?, V1 of .plus?> origin=null : K1 of .plus? diff --git a/compiler/testData/ir/irText/types/castsInsideCoroutineInference.fir.kt.txt b/compiler/testData/ir/irText/types/castsInsideCoroutineInference.fir.kt.txt index 6c921d41b55..de21f64cb90 100644 --- a/compiler/testData/ir/irText/types/castsInsideCoroutineInference.fir.kt.txt +++ b/compiler/testData/ir/irText/types/castsInsideCoroutineInference.fir.kt.txt @@ -1,5 +1,5 @@ @OptIn(markerClass = [ExperimentalTypeInference::class]) -fun scopedFlow(@BuilderInference block: @ExtensionFunctionType @ExtensionFunctionType SuspendFunction2, Unit>): Flow { +fun scopedFlow(@BuilderInference block: @ExtensionFunctionType SuspendFunction2, Unit>): Flow { return flow(block = local suspend fun FlowCollector.() { val collector: FlowCollector = flowScope(block = local suspend fun CoroutineScope.() { @@ -10,7 +10,7 @@ fun scopedFlow(@BuilderInference block: @ExtensionFunctionType @Exten ) } -fun Flow.onCompletion(action: @ExtensionFunctionType @ExtensionFunctionType SuspendFunction2, Throwable?, Unit>): Flow { +fun Flow.onCompletion(action: @ExtensionFunctionType SuspendFunction2, Throwable?, Unit>): Flow { return unsafeFlow(block = local suspend fun FlowCollector.() { val safeCollector: SafeCollector = SafeCollector(collector = ) safeCollector.invokeSafely(action = action) @@ -18,11 +18,11 @@ fun Flow.onCompletion(action: @ExtensionFunctionType @ExtensionFun ) } -suspend fun FlowCollector.invokeSafely(action: @ExtensionFunctionType @ExtensionFunctionType SuspendFunction2, Throwable?, Unit>) { +suspend fun FlowCollector.invokeSafely(action: @ExtensionFunctionType SuspendFunction2, Throwable?, Unit>) { } @OptIn(markerClass = [ExperimentalTypeInference::class]) -inline fun unsafeFlow(@BuilderInference crossinline block: @ExtensionFunctionType @ExtensionFunctionType SuspendFunction1, Unit>): Flow { +inline fun unsafeFlow(@BuilderInference crossinline block: @ExtensionFunctionType SuspendFunction1, Unit>): Flow { return TODO() } @@ -84,12 +84,12 @@ class SafeCollector : FlowCollector { } @OptIn(markerClass = [ExperimentalTypeInference::class]) -fun flow(@BuilderInference block: @ExtensionFunctionType @ExtensionFunctionType SuspendFunction1, Unit>): Flow { +fun flow(@BuilderInference block: @ExtensionFunctionType SuspendFunction1, Unit>): Flow { return TODO() } @OptIn(markerClass = [ExperimentalTypeInference::class]) -suspend fun flowScope(@BuilderInference block: @ExtensionFunctionType @ExtensionFunctionType SuspendFunction1): R { +suspend fun flowScope(@BuilderInference block: @ExtensionFunctionType SuspendFunction1): R { return TODO() } @@ -127,7 +127,7 @@ interface ReceiveChannel { } @OptIn(markerClass = [ExperimentalTypeInference::class]) -fun CoroutineScope.produce(@BuilderInference block: @ExtensionFunctionType @ExtensionFunctionType SuspendFunction1, Unit>): ReceiveChannel { +fun CoroutineScope.produce(@BuilderInference block: @ExtensionFunctionType SuspendFunction1, Unit>): ReceiveChannel { return TODO() } diff --git a/compiler/testData/ir/irText/types/castsInsideCoroutineInference.fir.txt b/compiler/testData/ir/irText/types/castsInsideCoroutineInference.fir.txt index bc4273f3b70..d8b8c9ab8a9 100644 --- a/compiler/testData/ir/irText/types/castsInsideCoroutineInference.fir.txt +++ b/compiler/testData/ir/irText/types/castsInsideCoroutineInference.fir.txt @@ -1,14 +1,14 @@ FILE fqName: fileName:/castsInsideCoroutineInference.kt - FUN name:scopedFlow visibility:public modality:FINAL (block:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction2<.CoroutineScope, .FlowCollector.scopedFlow>, kotlin.Unit>) returnType:.Flow.scopedFlow> + FUN name:scopedFlow visibility:public modality:FINAL (block:@[ExtensionFunctionType] kotlin.coroutines.SuspendFunction2<.CoroutineScope, .FlowCollector.scopedFlow>, kotlin.Unit>) returnType:.Flow.scopedFlow> annotations: OptIn(markerClass = [CLASS_REFERENCE 'CLASS IR_EXTERNAL_DECLARATION_STUB ANNOTATION_CLASS name:ExperimentalTypeInference modality:FINAL visibility:public superTypes:[kotlin.Annotation]' type=kotlin.reflect.KClass]) TYPE_PARAMETER name:R index:0 variance: superTypes:[kotlin.Any?] - VALUE_PARAMETER name:block index:0 type:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction2<.CoroutineScope, .FlowCollector.scopedFlow>, kotlin.Unit> + VALUE_PARAMETER name:block index:0 type:@[ExtensionFunctionType] kotlin.coroutines.SuspendFunction2<.CoroutineScope, .FlowCollector.scopedFlow>, kotlin.Unit> annotations: BuilderInference BLOCK_BODY - RETURN type=kotlin.Nothing from='public final fun scopedFlow (block: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction2<.CoroutineScope, .FlowCollector.scopedFlow>, kotlin.Unit>): .Flow.scopedFlow> declared in ' - CALL 'public final fun flow (block: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1<.FlowCollector.flow>, kotlin.Unit>): .Flow.flow> declared in ' type=.Flow.scopedFlow> origin=null + RETURN type=kotlin.Nothing from='public final fun scopedFlow (block: @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction2<.CoroutineScope, .FlowCollector.scopedFlow>, kotlin.Unit>): .Flow.scopedFlow> declared in ' + CALL 'public final fun flow (block: @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1<.FlowCollector.flow>, kotlin.Unit>): .Flow.flow> declared in ' type=.Flow.scopedFlow> origin=null : R of .scopedFlow block: FUN_EXPR type=kotlin.coroutines.SuspendFunction1<.FlowCollector.scopedFlow>, kotlin.Unit> origin=LAMBDA FUN LOCAL_FUNCTION_FOR_LAMBDA name: visibility:local modality:FINAL <> ($receiver:.FlowCollector.scopedFlow>) returnType:kotlin.Unit [suspend] @@ -16,24 +16,24 @@ FILE fqName: fileName:/castsInsideCoroutineInference.kt BLOCK_BODY VAR name:collector type:.FlowCollector [val] GET_VAR ': .FlowCollector.scopedFlow> declared in .scopedFlow.' type=.FlowCollector origin=null - CALL 'public final fun flowScope (block: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1<.CoroutineScope, R of .flowScope>): R of .flowScope [suspend] declared in ' type=kotlin.Unit origin=null + CALL 'public final fun flowScope (block: @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1<.CoroutineScope, R of .flowScope>): R of .flowScope [suspend] declared in ' type=kotlin.Unit origin=null : kotlin.Unit block: FUN_EXPR type=kotlin.coroutines.SuspendFunction1<.CoroutineScope, kotlin.Unit> origin=LAMBDA FUN LOCAL_FUNCTION_FOR_LAMBDA name: visibility:local modality:FINAL <> ($receiver:.CoroutineScope) returnType:kotlin.Unit [suspend] $receiver: VALUE_PARAMETER name: type:.CoroutineScope BLOCK_BODY CALL 'public abstract fun invoke (p1: P1 of kotlin.coroutines.SuspendFunction2, p2: P2 of kotlin.coroutines.SuspendFunction2): R of kotlin.coroutines.SuspendFunction2 [suspend,operator] declared in kotlin.coroutines.SuspendFunction2' type=kotlin.Unit origin=null - $this: GET_VAR 'block: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction2<.CoroutineScope, .FlowCollector.scopedFlow>, kotlin.Unit> declared in .scopedFlow' type=@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction2<.CoroutineScope, .FlowCollector.scopedFlow>, kotlin.Unit> origin=VARIABLE_AS_FUNCTION + $this: GET_VAR 'block: @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction2<.CoroutineScope, .FlowCollector.scopedFlow>, kotlin.Unit> declared in .scopedFlow' type=@[ExtensionFunctionType] kotlin.coroutines.SuspendFunction2<.CoroutineScope, .FlowCollector.scopedFlow>, kotlin.Unit> origin=VARIABLE_AS_FUNCTION p1: GET_VAR ': .CoroutineScope declared in .scopedFlow..' type=.CoroutineScope origin=null p2: TYPE_OP type=.FlowCollector origin=IMPLICIT_CAST typeOperand=.FlowCollector GET_VAR 'val collector: .FlowCollector [val] declared in .scopedFlow.' type=.FlowCollector.scopedFlow> origin=null - FUN name:onCompletion visibility:public modality:FINAL ($receiver:.Flow.onCompletion>, action:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction2<.FlowCollector.onCompletion>, kotlin.Throwable?, kotlin.Unit>) returnType:.Flow.onCompletion> + FUN name:onCompletion visibility:public modality:FINAL ($receiver:.Flow.onCompletion>, action:@[ExtensionFunctionType] kotlin.coroutines.SuspendFunction2<.FlowCollector.onCompletion>, kotlin.Throwable?, kotlin.Unit>) returnType:.Flow.onCompletion> TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] $receiver: VALUE_PARAMETER name: type:.Flow.onCompletion> - VALUE_PARAMETER name:action index:0 type:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction2<.FlowCollector.onCompletion>, kotlin.Throwable?, kotlin.Unit> + VALUE_PARAMETER name:action index:0 type:@[ExtensionFunctionType] kotlin.coroutines.SuspendFunction2<.FlowCollector.onCompletion>, kotlin.Throwable?, kotlin.Unit> BLOCK_BODY - RETURN type=kotlin.Nothing from='public final fun onCompletion (action: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction2<.FlowCollector.onCompletion>, kotlin.Throwable?, kotlin.Unit>): .Flow.onCompletion> declared in ' - CALL 'public final fun unsafeFlow (block: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1<.FlowCollector.unsafeFlow>, kotlin.Unit>): .Flow.unsafeFlow> [inline] declared in ' type=.Flow.onCompletion> origin=null + RETURN type=kotlin.Nothing from='public final fun onCompletion (action: @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction2<.FlowCollector.onCompletion>, kotlin.Throwable?, kotlin.Unit>): .Flow.onCompletion> declared in ' + CALL 'public final fun unsafeFlow (block: @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1<.FlowCollector.unsafeFlow>, kotlin.Unit>): .Flow.unsafeFlow> [inline] declared in ' type=.Flow.onCompletion> origin=null : T of .onCompletion block: FUN_EXPR type=kotlin.coroutines.SuspendFunction1<.FlowCollector.onCompletion>, kotlin.Unit> origin=LAMBDA FUN LOCAL_FUNCTION_FOR_LAMBDA name: visibility:local modality:FINAL <> ($receiver:.FlowCollector.onCompletion>) returnType:kotlin.Unit [suspend] @@ -43,24 +43,24 @@ FILE fqName: fileName:/castsInsideCoroutineInference.kt CONSTRUCTOR_CALL 'public constructor (collector: .FlowCollector.SafeCollector>) [primary] declared in .SafeCollector' type=.SafeCollector.onCompletion> origin=null : T of .onCompletion collector: GET_VAR ': .FlowCollector.onCompletion> declared in .onCompletion.' type=.FlowCollector.onCompletion> origin=null - CALL 'public final fun invokeSafely (action: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction2<.FlowCollector.invokeSafely>, kotlin.Throwable?, kotlin.Unit>): kotlin.Unit [suspend] declared in ' type=kotlin.Unit origin=null + CALL 'public final fun invokeSafely (action: @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction2<.FlowCollector.invokeSafely>, kotlin.Throwable?, kotlin.Unit>): kotlin.Unit [suspend] declared in ' type=kotlin.Unit origin=null : T of .onCompletion $receiver: GET_VAR 'val safeCollector: .SafeCollector [val] declared in .onCompletion.' type=.SafeCollector.onCompletion> origin=null - action: GET_VAR 'action: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction2<.FlowCollector.onCompletion>, kotlin.Throwable?, kotlin.Unit> declared in .onCompletion' type=@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction2<.FlowCollector.onCompletion>, kotlin.Throwable?, kotlin.Unit> origin=null - FUN name:invokeSafely visibility:public modality:FINAL ($receiver:.FlowCollector.invokeSafely>, action:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction2<.FlowCollector.invokeSafely>, kotlin.Throwable?, kotlin.Unit>) returnType:kotlin.Unit [suspend] + action: GET_VAR 'action: @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction2<.FlowCollector.onCompletion>, kotlin.Throwable?, kotlin.Unit> declared in .onCompletion' type=@[ExtensionFunctionType] kotlin.coroutines.SuspendFunction2<.FlowCollector.onCompletion>, kotlin.Throwable?, kotlin.Unit> origin=null + FUN name:invokeSafely visibility:public modality:FINAL ($receiver:.FlowCollector.invokeSafely>, action:@[ExtensionFunctionType] kotlin.coroutines.SuspendFunction2<.FlowCollector.invokeSafely>, kotlin.Throwable?, kotlin.Unit>) returnType:kotlin.Unit [suspend] TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] $receiver: VALUE_PARAMETER name: type:.FlowCollector.invokeSafely> - VALUE_PARAMETER name:action index:0 type:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction2<.FlowCollector.invokeSafely>, kotlin.Throwable?, kotlin.Unit> + VALUE_PARAMETER name:action index:0 type:@[ExtensionFunctionType] kotlin.coroutines.SuspendFunction2<.FlowCollector.invokeSafely>, kotlin.Throwable?, kotlin.Unit> BLOCK_BODY - FUN name:unsafeFlow visibility:public modality:FINAL (block:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1<.FlowCollector.unsafeFlow>, kotlin.Unit>) returnType:.Flow.unsafeFlow> [inline] + FUN name:unsafeFlow visibility:public modality:FINAL (block:@[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1<.FlowCollector.unsafeFlow>, kotlin.Unit>) returnType:.Flow.unsafeFlow> [inline] annotations: OptIn(markerClass = [CLASS_REFERENCE 'CLASS IR_EXTERNAL_DECLARATION_STUB ANNOTATION_CLASS name:ExperimentalTypeInference modality:FINAL visibility:public superTypes:[kotlin.Annotation]' type=kotlin.reflect.KClass]) TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] - VALUE_PARAMETER name:block index:0 type:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1<.FlowCollector.unsafeFlow>, kotlin.Unit> [crossinline] + VALUE_PARAMETER name:block index:0 type:@[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1<.FlowCollector.unsafeFlow>, kotlin.Unit> [crossinline] annotations: BuilderInference BLOCK_BODY - RETURN type=kotlin.Nothing from='public final fun unsafeFlow (block: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1<.FlowCollector.unsafeFlow>, kotlin.Unit>): .Flow.unsafeFlow> [inline] declared in ' + RETURN type=kotlin.Nothing from='public final fun unsafeFlow (block: @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1<.FlowCollector.unsafeFlow>, kotlin.Unit>): .Flow.unsafeFlow> [inline] declared in ' CALL 'public final fun TODO (): kotlin.Nothing [inline] declared in kotlin' type=kotlin.Nothing origin=null FUN name:onCompletion visibility:public modality:FINAL ($receiver:.Flow.onCompletion>, action:kotlin.coroutines.SuspendFunction1) returnType:IrErrorType annotations: @@ -82,7 +82,7 @@ FILE fqName: fileName:/castsInsideCoroutineInference.kt VALUE_PARAMETER name:flow index:0 type:.Flow<*> BLOCK_BODY RETURN type=kotlin.Nothing from='private final fun asFairChannel (flow: .Flow<*>): .ReceiveChannel declared in ' - CALL 'public final fun produce (block: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1<.ProducerScope.produce>, kotlin.Unit>): .ReceiveChannel.produce> declared in ' type=.ReceiveChannel origin=null + CALL 'public final fun produce (block: @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1<.ProducerScope.produce>, kotlin.Unit>): .ReceiveChannel.produce> declared in ' type=.ReceiveChannel origin=null : kotlin.Any $receiver: GET_VAR ': .CoroutineScope declared in .asFairChannel' type=.CoroutineScope origin=null block: FUN_EXPR type=kotlin.coroutines.SuspendFunction1<.ProducerScope, kotlin.Unit> origin=LAMBDA @@ -121,7 +121,7 @@ FILE fqName: fileName:/castsInsideCoroutineInference.kt VALUE_PARAMETER name:flow index:0 type:.Flow<*> BLOCK_BODY RETURN type=kotlin.Nothing from='private final fun asChannel (flow: .Flow<*>): .ReceiveChannel declared in ' - CALL 'public final fun produce (block: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1<.ProducerScope.produce>, kotlin.Unit>): .ReceiveChannel.produce> declared in ' type=.ReceiveChannel origin=null + CALL 'public final fun produce (block: @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1<.ProducerScope.produce>, kotlin.Unit>): .ReceiveChannel.produce> declared in ' type=.ReceiveChannel origin=null : kotlin.Any $receiver: GET_VAR ': .CoroutineScope declared in .asChannel' type=.CoroutineScope origin=null block: FUN_EXPR type=kotlin.coroutines.SuspendFunction1<.ProducerScope, kotlin.Unit> origin=LAMBDA @@ -190,25 +190,25 @@ FILE fqName: fileName:/castsInsideCoroutineInference.kt overridden: public open fun toString (): kotlin.String declared in kotlin.Any $this: VALUE_PARAMETER name: type:kotlin.Any - FUN name:flow visibility:public modality:FINAL (block:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1<.FlowCollector.flow>, kotlin.Unit>) returnType:.Flow.flow> + FUN name:flow visibility:public modality:FINAL (block:@[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1<.FlowCollector.flow>, kotlin.Unit>) returnType:.Flow.flow> annotations: OptIn(markerClass = [CLASS_REFERENCE 'CLASS IR_EXTERNAL_DECLARATION_STUB ANNOTATION_CLASS name:ExperimentalTypeInference modality:FINAL visibility:public superTypes:[kotlin.Annotation]' type=kotlin.reflect.KClass]) TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] - VALUE_PARAMETER name:block index:0 type:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1<.FlowCollector.flow>, kotlin.Unit> + VALUE_PARAMETER name:block index:0 type:@[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1<.FlowCollector.flow>, kotlin.Unit> annotations: BuilderInference BLOCK_BODY - RETURN type=kotlin.Nothing from='public final fun flow (block: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1<.FlowCollector.flow>, kotlin.Unit>): .Flow.flow> declared in ' + RETURN type=kotlin.Nothing from='public final fun flow (block: @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1<.FlowCollector.flow>, kotlin.Unit>): .Flow.flow> declared in ' CALL 'public final fun TODO (): kotlin.Nothing [inline] declared in kotlin' type=kotlin.Nothing origin=null - FUN name:flowScope visibility:public modality:FINAL (block:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1<.CoroutineScope, R of .flowScope>) returnType:R of .flowScope [suspend] + FUN name:flowScope visibility:public modality:FINAL (block:@[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1<.CoroutineScope, R of .flowScope>) returnType:R of .flowScope [suspend] annotations: OptIn(markerClass = [CLASS_REFERENCE 'CLASS IR_EXTERNAL_DECLARATION_STUB ANNOTATION_CLASS name:ExperimentalTypeInference modality:FINAL visibility:public superTypes:[kotlin.Annotation]' type=kotlin.reflect.KClass]) TYPE_PARAMETER name:R index:0 variance: superTypes:[kotlin.Any?] - VALUE_PARAMETER name:block index:0 type:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1<.CoroutineScope, R of .flowScope> + VALUE_PARAMETER name:block index:0 type:@[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1<.CoroutineScope, R of .flowScope> annotations: BuilderInference BLOCK_BODY - RETURN type=kotlin.Nothing from='public final fun flowScope (block: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1<.CoroutineScope, R of .flowScope>): R of .flowScope [suspend] declared in ' + RETURN type=kotlin.Nothing from='public final fun flowScope (block: @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1<.CoroutineScope, R of .flowScope>): R of .flowScope [suspend] declared in ' CALL 'public final fun TODO (): kotlin.Nothing [inline] declared in kotlin' type=kotlin.Nothing origin=null FUN name:collect visibility:public modality:FINAL ($receiver:.Flow.collect>, action:kotlin.coroutines.SuspendFunction1.collect, kotlin.Unit>) returnType:kotlin.Unit [inline,suspend] TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] @@ -308,16 +308,16 @@ FILE fqName: fileName:/castsInsideCoroutineInference.kt overridden: public open fun toString (): kotlin.String declared in kotlin.Any $this: VALUE_PARAMETER name: type:kotlin.Any - FUN name:produce visibility:public modality:FINAL ($receiver:.CoroutineScope, block:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1<.ProducerScope.produce>, kotlin.Unit>) returnType:.ReceiveChannel.produce> + FUN name:produce visibility:public modality:FINAL ($receiver:.CoroutineScope, block:@[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1<.ProducerScope.produce>, kotlin.Unit>) returnType:.ReceiveChannel.produce> annotations: OptIn(markerClass = [CLASS_REFERENCE 'CLASS IR_EXTERNAL_DECLARATION_STUB ANNOTATION_CLASS name:ExperimentalTypeInference modality:FINAL visibility:public superTypes:[kotlin.Annotation]' type=kotlin.reflect.KClass]) TYPE_PARAMETER name:E index:0 variance: superTypes:[kotlin.Any?] $receiver: VALUE_PARAMETER name: type:.CoroutineScope - VALUE_PARAMETER name:block index:0 type:@[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1<.ProducerScope.produce>, kotlin.Unit> + VALUE_PARAMETER name:block index:0 type:@[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1<.ProducerScope.produce>, kotlin.Unit> annotations: BuilderInference BLOCK_BODY - RETURN type=kotlin.Nothing from='public final fun produce (block: @[ExtensionFunctionType] @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1<.ProducerScope.produce>, kotlin.Unit>): .ReceiveChannel.produce> declared in ' + RETURN type=kotlin.Nothing from='public final fun produce (block: @[ExtensionFunctionType] kotlin.coroutines.SuspendFunction1<.ProducerScope.produce>, kotlin.Unit>): .ReceiveChannel.produce> declared in ' CALL 'public final fun TODO (): kotlin.Nothing [inline] declared in kotlin' type=kotlin.Nothing origin=null CLASS INTERFACE name:ProducerScope modality:ABSTRACT visibility:public superTypes:[.CoroutineScope; .SendChannel.ProducerScope>] $this: VALUE_PARAMETER INSTANCE_RECEIVER name: type:.ProducerScope.ProducerScope> From dea01125d694971446aba0628a73784ae21a4a98 Mon Sep 17 00:00:00 2001 From: Jinseong Jeon Date: Wed, 16 Dec 2020 15:48:21 -0800 Subject: [PATCH 142/196] FIR deserializer: keep SourceElement for more precise Fir2IrLazyClass's source --- .../kotlin/fir/deserialization/ClassDeserialization.kt | 2 ++ .../src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyClass.kt | 2 +- .../jetbrains/kotlin/fir/declarations/FirDeclarationUtil.kt | 4 ++++ .../box/annotations/typeAnnotations/typeAnnotationTarget6.kt | 1 - 4 files changed, 7 insertions(+), 2 deletions(-) diff --git a/compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/ClassDeserialization.kt b/compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/ClassDeserialization.kt index 38bbaa68b48..5c0b05b084b 100644 --- a/compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/ClassDeserialization.kt +++ b/compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/ClassDeserialization.kt @@ -203,6 +203,8 @@ fun deserializeClassToSymbol( context.annotationDeserializer.loadClassAnnotations(classProto, context.nameResolver) it.versionRequirementsTable = context.versionRequirementTable + + it.sourceElement = containerSource } } diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyClass.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyClass.kt index 7fcc8ad800e..8e88c2b00f1 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyClass.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/lazy/Fir2IrLazyClass.kt @@ -45,7 +45,7 @@ class Fir2IrLazyClass( override lateinit var parent: IrDeclarationParent override val source: SourceElement - get() = SourceElement.NO_SOURCE + get() = fir.sourceElement ?: SourceElement.NO_SOURCE @ObsoleteDescriptorBasedAPI override val descriptor: ClassDescriptor diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirDeclarationUtil.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirDeclarationUtil.kt index abeeaddb8cd..b0802632424 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirDeclarationUtil.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirDeclarationUtil.kt @@ -7,6 +7,7 @@ package org.jetbrains.kotlin.fir.declarations import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.descriptors.Modality +import org.jetbrains.kotlin.descriptors.SourceElement import org.jetbrains.kotlin.descriptors.Visibilities import org.jetbrains.kotlin.fir.declarations.builder.FirRegularClassBuilder import org.jetbrains.kotlin.fir.declarations.builder.FirTypeParameterBuilder @@ -128,6 +129,9 @@ fun FirRegularClass.addDeclaration(declaration: FirDeclaration) { } } +private object SourceElementKey : FirDeclarationDataKey() +var FirRegularClass.sourceElement: SourceElement? by FirDeclarationDataRegistry.data(SourceElementKey) + private object IsFromVarargKey : FirDeclarationDataKey() var FirProperty.isFromVararg: Boolean? by FirDeclarationDataRegistry.data(IsFromVarargKey) private object IsReferredViaField : FirDeclarationDataKey() diff --git a/compiler/testData/codegen/box/annotations/typeAnnotations/typeAnnotationTarget6.kt b/compiler/testData/codegen/box/annotations/typeAnnotations/typeAnnotationTarget6.kt index 0fa0a911574..a849dfc7adb 100644 --- a/compiler/testData/codegen/box/annotations/typeAnnotations/typeAnnotationTarget6.kt +++ b/compiler/testData/codegen/box/annotations/typeAnnotations/typeAnnotationTarget6.kt @@ -1,6 +1,5 @@ // KOTLIN_CONFIGURATION_FLAGS: +JVM.EMIT_JVM_TYPE_ANNOTATIONS // TARGET_BACKEND: JVM -// IGNORE_BACKEND_FIR: JVM_IR // No virtual method getAnnotatedReturnType()Ljava/lang/reflect/AnnotatedType // IGNORE_BACKEND: ANDROID From 6296f6dc3334ed73e9ef09280c304308915a52bd Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Thu, 17 Dec 2020 12:21:34 +0300 Subject: [PATCH 143/196] [FE] Don't throw assertion in OverrideResolver if directOverridden is empty Those descriptors may be empty in case user made a mistake and tried to delegate implementation of abstract class instead of interface (and we don't add functions from abstract class to overriden descriptors of fake overrides in case of delegation by) #KT-40510 Fixed --- .../kotlin/resolve/OverrideResolver.kt | 4 +++- .../tests/delegation/kt40510.fir.kt | 14 ++++++++++++ .../diagnostics/tests/delegation/kt40510.kt | 14 ++++++++++++ .../diagnostics/tests/delegation/kt40510.txt | 22 +++++++++++++++++++ .../test/runners/DiagnosticTestGenerated.java | 6 +++++ ...irOldFrontendDiagnosticsTestGenerated.java | 6 +++++ 6 files changed, 65 insertions(+), 1 deletion(-) create mode 100644 compiler/testData/diagnostics/tests/delegation/kt40510.fir.kt create mode 100644 compiler/testData/diagnostics/tests/delegation/kt40510.kt create mode 100644 compiler/testData/diagnostics/tests/delegation/kt40510.txt diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverrideResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverrideResolver.kt index 10168b7c88c..15445dfaa38 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverrideResolver.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverrideResolver.kt @@ -586,7 +586,9 @@ class OverrideResolver( if (kind != FAKE_OVERRIDE && kind != DELEGATION) return val directOverridden = descriptor.overriddenDescriptors - assert(!directOverridden.isEmpty()) { kind.toString() + " " + descriptor.name.asString() + " must override something" } + + // directOverridden may be empty if user tries to delegate implementation of abstract class instead of interface + if (directOverridden.isEmpty()) return // collects map from the directly overridden descriptor to the set of declarations: // -- if directly overridden is not fake, the set consists of one element: this directly overridden diff --git a/compiler/testData/diagnostics/tests/delegation/kt40510.fir.kt b/compiler/testData/diagnostics/tests/delegation/kt40510.fir.kt new file mode 100644 index 00000000000..75d72840e0c --- /dev/null +++ b/compiler/testData/diagnostics/tests/delegation/kt40510.fir.kt @@ -0,0 +1,14 @@ +// ISSUE: KT-40510 + +// FILE: foo/A.java +package foo; + +public abstract class A { + // package-private + abstract void foo(); +} + +// FILE: main.kt +import foo.A + +class DelegatedA(val a: A) : A by a diff --git a/compiler/testData/diagnostics/tests/delegation/kt40510.kt b/compiler/testData/diagnostics/tests/delegation/kt40510.kt new file mode 100644 index 00000000000..ca1dcd07848 --- /dev/null +++ b/compiler/testData/diagnostics/tests/delegation/kt40510.kt @@ -0,0 +1,14 @@ +// ISSUE: KT-40510 + +// FILE: foo/A.java +package foo; + +public abstract class A { + // package-private + abstract void foo(); +} + +// FILE: main.kt +import foo.A + +class DelegatedA(val a: A) : A by a diff --git a/compiler/testData/diagnostics/tests/delegation/kt40510.txt b/compiler/testData/diagnostics/tests/delegation/kt40510.txt new file mode 100644 index 00000000000..94aed60a082 --- /dev/null +++ b/compiler/testData/diagnostics/tests/delegation/kt40510.txt @@ -0,0 +1,22 @@ +package + +public final class DelegatedA : foo.A { + public constructor DelegatedA(/*0*/ a: foo.A) + public final val a: foo.A + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open /*delegation*/ fun foo(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +package foo { + + public abstract class A { + public constructor A() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public/*package*/ abstract fun foo(): kotlin.Unit + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } +} + diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java index 6e09f40619a..fbb0cacf8f4 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java @@ -7389,6 +7389,12 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { runTest("compiler/testData/diagnostics/tests/delegation/Delegation_ScopeInitializationOrder.kt"); } + @Test + @TestMetadata("kt40510.kt") + public void testKt40510() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegation/kt40510.kt"); + } + @Test @TestMetadata("kt8154.kt") public void testKt8154() throws Exception { diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java index 2df1ed4ac7a..5e40236383c 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java @@ -7383,6 +7383,12 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti runTest("compiler/testData/diagnostics/tests/delegation/Delegation_ScopeInitializationOrder.kt"); } + @Test + @TestMetadata("kt40510.kt") + public void testKt40510() throws Exception { + runTest("compiler/testData/diagnostics/tests/delegation/kt40510.kt"); + } + @Test @TestMetadata("kt8154.kt") public void testKt8154() throws Exception { From 92adccde478439143126ba1f02b7b58e5f007291 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Fri, 18 Dec 2020 11:25:31 +0300 Subject: [PATCH 144/196] Probably fix issue with creating module descriptor for SDK twice During creation and initialization of module descriptor for sdk in IdeaResolverForProject.BuiltInsCache.getOrCreateIfNeeded AbstractResolverForProject asks for sdk dependency for module descriptor for this sdk, so sometimes this module descriptor was created twice #KT-42001 Fixed EA-211562 --- .../kotlin/analyzer/AbstractResolverForProject.kt | 4 ++-- .../analyzer/ResolverForSingleModuleProject.kt | 4 ++-- .../compiler/MultiModuleJavaAnalysisCustomTest.kt | 2 +- .../idea/caches/resolve/IdeaResolverForProject.kt | 12 +++++++++--- 4 files changed, 14 insertions(+), 8 deletions(-) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/analyzer/AbstractResolverForProject.kt b/compiler/frontend/src/org/jetbrains/kotlin/analyzer/AbstractResolverForProject.kt index 1e07157dc1f..212e38791bb 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/analyzer/AbstractResolverForProject.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/analyzer/AbstractResolverForProject.kt @@ -52,7 +52,7 @@ abstract class AbstractResolverForProject( assert(moduleInfoToResolvableInfo.values.toSet() == modules.toSet()) } - abstract fun sdkDependency(module: M): M? + abstract fun sdkDependency(module: M, ownerModuleDescriptor: ModuleDescriptorImpl?): M? abstract fun modulesContent(module: M): ModuleContent abstract fun builtInsForModule(module: M): KotlinBuiltIns abstract fun createResolverForModule(descriptor: ModuleDescriptor, moduleInfo: M): ResolverForModule @@ -68,7 +68,7 @@ abstract class AbstractResolverForProject( LazyModuleDependencies( projectContext.storageManager, module, - sdkDependency(module), + sdkDependency(module, moduleDescriptor), this ) ) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/analyzer/ResolverForSingleModuleProject.kt b/compiler/frontend/src/org/jetbrains/kotlin/analyzer/ResolverForSingleModuleProject.kt index e2c36115eb4..d0ca5e77b57 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/analyzer/ResolverForSingleModuleProject.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/analyzer/ResolverForSingleModuleProject.kt @@ -35,7 +35,7 @@ class ResolverForSingleModuleProject( EmptyResolverForProject(), PackageOracleFactory.OptimisticFactory ) { - override fun sdkDependency(module: M): M? = sdkDependency + override fun sdkDependency(module: M, ownerModuleDescriptor: ModuleDescriptorImpl?): M? = sdkDependency init { knownDependencyModuleDescriptors.forEach { (module, descriptor) -> @@ -61,4 +61,4 @@ class ResolverForSingleModuleProject( this, languageVersionSettings ) -} \ No newline at end of file +} diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/MultiModuleJavaAnalysisCustomTest.kt b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/MultiModuleJavaAnalysisCustomTest.kt index 1e449e6e4bc..6040a0c17ce 100644 --- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/MultiModuleJavaAnalysisCustomTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/MultiModuleJavaAnalysisCustomTest.kt @@ -96,7 +96,7 @@ class MultiModuleJavaAnalysisCustomTest : KtUsefulTestCase() { projectContext, modules ) { - override fun sdkDependency(module: TestModule): TestModule? = null + override fun sdkDependency(module: TestModule, ownerModuleDescriptor: ModuleDescriptorImpl?): TestModule? = null override fun modulesContent(module: TestModule): ModuleContent = ModuleContent(module, module.kotlinFiles, module.javaFilesScope) diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/IdeaResolverForProject.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/IdeaResolverForProject.kt index a6d6c3ea69b..10e7d6de911 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/IdeaResolverForProject.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/IdeaResolverForProject.kt @@ -59,10 +59,16 @@ class IdeaResolverForProject( private val builtInsCache: BuiltInsCache = (delegateResolver as? IdeaResolverForProject)?.builtInsCache ?: BuiltInsCache(projectContext, this) - override fun sdkDependency(module: IdeaModuleInfo): SdkInfo? { + override fun sdkDependency(module: IdeaModuleInfo, ownerModuleDescriptor: ModuleDescriptorImpl?): SdkInfo? { if (projectContext.project.useCompositeAnalysis) { require(constantSdkDependencyIfAny == null) { "Shouldn't pass SDK dependency manually for composite analysis mode" } } + // This is needed for case when we find sdk dependency for module descriptor of + // that sdk itself. There was some situations when we create additional module + // descriptor for one SdkInfo + if (module is SdkInfo && ownerModuleDescriptor?.getCapability(ModuleInfo.Capability) == module) { + return module + } return constantSdkDependencyIfAny ?: module.findSdkAcrossDependencies() } @@ -133,7 +139,7 @@ class IdeaResolverForProject( private val cache = mutableMapOf() fun getOrCreateIfNeeded(module: IdeaModuleInfo): KotlinBuiltIns = projectContextFromSdkResolver.storageManager.compute { - val sdk = resolverForSdk.sdkDependency(module) + val sdk = resolverForSdk.sdkDependency(module, null) val key = module.platform.idePlatformKind.resolution.getKeyForBuiltIns(module, sdk) val cachedBuiltIns = cache[key] @@ -190,4 +196,4 @@ class IdeaResolverForProject( interface BuiltInsCacheKey { object DefaultBuiltInsKey : BuiltInsCacheKey -} \ No newline at end of file +} From 9bf2dfaa0237c688311b01974ea0c9cdbee8353d Mon Sep 17 00:00:00 2001 From: Simon Ogorodnik Date: Wed, 16 Dec 2020 15:39:13 +0300 Subject: [PATCH 145/196] KT-40200: Fix main function detector in lazy resolve overload resolver --- .../kotlin/frontend/java/di/injection.kt | 1 + .../jetbrains/kotlin/frontend/di/injection.kt | 7 ++++- .../kotlin/idea/MainFunctionDetector.kt | 15 +++++++++++ .../kotlin/resolve/CompilerEnvironment.kt | 2 ++ .../kotlin/resolve/OverloadResolver.kt | 5 ++-- .../caches/resolve/PerFileAnalysisCache.kt | 4 ++- .../IdeMainFunctionDetectorFactory.kt | 26 +++++++++++++++++++ .../kotlin/idea/project/IdeaEnvironment.kt | 2 ++ .../idea/project/ResolveElementCache.kt | 1 + 9 files changed, 59 insertions(+), 4 deletions(-) create mode 100644 idea/idea-analysis/src/org/jetbrains/kotlin/idea/compiler/IdeMainFunctionDetectorFactory.kt diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt index 4b814ca32f0..46a548bd6dd 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt @@ -28,6 +28,7 @@ import org.jetbrains.kotlin.descriptors.ModuleDescriptor import org.jetbrains.kotlin.frontend.di.configureIncrementalCompilation import org.jetbrains.kotlin.frontend.di.configureModule import org.jetbrains.kotlin.frontend.di.configureStandardResolveComponents +import org.jetbrains.kotlin.idea.MainFunctionDetector import org.jetbrains.kotlin.incremental.components.ExpectActualTracker import org.jetbrains.kotlin.incremental.components.LookupTracker import org.jetbrains.kotlin.load.java.AbstractJavaClassFinder diff --git a/compiler/frontend/src/org/jetbrains/kotlin/frontend/di/injection.kt b/compiler/frontend/src/org/jetbrains/kotlin/frontend/di/injection.kt index db014953858..68d5d6a23a2 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/frontend/di/injection.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/frontend/di/injection.kt @@ -24,6 +24,7 @@ import org.jetbrains.kotlin.container.useInstance import org.jetbrains.kotlin.context.ModuleContext import org.jetbrains.kotlin.contracts.ContractDeserializerImpl import org.jetbrains.kotlin.extensions.StorageComponentContainerContributor +import org.jetbrains.kotlin.idea.MainFunctionDetector import org.jetbrains.kotlin.incremental.components.ExpectActualTracker import org.jetbrains.kotlin.incremental.components.LookupTracker import org.jetbrains.kotlin.platform.TargetPlatform @@ -154,10 +155,12 @@ fun createContainerForLazyBodyResolve( bodyResolveCache: BodyResolveCache, analyzerServices: PlatformDependentAnalyzerServices, languageVersionSettings: LanguageVersionSettings, - moduleStructureOracle: ModuleStructureOracle + moduleStructureOracle: ModuleStructureOracle, + mainFunctionDetectorFactory: MainFunctionDetector.Factory ): StorageComponentContainer = createContainer("LazyBodyResolve", analyzerServices) { configureModule(moduleContext, platform, analyzerServices, bindingTrace, languageVersionSettings) + useInstance(mainFunctionDetectorFactory) useInstance(kotlinCodeAnalyzer) useInstance(kotlinCodeAnalyzer.fileScopeProvider) useInstance(bodyResolveCache) @@ -201,6 +204,7 @@ fun createContainerForLazyLocalClassifierAnalyzer( useImpl() useImpl() + useInstance(statementFilter) } @@ -219,6 +223,7 @@ fun createContainerForLazyResolve( useInstance(declarationProviderFactory) + targetEnvironment.configure(this) } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/idea/MainFunctionDetector.kt b/compiler/frontend/src/org/jetbrains/kotlin/idea/MainFunctionDetector.kt index b10a03c598c..e2e146944f6 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/idea/MainFunctionDetector.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/idea/MainFunctionDetector.kt @@ -24,6 +24,7 @@ import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.psi.KtDeclaration import org.jetbrains.kotlin.psi.KtNamedFunction import org.jetbrains.kotlin.resolve.BindingContext +import org.jetbrains.kotlin.resolve.BindingTrace import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils import org.jetbrains.kotlin.resolve.DescriptorUtils import org.jetbrains.kotlin.resolve.annotations.hasJvmStaticAnnotation @@ -202,4 +203,18 @@ class MainFunctionDetector { private fun hasAnnotationWithExactNumberOfArguments(function: KtNamedFunction, number: Int) = function.annotationEntries.any { it.valueArguments.size == number } } + + interface Factory { + fun createMainFunctionDetector(trace: BindingTrace, languageVersionSettings: LanguageVersionSettings): MainFunctionDetector + + class Ordinary : Factory { + override fun createMainFunctionDetector( + trace: BindingTrace, + languageVersionSettings: LanguageVersionSettings + ): MainFunctionDetector { + return MainFunctionDetector(trace.bindingContext, languageVersionSettings) + } + + } + } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/CompilerEnvironment.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/CompilerEnvironment.kt index 6806294da0c..0db6acc1c20 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/CompilerEnvironment.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/CompilerEnvironment.kt @@ -19,6 +19,7 @@ package org.jetbrains.kotlin.resolve import org.jetbrains.kotlin.container.StorageComponentContainer import org.jetbrains.kotlin.container.useImpl import org.jetbrains.kotlin.container.useInstance +import org.jetbrains.kotlin.idea.MainFunctionDetector import org.jetbrains.kotlin.resolve.lazy.CompilerLocalDescriptorResolver import org.jetbrains.kotlin.resolve.lazy.BasicAbsentDescriptorHandler @@ -28,5 +29,6 @@ object CompilerEnvironment : TargetEnvironment("Compiler") { container.useImpl() container.useImpl() container.useInstance(ModuleStructureOracle.SingleModule) + container.useImpl() } } \ No newline at end of file diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverloadResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverloadResolver.kt index c555af13e31..fa1f75b3b62 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverloadResolver.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverloadResolver.kt @@ -34,10 +34,11 @@ class OverloadResolver( private val trace: BindingTrace, private val overloadFilter: OverloadFilter, private val overloadChecker: OverloadChecker, - languageVersionSettings: LanguageVersionSettings + languageVersionSettings: LanguageVersionSettings, + mainFunctionDetectorFactory: MainFunctionDetector.Factory ) { - private val mainFunctionDetector = MainFunctionDetector(trace.bindingContext, languageVersionSettings) + private val mainFunctionDetector = mainFunctionDetectorFactory.createMainFunctionDetector(trace, languageVersionSettings) fun checkOverloads(c: BodiesResolveContext) { val inClasses = findConstructorsInNestedClassesAndTypeAliases(c) diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/PerFileAnalysisCache.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/PerFileAnalysisCache.kt index eebc46bde57..91bf8671418 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/PerFileAnalysisCache.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/PerFileAnalysisCache.kt @@ -28,6 +28,7 @@ import org.jetbrains.kotlin.frontend.di.createContainerForLazyBodyResolve import org.jetbrains.kotlin.idea.caches.project.getModuleInfo import org.jetbrains.kotlin.idea.caches.trackers.clearInBlockModifications import org.jetbrains.kotlin.idea.caches.trackers.inBlockModifications +import org.jetbrains.kotlin.idea.compiler.IdeMainFunctionDetectorFactory import org.jetbrains.kotlin.idea.project.IdeaModuleStructureOracle import org.jetbrains.kotlin.idea.project.findAnalyzerServices import org.jetbrains.kotlin.idea.project.languageVersionSettings @@ -449,7 +450,8 @@ private object KotlinResolveDataProvider { bodyResolveCache, targetPlatform.findAnalyzerServices(project), analyzableElement.languageVersionSettings, - IdeaModuleStructureOracle() + IdeaModuleStructureOracle(), + IdeMainFunctionDetectorFactory() ).get() lazyTopDownAnalyzer.analyzeDeclarations(TopDownAnalysisMode.TopLevelDeclarations, listOf(analyzableElement)) diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/compiler/IdeMainFunctionDetectorFactory.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/compiler/IdeMainFunctionDetectorFactory.kt new file mode 100644 index 00000000000..efb915c64cd --- /dev/null +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/compiler/IdeMainFunctionDetectorFactory.kt @@ -0,0 +1,26 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.idea.compiler + +import org.jetbrains.kotlin.config.LanguageVersionSettings +import org.jetbrains.kotlin.idea.MainFunctionDetector +import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptorIfAny +import org.jetbrains.kotlin.resolve.BindingTrace +import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode +import org.jetbrains.kotlin.utils.KotlinExceptionWithAttachments + +internal class IdeMainFunctionDetectorFactory : MainFunctionDetector.Factory { + override fun createMainFunctionDetector( + trace: BindingTrace, + languageVersionSettings: LanguageVersionSettings + ): MainFunctionDetector { + return MainFunctionDetector(languageVersionSettings) { function -> + function.resolveToDescriptorIfAny(bodyResolveMode = BodyResolveMode.FULL) + ?: throw KotlinExceptionWithAttachments("No descriptor resolved for $function") + .withAttachment("function.text", function.text) + } + } +} \ No newline at end of file diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/IdeaEnvironment.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/IdeaEnvironment.kt index 63d4d3f8fa8..282af7e272d 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/IdeaEnvironment.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/IdeaEnvironment.kt @@ -19,6 +19,7 @@ package org.jetbrains.kotlin.idea.project import org.jetbrains.kotlin.container.StorageComponentContainer import org.jetbrains.kotlin.container.useImpl import org.jetbrains.kotlin.idea.caches.lightClasses.LazyLightClassDataHolder +import org.jetbrains.kotlin.idea.compiler.IdeMainFunctionDetectorFactory import org.jetbrains.kotlin.resolve.TargetEnvironment object IdeaEnvironment : TargetEnvironment("Idea") { @@ -28,5 +29,6 @@ object IdeaEnvironment : TargetEnvironment("Idea") { container.useImpl() container.useImpl() container.useImpl() + container.useImpl() } } diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/ResolveElementCache.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/ResolveElementCache.kt index b7517f7be03..76054150cd0 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/ResolveElementCache.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/ResolveElementCache.kt @@ -29,6 +29,7 @@ import org.jetbrains.kotlin.idea.caches.resolve.util.analyzeControlFlow import org.jetbrains.kotlin.idea.caches.trackers.KotlinCodeBlockModificationListener import org.jetbrains.kotlin.idea.caches.trackers.KotlinCodeBlockModificationListenerCompat import org.jetbrains.kotlin.idea.caches.trackers.inBlockModificationCount +import org.jetbrains.kotlin.idea.compiler.IdeMainFunctionDetectorFactory import org.jetbrains.kotlin.idea.util.application.isUnitTestMode import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.platform.TargetPlatform From 9c2d06cf7031e01083b177dbe45ac835abe5befd Mon Sep 17 00:00:00 2001 From: Jinseong Jeon Date: Fri, 18 Dec 2020 00:06:46 -0800 Subject: [PATCH 146/196] FIR: strengthen resolution success check for augmented array set call This commit removes some false ambiguities & fixes compilation of tree-generator module with FIR --- .../FirExpressionsResolveTransformer.kt | 7 +- ...ityResolveWithVarargAndOperatorCall.fir.kt | 18 +++++ ...ibilityResolveWithVarargAndOperatorCall.kt | 1 - .../InconsistentGetSet.fir.kt | 6 +- .../caoWithAdaptationForSam.fir.kt.txt | 12 +--- .../caoWithAdaptationForSam.fir.txt | 72 +++++++------------ .../irText/expressions/lambdaInCAO.fir.kt.txt | 9 ++- .../ir/irText/expressions/lambdaInCAO.fir.txt | 36 +++++++--- 8 files changed, 88 insertions(+), 73 deletions(-) create mode 100644 compiler/testData/diagnostics/tests/callableReference/compatibilityResolveWithVarargAndOperatorCall.fir.kt diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt index ad2274e51e0..1241edbed7e 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt @@ -867,8 +867,11 @@ open class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransform } val secondResult = augmentedArraySetCall.assignCall.transformSingle(transformer, ResolutionMode.ContextIndependent) - val firstSucceed = firstCalls.all { it.typeRef !is FirErrorTypeRef } - val secondSucceed = secondCalls.all { it.typeRef !is FirErrorTypeRef } + fun isSuccessful(functionCall: FirFunctionCall): Boolean = + functionCall.typeRef !is FirErrorTypeRef && functionCall.calleeReference is FirResolvedNamedReference + + val firstSucceed = firstCalls.all(::isSuccessful) + val secondSucceed = secondCalls.all(::isSuccessful) val result: FirStatement = when { firstSucceed && secondSucceed -> { diff --git a/compiler/testData/diagnostics/tests/callableReference/compatibilityResolveWithVarargAndOperatorCall.fir.kt b/compiler/testData/diagnostics/tests/callableReference/compatibilityResolveWithVarargAndOperatorCall.fir.kt new file mode 100644 index 00000000000..f9b72970cea --- /dev/null +++ b/compiler/testData/diagnostics/tests/callableReference/compatibilityResolveWithVarargAndOperatorCall.fir.kt @@ -0,0 +1,18 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER + +fun interface IFoo { + fun foo(i: Int) +} + +fun interface IFoo2 : IFoo + +object A + +operator fun A.get(i: IFoo) = 1 +operator fun A.set(i: IFoo, newValue: Int) {} + +fun withVararg(vararg xs: Int) = 42 + +fun test1() { + A[::withVararg] += 1 +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/callableReference/compatibilityResolveWithVarargAndOperatorCall.kt b/compiler/testData/diagnostics/tests/callableReference/compatibilityResolveWithVarargAndOperatorCall.kt index 821c47c5809..c012456ffbe 100644 --- a/compiler/testData/diagnostics/tests/callableReference/compatibilityResolveWithVarargAndOperatorCall.kt +++ b/compiler/testData/diagnostics/tests/callableReference/compatibilityResolveWithVarargAndOperatorCall.kt @@ -1,4 +1,3 @@ -// FIR_IDENTICAL // !DIAGNOSTICS: -UNUSED_PARAMETER fun interface IFoo { diff --git a/compiler/testData/diagnostics/tests/operatorsOverloading/InconsistentGetSet.fir.kt b/compiler/testData/diagnostics/tests/operatorsOverloading/InconsistentGetSet.fir.kt index 006149d17ce..dcd7b5368ec 100644 --- a/compiler/testData/diagnostics/tests/operatorsOverloading/InconsistentGetSet.fir.kt +++ b/compiler/testData/diagnostics/tests/operatorsOverloading/InconsistentGetSet.fir.kt @@ -20,7 +20,7 @@ object MismatchingTypes { fun testMismatchingTypes() { ++MismatchingTypes[0] MismatchingTypes[0]++ - MismatchingTypes[0] += 1 + MismatchingTypes[0] += 1 } object MismatchingArities1 { @@ -36,10 +36,10 @@ object MismatchingArities2 { fun testMismatchingArities() { ++MismatchingArities1[0] MismatchingArities1[0]++ - MismatchingArities1[0] += 1 + MismatchingArities1[0] += 1 ++MismatchingArities2[0] MismatchingArities2[0]++ - MismatchingArities2[0] += 1 + MismatchingArities2[0] += 1 } diff --git a/compiler/testData/ir/irText/expressions/callableReferences/caoWithAdaptationForSam.fir.kt.txt b/compiler/testData/ir/irText/expressions/callableReferences/caoWithAdaptationForSam.fir.kt.txt index e5e4428a590..16b3427c296 100644 --- a/compiler/testData/ir/irText/expressions/callableReferences/caoWithAdaptationForSam.fir.kt.txt +++ b/compiler/testData/ir/irText/expressions/callableReferences/caoWithAdaptationForSam.fir.kt.txt @@ -44,19 +44,11 @@ fun withVararg(vararg xs: Int): Int { } fun test1() { - { // BLOCK - val <>: A = A - val <>: KFunction1 = ::withVararg - error("") /* ErrorCallExpression */<>; error("") /* ErrorCallExpression */<>; .plus(other = 1); - } + error("") /* ErrorCallExpression */ } fun test2() { - { // BLOCK - val <>: B = B - val <>: KFunction1 = ::withVararg - error("") /* ErrorCallExpression */<>; error("") /* ErrorCallExpression */<>; .plus(other = 1); - } + error("") /* ErrorCallExpression */ } fun test3(fn: Function1) { diff --git a/compiler/testData/ir/irText/expressions/callableReferences/caoWithAdaptationForSam.fir.txt b/compiler/testData/ir/irText/expressions/callableReferences/caoWithAdaptationForSam.fir.txt index 1c43268e701..d1943517037 100644 --- a/compiler/testData/ir/irText/expressions/callableReferences/caoWithAdaptationForSam.fir.txt +++ b/compiler/testData/ir/irText/expressions/callableReferences/caoWithAdaptationForSam.fir.txt @@ -104,47 +104,27 @@ FILE fqName: fileName:/caoWithAdaptationForSam.kt CONST Int type=kotlin.Int value=42 FUN name:test1 visibility:public modality:FINAL <> () returnType:kotlin.Unit BLOCK_BODY - BLOCK type=kotlin.Unit origin=null - VAR IR_TEMPORARY_VARIABLE name:tmp_0 type:.A [val] - GET_OBJECT 'CLASS OBJECT name:A modality:FINAL visibility:public superTypes:[kotlin.Any]' type=.A - VAR IR_TEMPORARY_VARIABLE name:tmp_1 type:kotlin.reflect.KFunction1 [val] - FUNCTION_REFERENCE 'public final fun withVararg (vararg xs: kotlin.Int): kotlin.Int declared in ' type=kotlin.reflect.KFunction1 origin=null reflectionTarget= - ERROR_CALL 'Unresolved reference: #' type=kotlin.Unit - GET_VAR 'val tmp_1: kotlin.reflect.KFunction1 [val] declared in .test1' type=kotlin.reflect.KFunction1 origin=null - CALL 'public final fun plus (other: kotlin.Int): kotlin.Int [operator] declared in kotlin.Int' type=kotlin.Int origin=null - $this: ERROR_CALL 'Unresolved reference: #' type=kotlin.Int - GET_VAR 'val tmp_1: kotlin.reflect.KFunction1 [val] declared in .test1' type=kotlin.reflect.KFunction1 origin=null - other: CONST Int type=kotlin.Int value=1 + ERROR_CALL 'FirArraySetCall (resolve isn't supported yet)' type=kotlin.Unit FUN name:test2 visibility:public modality:FINAL <> () returnType:kotlin.Unit BLOCK_BODY - BLOCK type=kotlin.Unit origin=null - VAR IR_TEMPORARY_VARIABLE name:tmp_2 type:.B [val] - GET_OBJECT 'CLASS OBJECT name:B modality:FINAL visibility:public superTypes:[kotlin.Any]' type=.B - VAR IR_TEMPORARY_VARIABLE name:tmp_3 type:kotlin.reflect.KFunction1 [val] - FUNCTION_REFERENCE 'public final fun withVararg (vararg xs: kotlin.Int): kotlin.Int declared in ' type=kotlin.reflect.KFunction1 origin=null reflectionTarget= - ERROR_CALL 'Unresolved reference: #' type=kotlin.Unit - GET_VAR 'val tmp_3: kotlin.reflect.KFunction1 [val] declared in .test2' type=kotlin.reflect.KFunction1 origin=null - CALL 'public final fun plus (other: kotlin.Int): kotlin.Int [operator] declared in kotlin.Int' type=kotlin.Int origin=null - $this: ERROR_CALL 'Unresolved reference: #' type=kotlin.Int - GET_VAR 'val tmp_3: kotlin.reflect.KFunction1 [val] declared in .test2' type=kotlin.reflect.KFunction1 origin=null - other: CONST Int type=kotlin.Int value=1 + ERROR_CALL 'FirArraySetCall (resolve isn't supported yet)' type=kotlin.Unit FUN name:test3 visibility:public modality:FINAL <> (fn:kotlin.Function1) returnType:kotlin.Unit VALUE_PARAMETER name:fn index:0 type:kotlin.Function1 BLOCK_BODY BLOCK type=kotlin.Unit origin=null - VAR IR_TEMPORARY_VARIABLE name:tmp_4 type:.A [val] + VAR IR_TEMPORARY_VARIABLE name:tmp_0 type:.A [val] GET_OBJECT 'CLASS OBJECT name:A modality:FINAL visibility:public superTypes:[kotlin.Any]' type=.A - VAR IR_TEMPORARY_VARIABLE name:tmp_5 type:kotlin.Function1 [val] + VAR IR_TEMPORARY_VARIABLE name:tmp_1 type:kotlin.Function1 [val] GET_VAR 'fn: kotlin.Function1 declared in .test3' type=kotlin.Function1 origin=null CALL 'public final fun set (i: .IFoo, newValue: kotlin.Int): kotlin.Unit [operator] declared in ' type=kotlin.Unit origin=null - $receiver: GET_VAR 'val tmp_4: .A [val] declared in .test3' type=.A origin=null + $receiver: GET_VAR 'val tmp_0: .A [val] declared in .test3' type=.A origin=null i: TYPE_OP type=.IFoo origin=SAM_CONVERSION typeOperand=.IFoo - GET_VAR 'val tmp_5: kotlin.Function1 [val] declared in .test3' type=kotlin.Function1 origin=null + GET_VAR 'val tmp_1: kotlin.Function1 [val] declared in .test3' type=kotlin.Function1 origin=null newValue: CALL 'public final fun plus (other: kotlin.Int): kotlin.Int [operator] declared in kotlin.Int' type=kotlin.Int origin=null $this: CALL 'public final fun get (i: .IFoo): kotlin.Int [operator] declared in ' type=kotlin.Int origin=null - $receiver: GET_VAR 'val tmp_4: .A [val] declared in .test3' type=.A origin=null + $receiver: GET_VAR 'val tmp_0: .A [val] declared in .test3' type=.A origin=null i: TYPE_OP type=.IFoo origin=SAM_CONVERSION typeOperand=.IFoo - GET_VAR 'val tmp_5: kotlin.Function1 [val] declared in .test3' type=kotlin.Function1 origin=null + GET_VAR 'val tmp_1: kotlin.Function1 [val] declared in .test3' type=kotlin.Function1 origin=null other: CONST Int type=kotlin.Int value=1 FUN name:test4 visibility:public modality:FINAL <> (fn:kotlin.Function1) returnType:kotlin.Unit VALUE_PARAMETER name:fn index:0 type:kotlin.Function1 @@ -154,18 +134,18 @@ FILE fqName: fileName:/caoWithAdaptationForSam.kt if: TYPE_OP type=kotlin.Boolean origin=INSTANCEOF typeOperand=.IFoo GET_VAR 'fn: kotlin.Function1 declared in .test4' type=kotlin.Function1 origin=null then: BLOCK type=kotlin.Unit origin=null - VAR IR_TEMPORARY_VARIABLE name:tmp_6 type:.A [val] + VAR IR_TEMPORARY_VARIABLE name:tmp_2 type:.A [val] GET_OBJECT 'CLASS OBJECT name:A modality:FINAL visibility:public superTypes:[kotlin.Any]' type=.A - VAR IR_TEMPORARY_VARIABLE name:tmp_7 type:.IFoo [val] + VAR IR_TEMPORARY_VARIABLE name:tmp_3 type:.IFoo [val] TYPE_OP type=.IFoo origin=IMPLICIT_CAST typeOperand=.IFoo GET_VAR 'fn: kotlin.Function1 declared in .test4' type=kotlin.Function1 origin=null CALL 'public final fun set (i: .IFoo, newValue: kotlin.Int): kotlin.Unit [operator] declared in ' type=kotlin.Unit origin=null - $receiver: GET_VAR 'val tmp_6: .A [val] declared in .test4' type=.A origin=null - i: GET_VAR 'val tmp_7: .IFoo [val] declared in .test4' type=.IFoo origin=null + $receiver: GET_VAR 'val tmp_2: .A [val] declared in .test4' type=.A origin=null + i: GET_VAR 'val tmp_3: .IFoo [val] declared in .test4' type=.IFoo origin=null newValue: CALL 'public final fun plus (other: kotlin.Int): kotlin.Int [operator] declared in kotlin.Int' type=kotlin.Int origin=null $this: CALL 'public final fun get (i: .IFoo): kotlin.Int [operator] declared in ' type=kotlin.Int origin=null - $receiver: GET_VAR 'val tmp_6: .A [val] declared in .test4' type=.A origin=null - i: GET_VAR 'val tmp_7: .IFoo [val] declared in .test4' type=.IFoo origin=null + $receiver: GET_VAR 'val tmp_2: .A [val] declared in .test4' type=.A origin=null + i: GET_VAR 'val tmp_3: .IFoo [val] declared in .test4' type=.IFoo origin=null other: CONST Int type=kotlin.Int value=1 FUN name:test5 visibility:public modality:FINAL <> (a:kotlin.Any) returnType:kotlin.Unit VALUE_PARAMETER name:a index:0 type:kotlin.Any @@ -174,20 +154,20 @@ FILE fqName: fileName:/caoWithAdaptationForSam.kt TYPE_OP type=kotlin.Function1 origin=CAST typeOperand=kotlin.Function1 GET_VAR 'a: kotlin.Any declared in .test5' type=kotlin.Any origin=null BLOCK type=kotlin.Unit origin=null - VAR IR_TEMPORARY_VARIABLE name:tmp_8 type:.A [val] + VAR IR_TEMPORARY_VARIABLE name:tmp_4 type:.A [val] GET_OBJECT 'CLASS OBJECT name:A modality:FINAL visibility:public superTypes:[kotlin.Any]' type=.A - VAR IR_TEMPORARY_VARIABLE name:tmp_9 type:kotlin.Function1 [val] + VAR IR_TEMPORARY_VARIABLE name:tmp_5 type:kotlin.Function1 [val] TYPE_OP type=kotlin.Function1 origin=IMPLICIT_CAST typeOperand=kotlin.Function1 GET_VAR 'a: kotlin.Any declared in .test5' type=kotlin.Any origin=null CALL 'public final fun set (i: .IFoo, newValue: kotlin.Int): kotlin.Unit [operator] declared in ' type=kotlin.Unit origin=null - $receiver: GET_VAR 'val tmp_8: .A [val] declared in .test5' type=.A origin=null + $receiver: GET_VAR 'val tmp_4: .A [val] declared in .test5' type=.A origin=null i: TYPE_OP type=.IFoo origin=SAM_CONVERSION typeOperand=.IFoo - GET_VAR 'val tmp_9: kotlin.Function1 [val] declared in .test5' type=kotlin.Function1 origin=null + GET_VAR 'val tmp_5: kotlin.Function1 [val] declared in .test5' type=kotlin.Function1 origin=null newValue: CALL 'public final fun plus (other: kotlin.Int): kotlin.Int [operator] declared in kotlin.Int' type=kotlin.Int origin=null $this: CALL 'public final fun get (i: .IFoo): kotlin.Int [operator] declared in ' type=kotlin.Int origin=null - $receiver: GET_VAR 'val tmp_8: .A [val] declared in .test5' type=.A origin=null + $receiver: GET_VAR 'val tmp_4: .A [val] declared in .test5' type=.A origin=null i: TYPE_OP type=.IFoo origin=SAM_CONVERSION typeOperand=.IFoo - GET_VAR 'val tmp_9: kotlin.Function1 [val] declared in .test5' type=kotlin.Function1 origin=null + GET_VAR 'val tmp_5: kotlin.Function1 [val] declared in .test5' type=kotlin.Function1 origin=null other: CONST Int type=kotlin.Int value=1 FUN name:test6 visibility:public modality:FINAL <> (a:kotlin.Any) returnType:kotlin.Unit VALUE_PARAMETER name:a index:0 type:kotlin.Any @@ -200,16 +180,16 @@ FILE fqName: fileName:/caoWithAdaptationForSam.kt TYPE_OP type=kotlin.Function1 origin=IMPLICIT_CAST typeOperand=kotlin.Function1 GET_VAR 'a: kotlin.Any declared in .test6' type=kotlin.Any origin=null BLOCK type=kotlin.Unit origin=null - VAR IR_TEMPORARY_VARIABLE name:tmp_10 type:.A [val] + VAR IR_TEMPORARY_VARIABLE name:tmp_6 type:.A [val] GET_OBJECT 'CLASS OBJECT name:A modality:FINAL visibility:public superTypes:[kotlin.Any]' type=.A - VAR IR_TEMPORARY_VARIABLE name:tmp_11 type:kotlin.Function1 [val] + VAR IR_TEMPORARY_VARIABLE name:tmp_7 type:kotlin.Function1 [val] TYPE_OP type=kotlin.Function1 origin=IMPLICIT_CAST typeOperand=kotlin.Function1 GET_VAR 'a: kotlin.Any declared in .test6' type=kotlin.Any origin=null CALL 'public final fun set (i: .IFoo, newValue: kotlin.Int): kotlin.Unit [operator] declared in ' type=kotlin.Unit origin=null - $receiver: GET_VAR 'val tmp_10: .A [val] declared in .test6' type=.A origin=null - i: GET_VAR 'val tmp_11: kotlin.Function1 [val] declared in .test6' type=kotlin.Function1 origin=null + $receiver: GET_VAR 'val tmp_6: .A [val] declared in .test6' type=.A origin=null + i: GET_VAR 'val tmp_7: kotlin.Function1 [val] declared in .test6' type=kotlin.Function1 origin=null newValue: CALL 'public final fun plus (other: kotlin.Int): kotlin.Int [operator] declared in kotlin.Int' type=kotlin.Int origin=null $this: CALL 'public final fun get (i: .IFoo): kotlin.Int [operator] declared in ' type=kotlin.Int origin=null - $receiver: GET_VAR 'val tmp_10: .A [val] declared in .test6' type=.A origin=null - i: GET_VAR 'val tmp_11: kotlin.Function1 [val] declared in .test6' type=kotlin.Function1 origin=null + $receiver: GET_VAR 'val tmp_6: .A [val] declared in .test6' type=.A origin=null + i: GET_VAR 'val tmp_7: kotlin.Function1 [val] declared in .test6' type=kotlin.Function1 origin=null other: CONST Int type=kotlin.Int value=1 diff --git a/compiler/testData/ir/irText/expressions/lambdaInCAO.fir.kt.txt b/compiler/testData/ir/irText/expressions/lambdaInCAO.fir.kt.txt index d1f0b5ede72..023777232f7 100644 --- a/compiler/testData/ir/irText/expressions/lambdaInCAO.fir.kt.txt +++ b/compiler/testData/ir/irText/expressions/lambdaInCAO.fir.kt.txt @@ -16,7 +16,14 @@ fun test1(a: Any) { } fun test2(a: Any) { - error("") /* ErrorCallExpression */ + { // BLOCK + val <>: Any = a + val <>: Function0 = local fun () { + return Unit + } + + <>.set(index = <>, value = <>.get(index = <>).plus(other = 42)) + } } fun test3(a: Any) { diff --git a/compiler/testData/ir/irText/expressions/lambdaInCAO.fir.txt b/compiler/testData/ir/irText/expressions/lambdaInCAO.fir.txt index e801946f7fd..7da6a4444d9 100644 --- a/compiler/testData/ir/irText/expressions/lambdaInCAO.fir.txt +++ b/compiler/testData/ir/irText/expressions/lambdaInCAO.fir.txt @@ -27,26 +27,42 @@ FILE fqName: fileName:/lambdaInCAO.kt FUN name:test2 visibility:public modality:FINAL <> (a:kotlin.Any) returnType:kotlin.Unit VALUE_PARAMETER name:a index:0 type:kotlin.Any BLOCK_BODY - ERROR_CALL 'FirArraySetCall (resolve isn't supported yet)' type=kotlin.Unit + BLOCK type=kotlin.Unit origin=null + VAR IR_TEMPORARY_VARIABLE name:tmp_0 type:kotlin.Any [val] + GET_VAR 'a: kotlin.Any declared in .test2' type=kotlin.Any origin=null + VAR IR_TEMPORARY_VARIABLE name:tmp_1 type:kotlin.Function0 [val] + FUN_EXPR type=kotlin.Function0 origin=LAMBDA + FUN LOCAL_FUNCTION_FOR_LAMBDA name: visibility:local modality:FINAL <> () returnType:kotlin.Unit + BLOCK_BODY + RETURN type=kotlin.Nothing from='local final fun (): kotlin.Unit declared in .test2' + GET_OBJECT 'CLASS IR_EXTERNAL_DECLARATION_STUB OBJECT name:Unit modality:FINAL visibility:public superTypes:[kotlin.Any]' type=kotlin.Unit + CALL 'public final fun set (index: kotlin.Function0, value: kotlin.Int): kotlin.Unit [operator] declared in ' type=kotlin.Unit origin=null + $receiver: GET_VAR 'val tmp_0: kotlin.Any [val] declared in .test2' type=kotlin.Any origin=null + index: GET_VAR 'val tmp_1: kotlin.Function0 [val] declared in .test2' type=kotlin.Function0 origin=null + value: CALL 'public final fun plus (other: kotlin.Int): kotlin.Int [operator] declared in kotlin.Int' type=kotlin.Int origin=null + $this: CALL 'public final fun get (index: kotlin.Function0): kotlin.Int [operator] declared in ' type=kotlin.Int origin=null + $receiver: GET_VAR 'val tmp_0: kotlin.Any [val] declared in .test2' type=kotlin.Any origin=null + index: GET_VAR 'val tmp_1: kotlin.Function0 [val] declared in .test2' type=kotlin.Function0 origin=null + other: CONST Int type=kotlin.Int value=42 FUN name:test3 visibility:public modality:FINAL <> (a:kotlin.Any) returnType:kotlin.Unit VALUE_PARAMETER name:a index:0 type:kotlin.Any BLOCK_BODY - VAR IR_TEMPORARY_VARIABLE name:tmp_0 type:kotlin.Any [val] + VAR IR_TEMPORARY_VARIABLE name:tmp_2 type:kotlin.Any [val] GET_VAR 'a: kotlin.Any declared in .test3' type=kotlin.Any origin=null - VAR IR_TEMPORARY_VARIABLE name:tmp_1 type:kotlin.Function0 [val] + VAR IR_TEMPORARY_VARIABLE name:tmp_3 type:kotlin.Function0 [val] FUN_EXPR type=kotlin.Function0 origin=LAMBDA FUN LOCAL_FUNCTION_FOR_LAMBDA name: visibility:local modality:FINAL <> () returnType:kotlin.Unit BLOCK_BODY RETURN type=kotlin.Nothing from='local final fun (): kotlin.Unit declared in .test3' GET_OBJECT 'CLASS IR_EXTERNAL_DECLARATION_STUB OBJECT name:Unit modality:FINAL visibility:public superTypes:[kotlin.Any]' type=kotlin.Unit - VAR IR_TEMPORARY_VARIABLE name:tmp_2 type:kotlin.Int [val] + VAR IR_TEMPORARY_VARIABLE name:tmp_4 type:kotlin.Int [val] CALL 'public final fun get (index: kotlin.Function0): kotlin.Int [operator] declared in ' type=kotlin.Int origin=null - $receiver: GET_VAR 'val tmp_0: kotlin.Any [val] declared in .test3' type=kotlin.Any origin=null - index: GET_VAR 'val tmp_1: kotlin.Function0 [val] declared in .test3' type=kotlin.Function0 origin=null + $receiver: GET_VAR 'val tmp_2: kotlin.Any [val] declared in .test3' type=kotlin.Any origin=null + index: GET_VAR 'val tmp_3: kotlin.Function0 [val] declared in .test3' type=kotlin.Function0 origin=null CALL 'public final fun set (index: kotlin.Function0, value: kotlin.Int): kotlin.Unit [operator] declared in ' type=kotlin.Unit origin=null - $receiver: GET_VAR 'val tmp_0: kotlin.Any [val] declared in .test3' type=kotlin.Any origin=null - index: GET_VAR 'val tmp_1: kotlin.Function0 [val] declared in .test3' type=kotlin.Function0 origin=null + $receiver: GET_VAR 'val tmp_2: kotlin.Any [val] declared in .test3' type=kotlin.Any origin=null + index: GET_VAR 'val tmp_3: kotlin.Function0 [val] declared in .test3' type=kotlin.Function0 origin=null value: CALL 'public final fun inc (): kotlin.Int [operator] declared in kotlin.Int' type=kotlin.Int origin=null - $this: GET_VAR 'val tmp_2: kotlin.Int [val] declared in .test3' type=kotlin.Int origin=null + $this: GET_VAR 'val tmp_4: kotlin.Int [val] declared in .test3' type=kotlin.Int origin=null TYPE_OP type=kotlin.Unit origin=IMPLICIT_COERCION_TO_UNIT typeOperand=kotlin.Unit - GET_VAR 'val tmp_2: kotlin.Int [val] declared in .test3' type=kotlin.Int origin=null + GET_VAR 'val tmp_4: kotlin.Int [val] declared in .test3' type=kotlin.Int origin=null From 9670f67912e9ff651d69876d86ebd4954667e46c Mon Sep 17 00:00:00 2001 From: Igor Yakovlev Date: Wed, 16 Dec 2020 16:21:00 +0300 Subject: [PATCH 147/196] [FIR IDE] Make annotations and extension receiver lazy --- .../api/symbols/DebugSymbolRenderer.kt | 2 +- .../api/symbols/markers/KtAnnotatedSymbol.kt | 3 +- .../markers/KtPossibleExtensionSymbol.kt | 8 ++- .../FirLightParameterForReceiver.kt | 6 +- .../api/fir/symbols/KtFirAnnotationCall.kt | 55 +++++++++++++++++-- .../fir/symbols/KtFirAnonymousObjectSymbol.kt | 6 +- .../fir/symbols/KtFirClassOrObjectSymbol.kt | 9 +-- .../api/fir/symbols/KtFirConstructorSymbol.kt | 5 +- .../KtFirConstructorValueParameterSymbol.kt | 10 ++-- .../api/fir/symbols/KtFirFileSymbol.kt | 6 +- .../api/fir/symbols/KtFirFunctionSymbol.kt | 13 ++--- .../KtFirFunctionValueParameterSymbol.kt | 7 +-- .../fir/symbols/KtFirKotlinPropertySymbol.kt | 14 ++--- .../fir/symbols/KtFirPropertyGetterSymbol.kt | 7 +-- .../fir/symbols/KtFirPropertySetterSymbol.kt | 7 +-- .../fir/symbols/KtFirSetterParameterSymbol.kt | 7 +-- .../KtFirSyntheticJavaPropertySymbol.kt | 14 ++--- .../fir/symbols/KtFirTypeAndAnnotations.kt | 40 ++++++++++++++ .../idea/frontend/api/fir/utils/firUtils.kt | 33 ----------- .../api/fir/AbstractResolveCallTest.kt | 2 +- 20 files changed, 141 insertions(+), 113 deletions(-) create mode 100644 idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirTypeAndAnnotations.kt diff --git a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/DebugSymbolRenderer.kt b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/DebugSymbolRenderer.kt index 51849436dcc..502eb12d474 100644 --- a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/DebugSymbolRenderer.kt +++ b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/DebugSymbolRenderer.kt @@ -62,7 +62,7 @@ object DebugSymbolRenderer { is KtNamedConstantValue -> "${renderValue(value.name)} = ${renderValue(value.expression)}" is KtAnnotationCall -> "${renderValue(value.classId)}${value.arguments.joinToString(prefix = "(", postfix = ")") { renderValue(it) }}" - is ReceiverTypeAndAnnotations -> "${renderValue(value.annotations)} ${renderValue(value.type)}" + is KtTypeAndAnnotations -> "${renderValue(value.annotations)} ${renderValue(value.type)}" else -> value::class.simpleName!! } diff --git a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/markers/KtAnnotatedSymbol.kt b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/markers/KtAnnotatedSymbol.kt index 4b164db3e02..58c17768514 100644 --- a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/markers/KtAnnotatedSymbol.kt +++ b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/markers/KtAnnotatedSymbol.kt @@ -6,11 +6,12 @@ package org.jetbrains.kotlin.idea.frontend.api.symbols.markers import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget +import org.jetbrains.kotlin.idea.frontend.api.ValidityTokenOwner import org.jetbrains.kotlin.idea.frontend.api.symbols.KtSymbol import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.psi.KtCallElement -abstract class KtAnnotationCall { +abstract class KtAnnotationCall : ValidityTokenOwner { abstract val classId: ClassId? abstract val useSiteTarget: AnnotationUseSiteTarget? abstract val psi: KtCallElement? diff --git a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/markers/KtPossibleExtensionSymbol.kt b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/markers/KtPossibleExtensionSymbol.kt index 5c5f5d71ca8..18fff49afc3 100644 --- a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/markers/KtPossibleExtensionSymbol.kt +++ b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/markers/KtPossibleExtensionSymbol.kt @@ -5,13 +5,17 @@ package org.jetbrains.kotlin.idea.frontend.api.symbols.markers +import org.jetbrains.kotlin.idea.frontend.api.ValidityTokenOwner import org.jetbrains.kotlin.idea.frontend.api.symbols.KtCallableSymbol import org.jetbrains.kotlin.idea.frontend.api.types.KtType -data class ReceiverTypeAndAnnotations(val type: KtType, val annotations: List) +abstract class KtTypeAndAnnotations : ValidityTokenOwner { + abstract val type: KtType + abstract val annotations: List +} interface KtPossibleExtensionSymbol { - val receiverTypeAndAnnotations: ReceiverTypeAndAnnotations? + val receiverType: KtTypeAndAnnotations? val isExtension: Boolean } diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/parameters/FirLightParameterForReceiver.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/parameters/FirLightParameterForReceiver.kt index 70d0009b084..4634667fb68 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/parameters/FirLightParameterForReceiver.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/parameters/FirLightParameterForReceiver.kt @@ -14,13 +14,13 @@ import org.jetbrains.kotlin.codegen.AsmUtil import org.jetbrains.kotlin.fir.declarations.FirResolvePhase import org.jetbrains.kotlin.idea.frontend.api.symbols.KtCallableSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.KtSymbol -import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.ReceiverTypeAndAnnotations +import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtTypeAndAnnotations import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtNamedSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtPossibleExtensionSymbol import org.jetbrains.kotlin.psi.KtParameter internal class FirLightParameterForReceiver private constructor( - private val receiverTypeAndAnnotations: ReceiverTypeAndAnnotations, + private val receiverTypeAndAnnotations: KtTypeAndAnnotations, private val context: KtSymbol, methodName: String, method: FirLightMethod @@ -36,7 +36,7 @@ internal class FirLightParameterForReceiver private constructor( if (callableSymbol !is KtPossibleExtensionSymbol) return null if (!callableSymbol.isExtension) return null - val extensionTypeAndAnnotations = callableSymbol.receiverTypeAndAnnotations ?: return null + val extensionTypeAndAnnotations = callableSymbol.receiverType ?: return null return FirLightParameterForReceiver( receiverTypeAndAnnotations = extensionTypeAndAnnotations, diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirAnnotationCall.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirAnnotationCall.kt index c092f0653f9..e9bd29d5c85 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirAnnotationCall.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirAnnotationCall.kt @@ -6,13 +6,58 @@ package org.jetbrains.kotlin.idea.frontend.api.fir.symbols import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.declarations.FirDeclaration +import org.jetbrains.kotlin.fir.declarations.FirResolvePhase +import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall +import org.jetbrains.kotlin.fir.resolve.fullyExpandedType +import org.jetbrains.kotlin.fir.resolve.toSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol +import org.jetbrains.kotlin.fir.types.ConeClassLikeType +import org.jetbrains.kotlin.fir.types.classId +import org.jetbrains.kotlin.fir.types.coneType +import org.jetbrains.kotlin.idea.fir.findPsi +import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirModuleResolveState +import org.jetbrains.kotlin.idea.frontend.api.ValidityToken +import org.jetbrains.kotlin.idea.frontend.api.fir.utils.convertConstantExpression +import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef +import org.jetbrains.kotlin.idea.frontend.api.fir.utils.mapAnnotationParameters +import org.jetbrains.kotlin.idea.frontend.api.fir.utils.weakRef import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.* import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.psi.KtCallElement class KtFirAnnotationCall( - override val classId: ClassId, - override val useSiteTarget: AnnotationUseSiteTarget?, - override val psi: KtCallElement?, - override val arguments: List -) : KtAnnotationCall() + containingDeclaration: FirDeclaration, + annotationCall: FirAnnotationCall, + resolveState: FirModuleResolveState, + override val token: ValidityToken, +) : KtAnnotationCall() { + + private val containingDeclarationRef = firRef(containingDeclaration, resolveState) + private val annotationCallRef by weakRef(annotationCall) + + override val psi: KtCallElement? by containingDeclarationRef.withFirAndCache { fir -> + annotationCallRef.findPsi(fir.session) as? KtCallElement + } + + private fun ConeClassLikeType.expandTypeAliasIfNeeded(session: FirSession): ConeClassLikeType { + val firTypeAlias = lookupTag.toSymbol(session) as? FirTypeAliasSymbol ?: return this + val expandedType = firTypeAlias.fir.expandedTypeRef.coneType + return expandedType.fullyExpandedType(session) as? ConeClassLikeType + ?: return this + } + + override val classId: ClassId? by containingDeclarationRef.withFirAndCache(FirResolvePhase.TYPES) { + val declaredCone = annotationCallRef.annotationTypeRef.coneType as? ConeClassLikeType + declaredCone?.expandTypeAliasIfNeeded(it.session)?.classId + } + + override val useSiteTarget: AnnotationUseSiteTarget? get() = annotationCallRef.useSiteTarget + + override val arguments: List by containingDeclarationRef.withFirAndCache(FirResolvePhase.TYPES) { + mapAnnotationParameters(annotationCallRef, it.session).map { (name, expression) -> + KtNamedConstantValue(name, expression.convertConstantExpression()) + } + } +} diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirAnonymousObjectSymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirAnonymousObjectSymbol.kt index f4de67d9eb3..592155a07f3 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirAnonymousObjectSymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirAnonymousObjectSymbol.kt @@ -13,10 +13,8 @@ import org.jetbrains.kotlin.idea.fir.findPsi import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirModuleResolveState import org.jetbrains.kotlin.idea.frontend.api.ValidityToken import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder -import org.jetbrains.kotlin.idea.frontend.api.fir.utils.convertAnnotation import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef import org.jetbrains.kotlin.idea.frontend.api.symbols.KtAnonymousObjectSymbol -import org.jetbrains.kotlin.idea.frontend.api.symbols.KtSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtAnnotationCall import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolKind import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.CanNotCreateSymbolPointerForLocalLibraryDeclarationException @@ -35,8 +33,8 @@ internal class KtFirAnonymousObjectSymbol( override val symbolKind: KtSymbolKind = KtSymbolKind.LOCAL override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.findPsi(fir.session) } - override val annotations: List by firRef.withFirAndCache(FirResolvePhase.TYPES) { - convertAnnotation(it) + override val annotations: List by firRef.withFirAndCache { fir -> + fir.annotations.map { KtFirAnnotationCall(fir, it, resolveState, token) } } override val superTypes: List by firRef.withFirAndCache(FirResolvePhase.SUPER_TYPES) { fir -> diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirClassOrObjectSymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirClassOrObjectSymbol.kt index f3dc94d8ac8..4170c408cd3 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirClassOrObjectSymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirClassOrObjectSymbol.kt @@ -13,9 +13,10 @@ import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirModuleResolveState import org.jetbrains.kotlin.idea.frontend.api.ValidityToken import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder import org.jetbrains.kotlin.idea.frontend.api.fir.symbols.pointers.KtFirClassOrObjectInLibrarySymbol -import org.jetbrains.kotlin.idea.frontend.api.fir.utils.convertAnnotation import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef -import org.jetbrains.kotlin.idea.frontend.api.symbols.* +import org.jetbrains.kotlin.idea.frontend.api.symbols.KtClassKind +import org.jetbrains.kotlin.idea.frontend.api.symbols.KtClassOrObjectSymbol +import org.jetbrains.kotlin.idea.frontend.api.symbols.KtConstructorSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtAnnotationCall import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolKind import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolModality @@ -45,8 +46,8 @@ internal class KtFirClassOrObjectSymbol( override val visibility: KtSymbolVisibility get() = getVisibility() - override val annotations: List by firRef.withFirAndCache(FirResolvePhase.TYPES) { - convertAnnotation(it) + override val annotations: List by firRef.withFirAndCache { fir -> + fir.annotations.map { KtFirAnnotationCall(fir, it, resolveState, token) } } override val isInner: Boolean get() = firRef.withFir(FirResolvePhase.STATUS) { it.isInner } diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirConstructorSymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirConstructorSymbol.kt index 70b96dee051..527c85bb25e 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirConstructorSymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirConstructorSymbol.kt @@ -16,7 +16,6 @@ import org.jetbrains.kotlin.idea.frontend.api.ValidityToken import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder import org.jetbrains.kotlin.idea.frontend.api.fir.symbols.pointers.KtFirConstructorSymbolPointer import org.jetbrains.kotlin.idea.frontend.api.fir.symbols.pointers.createSignature -import org.jetbrains.kotlin.idea.frontend.api.fir.utils.convertAnnotation import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef import org.jetbrains.kotlin.idea.frontend.api.symbols.KtConstructorParameterSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.KtConstructorSymbol @@ -49,8 +48,8 @@ internal class KtFirConstructorSymbol( override val visibility: KtSymbolVisibility get() = getVisibility() - override val annotations: List by firRef.withFirAndCache(FirResolvePhase.TYPES) { - convertAnnotation(it) + override val annotations: List by firRef.withFirAndCache { fir -> + fir.annotations.map { KtFirAnnotationCall(fir, it, resolveState, token) } } override val containingClassIdIfNonLocal: ClassId? diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirConstructorValueParameterSymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirConstructorValueParameterSymbol.kt index 181879eabfe..ff342fc410d 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirConstructorValueParameterSymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirConstructorValueParameterSymbol.kt @@ -11,15 +11,15 @@ import org.jetbrains.kotlin.fir.declarations.FirValueParameter import org.jetbrains.kotlin.idea.fir.findPsi import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirModuleResolveState import org.jetbrains.kotlin.idea.frontend.api.ValidityToken -import org.jetbrains.kotlin.idea.frontend.api.types.KtType import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder -import org.jetbrains.kotlin.idea.frontend.api.fir.utils.convertAnnotation import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef -import org.jetbrains.kotlin.idea.frontend.api.symbols.* +import org.jetbrains.kotlin.idea.frontend.api.symbols.KtConstructorParameterSymbol +import org.jetbrains.kotlin.idea.frontend.api.symbols.KtConstructorParameterSymbolKind import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtAnnotationCall import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolKind import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtPsiBasedSymbolPointer import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtSymbolPointer +import org.jetbrains.kotlin.idea.frontend.api.types.KtType import org.jetbrains.kotlin.name.Name internal class KtFirConstructorValueParameterSymbol( @@ -41,8 +41,8 @@ internal class KtFirConstructorValueParameterSymbol( } } - override val annotations: List by firRef.withFirAndCache(FirResolvePhase.TYPES) { - convertAnnotation(it) + override val annotations: List by firRef.withFirAndCache { fir -> + fir.annotations.map { KtFirAnnotationCall(fir, it, resolveState, token) } } override val constructorParameterKind: KtConstructorParameterSymbolKind diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirFileSymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirFileSymbol.kt index dadc3bff508..1063e6e15cf 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirFileSymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirFileSymbol.kt @@ -7,12 +7,10 @@ package org.jetbrains.kotlin.idea.frontend.api.fir.symbols import com.intellij.psi.PsiElement import org.jetbrains.kotlin.fir.declarations.FirFile -import org.jetbrains.kotlin.fir.declarations.FirResolvePhase import org.jetbrains.kotlin.idea.fir.findPsi import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirModuleResolveState import org.jetbrains.kotlin.idea.frontend.api.ValidityToken import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder -import org.jetbrains.kotlin.idea.frontend.api.fir.utils.convertAnnotation import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef import org.jetbrains.kotlin.idea.frontend.api.symbols.KtFileSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtAnnotationCall @@ -35,7 +33,7 @@ internal class KtFirFileSymbol( TODO("Creating pointers for files from library is not supported yet") } - override val annotations: List by firRef.withFirAndCache(FirResolvePhase.TYPES) { - convertAnnotation(it) + override val annotations: List by firRef.withFirAndCache { fir -> + fir.annotations.map { KtFirAnnotationCall(fir, it, resolveState, token) } } } \ No newline at end of file diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirFunctionSymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirFunctionSymbol.kt index dde0978d932..0ff303b4a23 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirFunctionSymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirFunctionSymbol.kt @@ -15,7 +15,6 @@ import org.jetbrains.kotlin.idea.frontend.api.ValidityToken import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder import org.jetbrains.kotlin.idea.frontend.api.fir.symbols.pointers.KtFirMemberFunctionSymbolPointer import org.jetbrains.kotlin.idea.frontend.api.fir.symbols.pointers.createSignature -import org.jetbrains.kotlin.idea.frontend.api.fir.utils.convertAnnotation import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef import org.jetbrains.kotlin.idea.frontend.api.symbols.KtFunctionSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.* @@ -48,20 +47,16 @@ internal class KtFirFunctionSymbol( } } - override val annotations: List by firRef.withFirAndCache(FirResolvePhase.TYPES) { - convertAnnotation(it) + override val annotations: List by firRef.withFirAndCache { fir -> + fir.annotations.map { KtFirAnnotationCall(fir, it, resolveState, token) } } override val isSuspend: Boolean get() = firRef.withFir { it.isSuspend } override val isOverride: Boolean get() = firRef.withFir { it.isOverride } - override val receiverTypeAndAnnotations: ReceiverTypeAndAnnotations? by firRef.withFirAndCache(FirResolvePhase.TYPES) { fir -> + override val receiverType: KtTypeAndAnnotations? by firRef.withFirAndCache { fir -> fir.receiverTypeRef?.let { typeRef -> - val type = builder.buildKtType(typeRef) - val annotations = typeRef.annotations.mapNotNull { - convertAnnotation(it, fir.session) - } - ReceiverTypeAndAnnotations(type, annotations) + KtFirTypeAndAnnotations(fir, typeRef, resolveState, token, builder) } } diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirFunctionValueParameterSymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirFunctionValueParameterSymbol.kt index a2516c1f75c..841c8c9e910 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirFunctionValueParameterSymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirFunctionValueParameterSymbol.kt @@ -11,14 +11,13 @@ import org.jetbrains.kotlin.fir.declarations.FirValueParameter import org.jetbrains.kotlin.idea.fir.findPsi import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirModuleResolveState import org.jetbrains.kotlin.idea.frontend.api.ValidityToken -import org.jetbrains.kotlin.idea.frontend.api.types.KtType import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder -import org.jetbrains.kotlin.idea.frontend.api.fir.utils.convertAnnotation import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef import org.jetbrains.kotlin.idea.frontend.api.symbols.KtFunctionParameterSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtAnnotationCall import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtPsiBasedSymbolPointer import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtSymbolPointer +import org.jetbrains.kotlin.idea.frontend.api.types.KtType import org.jetbrains.kotlin.name.Name internal class KtFirFunctionValueParameterSymbol( @@ -36,8 +35,8 @@ internal class KtFirFunctionValueParameterSymbol( override val hasDefaultValue: Boolean get() = firRef.withFir { it.defaultValue != null } - override val annotations: List by firRef.withFirAndCache(FirResolvePhase.TYPES) { - convertAnnotation(it) + override val annotations: List by firRef.withFirAndCache { fir -> + fir.annotations.map { KtFirAnnotationCall(fir, it, resolveState, token) } } override fun createPointer(): KtSymbolPointer { diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirKotlinPropertySymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirKotlinPropertySymbol.kt index 4b6b76392ab..9e4216c4d7e 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirKotlinPropertySymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirKotlinPropertySymbol.kt @@ -15,7 +15,6 @@ import org.jetbrains.kotlin.idea.frontend.api.ValidityToken import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder import org.jetbrains.kotlin.idea.frontend.api.fir.symbols.pointers.KtFirMemberPropertySymbolPointer import org.jetbrains.kotlin.idea.frontend.api.fir.symbols.pointers.createSignature -import org.jetbrains.kotlin.idea.frontend.api.fir.utils.convertAnnotation import org.jetbrains.kotlin.idea.frontend.api.fir.utils.convertConstantExpression import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef import org.jetbrains.kotlin.idea.frontend.api.symbols.KtKotlinPropertySymbol @@ -48,13 +47,9 @@ internal class KtFirKotlinPropertySymbol( override val name: Name get() = firRef.withFir { it.name } override val type: KtType by firRef.withFirAndCache(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) { fir -> builder.buildKtType(fir.returnTypeRef) } - override val receiverTypeAndAnnotations: ReceiverTypeAndAnnotations? by firRef.withFirAndCache(FirResolvePhase.TYPES) { fir -> + override val receiverType: KtTypeAndAnnotations? by firRef.withFirAndCache { fir -> fir.receiverTypeRef?.let { typeRef -> - val type = builder.buildKtType(typeRef) - val annotations = typeRef.annotations.mapNotNull { - convertAnnotation(it, fir.session) - } - ReceiverTypeAndAnnotations(type, annotations) + KtFirTypeAndAnnotations(fir, typeRef, resolveState, token, builder) } } @@ -71,9 +66,8 @@ internal class KtFirKotlinPropertySymbol( override val visibility: KtSymbolVisibility get() = getVisibility() - - override val annotations: List by firRef.withFirAndCache(FirResolvePhase.TYPES) { - convertAnnotation(it) + override val annotations: List by firRef.withFirAndCache { fir -> + fir.annotations.map { KtFirAnnotationCall(fir, it, resolveState, token) } } override val callableIdIfNonLocal: FqName? diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirPropertyGetterSymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirPropertyGetterSymbol.kt index 193eb71817b..b5347650c82 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirPropertyGetterSymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirPropertyGetterSymbol.kt @@ -8,14 +8,11 @@ package org.jetbrains.kotlin.idea.frontend.api.fir.symbols import com.intellij.psi.PsiElement import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor -import org.jetbrains.kotlin.fir.declarations.impl.FirValueParameterImpl import org.jetbrains.kotlin.idea.fir.findPsi import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirModuleResolveState import org.jetbrains.kotlin.idea.frontend.api.ValidityToken import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder -import org.jetbrains.kotlin.idea.frontend.api.fir.utils.convertAnnotation import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef -import org.jetbrains.kotlin.idea.frontend.api.symbols.KtParameterSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.KtPropertyGetterSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtAnnotationCall import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtCommonSymbolModality @@ -54,8 +51,8 @@ internal class KtFirPropertyGetterSymbol( override val type: KtType by firRef.withFirAndCache { builder.buildKtType(it.returnTypeRef) } override val modality: KtCommonSymbolModality get() = firRef.withFir(FirResolvePhase.STATUS) { it.modality.getSymbolModality() } override val visibility: KtSymbolVisibility get() = firRef.withFir(FirResolvePhase.STATUS) { it.visibility.getSymbolVisibility() } - override val annotations: List by firRef.withFirAndCache(FirResolvePhase.TYPES) { - convertAnnotation(it) + override val annotations: List by firRef.withFirAndCache { fir -> + fir.annotations.map { KtFirAnnotationCall(fir, it, resolveState, token) } } override fun createPointer(): KtSymbolPointer { diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirPropertySetterSymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirPropertySetterSymbol.kt index 0e4a239656c..493fca3ec1d 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirPropertySetterSymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirPropertySetterSymbol.kt @@ -8,12 +8,10 @@ package org.jetbrains.kotlin.idea.frontend.api.fir.symbols import com.intellij.psi.PsiElement import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor -import org.jetbrains.kotlin.fir.declarations.impl.FirValueParameterImpl import org.jetbrains.kotlin.idea.fir.findPsi import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirModuleResolveState import org.jetbrains.kotlin.idea.frontend.api.ValidityToken import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder -import org.jetbrains.kotlin.idea.frontend.api.fir.utils.convertAnnotation import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef import org.jetbrains.kotlin.idea.frontend.api.symbols.KtPropertySetterSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.KtSetterParameterSymbol @@ -23,7 +21,6 @@ import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolKind import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolVisibility import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtPsiBasedSymbolPointer import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtSymbolPointer -import org.jetbrains.kotlin.idea.frontend.api.types.KtType internal class KtFirPropertySetterSymbol( fir: FirPropertyAccessor, @@ -45,8 +42,8 @@ internal class KtFirPropertySetterSymbol( override val modality: KtCommonSymbolModality get() = firRef.withFir(FirResolvePhase.STATUS) { it.modality.getSymbolModality() } override val visibility: KtSymbolVisibility get() = firRef.withFir(FirResolvePhase.STATUS) { it.visibility.getSymbolVisibility() } - override val annotations: List by firRef.withFirAndCache(FirResolvePhase.TYPES) { - convertAnnotation(it) + override val annotations: List by firRef.withFirAndCache { fir -> + fir.annotations.map { KtFirAnnotationCall(fir, it, resolveState, token) } } override val parameter: KtSetterParameterSymbol by firRef.withFirAndCache { fir -> builder.buildFirSetterParameter(fir.valueParameters.single()) diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirSetterParameterSymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirSetterParameterSymbol.kt index 798b0d5b957..cbea83aada1 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirSetterParameterSymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirSetterParameterSymbol.kt @@ -11,14 +11,13 @@ import org.jetbrains.kotlin.fir.declarations.FirValueParameter import org.jetbrains.kotlin.idea.fir.findPsi import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirModuleResolveState import org.jetbrains.kotlin.idea.frontend.api.ValidityToken -import org.jetbrains.kotlin.idea.frontend.api.types.KtType import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder -import org.jetbrains.kotlin.idea.frontend.api.fir.utils.convertAnnotation import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef import org.jetbrains.kotlin.idea.frontend.api.symbols.KtSetterParameterSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtAnnotationCall import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtPsiBasedSymbolPointer import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtSymbolPointer +import org.jetbrains.kotlin.idea.frontend.api.types.KtType import org.jetbrains.kotlin.name.Name internal class KtFirSetterParameterSymbol( @@ -37,8 +36,8 @@ internal class KtFirSetterParameterSymbol( override val isVararg: Boolean = false - override val annotations: List by firRef.withFirAndCache(FirResolvePhase.TYPES) { - convertAnnotation(it) + override val annotations: List by firRef.withFirAndCache { fir -> + fir.annotations.map { KtFirAnnotationCall(fir, it, resolveState, token) } } override fun createPointer(): KtSymbolPointer { diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirSyntheticJavaPropertySymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirSyntheticJavaPropertySymbol.kt index c926a7bdfe6..58560eb5fef 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirSyntheticJavaPropertySymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirSyntheticJavaPropertySymbol.kt @@ -15,7 +15,6 @@ import org.jetbrains.kotlin.idea.frontend.api.ValidityToken import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder import org.jetbrains.kotlin.idea.frontend.api.fir.symbols.pointers.KtFirMemberPropertySymbolPointer import org.jetbrains.kotlin.idea.frontend.api.fir.symbols.pointers.createSignature -import org.jetbrains.kotlin.idea.frontend.api.fir.utils.convertAnnotation import org.jetbrains.kotlin.idea.frontend.api.fir.utils.convertConstantExpression import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef import org.jetbrains.kotlin.idea.frontend.api.symbols.KtPropertyGetterSymbol @@ -42,13 +41,9 @@ internal class KtFirSyntheticJavaPropertySymbol( override val isVal: Boolean get() = firRef.withFir { it.isVal } override val name: Name get() = firRef.withFir { it.name } override val type: KtType by firRef.withFirAndCache(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) { fir -> builder.buildKtType(fir.returnTypeRef) } - override val receiverTypeAndAnnotations: ReceiverTypeAndAnnotations? by firRef.withFirAndCache(FirResolvePhase.TYPES) { fir -> + override val receiverType: KtTypeAndAnnotations? by firRef.withFirAndCache { fir -> fir.receiverTypeRef?.let { typeRef -> - val type = builder.buildKtType(typeRef) - val annotations = typeRef.annotations.mapNotNull { - convertAnnotation(it, fir.session) - } - ReceiverTypeAndAnnotations(type, annotations) + KtFirTypeAndAnnotations(fir, typeRef, resolveState, token, builder) } } override val isExtension: Boolean get() = firRef.withFir { it.receiverTypeRef != null } @@ -59,9 +54,8 @@ internal class KtFirSyntheticJavaPropertySymbol( override val visibility: KtSymbolVisibility get() = getVisibility() - - override val annotations: List by firRef.withFirAndCache(FirResolvePhase.TYPES) { - convertAnnotation(it) + override val annotations: List by firRef.withFirAndCache { fir -> + fir.annotations.map { KtFirAnnotationCall(fir, it, resolveState, token) } } override val callableIdIfNonLocal: FqName? diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirTypeAndAnnotations.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirTypeAndAnnotations.kt new file mode 100644 index 00000000000..4756866d8d9 --- /dev/null +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirTypeAndAnnotations.kt @@ -0,0 +1,40 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.idea.frontend.api.fir.symbols + +import org.jetbrains.kotlin.fir.declarations.FirDeclaration +import org.jetbrains.kotlin.fir.declarations.FirResolvePhase +import org.jetbrains.kotlin.fir.types.FirTypeRef +import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirModuleResolveState +import org.jetbrains.kotlin.idea.frontend.api.ValidityToken +import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder +import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef +import org.jetbrains.kotlin.idea.frontend.api.fir.utils.weakRef +import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtAnnotationCall +import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtTypeAndAnnotations +import org.jetbrains.kotlin.idea.frontend.api.types.KtType + +internal class KtFirTypeAndAnnotations( + containingDeclaration: FirDeclaration, + receiverTypeRef: FirTypeRef, + resolveState: FirModuleResolveState, + override val token: ValidityToken, + private val builder: KtSymbolByFirBuilder +) : KtTypeAndAnnotations() { + + private val containingDeclarationRef = firRef(containingDeclaration, resolveState) + private val receiverWeakTypeRef by weakRef(receiverTypeRef) + + override val type: KtType by containingDeclarationRef.withFirAndCache(FirResolvePhase.TYPES) { + builder.buildKtType(receiverWeakTypeRef) + } + + override val annotations: List by containingDeclarationRef.withFirAndCache { fir -> + receiverWeakTypeRef.annotations.map { + KtFirAnnotationCall(fir, it, resolveState, token) + } + } +} \ No newline at end of file diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/utils/firUtils.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/utils/firUtils.kt index 93351990952..28c8bf744b3 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/utils/firUtils.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/utils/firUtils.kt @@ -55,37 +55,4 @@ internal fun FirExpression.convertConstantExpression(): KtConstantValue = when (this) { is FirConstExpression<*> -> KtSimpleConstantValue(value) else -> KtUnsupportedConstantValue - } - -private fun ConeClassLikeType.expandTypeAliasIfNeeded(session: FirSession): ConeClassLikeType { - val firTypeAlias = lookupTag.toSymbol(session) as? FirTypeAliasSymbol ?: return this - val expandedType = firTypeAlias.fir.expandedTypeRef.coneType - return expandedType.fullyExpandedType(session) as? ConeClassLikeType - ?: return this -} - -internal fun convertAnnotation( - annotationCall: FirAnnotationCall, - session: FirSession -): KtFirAnnotationCall? { - - val declaredCone = annotationCall.annotationTypeRef.coneType as? ConeClassLikeType ?: return null - - val classId = declaredCone.expandTypeAliasIfNeeded(session).classId ?: return null - - val resultList = mapAnnotationParameters(annotationCall, session).map { - KtNamedConstantValue(it.key, it.value.convertConstantExpression()) - } - - return KtFirAnnotationCall( - classId = classId, - useSiteTarget = annotationCall.useSiteTarget, - psi = annotationCall.psi as? KtCallElement, - arguments = resultList - ) -} - -internal fun convertAnnotation(declaration: FirAnnotatedDeclaration): List = - declaration.annotations.mapNotNull { - convertAnnotation(it, declaration.session) } \ No newline at end of file diff --git a/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/fir/AbstractResolveCallTest.kt b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/fir/AbstractResolveCallTest.kt index f589193a19c..acd1aed5076 100644 --- a/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/fir/AbstractResolveCallTest.kt +++ b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/fir/AbstractResolveCallTest.kt @@ -95,7 +95,7 @@ private fun KtCall.stringRepresentation(): String { is KtFunctionLikeSymbol -> buildString { append(if (this@stringValue is KtFunctionSymbol) callableIdIfNonLocal ?: name else "") append("(") - (this@stringValue as? KtFunctionSymbol)?.receiverTypeAndAnnotations?.let { receiver -> + (this@stringValue as? KtFunctionSymbol)?.receiverType?.let { receiver -> append(": ${receiver.type.render()}") if (valueParameters.isNotEmpty()) append(", ") } From 8891a337e290a8c8ba05a3370263c01692caf296 Mon Sep 17 00:00:00 2001 From: Igor Yakovlev Date: Wed, 16 Dec 2020 21:01:09 +0300 Subject: [PATCH 148/196] [FIR IDE] Implement type annotations for fir symbols --- .../KotlinFirLookupElementFactory.kt | 9 +-- .../weighers/ExpectedTypeWeigher.kt | 2 +- .../api/symbols/KtAnonymousObjectSymbol.kt | 3 +- .../frontend/api/symbols/KtClassLikeSymbol.kt | 2 +- .../frontend/api/symbols/markers/markers.kt | 2 +- .../classes/FirLightClassForEnumEntry.kt | 7 +- .../idea/asJava/classes/firLightClassUtils.kt | 6 +- .../asJava/fields/FirLightFieldEnumEntry.kt | 2 +- .../fields/FirLightFieldForPropertySymbol.kt | 4 +- .../kotlin/idea/asJava/firLightUtils.kt | 25 ++++--- .../FirLightAccessorMethodForSymbol.kt | 4 +- .../methods/FirLightSimpleMethodForSymbol.kt | 4 +- .../FirLightParameterBaseForSymbol.kt | 19 ++--- .../FirLightParameterForReceiver.kt | 2 +- .../parameters/FirLightTypeParameter.kt | 8 +- .../components/KtFirExpressionTypeProvider.kt | 9 +-- .../api/fir/symbols/KtFirAnnotationCall.kt | 37 +++++---- .../symbols/KtFirAnonymousFunctionSymbol.kt | 8 +- .../fir/symbols/KtFirAnonymousObjectSymbol.kt | 15 ++-- .../fir/symbols/KtFirClassOrObjectSymbol.kt | 18 ++--- .../api/fir/symbols/KtFirConstructorSymbol.kt | 12 ++- .../KtFirConstructorValueParameterSymbol.kt | 13 ++-- .../api/fir/symbols/KtFirEnumEntrySymbol.kt | 7 +- .../api/fir/symbols/KtFirFileSymbol.kt | 2 +- .../api/fir/symbols/KtFirFunctionSymbol.kt | 16 ++-- .../KtFirFunctionValueParameterSymbol.kt | 11 ++- .../api/fir/symbols/KtFirJavaFieldSymbol.kt | 6 +- .../fir/symbols/KtFirKotlinPropertySymbol.kt | 16 ++-- .../fir/symbols/KtFirLocalVariableSymbol.kt | 6 +- .../fir/symbols/KtFirPropertyGetterSymbol.kt | 15 ++-- .../fir/symbols/KtFirPropertySetterSymbol.kt | 5 +- .../fir/symbols/KtFirSetterParameterSymbol.kt | 14 ++-- .../KtFirSyntheticJavaPropertySymbol.kt | 18 ++--- .../fir/symbols/KtFirTypeAndAnnotations.kt | 75 ++++++++++++++----- .../fir/symbols/KtFirTypeParameterSymbol.kt | 2 +- .../api/fir/symbols/firSymbolUtils.kt | 16 +++- .../api/fir/utils/FirRefWithValidityCheck.kt | 2 +- .../idea/frontend/api/fir/utils/firUtils.kt | 21 +++--- .../api/fir/AbstractResolveCallTest.kt | 6 +- 39 files changed, 258 insertions(+), 191 deletions(-) diff --git a/idea/idea-fir/src/org/jetbrains/kotlin/idea/completion/KotlinFirLookupElementFactory.kt b/idea/idea-fir/src/org/jetbrains/kotlin/idea/completion/KotlinFirLookupElementFactory.kt index 01d79ba6a5a..5f42e22a93b 100644 --- a/idea/idea-fir/src/org/jetbrains/kotlin/idea/completion/KotlinFirLookupElementFactory.kt +++ b/idea/idea-fir/src/org/jetbrains/kotlin/idea/completion/KotlinFirLookupElementFactory.kt @@ -19,7 +19,6 @@ import com.intellij.psi.PsiElement import org.jetbrains.kotlin.idea.frontend.api.KtAnalysisSession import org.jetbrains.kotlin.idea.frontend.api.symbols.* import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtNamedSymbol -import org.jetbrains.kotlin.idea.frontend.api.types.KtType import org.jetbrains.kotlin.lexer.KtTokens import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.psi.KtTypeArgumentList @@ -67,7 +66,7 @@ private class TypeParameterLookupElementFactory { private class VariableLookupElementFactory { fun KtAnalysisSession.createLookup(symbol: KtVariableLikeSymbol): LookupElementBuilder { return LookupElementBuilder.create(UniqueLookupObject(), symbol.name.asString()) - .withTypeText(symbol.type.render()) + .withTypeText(symbol.annotatedType.type.render()) .markIfSyntheticJavaProperty(symbol) .withInsertHandler(createInsertHandler(symbol)) } @@ -95,7 +94,7 @@ private class FunctionLookupElementFactory { return try { LookupElementBuilder.create(UniqueLookupObject(), symbol.name.asString()) .withTailText(getTailText(symbol), true) - .withTypeText(symbol.type.render()) + .withTypeText(symbol.annotatedType.type.render()) .withInsertHandler(createInsertHandler(symbol)) } catch (e: Throwable) { if (e is ControlFlowException) throw e @@ -110,7 +109,7 @@ private class FunctionLookupElementFactory { private fun KtAnalysisSession.insertLambdaBraces(symbol: KtFunctionSymbol): Boolean { val singleParam = symbol.valueParameters.singleOrNull() - return singleParam != null && !singleParam.hasDefaultValue && singleParam.type.isBuiltInFunctionalType() + return singleParam != null && !singleParam.hasDefaultValue && singleParam.annotatedType.type.isBuiltInFunctionalType() } private fun KtAnalysisSession.createInsertHandler(symbol: KtFunctionSymbol): InsertHandler { @@ -232,7 +231,7 @@ private object ShortNamesRenderer { function.valueParameters.joinToString(", ", "(", ")") { renderFunctionParameter(it) } private fun KtAnalysisSession.renderFunctionParameter(param: KtFunctionParameterSymbol): String = - "${if (param.isVararg) "vararg " else ""}${param.name.asString()}: ${param.type.render()}" + "${if (param.isVararg) "vararg " else ""}${param.name.asString()}: ${param.annotatedType.type.render()}" } private fun Document.isTextAt(offset: Int, text: String) = diff --git a/idea/idea-fir/src/org/jetbrains/kotlin/idea/completion/weighers/ExpectedTypeWeigher.kt b/idea/idea-fir/src/org/jetbrains/kotlin/idea/completion/weighers/ExpectedTypeWeigher.kt index d77a1794f87..c44b669b31d 100644 --- a/idea/idea-fir/src/org/jetbrains/kotlin/idea/completion/weighers/ExpectedTypeWeigher.kt +++ b/idea/idea-fir/src/org/jetbrains/kotlin/idea/completion/weighers/ExpectedTypeWeigher.kt @@ -31,7 +31,7 @@ internal object ExpectedTypeWeigher { ) = when { expectedType == null -> MatchesExpectedType.NON_TYPABLE symbol !is KtTypedSymbol -> MatchesExpectedType.NON_TYPABLE - else -> MatchesExpectedType.matches(symbol.type isSubTypeOf expectedType) + else -> MatchesExpectedType.matches(symbol.annotatedType.type isSubTypeOf expectedType) } diff --git a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/KtAnonymousObjectSymbol.kt b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/KtAnonymousObjectSymbol.kt index 6c5db0b8210..149a72e7d72 100644 --- a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/KtAnonymousObjectSymbol.kt +++ b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/KtAnonymousObjectSymbol.kt @@ -8,11 +8,12 @@ package org.jetbrains.kotlin.idea.frontend.api.symbols import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtAnnotatedSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolWithMembers import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolWithKind +import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtTypeAndAnnotations import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtSymbolPointer import org.jetbrains.kotlin.idea.frontend.api.types.KtType abstract class KtAnonymousObjectSymbol : KtSymbolWithKind, KtAnnotatedSymbol, KtSymbolWithMembers { - abstract val superTypes: List + abstract val superTypes: List abstract override fun createPointer(): KtSymbolPointer } \ No newline at end of file diff --git a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/KtClassLikeSymbol.kt b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/KtClassLikeSymbol.kt index 3aa75dc4ca6..a7eef0dbde4 100644 --- a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/KtClassLikeSymbol.kt +++ b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/KtClassLikeSymbol.kt @@ -44,7 +44,7 @@ abstract class KtClassOrObjectSymbol : KtClassLikeSymbol(), abstract val companionObject: KtClassOrObjectSymbol? - abstract val superTypes: List + abstract val superTypes: List abstract val primaryConstructor: KtConstructorSymbol? diff --git a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/markers/markers.kt b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/markers/markers.kt index b1221a84399..bebe2ed0c23 100644 --- a/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/markers/markers.kt +++ b/idea/idea-frontend-api/src/org/jetbrains/kotlin/idea/frontend/api/symbols/markers/markers.kt @@ -15,7 +15,7 @@ interface KtNamedSymbol : KtSymbol { } interface KtTypedSymbol : KtSymbol { - val type: KtType + val annotatedType: KtTypeAndAnnotations } interface KtSymbolWithTypeParameters { diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightClassForEnumEntry.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightClassForEnumEntry.kt index 97648a2cd1a..7167ccd449f 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightClassForEnumEntry.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/FirLightClassForEnumEntry.kt @@ -14,7 +14,6 @@ import org.jetbrains.kotlin.idea.asJava.FirLightPsiJavaCodeReferenceElementWithN import org.jetbrains.kotlin.idea.asJava.classes.createMethods import org.jetbrains.kotlin.idea.frontend.api.fir.analyzeWithSymbolAsContext import org.jetbrains.kotlin.idea.frontend.api.symbols.KtEnumEntrySymbol -import org.jetbrains.kotlin.idea.frontend.api.types.KtClassType import org.jetbrains.kotlin.load.java.structure.LightClassOriginKind import org.jetbrains.kotlin.psi.KtClassOrObject @@ -83,9 +82,9 @@ internal class FirLightClassForEnumEntry( private val _extendsList: PsiReferenceList? by lazyPub { - val mappedType = (enumEntrySymbol.type as? KtClassType)?.let { - it.mapSupertype(this@FirLightClassForEnumEntry) - } ?: return@lazyPub null + val mappedType = enumEntrySymbol.annotatedType + .mapSupertype(this@FirLightClassForEnumEntry) + ?: return@lazyPub null KotlinSuperTypeListBuilder( kotlinOrigin = enumClass.kotlinOrigin?.getSuperTypeList(), diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/firLightClassUtils.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/firLightClassUtils.kt index e7e95670fd4..d4c015e822a 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/firLightClassUtils.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/classes/firLightClassUtils.kt @@ -25,6 +25,7 @@ import org.jetbrains.kotlin.idea.frontend.api.symbols.* import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtCommonSymbolModality import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolVisibility import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolWithMembers +import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtTypeAndAnnotations import org.jetbrains.kotlin.idea.frontend.api.types.KtClassType import org.jetbrains.kotlin.idea.frontend.api.types.KtType import org.jetbrains.kotlin.lexer.KtTokens @@ -268,7 +269,7 @@ internal fun FirLightClassBase.createField( ) } -internal fun FirLightClassBase.createInheritanceList(forExtendsList: Boolean, superTypes: List): PsiReferenceList { +internal fun FirLightClassBase.createInheritanceList(forExtendsList: Boolean, superTypes: List): PsiReferenceList { val role = if (forExtendsList) PsiReferenceList.Role.EXTENDS_LIST else PsiReferenceList.Role.IMPLEMENTS_LIST @@ -296,8 +297,7 @@ internal fun FirLightClassBase.createInheritanceList(forExtendsList: Boolean, su //TODO Add support for kotlin.collections. superTypes.asSequence() - .filterIsInstance() - .filter { it.needToAddTypeIntoList() } + .filter { it.type.needToAddTypeIntoList() } .mapNotNull { it.mapSupertype(this, kotlinCollectionAsIs = true) } .forEach { listBuilder.addReference(it) } diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/fields/FirLightFieldEnumEntry.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/fields/FirLightFieldEnumEntry.kt index 038c88c87b2..4465f9f9594 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/fields/FirLightFieldEnumEntry.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/fields/FirLightFieldEnumEntry.kt @@ -65,7 +65,7 @@ internal class FirLightFieldForEnumEntry( override fun getName(): String = enumEntrySymbol.name.asString() private val _type: PsiType by lazyPub { - enumEntrySymbol.type.asPsiType(enumEntrySymbol, this@FirLightFieldForEnumEntry, FirResolvePhase.TYPES) + enumEntrySymbol.annotatedType.asPsiType(enumEntrySymbol, this@FirLightFieldForEnumEntry, FirResolvePhase.TYPES) } override fun getType(): PsiType = _type diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/fields/FirLightFieldForPropertySymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/fields/FirLightFieldForPropertySymbol.kt index f6b67561033..2b495a14985 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/fields/FirLightFieldForPropertySymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/fields/FirLightFieldForPropertySymbol.kt @@ -29,7 +29,7 @@ internal class FirLightFieldForPropertySymbol( override val kotlinOrigin: KtDeclaration? = propertySymbol.psi as? KtDeclaration private val _returnedType: PsiType by lazyPub { - propertySymbol.type.asPsiType( + propertySymbol.annotatedType.asPsiType( propertySymbol, this@FirLightFieldForPropertySymbol, FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE @@ -83,7 +83,7 @@ internal class FirLightFieldForPropertySymbol( } val nullability = if (visibility != PsiModifier.PRIVATE && !(propertySymbol is KtKotlinPropertySymbol && propertySymbol.isLateInit)) - propertySymbol.type.getTypeNullability(propertySymbol, FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) + propertySymbol.annotatedType.type.getTypeNullability(propertySymbol, FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) else NullabilityType.Unknown val annotations = propertySymbol.computeAnnotations( diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/firLightUtils.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/firLightUtils.kt index 1a91c52d042..16b49999fcc 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/firLightUtils.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/firLightUtils.kt @@ -16,14 +16,12 @@ import org.jetbrains.kotlin.asJava.elements.KtLightMember import org.jetbrains.kotlin.codegen.signature.BothSignatureWriter import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.descriptors.Modality -import org.jetbrains.kotlin.descriptors.Visibilities import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.backend.jvm.jvmTypeMapper import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.isPrimitiveType import org.jetbrains.kotlin.fir.resolve.substitution.AbstractConeSubstitutor import org.jetbrains.kotlin.fir.resolve.toSymbol -import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl @@ -38,7 +36,6 @@ import org.jetbrains.kotlin.idea.frontend.api.symbols.* import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.* import org.jetbrains.kotlin.idea.frontend.api.types.* import org.jetbrains.kotlin.load.kotlin.TypeMappingMode -import org.jetbrains.kotlin.load.kotlin.TypeMappingModeInternals import org.jetbrains.kotlin.name.SpecialNames import org.jetbrains.kotlin.types.model.SimpleTypeMarker import java.text.StringCharacterIterator @@ -52,17 +49,18 @@ private fun PsiElement.nonExistentType() = JavaPsiFacade.getElementFactory(proje .createTypeFromText("error.NonExistentClass", this) internal fun KtTypedSymbol.asPsiType(parent: PsiElement, phase: FirResolvePhase): PsiType = - type.asPsiType(this, parent, phase) + annotatedType.asPsiType(this, parent, phase) -internal fun KtType.asPsiType( +internal fun KtTypeAndAnnotations.asPsiType( context: KtSymbol, parent: PsiElement, phase: FirResolvePhase ): PsiType { - require(this is KtFirType) + val type = this.type + require(type is KtFirType) require(context is KtFirSymbol<*>) val session = context.firRef.withFir(phase) { it.session } - return coneType.asPsiType(session, context.firRef.resolveState, TypeMappingMode.DEFAULT, parent) + return type.coneType.asPsiType(session, context.firRef.resolveState, TypeMappingMode.DEFAULT, parent) } internal fun KtClassOrObjectSymbol.typeForClassSymbol(psiElement: PsiElement): PsiType { @@ -153,12 +151,19 @@ private fun mapSupertype( psiContext ) as? PsiClassType -internal fun KtClassType.mapSupertype( +internal fun KtTypeAndAnnotations.mapSupertype( psiContext: PsiElement, kotlinCollectionAsIs: Boolean = false +): PsiClassType? = type.mapSupertype(psiContext, kotlinCollectionAsIs, emptyList()) + +internal fun KtType.mapSupertype( + psiContext: PsiElement, + kotlinCollectionAsIs: Boolean = false, + annotations: List ): PsiClassType? { + if (this !is KtClassType) return null require(this is KtFirClassType) - val contextSymbol = this.classSymbol + val contextSymbol = classSymbol require(contextSymbol is KtFirSymbol<*>) val session = contextSymbol.firRef.withFir { it.session } @@ -167,7 +172,7 @@ internal fun KtClassType.mapSupertype( psiContext, session, contextSymbol.firRef.resolveState, - this.coneType, + coneType, kotlinCollectionAsIs, ) } diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/methods/FirLightAccessorMethodForSymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/methods/FirLightAccessorMethodForSymbol.kt index ff69b173709..21165b55980 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/methods/FirLightAccessorMethodForSymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/methods/FirLightAccessorMethodForSymbol.kt @@ -71,7 +71,7 @@ internal class FirLightAccessorMethodForSymbol( !isPrivate && !(isParameter && (containingClass.isAnnotationType || containingClass.isEnum)) - val nullabilityType = if (nullabilityApplicable) containingPropertySymbol.type + val nullabilityType = if (nullabilityApplicable) containingPropertySymbol.annotatedType.type .getTypeNullability(containingPropertySymbol, FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) else NullabilityType.Unknown @@ -144,7 +144,7 @@ internal class FirLightAccessorMethodForSymbol( private val _returnedType: PsiType? by lazyPub { if (!isGetter) return@lazyPub PsiType.VOID - return@lazyPub containingPropertySymbol.type.asPsiType( + return@lazyPub containingPropertySymbol.annotatedType.asPsiType( context = containingPropertySymbol, parent = this@FirLightAccessorMethodForSymbol, phase = FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/methods/FirLightSimpleMethodForSymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/methods/FirLightSimpleMethodForSymbol.kt index 2f65a0c48f1..52240f81aa3 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/methods/FirLightSimpleMethodForSymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/methods/FirLightSimpleMethodForSymbol.kt @@ -58,7 +58,7 @@ internal class FirLightSimpleMethodForSymbol( private fun computeAnnotations(isPrivate: Boolean): List { val nullability = if (isVoidReturnType || isPrivate) NullabilityType.Unknown - else functionSymbol.type.getTypeNullability( + else functionSymbol.annotatedType.type.getTypeNullability( context = functionSymbol, phase = FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE ) @@ -122,7 +122,7 @@ internal class FirLightSimpleMethodForSymbol( override fun isConstructor(): Boolean = false private val isVoidReturnType: Boolean - get() = functionSymbol.type.run { + get() = functionSymbol.annotatedType.type.run { isUnit && nullabilityType != NullabilityType.Nullable } diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/parameters/FirLightParameterBaseForSymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/parameters/FirLightParameterBaseForSymbol.kt index a82b8e16e1a..159b28c3883 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/parameters/FirLightParameterBaseForSymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/parameters/FirLightParameterBaseForSymbol.kt @@ -8,11 +8,8 @@ package org.jetbrains.kotlin.idea.asJava import com.intellij.psi.* import org.jetbrains.kotlin.asJava.classes.lazyPub import org.jetbrains.kotlin.asJava.elements.FirLightIdentifier -import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget import org.jetbrains.kotlin.fir.declarations.FirResolvePhase import org.jetbrains.kotlin.idea.frontend.api.symbols.* -import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolKind -import org.jetbrains.kotlin.idea.util.ifTrue import org.jetbrains.kotlin.psi.KtParameter internal abstract class FirLightParameterBaseForSymbol( @@ -33,13 +30,17 @@ internal abstract class FirLightParameterBaseForSymbol( FirLightIdentifier(this, parameterSymbol) } - protected val nullabilityType: NullabilityType get() { - val nullabilityApplicable = !containingMethod.containingClass.let { it.isAnnotationType || it.isEnum } && - !containingMethod.hasModifierProperty(PsiModifier.PRIVATE) + protected val nullabilityType: NullabilityType + get() { + val nullabilityApplicable = !containingMethod.containingClass.let { it.isAnnotationType || it.isEnum } && + !containingMethod.hasModifierProperty(PsiModifier.PRIVATE) - return if (nullabilityApplicable) parameterSymbol.type.getTypeNullability(parameterSymbol, FirResolvePhase.TYPES) - else NullabilityType.Unknown - } + return if (nullabilityApplicable) parameterSymbol.annotatedType.type.getTypeNullability( + parameterSymbol, + FirResolvePhase.TYPES + ) + else NullabilityType.Unknown + } override fun getNameIdentifier(): PsiIdentifier = _identifier diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/parameters/FirLightParameterForReceiver.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/parameters/FirLightParameterForReceiver.kt index 4634667fb68..c643dc1d151 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/parameters/FirLightParameterForReceiver.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/parameters/FirLightParameterForReceiver.kt @@ -72,7 +72,7 @@ internal class FirLightParameterForReceiver private constructor( } private val _type: PsiType by lazyPub { - receiverTypeAndAnnotations.type.asPsiType(context, method, FirResolvePhase.TYPES) + receiverTypeAndAnnotations.asPsiType(context, method, FirResolvePhase.TYPES) } override fun getType(): PsiType = _type diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/parameters/FirLightTypeParameter.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/parameters/FirLightTypeParameter.kt index 25793088718..cd9334b9ffe 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/parameters/FirLightTypeParameter.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/asJava/parameters/FirLightTypeParameter.kt @@ -64,7 +64,13 @@ internal class FirLightTypeParameter( typeParameterSymbol.upperBounds .filterIsInstance() .filter { it.classId != StandardClassIds.Any } - .mapNotNull { it.mapSupertype(this, kotlinCollectionAsIs = true) } + .mapNotNull { + it.mapSupertype( + psiContext = this, + kotlinCollectionAsIs = true, + annotations = emptyList() + ) + } .forEach { listBuilder.addReference(it) } listBuilder diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirExpressionTypeProvider.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirExpressionTypeProvider.kt index 7ec8775ce3a..19ab4a10e10 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirExpressionTypeProvider.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/components/KtFirExpressionTypeProvider.kt @@ -11,23 +11,16 @@ import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.expressions.FirFunctionCall import org.jetbrains.kotlin.fir.expressions.argumentMapping import org.jetbrains.kotlin.fir.psi -import org.jetbrains.kotlin.fir.resolve.inference.isBuiltinFunctionalType -import org.jetbrains.kotlin.fir.types.ConeTypeCheckerContext import org.jetbrains.kotlin.fir.types.coneType import org.jetbrains.kotlin.idea.fir.low.level.api.api.getOrBuildFirOfType import org.jetbrains.kotlin.idea.fir.low.level.api.api.getOrBuildFirSafe import org.jetbrains.kotlin.idea.frontend.api.ValidityToken -import org.jetbrains.kotlin.idea.frontend.api.assertIsValid -import org.jetbrains.kotlin.idea.frontend.api.components.KtBuiltinTypes import org.jetbrains.kotlin.idea.frontend.api.components.KtExpressionTypeProvider import org.jetbrains.kotlin.idea.frontend.api.fir.KtFirAnalysisSession -import org.jetbrains.kotlin.idea.frontend.api.fir.types.KtFirType import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtTypedSymbol import org.jetbrains.kotlin.idea.frontend.api.types.KtType import org.jetbrains.kotlin.idea.frontend.api.withValidityAssertion import org.jetbrains.kotlin.psi.* -import org.jetbrains.kotlin.types.AbstractTypeChecker -import org.jetbrains.kotlin.types.AbstractTypeCheckerContext internal class KtFirExpressionTypeProvider( override val analysisSession: KtFirAnalysisSession, @@ -66,7 +59,7 @@ internal class KtFirExpressionTypeProvider( private fun getExpectedTypeByReturnExpression(expression: PsiElement): KtType? { val returnParent = expression.getReturnExpressionWithThisType() ?: return null val targetSymbol = with(analysisSession) { returnParent.getReturnTargetSymbol() } ?: return null - return (targetSymbol as? KtTypedSymbol)?.type + return (targetSymbol as? KtTypedSymbol)?.annotatedType?.type } private fun PsiElement.getReturnExpressionWithThisType(): KtReturnExpression? = diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirAnnotationCall.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirAnnotationCall.kt index e9bd29d5c85..3e84c1291ac 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirAnnotationCall.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirAnnotationCall.kt @@ -7,6 +7,7 @@ package org.jetbrains.kotlin.idea.frontend.api.fir.symbols import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.declarations.FirAnnotatedDeclaration import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.declarations.FirResolvePhase import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall @@ -19,6 +20,8 @@ import org.jetbrains.kotlin.fir.types.coneType import org.jetbrains.kotlin.idea.fir.findPsi import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirModuleResolveState import org.jetbrains.kotlin.idea.frontend.api.ValidityToken +import org.jetbrains.kotlin.idea.frontend.api.fir.utils.* +import org.jetbrains.kotlin.idea.frontend.api.fir.utils.FirRefWithValidityCheck import org.jetbrains.kotlin.idea.frontend.api.fir.utils.convertConstantExpression import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef import org.jetbrains.kotlin.idea.frontend.api.fir.utils.mapAnnotationParameters @@ -27,37 +30,33 @@ import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.* import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.psi.KtCallElement -class KtFirAnnotationCall( - containingDeclaration: FirDeclaration, - annotationCall: FirAnnotationCall, - resolveState: FirModuleResolveState, - override val token: ValidityToken, +internal class KtFirAnnotationCall( + private val containingDeclaration: FirRefWithValidityCheck, + annotationCall: FirAnnotationCall ) : KtAnnotationCall() { - private val containingDeclarationRef = firRef(containingDeclaration, resolveState) private val annotationCallRef by weakRef(annotationCall) - override val psi: KtCallElement? by containingDeclarationRef.withFirAndCache { fir -> - annotationCallRef.findPsi(fir.session) as? KtCallElement + override val token: ValidityToken get() = containingDeclaration.token + + override val psi: KtCallElement? by containingDeclaration.withFirAndCache { fir -> + fir.findPsi(fir.session) as? KtCallElement } - private fun ConeClassLikeType.expandTypeAliasIfNeeded(session: FirSession): ConeClassLikeType { - val firTypeAlias = lookupTag.toSymbol(session) as? FirTypeAliasSymbol ?: return this - val expandedType = firTypeAlias.fir.expandedTypeRef.coneType - return expandedType.fullyExpandedType(session) as? ConeClassLikeType - ?: return this - } - - override val classId: ClassId? by containingDeclarationRef.withFirAndCache(FirResolvePhase.TYPES) { + override val classId: ClassId? by containingDeclaration.withFirAndCache(FirResolvePhase.TYPES) { fir -> val declaredCone = annotationCallRef.annotationTypeRef.coneType as? ConeClassLikeType - declaredCone?.expandTypeAliasIfNeeded(it.session)?.classId + declaredCone?.expandTypeAliasIfNeeded(fir.session)?.classId } override val useSiteTarget: AnnotationUseSiteTarget? get() = annotationCallRef.useSiteTarget - override val arguments: List by containingDeclarationRef.withFirAndCache(FirResolvePhase.TYPES) { - mapAnnotationParameters(annotationCallRef, it.session).map { (name, expression) -> + override val arguments: List by containingDeclaration.withFirAndCache(FirResolvePhase.TYPES) { fir -> + mapAnnotationParameters(annotationCallRef, fir.session).map { (name, expression) -> KtNamedConstantValue(name, expression.convertConstantExpression()) } } } + +internal fun FirRefWithValidityCheck.toAnnotationsList() = withFir { fir -> + fir.annotations.map { KtFirAnnotationCall(this, it) } +} \ No newline at end of file diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirAnonymousFunctionSymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirAnonymousFunctionSymbol.kt index 12cf18b7d51..3cd8fbc80e1 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirAnonymousFunctionSymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirAnonymousFunctionSymbol.kt @@ -12,10 +12,11 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirValueParameterImpl import org.jetbrains.kotlin.idea.fir.findPsi import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirModuleResolveState import org.jetbrains.kotlin.idea.frontend.api.ValidityToken -import org.jetbrains.kotlin.idea.frontend.api.types.KtType import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder +import org.jetbrains.kotlin.idea.frontend.api.fir.utils.cached import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef import org.jetbrains.kotlin.idea.frontend.api.symbols.* +import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtTypeAndAnnotations import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtPsiBasedSymbolPointer import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtSymbolPointer @@ -28,7 +29,10 @@ internal class KtFirAnonymousFunctionSymbol( override val firRef = firRef(fir, resolveState) override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.findPsi(fir.session) } - override val type: KtType by firRef.withFirAndCache(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) { builder.buildKtType(it.returnTypeRef) } + override val annotatedType: KtTypeAndAnnotations by cached { + firRef.returnTypeAndAnnotations(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder) + } + override val valueParameters: List by firRef.withFirAndCache { fir -> fir.valueParameters.map { valueParameter -> check(valueParameter is FirValueParameterImpl) diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirAnonymousObjectSymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirAnonymousObjectSymbol.kt index 592155a07f3..220f2ec84ad 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirAnonymousObjectSymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirAnonymousObjectSymbol.kt @@ -7,20 +7,19 @@ package org.jetbrains.kotlin.idea.frontend.api.fir.symbols import com.intellij.psi.PsiElement import org.jetbrains.kotlin.fir.declarations.FirAnonymousObject -import org.jetbrains.kotlin.fir.declarations.FirResolvePhase -import org.jetbrains.kotlin.fir.declarations.superConeTypes import org.jetbrains.kotlin.idea.fir.findPsi import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirModuleResolveState import org.jetbrains.kotlin.idea.frontend.api.ValidityToken import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder +import org.jetbrains.kotlin.idea.frontend.api.fir.utils.cached import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef import org.jetbrains.kotlin.idea.frontend.api.symbols.KtAnonymousObjectSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtAnnotationCall import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolKind +import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtTypeAndAnnotations import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.CanNotCreateSymbolPointerForLocalLibraryDeclarationException import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtPsiBasedSymbolPointer import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtSymbolPointer -import org.jetbrains.kotlin.idea.frontend.api.types.KtType internal class KtFirAnonymousObjectSymbol( fir: FirAnonymousObject, @@ -33,14 +32,12 @@ internal class KtFirAnonymousObjectSymbol( override val symbolKind: KtSymbolKind = KtSymbolKind.LOCAL override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.findPsi(fir.session) } - override val annotations: List by firRef.withFirAndCache { fir -> - fir.annotations.map { KtFirAnnotationCall(fir, it, resolveState, token) } + override val annotations: List by cached { + firRef.toAnnotationsList() } - override val superTypes: List by firRef.withFirAndCache(FirResolvePhase.SUPER_TYPES) { fir -> - fir.superConeTypes.map { - builder.buildKtType(it) - } + override val superTypes: List by cached { + firRef.superTypesAndAnnotationsList(builder) } override fun createPointer(): KtSymbolPointer = diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirClassOrObjectSymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirClassOrObjectSymbol.kt index 4170c408cd3..e2e8ad37e1a 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirClassOrObjectSymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirClassOrObjectSymbol.kt @@ -13,18 +13,15 @@ import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirModuleResolveState import org.jetbrains.kotlin.idea.frontend.api.ValidityToken import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder import org.jetbrains.kotlin.idea.frontend.api.fir.symbols.pointers.KtFirClassOrObjectInLibrarySymbol +import org.jetbrains.kotlin.idea.frontend.api.fir.utils.cached import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef import org.jetbrains.kotlin.idea.frontend.api.symbols.KtClassKind import org.jetbrains.kotlin.idea.frontend.api.symbols.KtClassOrObjectSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.KtConstructorSymbol -import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtAnnotationCall -import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolKind -import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolModality -import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolVisibility +import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.* import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.CanNotCreateSymbolPointerForLocalLibraryDeclarationException import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtPsiBasedSymbolPointer import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtSymbolPointer -import org.jetbrains.kotlin.idea.frontend.api.types.KtType import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.Name @@ -46,8 +43,8 @@ internal class KtFirClassOrObjectSymbol( override val visibility: KtSymbolVisibility get() = getVisibility() - override val annotations: List by firRef.withFirAndCache { fir -> - fir.annotations.map { KtFirAnnotationCall(fir, it, resolveState, token) } + override val annotations: List by cached { + firRef.toAnnotationsList() } override val isInner: Boolean get() = firRef.withFir(FirResolvePhase.STATUS) { it.isInner } @@ -56,11 +53,10 @@ internal class KtFirClassOrObjectSymbol( fir.companionObject?.let { builder.buildClassSymbol(it) } } - override val superTypes: List by firRef.withFirAndCache(FirResolvePhase.SUPER_TYPES) { fir -> - fir.superConeTypes.map { - builder.buildKtType(it) - } + override val superTypes: List by cached { + firRef.superTypesAndAnnotationsList(builder) } + override val primaryConstructor: KtConstructorSymbol? by firRef.withFirAndCache(FirResolvePhase.RAW_FIR) { fir -> fir.getPrimaryConstructorIfAny()?.let { builder.buildConstructorSymbol(it) } } diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirConstructorSymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirConstructorSymbol.kt index 527c85bb25e..dae71f29763 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirConstructorSymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirConstructorSymbol.kt @@ -16,16 +16,17 @@ import org.jetbrains.kotlin.idea.frontend.api.ValidityToken import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder import org.jetbrains.kotlin.idea.frontend.api.fir.symbols.pointers.KtFirConstructorSymbolPointer import org.jetbrains.kotlin.idea.frontend.api.fir.symbols.pointers.createSignature +import org.jetbrains.kotlin.idea.frontend.api.fir.utils.cached import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef import org.jetbrains.kotlin.idea.frontend.api.symbols.KtConstructorParameterSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.KtConstructorSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtAnnotationCall import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolKind import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolVisibility +import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtTypeAndAnnotations import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.CanNotCreateSymbolPointerForLocalLibraryDeclarationException import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtPsiBasedSymbolPointer import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtSymbolPointer -import org.jetbrains.kotlin.idea.frontend.api.types.KtType import org.jetbrains.kotlin.idea.frontend.api.withValidityAssertion import org.jetbrains.kotlin.name.ClassId @@ -38,7 +39,10 @@ internal class KtFirConstructorSymbol( override val firRef = firRef(fir, resolveState) override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.findPsi(fir.session) } - override val type: KtType by firRef.withFirAndCache(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) { builder.buildKtType(it.returnTypeRef) } + override val annotatedType: KtTypeAndAnnotations by cached { + firRef.returnTypeAndAnnotations(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder) + } + override val valueParameters: List by firRef.withFirAndCache { fir -> fir.valueParameters.map { valueParameter -> check(valueParameter is FirValueParameterImpl) @@ -48,8 +52,8 @@ internal class KtFirConstructorSymbol( override val visibility: KtSymbolVisibility get() = getVisibility() - override val annotations: List by firRef.withFirAndCache { fir -> - fir.annotations.map { KtFirAnnotationCall(fir, it, resolveState, token) } + override val annotations: List by cached { + firRef.toAnnotationsList() } override val containingClassIdIfNonLocal: ClassId? diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirConstructorValueParameterSymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirConstructorValueParameterSymbol.kt index ff342fc410d..fb4acdfb76d 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirConstructorValueParameterSymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirConstructorValueParameterSymbol.kt @@ -12,14 +12,15 @@ import org.jetbrains.kotlin.idea.fir.findPsi import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirModuleResolveState import org.jetbrains.kotlin.idea.frontend.api.ValidityToken import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder +import org.jetbrains.kotlin.idea.frontend.api.fir.utils.cached import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef import org.jetbrains.kotlin.idea.frontend.api.symbols.KtConstructorParameterSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.KtConstructorParameterSymbolKind import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtAnnotationCall import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolKind +import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtTypeAndAnnotations import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtPsiBasedSymbolPointer import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtSymbolPointer -import org.jetbrains.kotlin.idea.frontend.api.types.KtType import org.jetbrains.kotlin.name.Name internal class KtFirConstructorValueParameterSymbol( @@ -29,10 +30,12 @@ internal class KtFirConstructorValueParameterSymbol( private val builder: KtSymbolByFirBuilder ) : KtConstructorParameterSymbol(), KtFirSymbol { override val firRef = firRef(fir, resolveState) - override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.findPsi(fir.session) } + override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.findPsi(fir.session) } override val name: Name get() = firRef.withFir { it.name } - override val type: KtType by firRef.withFirAndCache(FirResolvePhase.TYPES) { builder.buildKtType(it.returnTypeRef) } + override val annotatedType: KtTypeAndAnnotations by cached { + firRef.returnTypeAndAnnotations(FirResolvePhase.TYPES, builder) + } override val symbolKind: KtSymbolKind get() = firRef.withFir { fir -> when { @@ -41,8 +44,8 @@ internal class KtFirConstructorValueParameterSymbol( } } - override val annotations: List by firRef.withFirAndCache { fir -> - fir.annotations.map { KtFirAnnotationCall(fir, it, resolveState, token) } + override val annotations: List by cached { + firRef.toAnnotationsList() } override val constructorParameterKind: KtConstructorParameterSymbolKind diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirEnumEntrySymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirEnumEntrySymbol.kt index 31e28b8687f..660bf83b3b4 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirEnumEntrySymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirEnumEntrySymbol.kt @@ -15,11 +15,12 @@ import org.jetbrains.kotlin.idea.frontend.api.ValidityToken import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder import org.jetbrains.kotlin.idea.frontend.api.fir.symbols.pointers.KtFirEnumEntrySymbolPointer import org.jetbrains.kotlin.idea.frontend.api.fir.symbols.pointers.createSignature +import org.jetbrains.kotlin.idea.frontend.api.fir.utils.cached import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef import org.jetbrains.kotlin.idea.frontend.api.symbols.KtEnumEntrySymbol +import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtTypeAndAnnotations import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtPsiBasedSymbolPointer import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtSymbolPointer -import org.jetbrains.kotlin.idea.frontend.api.types.KtType import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.Name @@ -34,7 +35,9 @@ internal class KtFirEnumEntrySymbol( override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.findPsi(fir.session) } override val name: Name get() = firRef.withFir { it.name } - override val type: KtType by firRef.withFirAndCache(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) { fir -> builder.buildKtType(fir.returnTypeRef) } + override val annotatedType: KtTypeAndAnnotations by cached { + firRef.returnTypeAndAnnotations(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder) + } override val containingEnumClassIdIfNonLocal: ClassId? get() = firRef.withFir { it.containingClass()?.classId?.takeUnless { it.isLocal } } diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirFileSymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirFileSymbol.kt index 1063e6e15cf..0055f924281 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirFileSymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirFileSymbol.kt @@ -34,6 +34,6 @@ internal class KtFirFileSymbol( } override val annotations: List by firRef.withFirAndCache { fir -> - fir.annotations.map { KtFirAnnotationCall(fir, it, resolveState, token) } + fir.annotations.map { KtFirAnnotationCall(firRef, it) } } } \ No newline at end of file diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirFunctionSymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirFunctionSymbol.kt index 0ff303b4a23..b16c5851632 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirFunctionSymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirFunctionSymbol.kt @@ -15,13 +15,13 @@ import org.jetbrains.kotlin.idea.frontend.api.ValidityToken import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder import org.jetbrains.kotlin.idea.frontend.api.fir.symbols.pointers.KtFirMemberFunctionSymbolPointer import org.jetbrains.kotlin.idea.frontend.api.fir.symbols.pointers.createSignature +import org.jetbrains.kotlin.idea.frontend.api.fir.utils.cached import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef import org.jetbrains.kotlin.idea.frontend.api.symbols.KtFunctionSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.* import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.CanNotCreateSymbolPointerForLocalLibraryDeclarationException import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtPsiBasedSymbolPointer import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtSymbolPointer -import org.jetbrains.kotlin.idea.frontend.api.types.KtType import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name @@ -34,7 +34,9 @@ internal class KtFirFunctionSymbol( override val firRef = firRef(fir, resolveState) override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.findPsi(fir.session) } override val name: Name get() = firRef.withFir { it.name } - override val type: KtType by firRef.withFirAndCache(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) { fir -> builder.buildKtType(fir.returnTypeRef) } + override val annotatedType: KtTypeAndAnnotations by cached { + firRef.returnTypeAndAnnotations(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder) + } override val valueParameters: List by firRef.withFirAndCache { fir -> fir.valueParameters.map { valueParameter -> check(valueParameter is FirValueParameterImpl) @@ -47,17 +49,15 @@ internal class KtFirFunctionSymbol( } } - override val annotations: List by firRef.withFirAndCache { fir -> - fir.annotations.map { KtFirAnnotationCall(fir, it, resolveState, token) } + override val annotations: List by cached { + firRef.toAnnotationsList() } override val isSuspend: Boolean get() = firRef.withFir { it.isSuspend } override val isOverride: Boolean get() = firRef.withFir { it.isOverride } - override val receiverType: KtTypeAndAnnotations? by firRef.withFirAndCache { fir -> - fir.receiverTypeRef?.let { typeRef -> - KtFirTypeAndAnnotations(fir, typeRef, resolveState, token, builder) - } + override val receiverType: KtTypeAndAnnotations? by cached { + firRef.receiverTypeAndAnnotations(builder) } override val isOperator: Boolean get() = firRef.withFir { it.isOperator } diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirFunctionValueParameterSymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirFunctionValueParameterSymbol.kt index 841c8c9e910..04f9d434a0a 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirFunctionValueParameterSymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirFunctionValueParameterSymbol.kt @@ -12,12 +12,13 @@ import org.jetbrains.kotlin.idea.fir.findPsi import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirModuleResolveState import org.jetbrains.kotlin.idea.frontend.api.ValidityToken import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder +import org.jetbrains.kotlin.idea.frontend.api.fir.utils.cached import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef import org.jetbrains.kotlin.idea.frontend.api.symbols.KtFunctionParameterSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtAnnotationCall +import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtTypeAndAnnotations import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtPsiBasedSymbolPointer import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtSymbolPointer -import org.jetbrains.kotlin.idea.frontend.api.types.KtType import org.jetbrains.kotlin.name.Name internal class KtFirFunctionValueParameterSymbol( @@ -31,12 +32,14 @@ internal class KtFirFunctionValueParameterSymbol( override val name: Name get() = firRef.withFir { it.name } override val isVararg: Boolean get() = firRef.withFir { it.isVararg } - override val type: KtType by firRef.withFirAndCache(FirResolvePhase.TYPES) { fir -> builder.buildKtType(fir.returnTypeRef) } + override val annotatedType: KtTypeAndAnnotations by cached { + firRef.returnTypeAndAnnotations(FirResolvePhase.TYPES, builder) + } override val hasDefaultValue: Boolean get() = firRef.withFir { it.defaultValue != null } - override val annotations: List by firRef.withFirAndCache { fir -> - fir.annotations.map { KtFirAnnotationCall(fir, it, resolveState, token) } + override val annotations: List by cached { + firRef.toAnnotationsList() } override fun createPointer(): KtSymbolPointer { diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirJavaFieldSymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirJavaFieldSymbol.kt index 09eeb8e1d13..b39e8a0dbec 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirJavaFieldSymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirJavaFieldSymbol.kt @@ -13,10 +13,12 @@ import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirModuleResolveState import org.jetbrains.kotlin.idea.frontend.api.ValidityToken import org.jetbrains.kotlin.idea.frontend.api.types.KtType import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder +import org.jetbrains.kotlin.idea.frontend.api.fir.utils.cached import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef import org.jetbrains.kotlin.idea.frontend.api.symbols.KtJavaFieldSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtCommonSymbolModality import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolVisibility +import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtTypeAndAnnotations import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtSymbolPointer import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name @@ -30,7 +32,9 @@ internal class KtFirJavaFieldSymbol( override val firRef = firRef(fir, resolveState) override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.findPsi(fir.session) } - override val type: KtType by firRef.withFirAndCache(FirResolvePhase.TYPES) { fir -> builder.buildKtType(fir.returnTypeRef) } + override val annotatedType: KtTypeAndAnnotations by cached { + firRef.returnTypeAndAnnotations(FirResolvePhase.TYPES, builder) + } override val isVal: Boolean get() = firRef.withFir { it.isVal } override val name: Name get() = firRef.withFir { it.name } diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirKotlinPropertySymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirKotlinPropertySymbol.kt index 9e4216c4d7e..3aeef009e88 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirKotlinPropertySymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirKotlinPropertySymbol.kt @@ -15,6 +15,7 @@ import org.jetbrains.kotlin.idea.frontend.api.ValidityToken import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder import org.jetbrains.kotlin.idea.frontend.api.fir.symbols.pointers.KtFirMemberPropertySymbolPointer import org.jetbrains.kotlin.idea.frontend.api.fir.symbols.pointers.createSignature +import org.jetbrains.kotlin.idea.frontend.api.fir.utils.cached import org.jetbrains.kotlin.idea.frontend.api.fir.utils.convertConstantExpression import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef import org.jetbrains.kotlin.idea.frontend.api.symbols.KtKotlinPropertySymbol @@ -25,7 +26,6 @@ import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.* import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.CanNotCreateSymbolPointerForLocalLibraryDeclarationException import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtPsiBasedSymbolPointer import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtSymbolPointer -import org.jetbrains.kotlin.idea.frontend.api.types.KtType import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name @@ -45,12 +45,12 @@ internal class KtFirKotlinPropertySymbol( override val isVal: Boolean get() = firRef.withFir { it.isVal } override val name: Name get() = firRef.withFir { it.name } - override val type: KtType by firRef.withFirAndCache(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) { fir -> builder.buildKtType(fir.returnTypeRef) } - override val receiverType: KtTypeAndAnnotations? by firRef.withFirAndCache { fir -> - fir.receiverTypeRef?.let { typeRef -> - KtFirTypeAndAnnotations(fir, typeRef, resolveState, token, builder) - } + override val annotatedType: KtTypeAndAnnotations by cached { + firRef.returnTypeAndAnnotations(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder) + } + override val receiverType: KtTypeAndAnnotations? by cached { + firRef.receiverTypeAndAnnotations(builder) } override val isExtension: Boolean get() = firRef.withFir { it.receiverTypeRef != null } @@ -66,8 +66,8 @@ internal class KtFirKotlinPropertySymbol( override val visibility: KtSymbolVisibility get() = getVisibility() - override val annotations: List by firRef.withFirAndCache { fir -> - fir.annotations.map { KtFirAnnotationCall(fir, it, resolveState, token) } + override val annotations: List by cached { + firRef.toAnnotationsList() } override val callableIdIfNonLocal: FqName? diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirLocalVariableSymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirLocalVariableSymbol.kt index 2ce16c8211c..44e7a5f9cb5 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirLocalVariableSymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirLocalVariableSymbol.kt @@ -11,12 +11,12 @@ import org.jetbrains.kotlin.fir.declarations.FirResolvePhase import org.jetbrains.kotlin.idea.fir.findPsi import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirModuleResolveState import org.jetbrains.kotlin.idea.frontend.api.ValidityToken -import org.jetbrains.kotlin.idea.frontend.api.types.KtType import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder import org.jetbrains.kotlin.idea.frontend.api.fir.utils.cached import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef import org.jetbrains.kotlin.idea.frontend.api.symbols.KtLocalVariableSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolKind +import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtTypeAndAnnotations import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.CanNotCreateSymbolPointerForLocalLibraryDeclarationException import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtPsiBasedSymbolPointer import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtSymbolPointer @@ -38,7 +38,9 @@ internal class KtFirLocalVariableSymbol( override val isVal: Boolean get() = firRef.withFir { it.isVal } override val name: Name get() = firRef.withFir { it.name } - override val type: KtType by firRef.withFirAndCache(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) { fir -> builder.buildKtType(fir.returnTypeRef) } + override val annotatedType: KtTypeAndAnnotations by cached { + firRef.returnTypeAndAnnotations(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder) + } override val symbolKind: KtSymbolKind get() = KtSymbolKind.LOCAL override fun createPointer(): KtSymbolPointer { diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirPropertyGetterSymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirPropertyGetterSymbol.kt index b5347650c82..fb2911acd6c 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirPropertyGetterSymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirPropertyGetterSymbol.kt @@ -12,15 +12,12 @@ import org.jetbrains.kotlin.idea.fir.findPsi import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirModuleResolveState import org.jetbrains.kotlin.idea.frontend.api.ValidityToken import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder +import org.jetbrains.kotlin.idea.frontend.api.fir.utils.cached import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef import org.jetbrains.kotlin.idea.frontend.api.symbols.KtPropertyGetterSymbol -import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtAnnotationCall -import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtCommonSymbolModality -import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolKind -import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolVisibility +import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.* import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtPsiBasedSymbolPointer import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtSymbolPointer -import org.jetbrains.kotlin.idea.frontend.api.types.KtType internal class KtFirPropertyGetterSymbol( fir: FirPropertyAccessor, @@ -48,11 +45,13 @@ internal class KtFirPropertyGetterSymbol( } } - override val type: KtType by firRef.withFirAndCache { builder.buildKtType(it.returnTypeRef) } + override val annotatedType: KtTypeAndAnnotations by cached { + firRef.returnTypeAndAnnotations(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder) + } override val modality: KtCommonSymbolModality get() = firRef.withFir(FirResolvePhase.STATUS) { it.modality.getSymbolModality() } override val visibility: KtSymbolVisibility get() = firRef.withFir(FirResolvePhase.STATUS) { it.visibility.getSymbolVisibility() } - override val annotations: List by firRef.withFirAndCache { fir -> - fir.annotations.map { KtFirAnnotationCall(fir, it, resolveState, token) } + override val annotations: List by cached { + firRef.toAnnotationsList() } override fun createPointer(): KtSymbolPointer { diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirPropertySetterSymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirPropertySetterSymbol.kt index 493fca3ec1d..c511cacccd8 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirPropertySetterSymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirPropertySetterSymbol.kt @@ -12,6 +12,7 @@ import org.jetbrains.kotlin.idea.fir.findPsi import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirModuleResolveState import org.jetbrains.kotlin.idea.frontend.api.ValidityToken import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder +import org.jetbrains.kotlin.idea.frontend.api.fir.utils.cached import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef import org.jetbrains.kotlin.idea.frontend.api.symbols.KtPropertySetterSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.KtSetterParameterSymbol @@ -42,8 +43,8 @@ internal class KtFirPropertySetterSymbol( override val modality: KtCommonSymbolModality get() = firRef.withFir(FirResolvePhase.STATUS) { it.modality.getSymbolModality() } override val visibility: KtSymbolVisibility get() = firRef.withFir(FirResolvePhase.STATUS) { it.visibility.getSymbolVisibility() } - override val annotations: List by firRef.withFirAndCache { fir -> - fir.annotations.map { KtFirAnnotationCall(fir, it, resolveState, token) } + override val annotations: List by cached { + firRef.toAnnotationsList() } override val parameter: KtSetterParameterSymbol by firRef.withFirAndCache { fir -> builder.buildFirSetterParameter(fir.valueParameters.single()) diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirSetterParameterSymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirSetterParameterSymbol.kt index cbea83aada1..7a8368bdac5 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirSetterParameterSymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirSetterParameterSymbol.kt @@ -12,12 +12,13 @@ import org.jetbrains.kotlin.idea.fir.findPsi import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirModuleResolveState import org.jetbrains.kotlin.idea.frontend.api.ValidityToken import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder +import org.jetbrains.kotlin.idea.frontend.api.fir.utils.cached import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef import org.jetbrains.kotlin.idea.frontend.api.symbols.KtSetterParameterSymbol import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtAnnotationCall +import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtTypeAndAnnotations import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtPsiBasedSymbolPointer import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtSymbolPointer -import org.jetbrains.kotlin.idea.frontend.api.types.KtType import org.jetbrains.kotlin.name.Name internal class KtFirSetterParameterSymbol( @@ -27,17 +28,18 @@ internal class KtFirSetterParameterSymbol( private val builder: KtSymbolByFirBuilder ) : KtSetterParameterSymbol(), KtFirSymbol { override val firRef = firRef(fir, resolveState) - override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.findPsi(fir.session) } + override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.findPsi(fir.session) } override val name: Name get() = firRef.withFir { it.name } - override val type: KtType by firRef.withFirAndCache(FirResolvePhase.TYPES) { fir -> builder.buildKtType(fir.returnTypeRef) } - + override val annotatedType: KtTypeAndAnnotations by cached { + firRef.returnTypeAndAnnotations(FirResolvePhase.TYPES, builder) + } override val hasDefaultValue: Boolean get() = firRef.withFir { it.defaultValue != null } override val isVararg: Boolean = false - override val annotations: List by firRef.withFirAndCache { fir -> - fir.annotations.map { KtFirAnnotationCall(fir, it, resolveState, token) } + override val annotations: List by cached { + firRef.toAnnotationsList() } override fun createPointer(): KtSymbolPointer { diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirSyntheticJavaPropertySymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirSyntheticJavaPropertySymbol.kt index 58560eb5fef..ebe2eb44dfe 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirSyntheticJavaPropertySymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirSyntheticJavaPropertySymbol.kt @@ -15,6 +15,7 @@ import org.jetbrains.kotlin.idea.frontend.api.ValidityToken import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder import org.jetbrains.kotlin.idea.frontend.api.fir.symbols.pointers.KtFirMemberPropertySymbolPointer import org.jetbrains.kotlin.idea.frontend.api.fir.symbols.pointers.createSignature +import org.jetbrains.kotlin.idea.frontend.api.fir.utils.cached import org.jetbrains.kotlin.idea.frontend.api.fir.utils.convertConstantExpression import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef import org.jetbrains.kotlin.idea.frontend.api.symbols.KtPropertyGetterSymbol @@ -25,7 +26,6 @@ import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.* import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.CanNotCreateSymbolPointerForLocalLibraryDeclarationException import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtPsiBasedSymbolPointer import org.jetbrains.kotlin.idea.frontend.api.symbols.pointers.KtSymbolPointer -import org.jetbrains.kotlin.idea.frontend.api.types.KtType import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name @@ -40,22 +40,20 @@ internal class KtFirSyntheticJavaPropertySymbol( override val isVal: Boolean get() = firRef.withFir { it.isVal } override val name: Name get() = firRef.withFir { it.name } - override val type: KtType by firRef.withFirAndCache(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE) { fir -> builder.buildKtType(fir.returnTypeRef) } - override val receiverType: KtTypeAndAnnotations? by firRef.withFirAndCache { fir -> - fir.receiverTypeRef?.let { typeRef -> - KtFirTypeAndAnnotations(fir, typeRef, resolveState, token, builder) - } + override val annotatedType: KtTypeAndAnnotations by cached { + firRef.returnTypeAndAnnotations(FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, builder) + } + override val receiverType: KtTypeAndAnnotations? by cached { + firRef.receiverTypeAndAnnotations(builder) } override val isExtension: Boolean get() = firRef.withFir { it.receiverTypeRef != null } override val initializer: KtConstantValue? by firRef.withFirAndCache(FirResolvePhase.BODY_RESOLVE) { fir -> fir.initializer?.convertConstantExpression() } - override val modality: KtCommonSymbolModality get() = getModality() - override val visibility: KtSymbolVisibility get() = getVisibility() - override val annotations: List by firRef.withFirAndCache { fir -> - fir.annotations.map { KtFirAnnotationCall(fir, it, resolveState, token) } + override val annotations: List by cached { + firRef.toAnnotationsList() } override val callableIdIfNonLocal: FqName? diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirTypeAndAnnotations.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirTypeAndAnnotations.kt index 4756866d8d9..99e28dabc68 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirTypeAndAnnotations.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirTypeAndAnnotations.kt @@ -5,36 +5,73 @@ package org.jetbrains.kotlin.idea.frontend.api.fir.symbols -import org.jetbrains.kotlin.fir.declarations.FirDeclaration -import org.jetbrains.kotlin.fir.declarations.FirResolvePhase -import org.jetbrains.kotlin.fir.types.FirTypeRef -import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirModuleResolveState +import org.jetbrains.kotlin.fir.declarations.* +import org.jetbrains.kotlin.fir.types.* import org.jetbrains.kotlin.idea.frontend.api.ValidityToken import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder -import org.jetbrains.kotlin.idea.frontend.api.fir.utils.firRef +import org.jetbrains.kotlin.idea.frontend.api.fir.utils.FirRefWithValidityCheck +import org.jetbrains.kotlin.idea.frontend.api.fir.utils.cached import org.jetbrains.kotlin.idea.frontend.api.fir.utils.weakRef import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtAnnotationCall import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtTypeAndAnnotations import org.jetbrains.kotlin.idea.frontend.api.types.KtType -internal class KtFirTypeAndAnnotations( - containingDeclaration: FirDeclaration, - receiverTypeRef: FirTypeRef, - resolveState: FirModuleResolveState, - override val token: ValidityToken, - private val builder: KtSymbolByFirBuilder +internal class KtFirTypeAndAnnotations( + private val containingDeclaration: FirRefWithValidityCheck, + typeResolvePhase: FirResolvePhase, + private val builder: KtSymbolByFirBuilder, + private val typeRef: (T) -> FirTypeRef, ) : KtTypeAndAnnotations() { - private val containingDeclarationRef = firRef(containingDeclaration, resolveState) - private val receiverWeakTypeRef by weakRef(receiverTypeRef) + override val token: ValidityToken get() = containingDeclaration.token - override val type: KtType by containingDeclarationRef.withFirAndCache(FirResolvePhase.TYPES) { - builder.buildKtType(receiverWeakTypeRef) + override val type: KtType by containingDeclaration.withFirAndCache(typeResolvePhase) { fir -> + builder.buildKtType(typeRef(fir)) } - override val annotations: List by containingDeclarationRef.withFirAndCache { fir -> - receiverWeakTypeRef.annotations.map { - KtFirAnnotationCall(fir, it, resolveState, token) + override val annotations: List by containingDeclaration.withFirAndCache { fir -> + typeRef(fir).annotations.map { + KtFirAnnotationCall(containingDeclaration, it) } } -} \ No newline at end of file +} + +internal class KtSimpleFirTypeAndAnnotations( + coneType: ConeKotlinType, + annotationsList: List, + builder: KtSymbolByFirBuilder, + override val token: ValidityToken +) : KtTypeAndAnnotations() { + + private val coneTypeRef by weakRef(coneType) + private val annotationsListRef by weakRef(annotationsList) + + override val type: KtType by cached { + builder.buildKtType(coneTypeRef) + } + + override val annotations: List get() = annotationsListRef +} + +internal fun FirRefWithValidityCheck>.superTypesAndAnnotationsList(builder: KtSymbolByFirBuilder): List = + withFir(FirResolvePhase.SUPER_TYPES) { fir -> + fir.superTypeRefs.map { typeRef -> + val annotations = typeRef.annotations.map { annotation -> + KtFirAnnotationCall(this, annotation) + } + KtSimpleFirTypeAndAnnotations(typeRef.coneType, annotations, builder, token) + } + } + +internal fun FirRefWithValidityCheck.returnTypeAndAnnotations( + typeResolvePhase: FirResolvePhase, + builder: KtSymbolByFirBuilder +) = KtFirTypeAndAnnotations(this, typeResolvePhase, builder) { it.returnTypeRef } + +internal fun FirRefWithValidityCheck>.receiverTypeAndAnnotations(builder: KtSymbolByFirBuilder) = withFir { fir -> + fir.receiverTypeRef?.let { _ -> + KtFirTypeAndAnnotations(this, FirResolvePhase.TYPES, builder) { + it.receiverTypeRef ?: error { "Receiver expected for callable declaration but it is null" } + } + } +} diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirTypeParameterSymbol.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirTypeParameterSymbol.kt index 0727f759820..2097e0ade50 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirTypeParameterSymbol.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirTypeParameterSymbol.kt @@ -26,7 +26,7 @@ internal class KtFirTypeParameterSymbol( private val builder: KtSymbolByFirBuilder ) : KtTypeParameterSymbol(), KtFirSymbol { override val firRef = firRef(fir, resolveState) - override val psi: PsiElement? by firRef.withFirAndCache { it.findPsi(fir.session) } + override val psi: PsiElement? by firRef.withFirAndCache { fir -> fir.findPsi(fir.session) } override val name: Name get() = firRef.withFir { it.name } diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/firSymbolUtils.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/firSymbolUtils.kt index 8d59e319cbd..168f56922d4 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/firSymbolUtils.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/firSymbolUtils.kt @@ -9,10 +9,16 @@ import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.descriptors.Visibilities import org.jetbrains.kotlin.descriptors.Visibility import org.jetbrains.kotlin.descriptors.java.JavaVisibilities +import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration import org.jetbrains.kotlin.fir.declarations.FirResolvePhase import org.jetbrains.kotlin.fir.declarations.modality import org.jetbrains.kotlin.fir.declarations.visibility +import org.jetbrains.kotlin.fir.resolve.fullyExpandedType +import org.jetbrains.kotlin.fir.resolve.toSymbol +import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol +import org.jetbrains.kotlin.fir.types.ConeClassLikeType +import org.jetbrains.kotlin.fir.types.coneType import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtCommonSymbolModality import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolModality import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSymbolVisibility @@ -42,4 +48,12 @@ internal fun Visibility?.getSymbolVisibility(): KtSymbolVisibility = when (this) } internal fun KtFirSymbol.getVisibility(): KtSymbolVisibility = - firRef.withFir(FirResolvePhase.STATUS) { it.visibility.getSymbolVisibility() } \ No newline at end of file + firRef.withFir(FirResolvePhase.STATUS) { it.visibility.getSymbolVisibility() } + + +internal fun ConeClassLikeType.expandTypeAliasIfNeeded(session: FirSession): ConeClassLikeType { + val firTypeAlias = lookupTag.toSymbol(session) as? FirTypeAliasSymbol ?: return this + val expandedType = firTypeAlias.fir.expandedTypeRef.coneType + return expandedType.fullyExpandedType(session) as? ConeClassLikeType + ?: return this +} \ No newline at end of file diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/utils/FirRefWithValidityCheck.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/utils/FirRefWithValidityCheck.kt index d143492571c..0382bc3bfcc 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/utils/FirRefWithValidityCheck.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/utils/FirRefWithValidityCheck.kt @@ -15,7 +15,7 @@ import org.jetbrains.kotlin.idea.frontend.api.ValidityTokenOwner import org.jetbrains.kotlin.idea.frontend.api.assertIsValid import java.lang.ref.WeakReference -internal class FirRefWithValidityCheck(fir: D, resolveState: FirModuleResolveState, val token: ValidityToken) { +internal class FirRefWithValidityCheck(fir: D, resolveState: FirModuleResolveState, val token: ValidityToken) { private val firWeakRef = WeakReference(fir) private val resolveStateWeakRef = WeakReference(resolveState) diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/utils/firUtils.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/utils/firUtils.kt index 28c8bf744b3..5ea2b4b7ff5 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/utils/firUtils.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/utils/firUtils.kt @@ -5,21 +5,18 @@ package org.jetbrains.kotlin.idea.frontend.api.fir.utils import org.jetbrains.kotlin.fir.FirSession -import org.jetbrains.kotlin.fir.declarations.* -import org.jetbrains.kotlin.fir.expressions.* -import org.jetbrains.kotlin.fir.psi -import org.jetbrains.kotlin.fir.resolve.fullyExpandedType +import org.jetbrains.kotlin.fir.declarations.FirRegularClass +import org.jetbrains.kotlin.fir.declarations.getPrimaryConstructorIfAny +import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall +import org.jetbrains.kotlin.fir.expressions.FirConstExpression +import org.jetbrains.kotlin.fir.expressions.FirExpression +import org.jetbrains.kotlin.fir.expressions.FirNamedArgumentExpression import org.jetbrains.kotlin.fir.resolve.toSymbol -import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol import org.jetbrains.kotlin.fir.types.ConeClassLikeType -import org.jetbrains.kotlin.fir.types.classId import org.jetbrains.kotlin.fir.types.coneType -import org.jetbrains.kotlin.idea.frontend.api.fir.KtSymbolByFirBuilder -import org.jetbrains.kotlin.idea.frontend.api.fir.symbols.KtFirAnnotationCall -import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.* -import org.jetbrains.kotlin.psi.KtCallElement -import org.jetbrains.kotlin.fir.resolve.toSymbol -import org.jetbrains.kotlin.fir.symbols.impl.FirTypeAliasSymbol +import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtConstantValue +import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtSimpleConstantValue +import org.jetbrains.kotlin.idea.frontend.api.symbols.markers.KtUnsupportedConstantValue internal fun mapAnnotationParameters(annotationCall: FirAnnotationCall, session: FirSession): Map { diff --git a/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/fir/AbstractResolveCallTest.kt b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/fir/AbstractResolveCallTest.kt index acd1aed5076..0caa225b8d4 100644 --- a/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/fir/AbstractResolveCallTest.kt +++ b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/fir/AbstractResolveCallTest.kt @@ -100,12 +100,12 @@ private fun KtCall.stringRepresentation(): String { if (valueParameters.isNotEmpty()) append(", ") } valueParameters.joinTo(this) { parameter -> - "${parameter.name}: ${parameter.type.render()}" + "${parameter.name}: ${parameter.typeAndAnnotations.type.render()}" } append(")") - append(": ${type.render()}") + append(": ${typeAndAnnotations.type.render()}") } - is KtParameterSymbol -> "$name: ${type.render()}" + is KtParameterSymbol -> "$name: ${typeAndAnnotations.type.render()}" is KtSuccessCallTarget -> symbol.stringValue() is KtErrorCallTarget -> "ERR<${this.diagnostic.message}, [${candidates.joinToString { it.stringValue() }}]>" is Boolean -> toString() From fb9447074157454cb0c7f224ca4f7e4ebcd5d111 Mon Sep 17 00:00:00 2001 From: Igor Yakovlev Date: Thu, 17 Dec 2020 17:13:43 +0300 Subject: [PATCH 149/196] [FIR IDE] Fix resolve value parameter symbol --- .../low/level/api/lazy/resolve/FirLazyDeclarationResolver.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/lazy/resolve/FirLazyDeclarationResolver.kt b/idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/lazy/resolve/FirLazyDeclarationResolver.kt index 733e9ab746b..84a2d623b61 100644 --- a/idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/lazy/resolve/FirLazyDeclarationResolver.kt +++ b/idea/idea-frontend-fir/idea-fir-low-level-api/src/org/jetbrains/kotlin/idea/fir/low/level/api/lazy/resolve/FirLazyDeclarationResolver.kt @@ -39,7 +39,7 @@ internal class FirLazyDeclarationResolver( ) { if (declaration.resolvePhase >= toPhase) return - if (declaration is FirPropertyAccessor || declaration is FirTypeParameter) { + if (declaration is FirPropertyAccessor || declaration is FirTypeParameter || declaration is FirValueParameter) { val ktContainingResolvableDeclaration = when (val ktDeclaration = declaration.ktDeclaration) { is KtPropertyAccessor -> ktDeclaration.property is KtProperty -> ktDeclaration From 9e89cfae08c77326716c5f5d7e4f4cd555d943c9 Mon Sep 17 00:00:00 2001 From: Igor Yakovlev Date: Thu, 17 Dec 2020 20:24:45 +0300 Subject: [PATCH 150/196] [FIR IDE] Fixed invalid leaks test --- .../idea/frontend/api/fir/utils/FirRefWithValidityCheck.kt | 5 +++++ .../api/symbols/AbstractMemoryLeakInSymbolsTest.kt | 7 ++----- 2 files changed, 7 insertions(+), 5 deletions(-) diff --git a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/utils/FirRefWithValidityCheck.kt b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/utils/FirRefWithValidityCheck.kt index 0382bc3bfcc..0b41fc42de2 100644 --- a/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/utils/FirRefWithValidityCheck.kt +++ b/idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/utils/FirRefWithValidityCheck.kt @@ -5,6 +5,7 @@ package org.jetbrains.kotlin.idea.frontend.api.fir.utils +import org.jetbrains.annotations.TestOnly import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.declarations.FirResolvePhase import org.jetbrains.kotlin.idea.fir.low.level.api.api.FirModuleResolveState @@ -19,6 +20,10 @@ internal class FirRefWithValidityCheck(fir: D, resolveSt private val firWeakRef = WeakReference(fir) private val resolveStateWeakRef = WeakReference(resolveState) + @TestOnly + internal fun isCollected(): Boolean = + firWeakRef.get() == null && resolveStateWeakRef.get() == null + inline fun withFir(phase: FirResolvePhase = FirResolvePhase.RAW_FIR, crossinline action: (fir: D) -> R): R { token.assertIsValid() val fir = firWeakRef.get() diff --git a/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/symbols/AbstractMemoryLeakInSymbolsTest.kt b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/symbols/AbstractMemoryLeakInSymbolsTest.kt index ead4321986f..095b7ad9089 100644 --- a/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/symbols/AbstractMemoryLeakInSymbolsTest.kt +++ b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/symbols/AbstractMemoryLeakInSymbolsTest.kt @@ -58,11 +58,8 @@ abstract class AbstractMemoryLeakInSymbolsTest : KotlinLightCodeInsightFixtureTe private fun KtSymbol.hasNoFirElementLeak(): LeakCheckResult { require(this is KtFirSymbol<*>) - return try { - firRef.withFir { LeakCheckResult.Leak(this::class.simpleName!!) } - } catch (_: EntityWasGarbageCollectedException) { - LeakCheckResult.NoLeak - } + return if (firRef.isCollected()) LeakCheckResult.NoLeak + else LeakCheckResult.Leak(this::class.simpleName!!) } private sealed class LeakCheckResult { From c4b708b5dcc1120301c9b1ab8ae8683c689c0b0d Mon Sep 17 00:00:00 2001 From: Igor Yakovlev Date: Thu, 17 Dec 2020 18:09:13 +0300 Subject: [PATCH 151/196] [FIR IDE] Fixed test data for types --- .../fileScopeTest/simpleFileScope.kt.result | 12 +- .../testData/memberScopeByFqName/Int.txt | 248 ++++++++-------- .../memberScopeByFqName/MutableList.txt | 96 +++--- .../memberScopeByFqName/java.lang.String.txt | 274 +++++++++--------- .../resoreSymbolFromLibrary/class.txt | 2 +- .../resoreSymbolFromLibrary/classFromJdk.txt | 2 +- .../resoreSymbolFromLibrary/enumEntry.txt | 2 +- .../memberFunction.txt | 4 +- .../memberFunctionWithOverloads.txt | 8 +- .../resoreSymbolFromLibrary/nestedClass.txt | 2 +- .../testData/symbolPointer/class.kt | 2 +- .../symbolPointer/classPrimaryConstructor.kt | 4 +- .../classSecondaryConstructors.kt | 14 +- .../testData/symbolPointer/enum.kt | 6 +- .../testData/symbolPointer/memberFunctions.kt | 10 +- .../symbolPointer/memberProperties.kt | 12 +- .../symbolPointer/topLevelFunctions.kt | 8 +- .../symbolPointer/topLevelProperties.kt | 10 +- .../symbolsByFqName/fileWalkDirectionEnum.txt | 12 +- .../testData/symbolsByFqName/iterator.txt | 2 +- .../testData/symbolsByFqName/listOf.txt | 2 +- .../testData/symbolsByPsi/annotations.kt | 14 +- .../testData/symbolsByPsi/anonymousObject.kt | 16 +- .../testData/symbolsByPsi/class.kt | 2 +- .../testData/symbolsByPsi/classMembes.kt | 10 +- .../symbolsByPsi/classWithTypeParams.kt | 2 +- .../symbolsByPsi/extensionFunction.kt | 4 +- .../testData/symbolsByPsi/function.kt | 6 +- .../symbolsByPsi/functionWithTypeParams.kt | 6 +- .../testData/symbolsByPsi/implicitReturn.kt | 4 +- .../symbolsByPsi/localDeclarations.kt | 12 +- .../api/fir/AbstractResolveCallTest.kt | 6 +- 32 files changed, 407 insertions(+), 407 deletions(-) diff --git a/idea/idea-frontend-fir/testData/fileScopeTest/simpleFileScope.kt.result b/idea/idea-frontend-fir/testData/fileScopeTest/simpleFileScope.kt.result index 02f237af8fd..d3a8a218da9 100644 --- a/idea/idea-frontend-fir/testData/fileScopeTest/simpleFileScope.kt.result +++ b/idea/idea-frontend-fir/testData/fileScopeTest/simpleFileScope.kt.result @@ -8,6 +8,7 @@ CALLABLE NAMES: CALLABLE SYMBOLS: KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: test isExtension: false @@ -19,14 +20,14 @@ KtFirFunctionSymbol: modality: FINAL name: test origin: SOURCE - receiverTypeAndAnnotations: null + receiverType: null symbolKind: TOP_LEVEL - type: kotlin/Int typeParameters: [] valueParameters: [] visibility: PUBLIC KtFirKotlinPropertySymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: testVal getter: KtFirPropertyGetterSymbol() @@ -42,10 +43,9 @@ KtFirKotlinPropertySymbol: modality: FINAL name: testVal origin: SOURCE - receiverTypeAndAnnotations: null + receiverType: null setter: null symbolKind: TOP_LEVEL - type: kotlin/Int visibility: PUBLIC CLASSIFIER NAMES: @@ -62,7 +62,7 @@ KtFirClassOrObjectSymbol: name: C origin: SOURCE primaryConstructor: KtFirConstructorSymbol() - superTypes: [kotlin/Any] + superTypes: [[] kotlin/Any] symbolKind: TOP_LEVEL typeParameters: [] visibility: PUBLIC @@ -77,7 +77,7 @@ KtFirClassOrObjectSymbol: name: I origin: SOURCE primaryConstructor: null - superTypes: [kotlin/Any] + superTypes: [[] kotlin/Any] symbolKind: TOP_LEVEL typeParameters: [] visibility: PUBLIC diff --git a/idea/idea-frontend-fir/testData/memberScopeByFqName/Int.txt b/idea/idea-frontend-fir/testData/memberScopeByFqName/Int.txt index 4ba5de9ca15..ace6a3febd4 100644 --- a/idea/idea-frontend-fir/testData/memberScopeByFqName/Int.txt +++ b/idea/idea-frontend-fir/testData/memberScopeByFqName/Int.txt @@ -2,6 +2,7 @@ class: kotlin/Int // SYMBOLS: KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: kotlin.Int.and isExtension: false @@ -13,14 +14,14 @@ KtFirFunctionSymbol: modality: FINAL name: and origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(other)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: kotlin.Int.compareTo isExtension: false @@ -32,14 +33,14 @@ KtFirFunctionSymbol: modality: FINAL name: compareTo origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(other)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: kotlin.Int.compareTo isExtension: false @@ -51,14 +52,14 @@ KtFirFunctionSymbol: modality: FINAL name: compareTo origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(other)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: kotlin.Int.compareTo isExtension: false @@ -70,14 +71,14 @@ KtFirFunctionSymbol: modality: FINAL name: compareTo origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(other)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: kotlin.Int.compareTo isExtension: false @@ -89,14 +90,14 @@ KtFirFunctionSymbol: modality: OPEN name: compareTo origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(other)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: kotlin.Int.compareTo isExtension: false @@ -108,14 +109,14 @@ KtFirFunctionSymbol: modality: FINAL name: compareTo origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(other)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: kotlin.Int.compareTo isExtension: false @@ -127,14 +128,14 @@ KtFirFunctionSymbol: modality: FINAL name: compareTo origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(other)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: kotlin.Int.dec isExtension: false @@ -146,14 +147,14 @@ KtFirFunctionSymbol: modality: FINAL name: dec origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: kotlin.Int.div isExtension: false @@ -165,14 +166,14 @@ KtFirFunctionSymbol: modality: FINAL name: div origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(other)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Double annotations: [] callableIdIfNonLocal: kotlin.Int.div isExtension: false @@ -184,14 +185,14 @@ KtFirFunctionSymbol: modality: FINAL name: div origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Double typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(other)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Float annotations: [] callableIdIfNonLocal: kotlin.Int.div isExtension: false @@ -203,14 +204,14 @@ KtFirFunctionSymbol: modality: FINAL name: div origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Float typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(other)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: kotlin.Int.div isExtension: false @@ -222,14 +223,14 @@ KtFirFunctionSymbol: modality: FINAL name: div origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(other)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Long annotations: [] callableIdIfNonLocal: kotlin.Int.div isExtension: false @@ -241,14 +242,14 @@ KtFirFunctionSymbol: modality: FINAL name: div origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Long typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(other)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: kotlin.Int.div isExtension: false @@ -260,14 +261,14 @@ KtFirFunctionSymbol: modality: FINAL name: div origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(other)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: kotlin.Int.inc isExtension: false @@ -279,14 +280,14 @@ KtFirFunctionSymbol: modality: FINAL name: inc origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: kotlin.Int.inv isExtension: false @@ -298,14 +299,14 @@ KtFirFunctionSymbol: modality: FINAL name: inv origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: kotlin.Int.minus isExtension: false @@ -317,14 +318,14 @@ KtFirFunctionSymbol: modality: FINAL name: minus origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(other)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Double annotations: [] callableIdIfNonLocal: kotlin.Int.minus isExtension: false @@ -336,14 +337,14 @@ KtFirFunctionSymbol: modality: FINAL name: minus origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Double typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(other)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Float annotations: [] callableIdIfNonLocal: kotlin.Int.minus isExtension: false @@ -355,14 +356,14 @@ KtFirFunctionSymbol: modality: FINAL name: minus origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Float typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(other)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: kotlin.Int.minus isExtension: false @@ -374,14 +375,14 @@ KtFirFunctionSymbol: modality: FINAL name: minus origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(other)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Long annotations: [] callableIdIfNonLocal: kotlin.Int.minus isExtension: false @@ -393,14 +394,14 @@ KtFirFunctionSymbol: modality: FINAL name: minus origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Long typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(other)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: kotlin.Int.minus isExtension: false @@ -412,14 +413,14 @@ KtFirFunctionSymbol: modality: FINAL name: minus origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(other)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: kotlin.Int.or isExtension: false @@ -431,14 +432,14 @@ KtFirFunctionSymbol: modality: FINAL name: or origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(other)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: kotlin.Int.plus isExtension: false @@ -450,14 +451,14 @@ KtFirFunctionSymbol: modality: FINAL name: plus origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(other)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Double annotations: [] callableIdIfNonLocal: kotlin.Int.plus isExtension: false @@ -469,14 +470,14 @@ KtFirFunctionSymbol: modality: FINAL name: plus origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Double typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(other)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Float annotations: [] callableIdIfNonLocal: kotlin.Int.plus isExtension: false @@ -488,14 +489,14 @@ KtFirFunctionSymbol: modality: FINAL name: plus origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Float typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(other)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: kotlin.Int.plus isExtension: false @@ -507,14 +508,14 @@ KtFirFunctionSymbol: modality: FINAL name: plus origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(other)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Long annotations: [] callableIdIfNonLocal: kotlin.Int.plus isExtension: false @@ -526,14 +527,14 @@ KtFirFunctionSymbol: modality: FINAL name: plus origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Long typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(other)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: kotlin.Int.plus isExtension: false @@ -545,14 +546,14 @@ KtFirFunctionSymbol: modality: FINAL name: plus origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(other)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/ranges/IntRange annotations: [] callableIdIfNonLocal: kotlin.Int.rangeTo isExtension: false @@ -564,14 +565,14 @@ KtFirFunctionSymbol: modality: FINAL name: rangeTo origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/ranges/IntRange typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(other)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/ranges/IntRange annotations: [] callableIdIfNonLocal: kotlin.Int.rangeTo isExtension: false @@ -583,14 +584,14 @@ KtFirFunctionSymbol: modality: FINAL name: rangeTo origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/ranges/IntRange typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(other)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/ranges/LongRange annotations: [] callableIdIfNonLocal: kotlin.Int.rangeTo isExtension: false @@ -602,14 +603,14 @@ KtFirFunctionSymbol: modality: FINAL name: rangeTo origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/ranges/LongRange typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(other)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/ranges/IntRange annotations: [] callableIdIfNonLocal: kotlin.Int.rangeTo isExtension: false @@ -621,14 +622,14 @@ KtFirFunctionSymbol: modality: FINAL name: rangeTo origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/ranges/IntRange typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(other)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [kotlin/SinceKotlin(version = 1.1)] callableIdIfNonLocal: kotlin.Int.rem isExtension: false @@ -640,14 +641,14 @@ KtFirFunctionSymbol: modality: FINAL name: rem origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(other)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Double annotations: [kotlin/SinceKotlin(version = 1.1)] callableIdIfNonLocal: kotlin.Int.rem isExtension: false @@ -659,14 +660,14 @@ KtFirFunctionSymbol: modality: FINAL name: rem origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Double typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(other)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Float annotations: [kotlin/SinceKotlin(version = 1.1)] callableIdIfNonLocal: kotlin.Int.rem isExtension: false @@ -678,14 +679,14 @@ KtFirFunctionSymbol: modality: FINAL name: rem origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Float typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(other)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [kotlin/SinceKotlin(version = 1.1)] callableIdIfNonLocal: kotlin.Int.rem isExtension: false @@ -697,14 +698,14 @@ KtFirFunctionSymbol: modality: FINAL name: rem origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(other)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Long annotations: [kotlin/SinceKotlin(version = 1.1)] callableIdIfNonLocal: kotlin.Int.rem isExtension: false @@ -716,14 +717,14 @@ KtFirFunctionSymbol: modality: FINAL name: rem origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Long typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(other)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [kotlin/SinceKotlin(version = 1.1)] callableIdIfNonLocal: kotlin.Int.rem isExtension: false @@ -735,14 +736,14 @@ KtFirFunctionSymbol: modality: FINAL name: rem origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(other)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: kotlin.Int.shl isExtension: false @@ -754,14 +755,14 @@ KtFirFunctionSymbol: modality: FINAL name: shl origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(bitCount)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: kotlin.Int.shr isExtension: false @@ -773,14 +774,14 @@ KtFirFunctionSymbol: modality: FINAL name: shr origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(bitCount)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: kotlin.Int.times isExtension: false @@ -792,14 +793,14 @@ KtFirFunctionSymbol: modality: FINAL name: times origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(other)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Double annotations: [] callableIdIfNonLocal: kotlin.Int.times isExtension: false @@ -811,14 +812,14 @@ KtFirFunctionSymbol: modality: FINAL name: times origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Double typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(other)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Float annotations: [] callableIdIfNonLocal: kotlin.Int.times isExtension: false @@ -830,14 +831,14 @@ KtFirFunctionSymbol: modality: FINAL name: times origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Float typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(other)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: kotlin.Int.times isExtension: false @@ -849,14 +850,14 @@ KtFirFunctionSymbol: modality: FINAL name: times origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(other)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Long annotations: [] callableIdIfNonLocal: kotlin.Int.times isExtension: false @@ -868,14 +869,14 @@ KtFirFunctionSymbol: modality: FINAL name: times origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Long typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(other)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: kotlin.Int.times isExtension: false @@ -887,14 +888,14 @@ KtFirFunctionSymbol: modality: FINAL name: times origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(other)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Byte annotations: [] callableIdIfNonLocal: kotlin.Int.toByte isExtension: false @@ -906,14 +907,14 @@ KtFirFunctionSymbol: modality: OPEN name: toByte origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Byte typeParameters: [] valueParameters: [] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Char annotations: [] callableIdIfNonLocal: kotlin.Int.toChar isExtension: false @@ -925,14 +926,14 @@ KtFirFunctionSymbol: modality: OPEN name: toChar origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Char typeParameters: [] valueParameters: [] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Double annotations: [] callableIdIfNonLocal: kotlin.Int.toDouble isExtension: false @@ -944,14 +945,14 @@ KtFirFunctionSymbol: modality: OPEN name: toDouble origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Double typeParameters: [] valueParameters: [] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Float annotations: [] callableIdIfNonLocal: kotlin.Int.toFloat isExtension: false @@ -963,14 +964,14 @@ KtFirFunctionSymbol: modality: OPEN name: toFloat origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Float typeParameters: [] valueParameters: [] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: kotlin.Int.toInt isExtension: false @@ -982,14 +983,14 @@ KtFirFunctionSymbol: modality: OPEN name: toInt origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Long annotations: [] callableIdIfNonLocal: kotlin.Int.toLong isExtension: false @@ -1001,14 +1002,14 @@ KtFirFunctionSymbol: modality: OPEN name: toLong origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Long typeParameters: [] valueParameters: [] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Short annotations: [] callableIdIfNonLocal: kotlin.Int.toShort isExtension: false @@ -1020,14 +1021,14 @@ KtFirFunctionSymbol: modality: OPEN name: toShort origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Short typeParameters: [] valueParameters: [] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: kotlin.Int.unaryMinus isExtension: false @@ -1039,14 +1040,14 @@ KtFirFunctionSymbol: modality: FINAL name: unaryMinus origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: kotlin.Int.unaryPlus isExtension: false @@ -1058,14 +1059,14 @@ KtFirFunctionSymbol: modality: FINAL name: unaryPlus origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: kotlin.Int.ushr isExtension: false @@ -1077,14 +1078,14 @@ KtFirFunctionSymbol: modality: FINAL name: ushr origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(bitCount)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: kotlin.Int.xor isExtension: false @@ -1096,24 +1097,24 @@ KtFirFunctionSymbol: modality: FINAL name: xor origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(other)] visibility: PUBLIC KtFirConstructorSymbol: + annotatedType: [] kotlin/Int annotations: [] containingClassIdIfNonLocal: kotlin/Int isPrimary: true origin: LIBRARY symbolKind: MEMBER - type: kotlin/Int valueParameters: [] visibility: PRIVATE KtFirFunctionSymbol: + annotatedType: [] kotlin/Boolean annotations: [] callableIdIfNonLocal: kotlin.Int.equals isExtension: false @@ -1125,14 +1126,14 @@ KtFirFunctionSymbol: modality: OPEN name: equals origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Boolean typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(other)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: kotlin.Int.hashCode isExtension: false @@ -1144,14 +1145,14 @@ KtFirFunctionSymbol: modality: OPEN name: hashCode origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/String annotations: [] callableIdIfNonLocal: kotlin.Int.toString isExtension: false @@ -1163,9 +1164,8 @@ KtFirFunctionSymbol: modality: OPEN name: toString origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/String typeParameters: [] valueParameters: [] visibility: PUBLIC @@ -1180,7 +1180,7 @@ KtFirClassOrObjectSymbol: name: Companion origin: LIBRARY primaryConstructor: KtFirConstructorSymbol() - superTypes: [kotlin/Any] + superTypes: [[] kotlin/Any] symbolKind: MEMBER typeParameters: [] visibility: PUBLIC diff --git a/idea/idea-frontend-fir/testData/memberScopeByFqName/MutableList.txt b/idea/idea-frontend-fir/testData/memberScopeByFqName/MutableList.txt index 9aec62a1556..7c1140151c4 100644 --- a/idea/idea-frontend-fir/testData/memberScopeByFqName/MutableList.txt +++ b/idea/idea-frontend-fir/testData/memberScopeByFqName/MutableList.txt @@ -2,6 +2,7 @@ class: kotlin/collections/MutableList // SYMBOLS: KtFirFunctionSymbol: + annotatedType: [] kotlin/Boolean annotations: [] callableIdIfNonLocal: kotlin.collections.MutableList.add isExtension: false @@ -13,14 +14,14 @@ KtFirFunctionSymbol: modality: ABSTRACT name: add origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Boolean typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(element)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Unit annotations: [] callableIdIfNonLocal: kotlin.collections.MutableList.add isExtension: false @@ -32,14 +33,14 @@ KtFirFunctionSymbol: modality: ABSTRACT name: add origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Unit typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(index), KtFirFunctionValueParameterSymbol(element)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Boolean annotations: [] callableIdIfNonLocal: kotlin.collections.MutableList.addAll isExtension: false @@ -51,14 +52,14 @@ KtFirFunctionSymbol: modality: ABSTRACT name: addAll origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Boolean typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(index), KtFirFunctionValueParameterSymbol(elements)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Boolean annotations: [] callableIdIfNonLocal: kotlin.collections.MutableList.addAll isExtension: false @@ -70,14 +71,14 @@ KtFirFunctionSymbol: modality: ABSTRACT name: addAll origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Boolean typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(elements)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Unit annotations: [] callableIdIfNonLocal: kotlin.collections.MutableList.clear isExtension: false @@ -89,14 +90,14 @@ KtFirFunctionSymbol: modality: ABSTRACT name: clear origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Unit typeParameters: [] valueParameters: [] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/collections/MutableListIterator annotations: [] callableIdIfNonLocal: kotlin.collections.MutableList.listIterator isExtension: false @@ -108,14 +109,14 @@ KtFirFunctionSymbol: modality: ABSTRACT name: listIterator origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/collections/MutableListIterator typeParameters: [] valueParameters: [] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/collections/MutableListIterator annotations: [] callableIdIfNonLocal: kotlin.collections.MutableList.listIterator isExtension: false @@ -127,14 +128,14 @@ KtFirFunctionSymbol: modality: ABSTRACT name: listIterator origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/collections/MutableListIterator typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(index)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Boolean annotations: [] callableIdIfNonLocal: kotlin.collections.MutableList.remove isExtension: false @@ -146,14 +147,14 @@ KtFirFunctionSymbol: modality: ABSTRACT name: remove origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Boolean typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(element)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Boolean annotations: [] callableIdIfNonLocal: kotlin.collections.MutableList.removeAll isExtension: false @@ -165,14 +166,14 @@ KtFirFunctionSymbol: modality: ABSTRACT name: removeAll origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Boolean typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(elements)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] E annotations: [] callableIdIfNonLocal: kotlin.collections.MutableList.removeAt isExtension: false @@ -184,14 +185,14 @@ KtFirFunctionSymbol: modality: ABSTRACT name: removeAt origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: E typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(index)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Boolean annotations: [] callableIdIfNonLocal: kotlin.collections.MutableList.retainAll isExtension: false @@ -203,14 +204,14 @@ KtFirFunctionSymbol: modality: ABSTRACT name: retainAll origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Boolean typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(elements)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] E annotations: [] callableIdIfNonLocal: kotlin.collections.MutableList.set isExtension: false @@ -222,14 +223,14 @@ KtFirFunctionSymbol: modality: ABSTRACT name: set origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: E typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(index), KtFirFunctionValueParameterSymbol(element)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/collections/MutableList annotations: [] callableIdIfNonLocal: kotlin.collections.MutableList.subList isExtension: false @@ -241,14 +242,14 @@ KtFirFunctionSymbol: modality: ABSTRACT name: subList origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/collections/MutableList typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(fromIndex), KtFirFunctionValueParameterSymbol(toIndex)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Boolean annotations: [] callableIdIfNonLocal: kotlin.collections.MutableList.contains isExtension: false @@ -260,14 +261,14 @@ KtFirFunctionSymbol: modality: ABSTRACT name: contains origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Boolean typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(element)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Boolean annotations: [] callableIdIfNonLocal: kotlin.collections.MutableList.containsAll isExtension: false @@ -279,14 +280,14 @@ KtFirFunctionSymbol: modality: ABSTRACT name: containsAll origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Boolean typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(elements)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] E annotations: [] callableIdIfNonLocal: kotlin.collections.MutableList.get isExtension: false @@ -298,14 +299,14 @@ KtFirFunctionSymbol: modality: ABSTRACT name: get origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: E typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(index)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: kotlin.collections.MutableList.indexOf isExtension: false @@ -317,14 +318,14 @@ KtFirFunctionSymbol: modality: ABSTRACT name: indexOf origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(element)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Boolean annotations: [] callableIdIfNonLocal: kotlin.collections.MutableList.isEmpty isExtension: false @@ -336,14 +337,14 @@ KtFirFunctionSymbol: modality: ABSTRACT name: isEmpty origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Boolean typeParameters: [] valueParameters: [] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/collections/MutableIterator annotations: [] callableIdIfNonLocal: kotlin.collections.MutableList.iterator isExtension: false @@ -355,14 +356,14 @@ KtFirFunctionSymbol: modality: ABSTRACT name: iterator origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/collections/MutableIterator typeParameters: [] valueParameters: [] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: kotlin.collections.MutableList.lastIndexOf isExtension: false @@ -374,14 +375,14 @@ KtFirFunctionSymbol: modality: ABSTRACT name: lastIndexOf origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(element)] visibility: PUBLIC KtFirKotlinPropertySymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: kotlin.collections.List.size getter: null @@ -397,13 +398,13 @@ KtFirKotlinPropertySymbol: modality: ABSTRACT name: size origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null setter: null symbolKind: MEMBER - type: kotlin/Int visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Boolean annotations: [] callableIdIfNonLocal: kotlin.collections.MutableList.equals isExtension: false @@ -415,14 +416,14 @@ KtFirFunctionSymbol: modality: OPEN name: equals origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Boolean typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(other)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: kotlin.collections.MutableList.hashCode isExtension: false @@ -434,14 +435,14 @@ KtFirFunctionSymbol: modality: OPEN name: hashCode origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/String annotations: [] callableIdIfNonLocal: kotlin.collections.MutableList.toString isExtension: false @@ -453,9 +454,8 @@ KtFirFunctionSymbol: modality: OPEN name: toString origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/String typeParameters: [] valueParameters: [] visibility: PUBLIC diff --git a/idea/idea-frontend-fir/testData/memberScopeByFqName/java.lang.String.txt b/idea/idea-frontend-fir/testData/memberScopeByFqName/java.lang.String.txt index d09ec1a6802..cf991202261 100644 --- a/idea/idea-frontend-fir/testData/memberScopeByFqName/java.lang.String.txt +++ b/idea/idea-frontend-fir/testData/memberScopeByFqName/java.lang.String.txt @@ -2,26 +2,27 @@ class: java/lang/String // SYMBOLS: KtFirJavaFieldSymbol: + annotatedType: [] ft<@FlexibleNullability kotlin/CharArray, kotlin/CharArray?>! callableIdIfNonLocal: java.lang.String.value isVal: true modality: FINAL name: value origin: JAVA symbolKind: MEMBER - type: ft<@FlexibleNullability kotlin/CharArray, kotlin/CharArray?>! visibility: PRIVATE KtFirJavaFieldSymbol: + annotatedType: [] kotlin/Int callableIdIfNonLocal: java.lang.String.hash isVal: false modality: OPEN name: hash origin: JAVA symbolKind: MEMBER - type: kotlin/Int visibility: PRIVATE KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: java.lang.String.hash32 isExtension: false @@ -33,24 +34,24 @@ KtFirFunctionSymbol: modality: OPEN name: hash32 origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [] visibility: UNKNOWN KtFirJavaFieldSymbol: + annotatedType: [] kotlin/Int callableIdIfNonLocal: java.lang.String.hash32 isVal: false modality: OPEN name: hash32 origin: JAVA symbolKind: MEMBER - type: kotlin/Int visibility: PRIVATE KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: java.lang.String.length isExtension: false @@ -62,14 +63,14 @@ KtFirFunctionSymbol: modality: OPEN name: length origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [] visibility: PUBLIC KtFirKotlinPropertySymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: kotlin.CharSequence.length getter: KtFirPropertyGetterSymbol() @@ -85,13 +86,13 @@ KtFirKotlinPropertySymbol: modality: ABSTRACT name: length origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null setter: null symbolKind: MEMBER - type: kotlin/Int visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Boolean annotations: [] callableIdIfNonLocal: java.lang.String.isEmpty isExtension: false @@ -103,14 +104,14 @@ KtFirFunctionSymbol: modality: OPEN name: isEmpty origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Boolean typeParameters: [] valueParameters: [] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Char annotations: [] callableIdIfNonLocal: java.lang.String.charAt isExtension: false @@ -122,14 +123,14 @@ KtFirFunctionSymbol: modality: OPEN name: charAt origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Char typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(index)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: java.lang.String.codePointAt isExtension: false @@ -141,14 +142,14 @@ KtFirFunctionSymbol: modality: OPEN name: codePointAt origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(index)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: java.lang.String.codePointBefore isExtension: false @@ -160,14 +161,14 @@ KtFirFunctionSymbol: modality: OPEN name: codePointBefore origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(index)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: java.lang.String.codePointCount isExtension: false @@ -179,14 +180,14 @@ KtFirFunctionSymbol: modality: OPEN name: codePointCount origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(beginIndex), KtFirFunctionValueParameterSymbol(endIndex)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: java.lang.String.offsetByCodePoints isExtension: false @@ -198,14 +199,14 @@ KtFirFunctionSymbol: modality: OPEN name: offsetByCodePoints origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(index), KtFirFunctionValueParameterSymbol(codePointOffset)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Unit annotations: [] callableIdIfNonLocal: java.lang.String.getChars isExtension: false @@ -217,14 +218,14 @@ KtFirFunctionSymbol: modality: OPEN name: getChars origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Unit typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(dst), KtFirFunctionValueParameterSymbol(dstBegin)] visibility: UNKNOWN KtFirFunctionSymbol: + annotatedType: [] kotlin/Unit annotations: [] callableIdIfNonLocal: java.lang.String.getChars isExtension: false @@ -236,14 +237,14 @@ KtFirFunctionSymbol: modality: OPEN name: getChars origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Unit typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(srcBegin), KtFirFunctionValueParameterSymbol(srcEnd), KtFirFunctionValueParameterSymbol(dst), KtFirFunctionValueParameterSymbol(dstBegin)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Unit annotations: [kotlin/Deprecated(message = Deprecated in Java)] callableIdIfNonLocal: java.lang.String.getBytes isExtension: false @@ -255,14 +256,14 @@ KtFirFunctionSymbol: modality: OPEN name: getBytes origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Unit typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(srcBegin), KtFirFunctionValueParameterSymbol(srcEnd), KtFirFunctionValueParameterSymbol(dst), KtFirFunctionValueParameterSymbol(dstBegin)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] @EnhancedNullability kotlin/ByteArray annotations: [org/jetbrains/annotations/NotNull()] callableIdIfNonLocal: java.lang.String.getBytes isExtension: false @@ -274,14 +275,14 @@ KtFirFunctionSymbol: modality: OPEN name: getBytes origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: @EnhancedNullability kotlin/ByteArray typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(charsetName)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] @EnhancedNullability kotlin/ByteArray annotations: [org/jetbrains/annotations/NotNull()] callableIdIfNonLocal: java.lang.String.getBytes isExtension: false @@ -293,14 +294,14 @@ KtFirFunctionSymbol: modality: OPEN name: getBytes origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: @EnhancedNullability kotlin/ByteArray typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(charset)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] @EnhancedNullability kotlin/ByteArray annotations: [org/jetbrains/annotations/NotNull()] callableIdIfNonLocal: java.lang.String.getBytes isExtension: false @@ -312,14 +313,14 @@ KtFirFunctionSymbol: modality: OPEN name: getBytes origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: @EnhancedNullability kotlin/ByteArray typeParameters: [] valueParameters: [] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Boolean annotations: [] callableIdIfNonLocal: java.lang.String.equals isExtension: false @@ -331,14 +332,14 @@ KtFirFunctionSymbol: modality: OPEN name: equals origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Boolean typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(anObject)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Boolean annotations: [] callableIdIfNonLocal: java.lang.String.contentEquals isExtension: false @@ -350,14 +351,14 @@ KtFirFunctionSymbol: modality: OPEN name: contentEquals origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Boolean typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(sb)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Boolean annotations: [] callableIdIfNonLocal: java.lang.String.contentEquals isExtension: false @@ -369,14 +370,14 @@ KtFirFunctionSymbol: modality: OPEN name: contentEquals origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Boolean typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(cs)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Boolean annotations: [] callableIdIfNonLocal: java.lang.String.equalsIgnoreCase isExtension: false @@ -388,14 +389,14 @@ KtFirFunctionSymbol: modality: OPEN name: equalsIgnoreCase origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Boolean typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(anotherString)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: java.lang.String.compareTo isExtension: false @@ -407,14 +408,14 @@ KtFirFunctionSymbol: modality: OPEN name: compareTo origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(anotherString)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: java.lang.String.compareToIgnoreCase isExtension: false @@ -426,14 +427,14 @@ KtFirFunctionSymbol: modality: OPEN name: compareToIgnoreCase origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(str)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Boolean annotations: [] callableIdIfNonLocal: java.lang.String.regionMatches isExtension: false @@ -445,14 +446,14 @@ KtFirFunctionSymbol: modality: OPEN name: regionMatches origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Boolean typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(toffset), KtFirFunctionValueParameterSymbol(other), KtFirFunctionValueParameterSymbol(ooffset), KtFirFunctionValueParameterSymbol(len)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Boolean annotations: [] callableIdIfNonLocal: java.lang.String.regionMatches isExtension: false @@ -464,14 +465,14 @@ KtFirFunctionSymbol: modality: OPEN name: regionMatches origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Boolean typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(ignoreCase), KtFirFunctionValueParameterSymbol(toffset), KtFirFunctionValueParameterSymbol(other), KtFirFunctionValueParameterSymbol(ooffset), KtFirFunctionValueParameterSymbol(len)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Boolean annotations: [] callableIdIfNonLocal: java.lang.String.startsWith isExtension: false @@ -483,14 +484,14 @@ KtFirFunctionSymbol: modality: OPEN name: startsWith origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Boolean typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(prefix), KtFirFunctionValueParameterSymbol(toffset)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Boolean annotations: [] callableIdIfNonLocal: java.lang.String.startsWith isExtension: false @@ -502,14 +503,14 @@ KtFirFunctionSymbol: modality: OPEN name: startsWith origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Boolean typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(prefix)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Boolean annotations: [] callableIdIfNonLocal: java.lang.String.endsWith isExtension: false @@ -521,14 +522,14 @@ KtFirFunctionSymbol: modality: OPEN name: endsWith origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Boolean typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(suffix)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: java.lang.String.hashCode isExtension: false @@ -540,14 +541,14 @@ KtFirFunctionSymbol: modality: OPEN name: hashCode origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: java.lang.String.indexOf isExtension: false @@ -559,14 +560,14 @@ KtFirFunctionSymbol: modality: OPEN name: indexOf origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(ch)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: java.lang.String.indexOf isExtension: false @@ -578,14 +579,14 @@ KtFirFunctionSymbol: modality: OPEN name: indexOf origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(ch), KtFirFunctionValueParameterSymbol(fromIndex)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: java.lang.String.indexOf isExtension: false @@ -597,14 +598,14 @@ KtFirFunctionSymbol: modality: OPEN name: indexOf origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(str)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: java.lang.String.indexOf isExtension: false @@ -616,14 +617,14 @@ KtFirFunctionSymbol: modality: OPEN name: indexOf origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(str), KtFirFunctionValueParameterSymbol(fromIndex)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: java.lang.String.indexOfSupplementary isExtension: false @@ -635,14 +636,14 @@ KtFirFunctionSymbol: modality: OPEN name: indexOfSupplementary origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(ch), KtFirFunctionValueParameterSymbol(fromIndex)] visibility: PRIVATE KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: java.lang.String.lastIndexOf isExtension: false @@ -654,14 +655,14 @@ KtFirFunctionSymbol: modality: OPEN name: lastIndexOf origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(ch)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: java.lang.String.lastIndexOf isExtension: false @@ -673,14 +674,14 @@ KtFirFunctionSymbol: modality: OPEN name: lastIndexOf origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(ch), KtFirFunctionValueParameterSymbol(fromIndex)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: java.lang.String.lastIndexOf isExtension: false @@ -692,14 +693,14 @@ KtFirFunctionSymbol: modality: OPEN name: lastIndexOf origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(str)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: java.lang.String.lastIndexOf isExtension: false @@ -711,14 +712,14 @@ KtFirFunctionSymbol: modality: OPEN name: lastIndexOf origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(str), KtFirFunctionValueParameterSymbol(fromIndex)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: java.lang.String.lastIndexOfSupplementary isExtension: false @@ -730,14 +731,14 @@ KtFirFunctionSymbol: modality: OPEN name: lastIndexOfSupplementary origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(ch), KtFirFunctionValueParameterSymbol(fromIndex)] visibility: PRIVATE KtFirFunctionSymbol: + annotatedType: [] @EnhancedNullability kotlin/String annotations: [org/jetbrains/annotations/NotNull()] callableIdIfNonLocal: java.lang.String.substring isExtension: false @@ -749,14 +750,14 @@ KtFirFunctionSymbol: modality: OPEN name: substring origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: @EnhancedNullability kotlin/String typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(beginIndex)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] @EnhancedNullability kotlin/String annotations: [org/jetbrains/annotations/NotNull()] callableIdIfNonLocal: java.lang.String.substring isExtension: false @@ -768,14 +769,14 @@ KtFirFunctionSymbol: modality: OPEN name: substring origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: @EnhancedNullability kotlin/String typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(beginIndex), KtFirFunctionValueParameterSymbol(endIndex)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] @EnhancedNullability kotlin/CharSequence annotations: [org/jetbrains/annotations/NotNull()] callableIdIfNonLocal: java.lang.String.subSequence isExtension: false @@ -787,14 +788,14 @@ KtFirFunctionSymbol: modality: OPEN name: subSequence origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: @EnhancedNullability kotlin/CharSequence typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(beginIndex), KtFirFunctionValueParameterSymbol(endIndex)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] @EnhancedNullability kotlin/String annotations: [org/jetbrains/annotations/NotNull()] callableIdIfNonLocal: java.lang.String.concat isExtension: false @@ -806,14 +807,14 @@ KtFirFunctionSymbol: modality: OPEN name: concat origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: @EnhancedNullability kotlin/String typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(str)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] @EnhancedNullability kotlin/String annotations: [org/jetbrains/annotations/NotNull()] callableIdIfNonLocal: java.lang.String.replace isExtension: false @@ -825,14 +826,14 @@ KtFirFunctionSymbol: modality: OPEN name: replace origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: @EnhancedNullability kotlin/String typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(oldChar), KtFirFunctionValueParameterSymbol(newChar)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] @EnhancedNullability kotlin/String annotations: [org/jetbrains/annotations/NotNull()] callableIdIfNonLocal: java.lang.String.replace isExtension: false @@ -844,14 +845,14 @@ KtFirFunctionSymbol: modality: OPEN name: replace origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: @EnhancedNullability kotlin/String typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(target), KtFirFunctionValueParameterSymbol(replacement)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Boolean annotations: [] callableIdIfNonLocal: java.lang.String.matches isExtension: false @@ -863,14 +864,14 @@ KtFirFunctionSymbol: modality: OPEN name: matches origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Boolean typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(regex)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Boolean annotations: [] callableIdIfNonLocal: java.lang.String.contains isExtension: false @@ -882,14 +883,14 @@ KtFirFunctionSymbol: modality: OPEN name: contains origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Boolean typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(s)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] @EnhancedNullability kotlin/String annotations: [org/jetbrains/annotations/NotNull()] callableIdIfNonLocal: java.lang.String.replaceFirst isExtension: false @@ -901,14 +902,14 @@ KtFirFunctionSymbol: modality: OPEN name: replaceFirst origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: @EnhancedNullability kotlin/String typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(regex), KtFirFunctionValueParameterSymbol(replacement)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] @EnhancedNullability kotlin/String annotations: [org/jetbrains/annotations/NotNull()] callableIdIfNonLocal: java.lang.String.replaceAll isExtension: false @@ -920,14 +921,14 @@ KtFirFunctionSymbol: modality: OPEN name: replaceAll origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: @EnhancedNullability kotlin/String typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(regex), KtFirFunctionValueParameterSymbol(replacement)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] ft<@EnhancedNullability kotlin/Array!>, @EnhancedNullability kotlin/Array!>> annotations: [org/jetbrains/annotations/NotNull()] callableIdIfNonLocal: java.lang.String.split isExtension: false @@ -939,14 +940,14 @@ KtFirFunctionSymbol: modality: OPEN name: split origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: ft<@EnhancedNullability kotlin/Array!>, @EnhancedNullability kotlin/Array!>> typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(regex), KtFirFunctionValueParameterSymbol(limit)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] ft<@EnhancedNullability kotlin/Array!>, @EnhancedNullability kotlin/Array!>> annotations: [org/jetbrains/annotations/NotNull()] callableIdIfNonLocal: java.lang.String.split isExtension: false @@ -958,14 +959,14 @@ KtFirFunctionSymbol: modality: OPEN name: split origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: ft<@EnhancedNullability kotlin/Array!>, @EnhancedNullability kotlin/Array!>> typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(regex)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] @EnhancedNullability kotlin/String annotations: [org/jetbrains/annotations/NotNull()] callableIdIfNonLocal: java.lang.String.toLowerCase isExtension: false @@ -977,14 +978,14 @@ KtFirFunctionSymbol: modality: OPEN name: toLowerCase origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: @EnhancedNullability kotlin/String typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(locale)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] @EnhancedNullability kotlin/String annotations: [org/jetbrains/annotations/NotNull()] callableIdIfNonLocal: java.lang.String.toLowerCase isExtension: false @@ -996,14 +997,14 @@ KtFirFunctionSymbol: modality: OPEN name: toLowerCase origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: @EnhancedNullability kotlin/String typeParameters: [] valueParameters: [] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] @EnhancedNullability kotlin/String annotations: [org/jetbrains/annotations/NotNull()] callableIdIfNonLocal: java.lang.String.toUpperCase isExtension: false @@ -1015,14 +1016,14 @@ KtFirFunctionSymbol: modality: OPEN name: toUpperCase origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: @EnhancedNullability kotlin/String typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(locale)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] @EnhancedNullability kotlin/String annotations: [org/jetbrains/annotations/NotNull()] callableIdIfNonLocal: java.lang.String.toUpperCase isExtension: false @@ -1034,14 +1035,14 @@ KtFirFunctionSymbol: modality: OPEN name: toUpperCase origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: @EnhancedNullability kotlin/String typeParameters: [] valueParameters: [] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] @EnhancedNullability kotlin/String annotations: [org/jetbrains/annotations/NotNull()] callableIdIfNonLocal: java.lang.String.trim isExtension: false @@ -1053,14 +1054,14 @@ KtFirFunctionSymbol: modality: OPEN name: trim origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: @EnhancedNullability kotlin/String typeParameters: [] valueParameters: [] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] @FlexibleNullability kotlin/String annotations: [] callableIdIfNonLocal: java.lang.String.toString isExtension: false @@ -1072,14 +1073,14 @@ KtFirFunctionSymbol: modality: OPEN name: toString origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: @FlexibleNullability kotlin/String typeParameters: [] valueParameters: [] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] @EnhancedNullability kotlin/CharArray annotations: [org/jetbrains/annotations/NotNull()] callableIdIfNonLocal: java.lang.String.toCharArray isExtension: false @@ -1091,14 +1092,14 @@ KtFirFunctionSymbol: modality: OPEN name: toCharArray origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: @EnhancedNullability kotlin/CharArray typeParameters: [] valueParameters: [] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] @EnhancedNullability kotlin/String annotations: [org/jetbrains/annotations/NotNull()] callableIdIfNonLocal: java.lang.String.intern isExtension: false @@ -1110,184 +1111,184 @@ KtFirFunctionSymbol: modality: OPEN name: intern origin: JAVA - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: @EnhancedNullability kotlin/String typeParameters: [] valueParameters: [] visibility: PUBLIC KtFirConstructorSymbol: + annotatedType: [] java/lang/String annotations: [] containingClassIdIfNonLocal: java/lang/String isPrimary: false origin: JAVA symbolKind: MEMBER - type: java/lang/String valueParameters: [] visibility: PUBLIC KtFirConstructorSymbol: + annotatedType: [] java/lang/String annotations: [] containingClassIdIfNonLocal: java/lang/String isPrimary: false origin: JAVA symbolKind: MEMBER - type: java/lang/String valueParameters: [KtFirConstructorValueParameterSymbol(original)] visibility: PUBLIC KtFirConstructorSymbol: + annotatedType: [] java/lang/String annotations: [] containingClassIdIfNonLocal: java/lang/String isPrimary: false origin: JAVA symbolKind: MEMBER - type: java/lang/String valueParameters: [KtFirConstructorValueParameterSymbol(value)] visibility: PUBLIC KtFirConstructorSymbol: + annotatedType: [] java/lang/String annotations: [] containingClassIdIfNonLocal: java/lang/String isPrimary: false origin: JAVA symbolKind: MEMBER - type: java/lang/String valueParameters: [KtFirConstructorValueParameterSymbol(value), KtFirConstructorValueParameterSymbol(offset), KtFirConstructorValueParameterSymbol(count)] visibility: PUBLIC KtFirConstructorSymbol: + annotatedType: [] java/lang/String annotations: [] containingClassIdIfNonLocal: java/lang/String isPrimary: false origin: JAVA symbolKind: MEMBER - type: java/lang/String valueParameters: [KtFirConstructorValueParameterSymbol(codePoints), KtFirConstructorValueParameterSymbol(offset), KtFirConstructorValueParameterSymbol(count)] visibility: PUBLIC KtFirConstructorSymbol: + annotatedType: [] java/lang/String annotations: [kotlin/Deprecated(message = Deprecated in Java)] containingClassIdIfNonLocal: java/lang/String isPrimary: false origin: JAVA symbolKind: MEMBER - type: java/lang/String valueParameters: [KtFirConstructorValueParameterSymbol(ascii), KtFirConstructorValueParameterSymbol(hibyte), KtFirConstructorValueParameterSymbol(offset), KtFirConstructorValueParameterSymbol(count)] visibility: PUBLIC KtFirConstructorSymbol: + annotatedType: [] java/lang/String annotations: [kotlin/Deprecated(message = Deprecated in Java)] containingClassIdIfNonLocal: java/lang/String isPrimary: false origin: JAVA symbolKind: MEMBER - type: java/lang/String valueParameters: [KtFirConstructorValueParameterSymbol(ascii), KtFirConstructorValueParameterSymbol(hibyte)] visibility: PUBLIC KtFirConstructorSymbol: + annotatedType: [] java/lang/String annotations: [] containingClassIdIfNonLocal: java/lang/String isPrimary: false origin: JAVA symbolKind: MEMBER - type: java/lang/String valueParameters: [KtFirConstructorValueParameterSymbol(bytes), KtFirConstructorValueParameterSymbol(offset), KtFirConstructorValueParameterSymbol(length), KtFirConstructorValueParameterSymbol(charsetName)] visibility: PUBLIC KtFirConstructorSymbol: + annotatedType: [] java/lang/String annotations: [] containingClassIdIfNonLocal: java/lang/String isPrimary: false origin: JAVA symbolKind: MEMBER - type: java/lang/String valueParameters: [KtFirConstructorValueParameterSymbol(bytes), KtFirConstructorValueParameterSymbol(offset), KtFirConstructorValueParameterSymbol(length), KtFirConstructorValueParameterSymbol(charset)] visibility: PUBLIC KtFirConstructorSymbol: + annotatedType: [] java/lang/String annotations: [] containingClassIdIfNonLocal: java/lang/String isPrimary: false origin: JAVA symbolKind: MEMBER - type: java/lang/String valueParameters: [KtFirConstructorValueParameterSymbol(bytes), KtFirConstructorValueParameterSymbol(charsetName)] visibility: PUBLIC KtFirConstructorSymbol: + annotatedType: [] java/lang/String annotations: [] containingClassIdIfNonLocal: java/lang/String isPrimary: false origin: JAVA symbolKind: MEMBER - type: java/lang/String valueParameters: [KtFirConstructorValueParameterSymbol(bytes), KtFirConstructorValueParameterSymbol(charset)] visibility: PUBLIC KtFirConstructorSymbol: + annotatedType: [] java/lang/String annotations: [] containingClassIdIfNonLocal: java/lang/String isPrimary: false origin: JAVA symbolKind: MEMBER - type: java/lang/String valueParameters: [KtFirConstructorValueParameterSymbol(bytes), KtFirConstructorValueParameterSymbol(offset), KtFirConstructorValueParameterSymbol(length)] visibility: PUBLIC KtFirConstructorSymbol: + annotatedType: [] java/lang/String annotations: [] containingClassIdIfNonLocal: java/lang/String isPrimary: false origin: JAVA symbolKind: MEMBER - type: java/lang/String valueParameters: [KtFirConstructorValueParameterSymbol(bytes)] visibility: PUBLIC KtFirConstructorSymbol: + annotatedType: [] java/lang/String annotations: [] containingClassIdIfNonLocal: java/lang/String isPrimary: false origin: JAVA symbolKind: MEMBER - type: java/lang/String valueParameters: [KtFirConstructorValueParameterSymbol(buffer)] visibility: PUBLIC KtFirConstructorSymbol: + annotatedType: [] java/lang/String annotations: [] containingClassIdIfNonLocal: java/lang/String isPrimary: false origin: JAVA symbolKind: MEMBER - type: java/lang/String valueParameters: [KtFirConstructorValueParameterSymbol(builder)] visibility: PUBLIC KtFirConstructorSymbol: + annotatedType: [] java/lang/String annotations: [] containingClassIdIfNonLocal: java/lang/String isPrimary: false origin: JAVA symbolKind: MEMBER - type: java/lang/String valueParameters: [KtFirConstructorValueParameterSymbol(value), KtFirConstructorValueParameterSymbol(share)] visibility: UNKNOWN KtFirConstructorSymbol: + annotatedType: [] java/lang/String annotations: [kotlin/Deprecated(message = Deprecated in Java)] containingClassIdIfNonLocal: java/lang/String isPrimary: false origin: JAVA symbolKind: MEMBER - type: java/lang/String valueParameters: [KtFirConstructorValueParameterSymbol(offset), KtFirConstructorValueParameterSymbol(count), KtFirConstructorValueParameterSymbol(value)] visibility: UNKNOWN KtFirFunctionSymbol: + annotatedType: [] kotlin/Char annotations: [] callableIdIfNonLocal: kotlin.CharSequence.get isExtension: false @@ -1299,9 +1300,8 @@ KtFirFunctionSymbol: modality: ABSTRACT name: get origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Char typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(index)] visibility: PUBLIC @@ -1316,7 +1316,7 @@ KtFirClassOrObjectSymbol: name: CaseInsensitiveComparator origin: JAVA primaryConstructor: null - superTypes: [kotlin/Any, java/util/Comparator!>, java/io/Serializable] + superTypes: [[] kotlin/Any, [] java/util/Comparator!>, [] java/io/Serializable] symbolKind: MEMBER typeParameters: [] visibility: PRIVATE diff --git a/idea/idea-frontend-fir/testData/resoreSymbolFromLibrary/class.txt b/idea/idea-frontend-fir/testData/resoreSymbolFromLibrary/class.txt index 224657cb944..35a1761be6e 100644 --- a/idea/idea-frontend-fir/testData/resoreSymbolFromLibrary/class.txt +++ b/idea/idea-frontend-fir/testData/resoreSymbolFromLibrary/class.txt @@ -13,7 +13,7 @@ KtFirClassOrObjectSymbol: name: Lazy origin: LIBRARY primaryConstructor: null - superTypes: [kotlin/Any] + superTypes: [[] kotlin/Any] symbolKind: TOP_LEVEL typeParameters: [KtFirTypeParameterSymbol(T)] visibility: PUBLIC diff --git a/idea/idea-frontend-fir/testData/resoreSymbolFromLibrary/classFromJdk.txt b/idea/idea-frontend-fir/testData/resoreSymbolFromLibrary/classFromJdk.txt index d76cefbae29..fdaadb53a6d 100644 --- a/idea/idea-frontend-fir/testData/resoreSymbolFromLibrary/classFromJdk.txt +++ b/idea/idea-frontend-fir/testData/resoreSymbolFromLibrary/classFromJdk.txt @@ -13,7 +13,7 @@ KtFirClassOrObjectSymbol: name: String origin: JAVA primaryConstructor: null - superTypes: [kotlin/Any, java/io/Serializable, kotlin/Comparable!>, kotlin/CharSequence] + superTypes: [[] kotlin/Any, [] java/io/Serializable, [] kotlin/Comparable!>, [] kotlin/CharSequence] symbolKind: MEMBER typeParameters: [] visibility: PUBLIC diff --git a/idea/idea-frontend-fir/testData/resoreSymbolFromLibrary/enumEntry.txt b/idea/idea-frontend-fir/testData/resoreSymbolFromLibrary/enumEntry.txt index f28aa16e883..c28030f53cf 100644 --- a/idea/idea-frontend-fir/testData/resoreSymbolFromLibrary/enumEntry.txt +++ b/idea/idea-frontend-fir/testData/resoreSymbolFromLibrary/enumEntry.txt @@ -4,8 +4,8 @@ callable: kotlin/LazyThreadSafetyMode.SYNCHRONIZED // SYMBOLS: KtFirEnumEntrySymbol: + annotatedType: [] kotlin/LazyThreadSafetyMode containingEnumClassIdIfNonLocal: kotlin/LazyThreadSafetyMode name: SYNCHRONIZED origin: LIBRARY symbolKind: MEMBER - type: kotlin/LazyThreadSafetyMode diff --git a/idea/idea-frontend-fir/testData/resoreSymbolFromLibrary/memberFunction.txt b/idea/idea-frontend-fir/testData/resoreSymbolFromLibrary/memberFunction.txt index 12db4e5291c..c7c45da403b 100644 --- a/idea/idea-frontend-fir/testData/resoreSymbolFromLibrary/memberFunction.txt +++ b/idea/idea-frontend-fir/testData/resoreSymbolFromLibrary/memberFunction.txt @@ -2,6 +2,7 @@ callable: kotlin/collections/List.get // SYMBOLS: KtFirFunctionSymbol: + annotatedType: [] E annotations: [] callableIdIfNonLocal: kotlin.collections.List.get isExtension: false @@ -13,9 +14,8 @@ KtFirFunctionSymbol: modality: ABSTRACT name: get origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: E typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(index)] visibility: PUBLIC diff --git a/idea/idea-frontend-fir/testData/resoreSymbolFromLibrary/memberFunctionWithOverloads.txt b/idea/idea-frontend-fir/testData/resoreSymbolFromLibrary/memberFunctionWithOverloads.txt index 8e85c70287f..8125eaeb298 100644 --- a/idea/idea-frontend-fir/testData/resoreSymbolFromLibrary/memberFunctionWithOverloads.txt +++ b/idea/idea-frontend-fir/testData/resoreSymbolFromLibrary/memberFunctionWithOverloads.txt @@ -2,6 +2,7 @@ callable: kotlin/collections/List.listIterator // SYMBOLS: KtFirFunctionSymbol: + annotatedType: [] kotlin/collections/ListIterator annotations: [] callableIdIfNonLocal: kotlin.collections.List.listIterator isExtension: false @@ -13,14 +14,14 @@ KtFirFunctionSymbol: modality: ABSTRACT name: listIterator origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/collections/ListIterator typeParameters: [] valueParameters: [] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/collections/ListIterator annotations: [] callableIdIfNonLocal: kotlin.collections.List.listIterator isExtension: false @@ -32,9 +33,8 @@ KtFirFunctionSymbol: modality: ABSTRACT name: listIterator origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/collections/ListIterator typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(index)] visibility: PUBLIC diff --git a/idea/idea-frontend-fir/testData/resoreSymbolFromLibrary/nestedClass.txt b/idea/idea-frontend-fir/testData/resoreSymbolFromLibrary/nestedClass.txt index 83ba77170c4..c69a559290d 100644 --- a/idea/idea-frontend-fir/testData/resoreSymbolFromLibrary/nestedClass.txt +++ b/idea/idea-frontend-fir/testData/resoreSymbolFromLibrary/nestedClass.txt @@ -11,7 +11,7 @@ KtFirClassOrObjectSymbol: name: MutableEntry origin: LIBRARY primaryConstructor: null - superTypes: [kotlin/collections/Map.Entry] + superTypes: [[] kotlin/collections/Map.Entry] symbolKind: MEMBER typeParameters: [KtFirTypeParameterSymbol(K), KtFirTypeParameterSymbol(V)] visibility: PUBLIC diff --git a/idea/idea-frontend-fir/testData/symbolPointer/class.kt b/idea/idea-frontend-fir/testData/symbolPointer/class.kt index 2c3a1c397ad..355debbe27b 100644 --- a/idea/idea-frontend-fir/testData/symbolPointer/class.kt +++ b/idea/idea-frontend-fir/testData/symbolPointer/class.kt @@ -12,7 +12,7 @@ KtFirClassOrObjectSymbol: name: A origin: SOURCE primaryConstructor: KtFirConstructorSymbol() - superTypes: [kotlin/Any] + superTypes: [[] kotlin/Any] symbolKind: TOP_LEVEL typeParameters: [] visibility: PUBLIC diff --git a/idea/idea-frontend-fir/testData/symbolPointer/classPrimaryConstructor.kt b/idea/idea-frontend-fir/testData/symbolPointer/classPrimaryConstructor.kt index 9f3bef02003..546312e8e46 100644 --- a/idea/idea-frontend-fir/testData/symbolPointer/classPrimaryConstructor.kt +++ b/idea/idea-frontend-fir/testData/symbolPointer/classPrimaryConstructor.kt @@ -3,12 +3,12 @@ class A() { // SYMBOLS: KtFirConstructorSymbol: + annotatedType: [] A annotations: [] containingClassIdIfNonLocal: A isPrimary: true origin: SOURCE symbolKind: MEMBER - type: A valueParameters: [] visibility: PUBLIC @@ -22,7 +22,7 @@ KtFirClassOrObjectSymbol: name: A origin: SOURCE primaryConstructor: KtFirConstructorSymbol() - superTypes: [kotlin/Any] + superTypes: [[] kotlin/Any] symbolKind: TOP_LEVEL typeParameters: [] visibility: PUBLIC diff --git a/idea/idea-frontend-fir/testData/symbolPointer/classSecondaryConstructors.kt b/idea/idea-frontend-fir/testData/symbolPointer/classSecondaryConstructors.kt index cbce77c71da..d0c261bb2d8 100644 --- a/idea/idea-frontend-fir/testData/symbolPointer/classSecondaryConstructors.kt +++ b/idea/idea-frontend-fir/testData/symbolPointer/classSecondaryConstructors.kt @@ -5,59 +5,59 @@ class A() { // SYMBOLS: KtFirConstructorSymbol: + annotatedType: [] A annotations: [] containingClassIdIfNonLocal: A isPrimary: true origin: SOURCE symbolKind: MEMBER - type: A valueParameters: [] visibility: PUBLIC KtFirFunctionValueParameterSymbol: + annotatedType: [] kotlin/Int annotations: [] hasDefaultValue: false isVararg: false name: x origin: SOURCE symbolKind: NON_PROPERTY_PARAMETER - type: kotlin/Int KtFirConstructorSymbol: + annotatedType: [] A annotations: [] containingClassIdIfNonLocal: A isPrimary: false origin: SOURCE symbolKind: MEMBER - type: A valueParameters: Could not render due to java.lang.ClassCastException: org.jetbrains.kotlin.idea.frontend.api.fir.symbols.KtFirFunctionValueParameterSymbol cannot be cast to org.jetbrains.kotlin.idea.frontend.api.fir.symbols.KtFirConstructorValueParameterSymbol visibility: PUBLIC KtFirFunctionValueParameterSymbol: + annotatedType: [] kotlin/Int annotations: [] hasDefaultValue: false isVararg: false name: y origin: SOURCE symbolKind: NON_PROPERTY_PARAMETER - type: kotlin/Int KtFirFunctionValueParameterSymbol: + annotatedType: [] kotlin/String annotations: [] hasDefaultValue: false isVararg: false name: z origin: SOURCE symbolKind: NON_PROPERTY_PARAMETER - type: kotlin/String KtFirConstructorSymbol: + annotatedType: [] A annotations: [] containingClassIdIfNonLocal: A isPrimary: false origin: SOURCE symbolKind: MEMBER - type: A valueParameters: Could not render due to java.lang.ClassCastException: org.jetbrains.kotlin.idea.frontend.api.fir.symbols.KtFirFunctionValueParameterSymbol cannot be cast to org.jetbrains.kotlin.idea.frontend.api.fir.symbols.KtFirConstructorValueParameterSymbol visibility: PUBLIC @@ -71,7 +71,7 @@ KtFirClassOrObjectSymbol: name: A origin: SOURCE primaryConstructor: KtFirConstructorSymbol() - superTypes: [kotlin/Any] + superTypes: [[] kotlin/Any] symbolKind: TOP_LEVEL typeParameters: [] visibility: PUBLIC diff --git a/idea/idea-frontend-fir/testData/symbolPointer/enum.kt b/idea/idea-frontend-fir/testData/symbolPointer/enum.kt index b05ecb9d2cb..edc14a00daa 100644 --- a/idea/idea-frontend-fir/testData/symbolPointer/enum.kt +++ b/idea/idea-frontend-fir/testData/symbolPointer/enum.kt @@ -4,18 +4,18 @@ enum class X { // SYMBOLS: KtFirEnumEntrySymbol: + annotatedType: [] X containingEnumClassIdIfNonLocal: X name: Y origin: SOURCE symbolKind: MEMBER - type: X KtFirEnumEntrySymbol: + annotatedType: [] X containingEnumClassIdIfNonLocal: X name: Z origin: SOURCE symbolKind: MEMBER - type: X KtFirClassOrObjectSymbol: annotations: [] @@ -27,7 +27,7 @@ KtFirClassOrObjectSymbol: name: X origin: SOURCE primaryConstructor: KtFirConstructorSymbol() - superTypes: [kotlin/Enum] + superTypes: [[] kotlin/Enum] symbolKind: TOP_LEVEL typeParameters: [] visibility: PUBLIC diff --git a/idea/idea-frontend-fir/testData/symbolPointer/memberFunctions.kt b/idea/idea-frontend-fir/testData/symbolPointer/memberFunctions.kt index 844c5a04c34..174b73cc883 100644 --- a/idea/idea-frontend-fir/testData/symbolPointer/memberFunctions.kt +++ b/idea/idea-frontend-fir/testData/symbolPointer/memberFunctions.kt @@ -5,6 +5,7 @@ class A { // SYMBOLS: KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: A.x isExtension: false @@ -16,14 +17,14 @@ KtFirFunctionSymbol: modality: FINAL name: x origin: SOURCE - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Unit annotations: [] callableIdIfNonLocal: A.y isExtension: false @@ -35,9 +36,8 @@ KtFirFunctionSymbol: modality: FINAL name: y origin: SOURCE - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Unit typeParameters: [] valueParameters: [] visibility: PUBLIC @@ -52,7 +52,7 @@ KtFirClassOrObjectSymbol: name: A origin: SOURCE primaryConstructor: KtFirConstructorSymbol() - superTypes: [kotlin/Any] + superTypes: [[] kotlin/Any] symbolKind: TOP_LEVEL typeParameters: [] visibility: PUBLIC diff --git a/idea/idea-frontend-fir/testData/symbolPointer/memberProperties.kt b/idea/idea-frontend-fir/testData/symbolPointer/memberProperties.kt index 9c46bf6f8d7..5df6abded97 100644 --- a/idea/idea-frontend-fir/testData/symbolPointer/memberProperties.kt +++ b/idea/idea-frontend-fir/testData/symbolPointer/memberProperties.kt @@ -5,6 +5,7 @@ class A { // SYMBOLS: KtFirKotlinPropertySymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: A.x getter: KtFirPropertyGetterSymbol() @@ -20,13 +21,13 @@ KtFirKotlinPropertySymbol: modality: FINAL name: x origin: SOURCE - receiverTypeAndAnnotations: null + receiverType: null setter: null symbolKind: MEMBER - type: kotlin/Int visibility: PUBLIC KtFirPropertyGetterSymbol: + annotatedType: [] kotlin/Int annotations: [] hasBody: true isDefault: false @@ -35,10 +36,10 @@ KtFirPropertyGetterSymbol: modality: FINAL origin: SOURCE symbolKind: TOP_LEVEL - type: kotlin/Int visibility: PUBLIC KtFirKotlinPropertySymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: A.y getter: KtFirPropertyGetterSymbol() @@ -54,10 +55,9 @@ KtFirKotlinPropertySymbol: modality: FINAL name: y origin: SOURCE - receiverTypeAndAnnotations: [] kotlin/Int + receiverType: [] kotlin/Int setter: null symbolKind: MEMBER - type: kotlin/Int visibility: PUBLIC KtFirClassOrObjectSymbol: @@ -70,7 +70,7 @@ KtFirClassOrObjectSymbol: name: A origin: SOURCE primaryConstructor: KtFirConstructorSymbol() - superTypes: [kotlin/Any] + superTypes: [[] kotlin/Any] symbolKind: TOP_LEVEL typeParameters: [] visibility: PUBLIC diff --git a/idea/idea-frontend-fir/testData/symbolPointer/topLevelFunctions.kt b/idea/idea-frontend-fir/testData/symbolPointer/topLevelFunctions.kt index 17777c8c6c9..c7d38974d80 100644 --- a/idea/idea-frontend-fir/testData/symbolPointer/topLevelFunctions.kt +++ b/idea/idea-frontend-fir/testData/symbolPointer/topLevelFunctions.kt @@ -3,6 +3,7 @@ fun y() {} // SYMBOLS: KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: x isExtension: false @@ -14,14 +15,14 @@ KtFirFunctionSymbol: modality: FINAL name: x origin: SOURCE - receiverTypeAndAnnotations: null + receiverType: null symbolKind: TOP_LEVEL - type: kotlin/Int typeParameters: [] valueParameters: [] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Unit annotations: [] callableIdIfNonLocal: y isExtension: false @@ -33,9 +34,8 @@ KtFirFunctionSymbol: modality: FINAL name: y origin: SOURCE - receiverTypeAndAnnotations: null + receiverType: null symbolKind: TOP_LEVEL - type: kotlin/Unit typeParameters: [] valueParameters: [] visibility: PUBLIC diff --git a/idea/idea-frontend-fir/testData/symbolPointer/topLevelProperties.kt b/idea/idea-frontend-fir/testData/symbolPointer/topLevelProperties.kt index ad553f09584..df1908ba32b 100644 --- a/idea/idea-frontend-fir/testData/symbolPointer/topLevelProperties.kt +++ b/idea/idea-frontend-fir/testData/symbolPointer/topLevelProperties.kt @@ -3,6 +3,7 @@ val Int.y get() = this // SYMBOLS: KtFirKotlinPropertySymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: x getter: KtFirPropertyGetterSymbol() @@ -18,13 +19,13 @@ KtFirKotlinPropertySymbol: modality: FINAL name: x origin: SOURCE - receiverTypeAndAnnotations: null + receiverType: null setter: null symbolKind: TOP_LEVEL - type: kotlin/Int visibility: PUBLIC KtFirPropertyGetterSymbol: + annotatedType: [] kotlin/Int annotations: [] hasBody: true isDefault: false @@ -33,10 +34,10 @@ KtFirPropertyGetterSymbol: modality: FINAL origin: SOURCE symbolKind: TOP_LEVEL - type: kotlin/Int visibility: PUBLIC KtFirKotlinPropertySymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: y getter: KtFirPropertyGetterSymbol() @@ -52,8 +53,7 @@ KtFirKotlinPropertySymbol: modality: FINAL name: y origin: SOURCE - receiverTypeAndAnnotations: [] kotlin/Int + receiverType: [] kotlin/Int setter: null symbolKind: TOP_LEVEL - type: kotlin/Int visibility: PUBLIC diff --git a/idea/idea-frontend-fir/testData/symbolsByFqName/fileWalkDirectionEnum.txt b/idea/idea-frontend-fir/testData/symbolsByFqName/fileWalkDirectionEnum.txt index 02091117866..5c18c8c2598 100644 --- a/idea/idea-frontend-fir/testData/symbolsByFqName/fileWalkDirectionEnum.txt +++ b/idea/idea-frontend-fir/testData/symbolsByFqName/fileWalkDirectionEnum.txt @@ -2,6 +2,7 @@ callable: kotlin/collections/listOf // SYMBOLS: KtFirFunctionSymbol: + annotatedType: [] kotlin/collections/List annotations: [] callableIdIfNonLocal: kotlin.collections.listOf isExtension: false @@ -13,14 +14,14 @@ KtFirFunctionSymbol: modality: FINAL name: listOf origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: TOP_LEVEL - type: kotlin/collections/List typeParameters: [KtFirTypeParameterSymbol(T)] valueParameters: [KtFirFunctionValueParameterSymbol(element)] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/collections/List annotations: [] callableIdIfNonLocal: kotlin.collections.listOf isExtension: false @@ -32,14 +33,14 @@ KtFirFunctionSymbol: modality: FINAL name: listOf origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: TOP_LEVEL - type: kotlin/collections/List typeParameters: [KtFirTypeParameterSymbol(T)] valueParameters: [] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/collections/List annotations: [] callableIdIfNonLocal: kotlin.collections.listOf isExtension: false @@ -51,9 +52,8 @@ KtFirFunctionSymbol: modality: FINAL name: listOf origin: LIBRARY - receiverTypeAndAnnotations: null + receiverType: null symbolKind: TOP_LEVEL - type: kotlin/collections/List typeParameters: [KtFirTypeParameterSymbol(T)] valueParameters: [KtFirFunctionValueParameterSymbol(elements)] visibility: PUBLIC diff --git a/idea/idea-frontend-fir/testData/symbolsByFqName/iterator.txt b/idea/idea-frontend-fir/testData/symbolsByFqName/iterator.txt index dd99cc18b1a..303ae5b61c0 100644 --- a/idea/idea-frontend-fir/testData/symbolsByFqName/iterator.txt +++ b/idea/idea-frontend-fir/testData/symbolsByFqName/iterator.txt @@ -11,7 +11,7 @@ KtFirClassOrObjectSymbol: name: Iterator origin: LIBRARY primaryConstructor: null - superTypes: [kotlin/Any] + superTypes: [[] kotlin/Any] symbolKind: TOP_LEVEL typeParameters: [KtFirTypeParameterSymbol(T)] visibility: PUBLIC diff --git a/idea/idea-frontend-fir/testData/symbolsByFqName/listOf.txt b/idea/idea-frontend-fir/testData/symbolsByFqName/listOf.txt index e0d6d9fe9a9..8ed8987ff7e 100644 --- a/idea/idea-frontend-fir/testData/symbolsByFqName/listOf.txt +++ b/idea/idea-frontend-fir/testData/symbolsByFqName/listOf.txt @@ -11,7 +11,7 @@ KtFirClassOrObjectSymbol: name: FileWalkDirection origin: LIBRARY primaryConstructor: KtFirConstructorSymbol() - superTypes: [kotlin/Enum] + superTypes: [[] kotlin/Enum] symbolKind: TOP_LEVEL typeParameters: [] visibility: PUBLIC diff --git a/idea/idea-frontend-fir/testData/symbolsByPsi/annotations.kt b/idea/idea-frontend-fir/testData/symbolsByPsi/annotations.kt index 15c53a7a7d4..9848a09db9c 100644 --- a/idea/idea-frontend-fir/testData/symbolsByPsi/annotations.kt +++ b/idea/idea-frontend-fir/testData/symbolsByPsi/annotations.kt @@ -12,30 +12,30 @@ class X { // SYMBOLS: /* KtFirFunctionValueParameterSymbol: + annotatedType: [] kotlin/String annotations: [] hasDefaultValue: false isVararg: false name: param1 origin: SOURCE symbolKind: NON_PROPERTY_PARAMETER - type: kotlin/String KtFirFunctionValueParameterSymbol: + annotatedType: [] kotlin/Int annotations: [] hasDefaultValue: false isVararg: false name: param2 origin: SOURCE symbolKind: NON_PROPERTY_PARAMETER - type: kotlin/Int KtFirConstructorSymbol: + annotatedType: [] Anno annotations: [] containingClassIdIfNonLocal: Anno isPrimary: true origin: SOURCE symbolKind: MEMBER - type: Anno valueParameters: Could not render due to java.lang.ClassCastException: org.jetbrains.kotlin.idea.frontend.api.fir.symbols.KtFirFunctionValueParameterSymbol cannot be cast to org.jetbrains.kotlin.idea.frontend.api.fir.symbols.KtFirConstructorValueParameterSymbol visibility: PUBLIC @@ -49,12 +49,13 @@ KtFirClassOrObjectSymbol: name: Anno origin: SOURCE primaryConstructor: KtFirConstructorSymbol() - superTypes: [kotlin/Annotation] + superTypes: [[] kotlin/Annotation] symbolKind: TOP_LEVEL typeParameters: [] visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Unit annotations: [Anno(param1 = funparam, param2 = 3)] callableIdIfNonLocal: X.x isExtension: false @@ -66,9 +67,8 @@ KtFirFunctionSymbol: modality: FINAL name: x origin: SOURCE - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Unit typeParameters: [] valueParameters: [] visibility: PUBLIC @@ -83,7 +83,7 @@ KtFirClassOrObjectSymbol: name: X origin: SOURCE primaryConstructor: KtFirConstructorSymbol() - superTypes: [kotlin/Any] + superTypes: [[] kotlin/Any] symbolKind: TOP_LEVEL typeParameters: [] visibility: PUBLIC diff --git a/idea/idea-frontend-fir/testData/symbolsByPsi/anonymousObject.kt b/idea/idea-frontend-fir/testData/symbolsByPsi/anonymousObject.kt index 06443c07def..752929ff317 100644 --- a/idea/idea-frontend-fir/testData/symbolsByPsi/anonymousObject.kt +++ b/idea/idea-frontend-fir/testData/symbolsByPsi/anonymousObject.kt @@ -10,6 +10,7 @@ class AnonymousContainer { // SYMBOLS: /* KtFirFunctionSymbol: + annotatedType: [] kotlin/Unit annotations: [] callableIdIfNonLocal: .run isExtension: false @@ -21,14 +22,14 @@ KtFirFunctionSymbol: modality: FINAL name: run origin: SOURCE - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Unit typeParameters: [] valueParameters: [] visibility: PUBLIC KtFirKotlinPropertySymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: .data getter: KtFirPropertyGetterSymbol() @@ -44,19 +45,19 @@ KtFirKotlinPropertySymbol: modality: FINAL name: data origin: SOURCE - receiverTypeAndAnnotations: null + receiverType: null setter: null symbolKind: MEMBER - type: kotlin/Int visibility: PUBLIC KtFirAnonymousObjectSymbol: annotations: [] origin: SOURCE - superTypes: [java/lang/Runnable] + superTypes: [[] java/lang/Runnable] symbolKind: LOCAL KtFirKotlinPropertySymbol: + annotatedType: [] java/lang/Runnable annotations: [] callableIdIfNonLocal: AnonymousContainer.anonymousObject getter: KtFirPropertyGetterSymbol() @@ -72,10 +73,9 @@ KtFirKotlinPropertySymbol: modality: FINAL name: anonymousObject origin: SOURCE - receiverTypeAndAnnotations: null + receiverType: null setter: null symbolKind: MEMBER - type: java/lang/Runnable visibility: PUBLIC KtFirClassOrObjectSymbol: @@ -88,7 +88,7 @@ KtFirClassOrObjectSymbol: name: AnonymousContainer origin: SOURCE primaryConstructor: KtFirConstructorSymbol() - superTypes: [kotlin/Any] + superTypes: [[] kotlin/Any] symbolKind: TOP_LEVEL typeParameters: [] visibility: PUBLIC diff --git a/idea/idea-frontend-fir/testData/symbolsByPsi/class.kt b/idea/idea-frontend-fir/testData/symbolsByPsi/class.kt index ea6fba4064a..5d66681ccdf 100644 --- a/idea/idea-frontend-fir/testData/symbolsByPsi/class.kt +++ b/idea/idea-frontend-fir/testData/symbolsByPsi/class.kt @@ -13,7 +13,7 @@ KtFirClassOrObjectSymbol: name: A origin: SOURCE primaryConstructor: KtFirConstructorSymbol() - superTypes: [kotlin/Any] + superTypes: [[] kotlin/Any] symbolKind: TOP_LEVEL typeParameters: [] visibility: PUBLIC diff --git a/idea/idea-frontend-fir/testData/symbolsByPsi/classMembes.kt b/idea/idea-frontend-fir/testData/symbolsByPsi/classMembes.kt index a09e8d0f015..f7f391475f0 100644 --- a/idea/idea-frontend-fir/testData/symbolsByPsi/classMembes.kt +++ b/idea/idea-frontend-fir/testData/symbolsByPsi/classMembes.kt @@ -6,6 +6,7 @@ class A { // SYMBOLS: /* KtFirKotlinPropertySymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: A.a getter: KtFirPropertyGetterSymbol() @@ -21,13 +22,13 @@ KtFirKotlinPropertySymbol: modality: FINAL name: a origin: SOURCE - receiverTypeAndAnnotations: null + receiverType: null setter: null symbolKind: MEMBER - type: kotlin/Int visibility: PUBLIC KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: A.x isExtension: false @@ -39,9 +40,8 @@ KtFirFunctionSymbol: modality: FINAL name: x origin: SOURCE - receiverTypeAndAnnotations: null + receiverType: null symbolKind: MEMBER - type: kotlin/Int typeParameters: [] valueParameters: [] visibility: PUBLIC @@ -56,7 +56,7 @@ KtFirClassOrObjectSymbol: name: A origin: SOURCE primaryConstructor: KtFirConstructorSymbol() - superTypes: [kotlin/Any] + superTypes: [[] kotlin/Any] symbolKind: TOP_LEVEL typeParameters: [] visibility: PUBLIC diff --git a/idea/idea-frontend-fir/testData/symbolsByPsi/classWithTypeParams.kt b/idea/idea-frontend-fir/testData/symbolsByPsi/classWithTypeParams.kt index faa01f04031..15a28cbed28 100644 --- a/idea/idea-frontend-fir/testData/symbolsByPsi/classWithTypeParams.kt +++ b/idea/idea-frontend-fir/testData/symbolsByPsi/classWithTypeParams.kt @@ -23,7 +23,7 @@ KtFirClassOrObjectSymbol: name: A origin: SOURCE primaryConstructor: KtFirConstructorSymbol() - superTypes: [kotlin/Any] + superTypes: [[] kotlin/Any] symbolKind: TOP_LEVEL typeParameters: [KtFirTypeParameterSymbol(T), KtFirTypeParameterSymbol(R)] visibility: PUBLIC diff --git a/idea/idea-frontend-fir/testData/symbolsByPsi/extensionFunction.kt b/idea/idea-frontend-fir/testData/symbolsByPsi/extensionFunction.kt index b519d7d447e..e9515d30828 100644 --- a/idea/idea-frontend-fir/testData/symbolsByPsi/extensionFunction.kt +++ b/idea/idea-frontend-fir/testData/symbolsByPsi/extensionFunction.kt @@ -3,6 +3,7 @@ fun String.foo(): Int = 10 // SYMBOLS: /* KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: foo isExtension: true @@ -14,9 +15,8 @@ KtFirFunctionSymbol: modality: FINAL name: foo origin: SOURCE - receiverTypeAndAnnotations: [] kotlin/String + receiverType: [] kotlin/String symbolKind: TOP_LEVEL - type: kotlin/Int typeParameters: [] valueParameters: [] visibility: PUBLIC diff --git a/idea/idea-frontend-fir/testData/symbolsByPsi/function.kt b/idea/idea-frontend-fir/testData/symbolsByPsi/function.kt index a460b74a83e..4c2b5c9bb38 100644 --- a/idea/idea-frontend-fir/testData/symbolsByPsi/function.kt +++ b/idea/idea-frontend-fir/testData/symbolsByPsi/function.kt @@ -3,15 +3,16 @@ fun foo(x: Int) {} // SYMBOLS: /* KtFirFunctionValueParameterSymbol: + annotatedType: [] kotlin/Int annotations: [] hasDefaultValue: false isVararg: false name: x origin: SOURCE symbolKind: NON_PROPERTY_PARAMETER - type: kotlin/Int KtFirFunctionSymbol: + annotatedType: [] kotlin/Unit annotations: [] callableIdIfNonLocal: foo isExtension: false @@ -23,9 +24,8 @@ KtFirFunctionSymbol: modality: FINAL name: foo origin: SOURCE - receiverTypeAndAnnotations: null + receiverType: null symbolKind: TOP_LEVEL - type: kotlin/Unit typeParameters: [] valueParameters: [KtFirFunctionValueParameterSymbol(x)] visibility: PUBLIC diff --git a/idea/idea-frontend-fir/testData/symbolsByPsi/functionWithTypeParams.kt b/idea/idea-frontend-fir/testData/symbolsByPsi/functionWithTypeParams.kt index 4ba2957b865..90968f67a11 100644 --- a/idea/idea-frontend-fir/testData/symbolsByPsi/functionWithTypeParams.kt +++ b/idea/idea-frontend-fir/testData/symbolsByPsi/functionWithTypeParams.kt @@ -8,15 +8,16 @@ KtFirTypeParameterSymbol: upperBounds: [kotlin/Any?] KtFirFunctionValueParameterSymbol: + annotatedType: [] X annotations: [] hasDefaultValue: false isVararg: false name: x origin: SOURCE symbolKind: NON_PROPERTY_PARAMETER - type: X KtFirFunctionSymbol: + annotatedType: [] kotlin/Unit annotations: [] callableIdIfNonLocal: foo isExtension: false @@ -28,9 +29,8 @@ KtFirFunctionSymbol: modality: FINAL name: foo origin: SOURCE - receiverTypeAndAnnotations: null + receiverType: null symbolKind: TOP_LEVEL - type: kotlin/Unit typeParameters: [KtFirTypeParameterSymbol(X)] valueParameters: [KtFirFunctionValueParameterSymbol(x)] visibility: PUBLIC diff --git a/idea/idea-frontend-fir/testData/symbolsByPsi/implicitReturn.kt b/idea/idea-frontend-fir/testData/symbolsByPsi/implicitReturn.kt index f044fbf1734..4cc39a204e0 100644 --- a/idea/idea-frontend-fir/testData/symbolsByPsi/implicitReturn.kt +++ b/idea/idea-frontend-fir/testData/symbolsByPsi/implicitReturn.kt @@ -3,6 +3,7 @@ fun foo(): Int = 10 // SYMBOLS: /* KtFirFunctionSymbol: + annotatedType: [] kotlin/Int annotations: [] callableIdIfNonLocal: foo isExtension: false @@ -14,9 +15,8 @@ KtFirFunctionSymbol: modality: FINAL name: foo origin: SOURCE - receiverTypeAndAnnotations: null + receiverType: null symbolKind: TOP_LEVEL - type: kotlin/Int typeParameters: [] valueParameters: [] visibility: PUBLIC diff --git a/idea/idea-frontend-fir/testData/symbolsByPsi/localDeclarations.kt b/idea/idea-frontend-fir/testData/symbolsByPsi/localDeclarations.kt index db3272312ed..4dadc23c08f 100644 --- a/idea/idea-frontend-fir/testData/symbolsByPsi/localDeclarations.kt +++ b/idea/idea-frontend-fir/testData/symbolsByPsi/localDeclarations.kt @@ -8,13 +8,14 @@ fun yyy() { // SYMBOLS: /* KtFirLocalVariableSymbol: + annotatedType: [] kotlin/Int isVal: true name: q origin: SOURCE symbolKind: LOCAL - type: kotlin/Int KtFirFunctionSymbol: + annotatedType: [] kotlin/Unit annotations: [] callableIdIfNonLocal: null isExtension: false @@ -26,9 +27,8 @@ KtFirFunctionSymbol: modality: FINAL name: aaa origin: SOURCE - receiverTypeAndAnnotations: null + receiverType: null symbolKind: LOCAL - type: kotlin/Unit typeParameters: [] valueParameters: [] visibility: LOCAL @@ -43,12 +43,13 @@ KtFirClassOrObjectSymbol: name: F origin: SOURCE primaryConstructor: KtFirConstructorSymbol() - superTypes: [kotlin/Any] + superTypes: [[] kotlin/Any] symbolKind: LOCAL typeParameters: [] visibility: LOCAL KtFirFunctionSymbol: + annotatedType: [] kotlin/Unit annotations: [] callableIdIfNonLocal: yyy isExtension: false @@ -60,9 +61,8 @@ KtFirFunctionSymbol: modality: FINAL name: yyy origin: SOURCE - receiverTypeAndAnnotations: null + receiverType: null symbolKind: TOP_LEVEL - type: kotlin/Unit typeParameters: [] valueParameters: [] visibility: PUBLIC diff --git a/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/fir/AbstractResolveCallTest.kt b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/fir/AbstractResolveCallTest.kt index 0caa225b8d4..3bfc101f4de 100644 --- a/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/fir/AbstractResolveCallTest.kt +++ b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/fir/AbstractResolveCallTest.kt @@ -100,12 +100,12 @@ private fun KtCall.stringRepresentation(): String { if (valueParameters.isNotEmpty()) append(", ") } valueParameters.joinTo(this) { parameter -> - "${parameter.name}: ${parameter.typeAndAnnotations.type.render()}" + "${parameter.name}: ${parameter.annotatedType.type.render()}" } append(")") - append(": ${typeAndAnnotations.type.render()}") + append(": ${annotatedType.type.render()}") } - is KtParameterSymbol -> "$name: ${typeAndAnnotations.type.render()}" + is KtParameterSymbol -> "$name: ${annotatedType.type.render()}" is KtSuccessCallTarget -> symbol.stringValue() is KtErrorCallTarget -> "ERR<${this.diagnostic.message}, [${candidates.joinToString { it.stringValue() }}]>" is Boolean -> toString() From 63aa8092800471d8f88b807df139a28734b67ced Mon Sep 17 00:00:00 2001 From: Igor Yakovlev Date: Thu, 17 Dec 2020 20:55:36 +0300 Subject: [PATCH 152/196] [FIR IDE] Add fir type annotations test --- .../testData/symbolsByPsi/typeAnnotations.kt | 159 ++++++++++++++++++ .../SymbolsByPsiBuildingTestGenerated.java | 5 + 2 files changed, 164 insertions(+) create mode 100644 idea/idea-frontend-fir/testData/symbolsByPsi/typeAnnotations.kt diff --git a/idea/idea-frontend-fir/testData/symbolsByPsi/typeAnnotations.kt b/idea/idea-frontend-fir/testData/symbolsByPsi/typeAnnotations.kt new file mode 100644 index 00000000000..8a9da363095 --- /dev/null +++ b/idea/idea-frontend-fir/testData/symbolsByPsi/typeAnnotations.kt @@ -0,0 +1,159 @@ + +@Target(AnnotationTarget.TYPE) +annotation class Anno1 +@Target(AnnotationTarget.TYPE) +annotation class Anno2 +@Target(AnnotationTarget.TYPE) +annotation class Anno3 +@Target(AnnotationTarget.TYPE) +annotation class Anno4 + +interface I + +class X : @Anno1 I { + fun f(arg: @Anno2 I): @Anno3 I = arg + val x: @Anno4 I = this +} + +// SYMBOLS: +/* +KtFirClassOrObjectSymbol: + annotations: [kotlin/annotation/Target(allowedTargets = KtUnsupportedConstantValue)] + classIdIfNonLocal: Anno1 + classKind: ANNOTATION_CLASS + companionObject: null + isInner: false + modality: FINAL + name: Anno1 + origin: SOURCE + primaryConstructor: KtFirConstructorSymbol() + superTypes: [[] kotlin/Annotation] + symbolKind: TOP_LEVEL + typeParameters: [] + visibility: PUBLIC + +KtFirClassOrObjectSymbol: + annotations: [kotlin/annotation/Target(allowedTargets = KtUnsupportedConstantValue)] + classIdIfNonLocal: Anno2 + classKind: ANNOTATION_CLASS + companionObject: null + isInner: false + modality: FINAL + name: Anno2 + origin: SOURCE + primaryConstructor: KtFirConstructorSymbol() + superTypes: [[] kotlin/Annotation] + symbolKind: TOP_LEVEL + typeParameters: [] + visibility: PUBLIC + +KtFirClassOrObjectSymbol: + annotations: [kotlin/annotation/Target(allowedTargets = KtUnsupportedConstantValue)] + classIdIfNonLocal: Anno3 + classKind: ANNOTATION_CLASS + companionObject: null + isInner: false + modality: FINAL + name: Anno3 + origin: SOURCE + primaryConstructor: KtFirConstructorSymbol() + superTypes: [[] kotlin/Annotation] + symbolKind: TOP_LEVEL + typeParameters: [] + visibility: PUBLIC + +KtFirClassOrObjectSymbol: + annotations: [kotlin/annotation/Target(allowedTargets = KtUnsupportedConstantValue)] + classIdIfNonLocal: Anno4 + classKind: ANNOTATION_CLASS + companionObject: null + isInner: false + modality: FINAL + name: Anno4 + origin: SOURCE + primaryConstructor: KtFirConstructorSymbol() + superTypes: [[] kotlin/Annotation] + symbolKind: TOP_LEVEL + typeParameters: [] + visibility: PUBLIC + +KtFirClassOrObjectSymbol: + annotations: [] + classIdIfNonLocal: I + classKind: INTERFACE + companionObject: null + isInner: false + modality: ABSTRACT + name: I + origin: SOURCE + primaryConstructor: null + superTypes: [[] kotlin/Any] + symbolKind: TOP_LEVEL + typeParameters: [] + visibility: PUBLIC + +KtFirFunctionValueParameterSymbol: + annotatedType: [Anno2()] I + annotations: [] + hasDefaultValue: false + isVararg: false + name: arg + origin: SOURCE + symbolKind: NON_PROPERTY_PARAMETER + +KtFirFunctionSymbol: + annotatedType: [Anno3()] I + annotations: [] + callableIdIfNonLocal: X.f + isExtension: false + isExternal: false + isInline: false + isOperator: false + isOverride: false + isSuspend: false + modality: FINAL + name: f + origin: SOURCE + receiverType: null + symbolKind: MEMBER + typeParameters: [] + valueParameters: [KtFirFunctionValueParameterSymbol(arg)] + visibility: PUBLIC + +KtFirKotlinPropertySymbol: + annotatedType: [Anno4()] I + annotations: [] + callableIdIfNonLocal: X.x + getter: KtFirPropertyGetterSymbol() + hasBackingField: true + hasGetter: true + hasSetter: false + initializer: KtUnsupportedConstantValue + isConst: false + isExtension: false + isLateInit: false + isOverride: false + isVal: true + modality: FINAL + name: x + origin: SOURCE + receiverType: null + setter: null + symbolKind: MEMBER + visibility: PUBLIC + +KtFirClassOrObjectSymbol: + annotations: [] + classIdIfNonLocal: X + classKind: CLASS + companionObject: null + isInner: false + modality: FINAL + name: X + origin: SOURCE + primaryConstructor: KtFirConstructorSymbol() + superTypes: [[Anno1()] I] + symbolKind: TOP_LEVEL + typeParameters: [] + visibility: PUBLIC +*/ diff --git a/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/symbols/SymbolsByPsiBuildingTestGenerated.java b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/symbols/SymbolsByPsiBuildingTestGenerated.java index 6a5b31bd59c..bab8fcbd38c 100644 --- a/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/symbols/SymbolsByPsiBuildingTestGenerated.java +++ b/idea/idea-frontend-fir/tests/org/jetbrains/kotlin/idea/frontend/api/symbols/SymbolsByPsiBuildingTestGenerated.java @@ -78,4 +78,9 @@ public class SymbolsByPsiBuildingTestGenerated extends AbstractSymbolsByPsiBuild public void testLocalDeclarations() throws Exception { runTest("idea/idea-frontend-fir/testData/symbolsByPsi/localDeclarations.kt"); } + + @TestMetadata("typeAnnotations.kt") + public void testTypeAnnotations() throws Exception { + runTest("idea/idea-frontend-fir/testData/symbolsByPsi/typeAnnotations.kt"); + } } From f0ab8bc332a60c911a348cc5b664031f18a23438 Mon Sep 17 00:00:00 2001 From: Victor Petukhov Date: Fri, 27 Nov 2020 11:44:34 +0300 Subject: [PATCH 153/196] Clean up some code in `compiler.resolution.common.jvm` --- .../structure/impl/classFiles/Annotations.kt | 52 +++++++++---------- .../classFiles/BinaryClassSignatureParser.kt | 38 +++++++------- 2 files changed, 44 insertions(+), 46 deletions(-) diff --git a/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/Annotations.kt b/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/Annotations.kt index e1ac5a9cb6c..b4f33417d63 100644 --- a/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/Annotations.kt +++ b/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/Annotations.kt @@ -25,11 +25,11 @@ import org.jetbrains.org.objectweb.asm.* import java.lang.reflect.Array internal class AnnotationsAndParameterCollectorMethodVisitor( - private val member: BinaryJavaMethodBase, - private val context: ClassifierResolutionContext, - private val signatureParser: BinaryClassSignatureParser, - private val parametersToSkipNumber: Int, - private val parametersCountInMethodDesc: Int + private val member: BinaryJavaMethodBase, + private val context: ClassifierResolutionContext, + private val signatureParser: BinaryClassSignatureParser, + private val parametersToSkipNumber: Int, + private val parametersCountInMethodDesc: Int ) : MethodVisitor(ASM_API_VERSION_FOR_CLASS_READING) { private var parameterIndex = 0 @@ -106,17 +106,17 @@ internal class AnnotationsAndParameterCollectorMethodVisitor( } class BinaryJavaAnnotation private constructor( - desc: String, - private val context: ClassifierResolutionContext, - override val arguments: Collection + desc: String, + private val context: ClassifierResolutionContext, + override val arguments: Collection ) : JavaAnnotation { companion object { fun createAnnotationAndVisitor( - desc: String, - context: ClassifierResolutionContext, - signatureParser: BinaryClassSignatureParser + desc: String, + context: ClassifierResolutionContext, + signatureParser: BinaryClassSignatureParser ): Pair { val arguments = mutableListOf() val annotation = BinaryJavaAnnotation(desc, context, arguments) @@ -155,9 +155,9 @@ class BinaryJavaAnnotation private constructor( context.resolveByInternalName(Type.getType(desc).internalName) } - override val classId: ClassId? + override val classId: ClassId get() = classifierResolutionResult.classifier.safeAs()?.classId - ?: ClassId.topLevel(FqName(classifierResolutionResult.qualifiedName)) + ?: ClassId.topLevel(FqName(classifierResolutionResult.qualifiedName)) override fun resolve() = classifierResolutionResult.classifier as? JavaClass } @@ -224,37 +224,37 @@ abstract class PlainJavaAnnotationArgument(name: String?) : JavaAnnotationArgume } class PlainJavaLiteralAnnotationArgument( - name: String?, - override val value: Any? + name: String?, + override val value: Any? ) : PlainJavaAnnotationArgument(name), JavaLiteralAnnotationArgument class PlainJavaClassObjectAnnotationArgument( - name: String?, - private val type: Type, - private val signatureParser: BinaryClassSignatureParser, - private val context: ClassifierResolutionContext + name: String?, + private val type: Type, + private val signatureParser: BinaryClassSignatureParser, + private val context: ClassifierResolutionContext ) : PlainJavaAnnotationArgument(name), JavaClassObjectAnnotationArgument { override fun getReferencedType() = signatureParser.mapAsmType(type, context) } class PlainJavaArrayAnnotationArgument( - name: String?, - private val elements: List + name: String?, + private val elements: List ) : PlainJavaAnnotationArgument(name), JavaArrayAnnotationArgument { override fun getElements(): List = elements } class PlainJavaAnnotationAsAnnotationArgument( - name: String?, - private val annotation: JavaAnnotation + name: String?, + private val annotation: JavaAnnotation ) : PlainJavaAnnotationArgument(name), JavaAnnotationAsAnnotationArgument { override fun getAnnotation() = annotation } class PlainJavaEnumValueAnnotationArgument( - name: String?, - override val enumClassId: ClassId, - entryName: String + name: String?, + override val enumClassId: ClassId, + entryName: String ) : PlainJavaAnnotationArgument(name), JavaEnumValueAnnotationArgument { override val entryName = Name.identifier(entryName) } diff --git a/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/BinaryClassSignatureParser.kt b/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/BinaryClassSignatureParser.kt index 3e5d23c7580..13448788ce3 100644 --- a/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/BinaryClassSignatureParser.kt +++ b/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/BinaryClassSignatureParser.kt @@ -105,8 +105,8 @@ class BinaryClassSignatureParser { } private fun parseParameterizedClassRefSignature( - signature: CharacterIterator, - context: ClassifierResolutionContext + signature: CharacterIterator, + context: ClassifierResolutionContext ): JavaClassifierType { val canonicalName = StringBuilder() @@ -120,12 +120,10 @@ class BinaryClassSignatureParser { signature.next() do { group.add(parseClassOrTypeVariableElement(signature, context)) - } - while (signature.current() != '>') + } while (signature.current() != '>') argumentGroups.add(group) - } - else if (c != ' ') { + } else if (c != ' ') { canonicalName.append(c) } signature.next() @@ -199,21 +197,21 @@ class BinaryClassSignatureParser { fun mapAsmType(type: Type, context: ClassifierResolutionContext) = parseTypeString(StringCharacterIterator(type.descriptor), context) private fun parseTypeWithoutVarianceAndArray(signature: CharacterIterator, context: ClassifierResolutionContext) = - when (signature.current()) { - 'L' -> parseParameterizedClassRefSignature(signature, context) - 'T' -> parseTypeVariableRefSignature(signature, context) + when (signature.current()) { + 'L' -> parseParameterizedClassRefSignature(signature, context) + 'T' -> parseTypeVariableRefSignature(signature, context) - 'B' -> parsePrimitiveType(signature, PrimitiveType.BYTE) - 'C' -> parsePrimitiveType(signature, PrimitiveType.CHAR) - 'D' -> parsePrimitiveType(signature, PrimitiveType.DOUBLE) - 'F' -> parsePrimitiveType(signature, PrimitiveType.FLOAT) - 'I' -> parsePrimitiveType(signature, PrimitiveType.INT) - 'J' -> parsePrimitiveType(signature, PrimitiveType.LONG) - 'Z' -> parsePrimitiveType(signature, PrimitiveType.BOOLEAN) - 'S' -> parsePrimitiveType(signature, PrimitiveType.SHORT) - 'V' -> parsePrimitiveType(signature, null) - else -> null - } + 'B' -> parsePrimitiveType(signature, PrimitiveType.BYTE) + 'C' -> parsePrimitiveType(signature, PrimitiveType.CHAR) + 'D' -> parsePrimitiveType(signature, PrimitiveType.DOUBLE) + 'F' -> parsePrimitiveType(signature, PrimitiveType.FLOAT) + 'I' -> parsePrimitiveType(signature, PrimitiveType.INT) + 'J' -> parsePrimitiveType(signature, PrimitiveType.LONG) + 'Z' -> parsePrimitiveType(signature, PrimitiveType.BOOLEAN) + 'S' -> parsePrimitiveType(signature, PrimitiveType.SHORT) + 'V' -> parsePrimitiveType(signature, null) + else -> null + } private fun parsePrimitiveType(signature: CharacterIterator, primitiveType: PrimitiveType?): JavaType { signature.next() From 0833719a79986462f01f18de4904f65fab91f539 Mon Sep 17 00:00:00 2001 From: Victor Petukhov Date: Fri, 27 Nov 2020 11:54:23 +0300 Subject: [PATCH 154/196] Support annotations on array types ^KT-24392 Fixed ^KT-18768 Fixed --- .../kotlin/load/java/lazy/types/JavaTypeResolver.kt | 12 +++++++++--- .../jetbrains/kotlin/builtins/KotlinBuiltIns.java | 9 +++++++-- 2 files changed, 16 insertions(+), 5 deletions(-) diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/types/JavaTypeResolver.kt b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/types/JavaTypeResolver.kt index 42a53d7ac78..2bdc2baecda 100644 --- a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/types/JavaTypeResolver.kt +++ b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/types/JavaTypeResolver.kt @@ -19,6 +19,7 @@ package org.jetbrains.kotlin.load.java.lazy.types import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMapper import org.jetbrains.kotlin.descriptors.ClassDescriptor import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor +import org.jetbrains.kotlin.descriptors.annotations.Annotations import org.jetbrains.kotlin.load.java.components.TypeUsage import org.jetbrains.kotlin.load.java.components.TypeUsage.COMMON import org.jetbrains.kotlin.load.java.components.TypeUsage.SUPERTYPE @@ -61,8 +62,13 @@ class JavaTypeResolver( fun transformArrayType(arrayType: JavaArrayType, attr: JavaTypeAttributes, isVararg: Boolean = false): KotlinType { val javaComponentType = arrayType.componentType val primitiveType = (javaComponentType as? JavaPrimitiveType)?.type + val annotations = LazyJavaAnnotations(c, arrayType) + if (primitiveType != null) { val jetType = c.module.builtIns.getPrimitiveArrayKotlinType(primitiveType) + + jetType.replaceAnnotations(Annotations.create(annotations + jetType.annotations)) + return if (attr.isForAnnotationParameter) jetType else KotlinTypeFactory.flexibleType(jetType, jetType.makeNullableAsSpecified(true)) @@ -75,12 +81,12 @@ class JavaTypeResolver( if (attr.isForAnnotationParameter) { val projectionKind = if (isVararg) OUT_VARIANCE else INVARIANT - return c.module.builtIns.getArrayType(projectionKind, componentType) + return c.module.builtIns.getArrayType(projectionKind, componentType, annotations) } return KotlinTypeFactory.flexibleType( - c.module.builtIns.getArrayType(INVARIANT, componentType), - c.module.builtIns.getArrayType(OUT_VARIANCE, componentType).makeNullableAsSpecified(true) + c.module.builtIns.getArrayType(INVARIANT, componentType, annotations), + c.module.builtIns.getArrayType(OUT_VARIANCE, componentType, annotations).makeNullableAsSpecified(true) ) } diff --git a/core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java b/core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java index d0bfb5fcaf8..8c65ca36014 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java +++ b/core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java @@ -653,9 +653,14 @@ public abstract class KotlinBuiltIns { } @NotNull - public SimpleType getArrayType(@NotNull Variance projectionType, @NotNull KotlinType argument) { + public SimpleType getArrayType(@NotNull Variance projectionType, @NotNull KotlinType argument, @NotNull Annotations annotations) { List types = Collections.singletonList(new TypeProjectionImpl(projectionType, argument)); - return KotlinTypeFactory.simpleNotNullType(Annotations.Companion.getEMPTY(), getArray(), types); + return KotlinTypeFactory.simpleNotNullType(annotations, getArray(), types); + } + + @NotNull + public SimpleType getArrayType(@NotNull Variance projectionType, @NotNull KotlinType argument) { + return getArrayType(projectionType, argument, Annotations.Companion.getEMPTY()); } @NotNull From a89329e07757d85f62f66f45c6141ab1e120d971 Mon Sep 17 00:00:00 2001 From: Victor Petukhov Date: Tue, 1 Dec 2020 18:21:44 +0300 Subject: [PATCH 155/196] Support reading from class files of the type use annotations on type parameters and type arguments ^KT-11454 Fixed --- .../structure/impl/classFiles/Annotations.kt | 128 +++++++++++----- .../classFiles/BinaryClassSignatureParser.kt | 15 +- .../impl/classFiles/BinaryJavaClass.kt | 52 ++++++- .../impl/classFiles/BinaryJavaClass.kt.201 | 57 ++++--- .../java/structure/impl/classFiles/Methods.kt | 126 ++++++++-------- .../java/structure/impl/classFiles/Other.kt | 36 +++-- .../java/structure/impl/classFiles/Types.kt | 35 ++--- .../TypeParameterAnnotations.javac.txt | 14 -- .../TypeParameterAnnotations.runtime.txt | 14 -- .../Basic.java} | 12 +- .../typeParameterAnnotations/Basic.javac.txt | 14 ++ .../Basic.runtime.txt | 14 ++ .../typeParameterAnnotations/Basic.txt | 19 +++ .../BaseClassTypeArguments.java | 26 ++++ .../BaseClassTypeArguments.txt | 39 +++++ .../typeUseAnnotations/Basic.java} | 2 +- .../typeUseAnnotations/Basic.txt} | 8 +- .../ClassTypeParameterBounds.java | 33 +++++ .../ClassTypeParameterBounds.txt | 61 ++++++++ .../typeUseAnnotations/MethodReceiver.java | 23 +++ .../typeUseAnnotations/MethodReceiver.txt | 16 ++ .../MethodTypeParameterBounds.java | 33 +++++ .../MethodTypeParameterBounds.txt | 37 +++++ .../typeUseAnnotations/ReturnType.java | 95 ++++++++++++ .../typeUseAnnotations/ReturnType.txt | 88 +++++++++++ .../typeUseAnnotations/ValueArguments.java | 117 +++++++++++++++ .../typeUseAnnotations/ValueArguments.txt | 99 +++++++++++++ .../typeParameterAnnotations/Basic.java | 22 +++ .../typeParameterAnnotations/Basic.javac.txt} | 8 +- .../Basic.runtime.txt | 14 ++ .../typeParameterAnnotations/Basic.txt | 19 +++ .../BaseClassTypeArguments.java | 26 ++++ .../BaseClassTypeArguments.txt | 17 +++ .../typeUseAnnotations/Basic.java} | 4 +- .../typeUseAnnotations/Basic.txt} | 8 +- .../ClassTypeParameterBounds.java | 33 +++++ .../ClassTypeParameterBounds.txt | 56 +++++++ .../typeUseAnnotations/MethodReceiver.java | 23 +++ .../typeUseAnnotations/MethodReceiver.txt | 11 ++ .../MethodTypeParameterBounds.java | 33 +++++ .../MethodTypeParameterBounds.txt | 32 ++++ .../typeUseAnnotations/ReturnType.java | 95 ++++++++++++ .../typeUseAnnotations/ReturnType.txt | 74 ++++++++++ .../typeUseAnnotations/ValueArguments.java | 117 +++++++++++++++ .../typeUseAnnotations/ValueArguments.txt | 85 +++++++++++ .../jvm/compiler/LoadJava8TestGenerated.java | 139 ++++++++++++++++-- ...Java8WithPsiClassReadingTestGenerated.java | 68 ++++++++- .../LoadJava8UsingJavacTestGenerated.java | 139 ++++++++++++++++-- .../load/java/structure/javaElements.kt | 16 +- .../kotlin/load/java/structure/javaTypes.kt | 4 +- .../runtime/structure/ReflectJavaArrayType.kt | 5 + .../structure/ReflectJavaPrimitiveType.kt | 5 + .../structure/ReflectJavaWildcardType.kt | 5 + ...8RuntimeDescriptorLoaderTestGenerated.java | 68 ++++++++- 54 files changed, 2077 insertions(+), 262 deletions(-) delete mode 100644 compiler/testData/loadJava8/compiledJava/TypeParameterAnnotations.javac.txt delete mode 100644 compiler/testData/loadJava8/compiledJava/TypeParameterAnnotations.runtime.txt rename compiler/testData/loadJava8/compiledJava/{TypeParameterAnnotations.java => typeParameterAnnotations/Basic.java} (52%) create mode 100644 compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic.javac.txt create mode 100644 compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic.runtime.txt create mode 100644 compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic.txt create mode 100644 compiler/testData/loadJava8/compiledJava/typeUseAnnotations/BaseClassTypeArguments.java create mode 100644 compiler/testData/loadJava8/compiledJava/typeUseAnnotations/BaseClassTypeArguments.txt rename compiler/testData/loadJava8/{sourceJava/TypeAnnotations.java => compiledJava/typeUseAnnotations/Basic.java} (91%) rename compiler/testData/loadJava8/{sourceJava/TypeAnnotations.txt => compiledJava/typeUseAnnotations/Basic.txt} (57%) create mode 100644 compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ClassTypeParameterBounds.java create mode 100644 compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ClassTypeParameterBounds.txt create mode 100644 compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodReceiver.java create mode 100644 compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodReceiver.txt create mode 100644 compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodTypeParameterBounds.java create mode 100644 compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodTypeParameterBounds.txt create mode 100644 compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ReturnType.java create mode 100644 compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ReturnType.txt create mode 100644 compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ValueArguments.java create mode 100644 compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ValueArguments.txt create mode 100644 compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic.java rename compiler/testData/loadJava8/{compiledJava/TypeParameterAnnotations.txt => sourceJava/typeParameterAnnotations/Basic.javac.txt} (54%) create mode 100644 compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic.runtime.txt create mode 100644 compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic.txt create mode 100644 compiler/testData/loadJava8/sourceJava/typeUseAnnotations/BaseClassTypeArguments.java create mode 100644 compiler/testData/loadJava8/sourceJava/typeUseAnnotations/BaseClassTypeArguments.txt rename compiler/testData/loadJava8/{compiledJava/TypeAnnotations.java => sourceJava/typeUseAnnotations/Basic.java} (59%) rename compiler/testData/loadJava8/{compiledJava/TypeAnnotations.txt => sourceJava/typeUseAnnotations/Basic.txt} (62%) create mode 100644 compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ClassTypeParameterBounds.java create mode 100644 compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ClassTypeParameterBounds.txt create mode 100644 compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodReceiver.java create mode 100644 compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodReceiver.txt create mode 100644 compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodTypeParameterBounds.java create mode 100644 compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodTypeParameterBounds.txt create mode 100644 compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ReturnType.java create mode 100644 compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ReturnType.txt create mode 100644 compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ValueArguments.java create mode 100644 compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ValueArguments.txt diff --git a/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/Annotations.kt b/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/Annotations.kt index b4f33417d63..2cae0ecc160 100644 --- a/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/Annotations.kt +++ b/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/Annotations.kt @@ -17,6 +17,7 @@ package org.jetbrains.kotlin.load.java.structure.impl.classFiles import org.jetbrains.kotlin.load.java.structure.* +import org.jetbrains.kotlin.load.java.structure.impl.classFiles.BinaryJavaAnnotation.Companion.computeTargetType import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name @@ -56,10 +57,7 @@ internal class AnnotationsAndParameterCollectorMethodVisitor( } override fun visitAnnotation(desc: String, visible: Boolean) = - BinaryJavaAnnotation.addAnnotation( - member.annotations as MutableCollection, - desc, context, signatureParser - ) + BinaryJavaAnnotation.addAnnotation(member, desc, context, signatureParser) @Suppress("NOTHING_TO_OVERRIDE") override fun visitAnnotableParameterCount(parameterCount: Int, visible: Boolean) { @@ -76,33 +74,38 @@ internal class AnnotationsAndParameterCollectorMethodVisitor( val index = absoluteParameterIndex - parametersToSkipNumber if (index < 0) return null - val annotations = - member.valueParameters[index].annotations as MutableCollection? - ?: return null - - return BinaryJavaAnnotation.addAnnotation(annotations, desc, context, signatureParser) + return BinaryJavaAnnotation.addAnnotation(member.valueParameters[index], desc, context, signatureParser) } override fun visitTypeAnnotation(typeRef: Int, typePath: TypePath?, desc: String, visible: Boolean): AnnotationVisitor? { - // TODO: support annotations on type arguments - if (typePath != null) return null - val typeReference = TypeReference(typeRef) - return when (typeReference.sort) { - TypeReference.METHOD_RETURN -> member.safeAs()?.returnType?.let { - BinaryJavaAnnotation.addTypeAnnotation(it, desc, context, signatureParser) - } + if (typePath != null) { + val baseType = when (typeReference.sort) { + TypeReference.METHOD_RETURN -> member.safeAs()?.returnType + TypeReference.METHOD_FORMAL_PARAMETER -> member.valueParameters[typeReference.formalParameterIndex].type + TypeReference.METHOD_TYPE_PARAMETER_BOUND -> + BinaryJavaAnnotation.computeTypeParameterBound(member.typeParameters, typeReference) + else -> null + } ?: return null - TypeReference.METHOD_FORMAL_PARAMETER -> - BinaryJavaAnnotation.addTypeAnnotation( - member.valueParameters[typeReference.formalParameterIndex].type, - desc, context, signatureParser - ) - - else -> null + return BinaryJavaAnnotation.addAnnotation( + computeTargetType(baseType, translatePath(typePath)) as JavaPlainType, desc, context, signatureParser + ) } + + val targetType = when (typeReference.sort) { + TypeReference.METHOD_RETURN -> (member as? BinaryJavaMethod)?.returnType as JavaPlainType + TypeReference.METHOD_TYPE_PARAMETER -> member.typeParameters[typeReference.typeParameterIndex] as BinaryJavaTypeParameter + TypeReference.METHOD_FORMAL_PARAMETER -> member.valueParameters[typeReference.formalParameterIndex].type as JavaPlainType + TypeReference.METHOD_TYPE_PARAMETER_BOUND -> BinaryJavaAnnotation.computeTypeParameterBound(member.typeParameters, typeReference) as JavaPlainType + else -> null + } ?: return null + + return BinaryJavaAnnotation.addAnnotation(targetType, desc, context, signatureParser) } + + enum class PathElementType { ARRAY_ELEMENT, WILDCARD_BOUND, ENCLOSING_CLASS, TYPE_ARGUMENT } } class BinaryJavaAnnotation private constructor( @@ -125,29 +128,76 @@ class BinaryJavaAnnotation private constructor( } fun addAnnotation( - annotations: MutableCollection, - desc: String, - context: ClassifierResolutionContext, - signatureParser: BinaryClassSignatureParser + annotationOwner: MutableJavaAnnotationOwner, + desc: String, + context: ClassifierResolutionContext, + signatureParser: BinaryClassSignatureParser ): AnnotationVisitor { val (javaAnnotation, annotationVisitor) = createAnnotationAndVisitor(desc, context, signatureParser) - annotations.add(javaAnnotation) - + annotationOwner.annotations.add(javaAnnotation) return annotationVisitor } - fun addTypeAnnotation( - type: JavaType, - desc: String, - context: ClassifierResolutionContext, - signatureParser: BinaryClassSignatureParser - ): AnnotationVisitor? { - type as? PlainJavaClassifierType ?: return null + internal fun translatePath(path: TypePath): List> { + val length = path.length + val list = mutableListOf>() + for (i in 0 until length) { + when (path.getStep(i)) { + TypePath.INNER_TYPE -> { + continue + } + TypePath.ARRAY_ELEMENT -> { + list.add(AnnotationsAndParameterCollectorMethodVisitor.PathElementType.ARRAY_ELEMENT to null) + } + TypePath.WILDCARD_BOUND -> { + list.add(AnnotationsAndParameterCollectorMethodVisitor.PathElementType.WILDCARD_BOUND to null) + } + TypePath.TYPE_ARGUMENT -> { + list.add(AnnotationsAndParameterCollectorMethodVisitor.PathElementType.TYPE_ARGUMENT to path.getStepArgument(i)) + } + } + } + return list + } - val (javaAnnotation, annotationVisitor) = createAnnotationAndVisitor(desc, context, signatureParser) - type.addAnnotation(javaAnnotation) + internal fun computeTargetType( + baseType: JavaType, + typePath: List> + ): JavaType { + var targetType = baseType - return annotationVisitor + for (element in typePath) { + when (element.first) { + AnnotationsAndParameterCollectorMethodVisitor.PathElementType.TYPE_ARGUMENT -> { + if (targetType is JavaClassifierType) { + targetType = targetType.typeArguments[element.second!!]!! + } + } + AnnotationsAndParameterCollectorMethodVisitor.PathElementType.WILDCARD_BOUND -> { + if (targetType is JavaWildcardType) { + targetType = targetType.bound!! + } + } + AnnotationsAndParameterCollectorMethodVisitor.PathElementType.ARRAY_ELEMENT -> { + if (targetType is JavaArrayType) { + targetType = targetType.componentType + } + } + } + } + + return targetType + } + + internal fun computeTypeParameterBound( + typeParameters: List, + typeReference: TypeReference + ): JavaClassifierType { + val typeParameter = typeParameters[typeReference.typeParameterIndex] as BinaryJavaTypeParameter + val boundIndex = + if (typeParameter.hasImplicitObjectClassBound) typeReference.typeParameterBoundIndex - 1 else typeReference.typeParameterBoundIndex + + return typeParameters[typeReference.typeParameterIndex].upperBounds.toList()[boundIndex] } } diff --git a/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/BinaryClassSignatureParser.kt b/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/BinaryClassSignatureParser.kt index 13448788ce3..7fd5be448e6 100644 --- a/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/BinaryClassSignatureParser.kt +++ b/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/BinaryClassSignatureParser.kt @@ -66,13 +66,20 @@ class BinaryClassSignatureParser { // postpone list allocation till a second bound is seen; ignore sole Object bound val bounds: MutableList = SmartList() + var hasImplicitObjectBound = false while (signature.current() == ':') { signature.next() - val bound = parseClassifierRefSignature(signature, context) ?: continue - bounds.add(bound) + + // '::' means that the implicit object bound is between ':' + if (signature.current() == ':') { + hasImplicitObjectBound = true + continue + } + + bounds.add(parseClassifierRefSignature(signature, context) ?: continue) } - return BinaryJavaTypeParameter(Name.identifier(parameterName), bounds) + return BinaryJavaTypeParameter(Name.identifier(parameterName), bounds, hasImplicitObjectBound) } fun parseClassifierRefSignature(signature: CharacterIterator, context: ClassifierResolutionContext): JavaClassifierType? { @@ -83,7 +90,7 @@ class BinaryClassSignatureParser { } } - private fun parseTypeVariableRefSignature(signature: CharacterIterator, context: ClassifierResolutionContext): JavaClassifierType? { + private fun parseTypeVariableRefSignature(signature: CharacterIterator, context: ClassifierResolutionContext): JavaClassifierType { val id = StringBuilder() signature.next() diff --git a/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/BinaryJavaClass.kt b/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/BinaryJavaClass.kt index 3dbf87805b9..06db541e6c2 100644 --- a/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/BinaryJavaClass.kt +++ b/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/BinaryJavaClass.kt @@ -22,6 +22,7 @@ import gnu.trove.THashMap import org.jetbrains.kotlin.builtins.PrimitiveType import org.jetbrains.kotlin.load.java.structure.* import org.jetbrains.kotlin.load.java.structure.impl.VirtualFileBoundJavaClass +import org.jetbrains.kotlin.load.java.structure.impl.classFiles.BinaryJavaAnnotation.Companion.computeTypeParameterBound import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.utils.SmartList @@ -38,12 +39,12 @@ class BinaryJavaClass( override var access: Int = 0, override val outerClass: JavaClass?, classContent: ByteArray? = null -) : ClassVisitor(ASM_API_VERSION_FOR_CLASS_READING), VirtualFileBoundJavaClass, BinaryJavaModifierListOwner, MapBasedJavaAnnotationOwner { - private lateinit var myInternalName: String - +) : ClassVisitor(ASM_API_VERSION_FOR_CLASS_READING), VirtualFileBoundJavaClass, BinaryJavaModifierListOwner, MutableJavaAnnotationOwner { override val annotations: MutableCollection = SmartList() + override lateinit var typeParameters: List - override lateinit var supertypes: Collection + override lateinit var supertypes: List + override val methods = arrayListOf() override val fields = arrayListOf() override val constructors = arrayListOf() @@ -51,6 +52,12 @@ class BinaryJavaClass( override fun hasDefaultConstructor() = false // never: all constructors explicit in bytecode + private lateinit var myInternalName: String + + // In accordance with JVMS, super class always comes before the interface list + private val superclass: JavaClassifierType? get() = supertypes.firstOrNull() + private val interfaces: List get() = supertypes.drop(1) + override val annotationsByFqName by buildLazyValueForMap() // Short name of a nested class of this class -> access flags as seen in the InnerClasses attribute value. @@ -75,6 +82,37 @@ class BinaryJavaClass( override fun isFromSourceCodeInScope(scope: SearchScope): Boolean = false + override fun visitTypeAnnotation(typeRef: Int, typePath: TypePath?, descriptor: String?, visible: Boolean): AnnotationVisitor? { + val typeReference = TypeReference(typeRef) + if (descriptor == null) + return null + + if (typePath != null) { + val translatedPath = BinaryJavaAnnotation.translatePath(typePath) + + when (typeReference.sort) { + TypeReference.CLASS_TYPE_PARAMETER_BOUND -> { + val baseType = computeTypeParameterBound(typeParameters, typeReference) + val targetType = BinaryJavaAnnotation.computeTargetType(baseType, translatedPath) + + return BinaryJavaAnnotation.addAnnotation(targetType as JavaPlainType, descriptor, context, signatureParser) + } + } + } + + return when (typeReference.sort) { + TypeReference.CLASS_TYPE_PARAMETER -> + BinaryJavaAnnotation.addAnnotation( + typeParameters[typeReference.typeParameterIndex] as BinaryJavaTypeParameter, descriptor, context, signatureParser + ) + TypeReference.CLASS_TYPE_PARAMETER_BOUND -> + BinaryJavaAnnotation.addAnnotation( + computeTypeParameterBound(typeParameters, typeReference) as JavaPlainType, descriptor, context, signatureParser + ) + else -> null + } + } + override fun visitEnd() { methods.trimToSize() fields.trimToSize() @@ -181,11 +219,11 @@ class BinaryJavaClass( object : FieldVisitor(ASM_API_VERSION_FOR_CLASS_READING) { override fun visitAnnotation(desc: String, visible: Boolean) = - BinaryJavaAnnotation.addAnnotation(this@run.annotations, desc, context, signatureParser) + BinaryJavaAnnotation.addAnnotation(this@run, desc, context, signatureParser) override fun visitTypeAnnotation(typeRef: Int, typePath: TypePath?, desc: String, visible: Boolean) = if (typePath == null) - BinaryJavaAnnotation.addTypeAnnotation(type, desc, context, signatureParser) + BinaryJavaAnnotation.addAnnotation(type as JavaPlainType, desc, context, signatureParser) else null } @@ -222,7 +260,7 @@ class BinaryJavaClass( } override fun visitAnnotation(desc: String, visible: Boolean) = - BinaryJavaAnnotation.addAnnotation(annotations, desc, context, signatureParser) + BinaryJavaAnnotation.addAnnotation(this, desc, context, signatureParser) override fun findInnerClass(name: Name): JavaClass? = findInnerClass(name, classFileContent = null) diff --git a/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/BinaryJavaClass.kt.201 b/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/BinaryJavaClass.kt.201 index 2c38ac263ee..8de96673afb 100644 --- a/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/BinaryJavaClass.kt.201 +++ b/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/BinaryJavaClass.kt.201 @@ -22,6 +22,7 @@ import gnu.trove.THashMap import org.jetbrains.kotlin.builtins.PrimitiveType import org.jetbrains.kotlin.load.java.structure.* import org.jetbrains.kotlin.load.java.structure.impl.VirtualFileBoundJavaClass +import org.jetbrains.kotlin.load.java.structure.impl.classFiles.BinaryJavaAnnotation.Companion.computeTypeParameterBound import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.utils.SmartList @@ -38,12 +39,12 @@ class BinaryJavaClass( override var access: Int = 0, override val outerClass: JavaClass?, classContent: ByteArray? = null -) : ClassVisitor(ASM_API_VERSION_FOR_CLASS_READING), VirtualFileBoundJavaClass, BinaryJavaModifierListOwner, MapBasedJavaAnnotationOwner { - private lateinit var myInternalName: String - +) : ClassVisitor(ASM_API_VERSION_FOR_CLASS_READING), VirtualFileBoundJavaClass, BinaryJavaModifierListOwner, MutableJavaAnnotationOwner { override val annotations: MutableCollection = SmartList() + override lateinit var typeParameters: List - override lateinit var supertypes: Collection + override lateinit var supertypes: List + override val methods = arrayListOf() override val fields = arrayListOf() override val constructors = arrayListOf() @@ -51,6 +52,12 @@ class BinaryJavaClass( override fun hasDefaultConstructor() = false // never: all constructors explicit in bytecode + private lateinit var myInternalName: String + + // In accordance with JVMS, super class always comes before the interface list + private val superclass: JavaClassifierType? get() = supertypes.firstOrNull() + private val implementedInterfaces: List get() = supertypes.drop(1) + override val annotationsByFqName by buildLazyValueForMap() // Short name of a nested class of this class -> access flags as seen in the InnerClasses attribute value. @@ -69,11 +76,34 @@ class BinaryJavaClass( override val isRecord get() = false override val lightClassOriginKind: LightClassOriginKind? get() = null + override val isSealed: Boolean get() = permittedTypes.isNotEmpty() override val permittedTypes = arrayListOf() override fun isFromSourceCodeInScope(scope: SearchScope): Boolean = false + override fun visitTypeAnnotation(typeRef: Int, typePath: TypePath?, descriptor: String?, visible: Boolean): AnnotationVisitor? { + if (descriptor == null) + return null + + fun getTargetType(baseType: JavaType) = + if (typePath != null) BinaryJavaAnnotation.computeTargetType(baseType, typePath) else baseType + + val typeReference = TypeReference(typeRef) + + val annotationOwner = when (typeReference.sort) { + TypeReference.CLASS_EXTENDS -> + getTargetType(if (typeReference.superTypeIndex == -1) superclass!! else implementedInterfaces[typeReference.superTypeIndex]) + TypeReference.CLASS_TYPE_PARAMETER -> typeParameters[typeReference.typeParameterIndex] + TypeReference.CLASS_TYPE_PARAMETER_BOUND -> getTargetType(computeTypeParameterBound(typeParameters, typeReference)) + else -> return null + } + + if (annotationOwner !is MutableJavaAnnotationOwner) return null + + return BinaryJavaAnnotation.addAnnotation(annotationOwner, descriptor, context, signatureParser, isFreshlySupportedAnnotation = true) + } + override fun visitEnd() { methods.trimToSize() fields.trimToSize() @@ -172,23 +202,12 @@ class BinaryJavaClass( if (access.isSet(Opcodes.ACC_SYNTHETIC)) return null val type = signatureParser.parseTypeString(StringCharacterIterator(signature ?: desc), context) - val processedValue = processValue(value, type) + val filed = BinaryJavaField(Name.identifier(name), access, this, access.isSet(Opcodes.ACC_ENUM), type, processedValue) - return BinaryJavaField(Name.identifier(name), access, this, access.isSet(Opcodes.ACC_ENUM), type, processedValue).run { - fields.add(this) + fields.add(filed) - object : FieldVisitor(ASM_API_VERSION_FOR_CLASS_READING) { - override fun visitAnnotation(desc: String, visible: Boolean) = - BinaryJavaAnnotation.addAnnotation(this@run.annotations, desc, context, signatureParser) - - override fun visitTypeAnnotation(typeRef: Int, typePath: TypePath?, desc: String, visible: Boolean) = - if (typePath == null) - BinaryJavaAnnotation.addTypeAnnotation(type, desc, context, signatureParser) - else - null - } - } + return AnnotationsCollectorFieldVisitor(filed, context, signatureParser) } /** @@ -211,7 +230,7 @@ class BinaryJavaClass( } override fun visitAnnotation(desc: String, visible: Boolean) = - BinaryJavaAnnotation.addAnnotation(annotations, desc, context, signatureParser) + BinaryJavaAnnotation.addAnnotation(this, desc, context, signatureParser) override fun findInnerClass(name: Name): JavaClass? = findInnerClass(name, classFileContent = null) diff --git a/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/Methods.kt b/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/Methods.kt index 77ef489fc6b..40dac89ef99 100644 --- a/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/Methods.kt +++ b/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/Methods.kt @@ -29,31 +29,30 @@ import java.text.CharacterIterator import java.text.StringCharacterIterator abstract class BinaryJavaMethodBase( - override val access: Int, - override val containingClass: JavaClass, - val valueParameters: List, - val typeParameters: List, - override val name: Name -) : JavaMember, MapBasedJavaAnnotationOwner, BinaryJavaModifierListOwner { + override val access: Int, + override val containingClass: JavaClass, + val valueParameters: List, + val typeParameters: List, + override val name: Name +) : JavaMember, BinaryJavaModifierListOwner, MutableJavaAnnotationOwner { + override val annotations: MutableCollection = SmartList() override val annotationsByFqName by buildLazyValueForMap() - override val annotations: Collection = SmartList() - companion object { private class MethodInfo( - val returnType: JavaType, - val typeParameters: List, - val valueParameterTypes: List + val returnType: JavaType, + val typeParameters: List, + val valueParameterTypes: List ) fun create( - name: String, - access: Int, - desc: String, - signature: String?, - containingClass: JavaClass, - parentContext: ClassifierResolutionContext, - signatureParser: BinaryClassSignatureParser + name: String, + access: Int, + desc: String, + signature: String?, + containingClass: JavaClass, + parentContext: ClassifierResolutionContext, + signatureParser: BinaryClassSignatureParser ): Pair { val isConstructor = "" == name val isVarargs = access.isSet(Opcodes.ACC_VARARGS) @@ -61,23 +60,23 @@ abstract class BinaryJavaMethodBase( val isInnerClassConstructor = isConstructor && containingClass.outerClass != null && !containingClass.isStatic val isEnumConstructor = containingClass.isEnum && isConstructor val info: MethodInfo = - if (signature != null) { - val contextForMethod = parentContext.copyForMember() - parseMethodSignature(signature, signatureParser, contextForMethod).also { - contextForMethod.addTypeParameters(it.typeParameters) - } - } else - parseMethodDescription(desc, parentContext, signatureParser).let { - when { - isEnumConstructor -> - // skip ordinal/name parameters for enum constructors - MethodInfo(it.returnType, it.typeParameters, it.valueParameterTypes.drop(2)) - isInnerClassConstructor -> - // omit synthetic inner class constructor parameter - MethodInfo(it.returnType, it.typeParameters, it.valueParameterTypes.drop(1)) - else -> it - } + if (signature != null) { + val contextForMethod = parentContext.copyForMember() + parseMethodSignature(signature, signatureParser, contextForMethod).also { + contextForMethod.addTypeParameters(it.typeParameters) + } + } else + parseMethodDescription(desc, parentContext, signatureParser).let { + when { + isEnumConstructor -> + // skip ordinal/name parameters for enum constructors + MethodInfo(it.returnType, it.typeParameters, it.valueParameterTypes.drop(2)) + isInnerClassConstructor -> + // omit synthetic inner class constructor parameter + MethodInfo(it.returnType, it.typeParameters, it.valueParameterTypes.drop(1)) + else -> it } + } val parameterTypes = info.valueParameterTypes val paramCount = parameterTypes.size @@ -87,15 +86,15 @@ abstract class BinaryJavaMethodBase( } val member: BinaryJavaMethodBase = - if (isConstructor) - BinaryJavaConstructor(access, containingClass, parameterList, info.typeParameters) - else - BinaryJavaMethod( - access, containingClass, - parameterList, - info.typeParameters, - Name.identifier(name), info.returnType - ) + if (isConstructor) + BinaryJavaConstructor(access, containingClass, parameterList, info.typeParameters) + else + BinaryJavaMethod( + access, containingClass, + parameterList, + info.typeParameters, + Name.identifier(name), info.returnType + ) val paramIgnoreCount = when { isEnumConstructor -> 2 @@ -114,9 +113,9 @@ abstract class BinaryJavaMethodBase( } private fun parseMethodDescription( - desc: String, - context: ClassifierResolutionContext, - signatureParser: BinaryClassSignatureParser + desc: String, + context: ClassifierResolutionContext, + signatureParser: BinaryClassSignatureParser ): MethodInfo { val returnType = signatureParser.mapAsmType(Type.getReturnType(desc), context) val parameterTypes = Type.getArgumentTypes(desc).map { signatureParser.mapAsmType(it, context) } @@ -125,9 +124,9 @@ abstract class BinaryJavaMethodBase( } private fun parseMethodSignature( - signature: String, - signatureParser: BinaryClassSignatureParser, - context: ClassifierResolutionContext + signature: String, + signatureParser: BinaryClassSignatureParser, + context: ClassifierResolutionContext ): MethodInfo { val iterator = StringCharacterIterator(signature) val typeParameters = signatureParser.parseTypeParametersDeclaration(iterator, context) @@ -137,8 +136,7 @@ abstract class BinaryJavaMethodBase( var paramTypes: List if (iterator.current() == ')') { paramTypes = emptyList() - } - else { + } else { paramTypes = mutableListOf() while (iterator.current() != ')' && iterator.current() != CharacterIterator.DONE) { paramTypes.add(signatureParser.parseTypeString(iterator, context)) @@ -157,14 +155,14 @@ abstract class BinaryJavaMethodBase( } class BinaryJavaMethod( - flags: Int, - containingClass: JavaClass, - valueParameters: List, - typeParameters: List, - name: Name, - override val returnType: JavaType + flags: Int, + containingClass: JavaClass, + valueParameters: List, + typeParameters: List, + name: Name, + override val returnType: JavaType ) : BinaryJavaMethodBase( - flags, containingClass, valueParameters, typeParameters, name + flags, containingClass, valueParameters, typeParameters, name ), JavaMethod { override var annotationParameterDefaultValue: JavaAnnotationArgument? = null internal set(value) { @@ -178,11 +176,11 @@ class BinaryJavaMethod( } class BinaryJavaConstructor( - flags: Int, - containingClass: JavaClass, - valueParameters: List, - typeParameters: List + flags: Int, + containingClass: JavaClass, + valueParameters: List, + typeParameters: List ) : BinaryJavaMethodBase( - flags, containingClass, valueParameters, typeParameters, - SpecialNames.NO_NAME_PROVIDED + flags, containingClass, valueParameters, typeParameters, + SpecialNames.NO_NAME_PROVIDED ), JavaConstructor diff --git a/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/Other.kt b/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/Other.kt index 9328dbcc8fa..975245f6c61 100644 --- a/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/Other.kt +++ b/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/Other.kt @@ -17,20 +17,19 @@ package org.jetbrains.kotlin.load.java.structure.impl.classFiles import org.jetbrains.kotlin.load.java.structure.* -import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.utils.SmartList import org.jetbrains.org.objectweb.asm.ClassReader import org.jetbrains.org.objectweb.asm.ClassVisitor class BinaryJavaField( - override val name: Name, - override val access: Int, - override val containingClass: JavaClass, - override val isEnumEntry: Boolean, - override val type: JavaType, - override val initializerValue: Any? -) : JavaField, MapBasedJavaAnnotationOwner, BinaryJavaModifierListOwner { + override val name: Name, + override val access: Int, + override val containingClass: JavaClass, + override val isEnumEntry: Boolean, + override val type: JavaType, + override val initializerValue: Any? +) : JavaField, BinaryJavaModifierListOwner, MutableJavaAnnotationOwner { override val annotations: MutableCollection = SmartList() override val annotationsByFqName by buildLazyValueForMap() @@ -39,20 +38,19 @@ class BinaryJavaField( } class BinaryJavaTypeParameter( - override val name: Name, - override val upperBounds: Collection -) : JavaTypeParameter { - // TODO: support annotations on type parameters - override val annotations get() = emptyList() - override fun findAnnotation(fqName: FqName) = null - - override val isDeprecatedInJavaDoc get() = false + override val name: Name, + override val upperBounds: Collection, + // If all bounds are interfaces then a type parameter has implicit Object class bound + val hasImplicitObjectClassBound: Boolean +) : JavaTypeParameter, ListBasedJavaAnnotationOwner, MutableJavaAnnotationOwner { + override val annotations: MutableCollection = SmartList() + override val isDeprecatedInJavaDoc = false } class BinaryJavaValueParameter( - override val type: JavaType, - override val isVararg: Boolean -) : JavaValueParameter, MapBasedJavaAnnotationOwner { + override val type: JavaType, + override val isVararg: Boolean +) : JavaValueParameter, MapBasedJavaAnnotationOwner, MutableJavaAnnotationOwner { override val annotations: MutableCollection = SmartList() override val annotationsByFqName by buildLazyValueForMap() diff --git a/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/Types.kt b/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/Types.kt index 9c17f038908..9facc4f623c 100644 --- a/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/Types.kt +++ b/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/Types.kt @@ -18,21 +18,25 @@ package org.jetbrains.kotlin.load.java.structure.impl.classFiles import org.jetbrains.kotlin.builtins.PrimitiveType import org.jetbrains.kotlin.load.java.structure.* -import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.utils.SmartList import org.jetbrains.kotlin.utils.addToStdlib.safeAs +internal abstract class JavaPlainType : ListBasedJavaAnnotationOwner, MutableJavaAnnotationOwner { + override val annotations: MutableCollection = SmartList() + override val isDeprecatedInJavaDoc = false +} + // They are only used for java class files, but potentially may be used in other cases // It would be better to call them like JavaSomeTypeImpl, but these names are already occupied by the PSI based types -internal class PlainJavaArrayType(override val componentType: JavaType) : JavaArrayType -internal class PlainJavaWildcardType(override val bound: JavaType?, override val isExtends: Boolean) : JavaWildcardType -internal class PlainJavaPrimitiveType(override val type: PrimitiveType?) : JavaPrimitiveType +internal class PlainJavaArrayType(override val componentType: JavaType) : JavaPlainType(), JavaArrayType +internal class PlainJavaWildcardType(override val bound: JavaType?, override val isExtends: Boolean) : JavaPlainType(), JavaWildcardType +internal class PlainJavaPrimitiveType(override val type: PrimitiveType?) : JavaPlainType(), JavaPrimitiveType internal class PlainJavaClassifierType( - // calculation of classifier and canonicalText - classifierComputation: () -> ClassifierResolutionContext.Result, - override val typeArguments: List -) : JavaClassifierType { + // calculation of classifier and canonicalText + classifierComputation: () -> ClassifierResolutionContext.Result, + override val typeArguments: List +) : JavaPlainType(), JavaClassifierType { private val classifierResolverResult by lazy(LazyThreadSafetyMode.NONE, classifierComputation) override val classifier get() = classifierResolverResult.classifier @@ -40,21 +44,6 @@ internal class PlainJavaClassifierType( get() = typeArguments.isEmpty() && classifierResolverResult.classifier?.safeAs()?.typeParameters?.isNotEmpty() == true - private var _annotations = emptyList() - override val annotations get() = _annotations - - override fun findAnnotation(fqName: FqName) = annotations.find { it.classId?.asSingleFqName() == fqName } - - internal fun addAnnotation(annotation: JavaAnnotation) { - if (_annotations.isEmpty()) { - _annotations = SmartList() - } - - (_annotations as MutableList).add(annotation) - } - - override val isDeprecatedInJavaDoc get() = false - override val classifierQualifiedName: String get() = classifierResolverResult.qualifiedName diff --git a/compiler/testData/loadJava8/compiledJava/TypeParameterAnnotations.javac.txt b/compiler/testData/loadJava8/compiledJava/TypeParameterAnnotations.javac.txt deleted file mode 100644 index e78e8750b0b..00000000000 --- a/compiler/testData/loadJava8/compiledJava/TypeParameterAnnotations.javac.txt +++ /dev/null @@ -1,14 +0,0 @@ -package test - -public open class TypeParameterAnnotations { - public constructor TypeParameterAnnotations() - - @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE_PARAMETER}) public final annotation class A : kotlin.Annotation { - public constructor A(/*0*/ value: kotlin.String = ...) - public final val value: kotlin.String - } - - public interface G { - public abstract fun foo(/*0*/ p0: R!): kotlin.Unit - } -} diff --git a/compiler/testData/loadJava8/compiledJava/TypeParameterAnnotations.runtime.txt b/compiler/testData/loadJava8/compiledJava/TypeParameterAnnotations.runtime.txt deleted file mode 100644 index 98273e896e2..00000000000 --- a/compiler/testData/loadJava8/compiledJava/TypeParameterAnnotations.runtime.txt +++ /dev/null @@ -1,14 +0,0 @@ -package test - -public open class TypeParameterAnnotations { - public constructor TypeParameterAnnotations() - - @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE_PARAMETER}) @kotlin.annotation.Retention(value = ...) public final annotation class A : kotlin.Annotation { - public final val value: kotlin.String - public final fun (): kotlin.String - } - - public interface G { - public abstract fun foo(/*0*/ R!): kotlin.Unit - } -} diff --git a/compiler/testData/loadJava8/compiledJava/TypeParameterAnnotations.java b/compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic.java similarity index 52% rename from compiler/testData/loadJava8/compiledJava/TypeParameterAnnotations.java rename to compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic.java index 55dbc0b0bd1..65420a47763 100644 --- a/compiler/testData/loadJava8/compiledJava/TypeParameterAnnotations.java +++ b/compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic.java @@ -2,15 +2,21 @@ package test; import java.lang.annotation.*; -public class TypeParameterAnnotations { +public class Basic { @Target(ElementType.TYPE_PARAMETER) public @interface A { String value() default ""; } - // Currently annotations on type parameters and arguments are not loaded from compiled code because of IDEA-153093 - // Once it will be fixed check if KT-11454 is ready to be resolved public interface G<@A T> { <@A("abc") R> void foo(R r); } + + public interface G1 { + void foo(R r); + } + + void foo(R r) { + + } } diff --git a/compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic.javac.txt b/compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic.javac.txt new file mode 100644 index 00000000000..900f301900d --- /dev/null +++ b/compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic.javac.txt @@ -0,0 +1,14 @@ +package test + +public open class Basic { + public constructor Basic() + + @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE_PARAMETER}) public final annotation class A : kotlin.Annotation { + public constructor A(/*0*/ value: kotlin.String = ...) + public final val value: kotlin.String + } + + public interface G { + public abstract fun foo(/*0*/ p0: R!): kotlin.Unit + } +} diff --git a/compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic.runtime.txt b/compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic.runtime.txt new file mode 100644 index 00000000000..2a256fb0fdf --- /dev/null +++ b/compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic.runtime.txt @@ -0,0 +1,14 @@ +package test + +public open class Basic { + public constructor Basic() + + @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE_PARAMETER}) @kotlin.annotation.Retention(value = ...) public final annotation class A : kotlin.Annotation { + public final val value: kotlin.String + public final fun (): kotlin.String + } + + public interface G { + public abstract fun foo(/*0*/ R!): kotlin.Unit + } +} diff --git a/compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic.txt b/compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic.txt new file mode 100644 index 00000000000..5e35b2ed9cb --- /dev/null +++ b/compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic.txt @@ -0,0 +1,19 @@ +package test + +public open class Basic { + public constructor Basic() + public/*package*/ open fun foo(/*0*/ p0: R!): kotlin.Unit + + @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE_PARAMETER}) public final annotation class A : kotlin.Annotation { + public constructor A(/*0*/ value: kotlin.String = ...) + public final val value: kotlin.String + } + + public interface G { + public abstract fun foo(/*0*/ p0: R!): kotlin.Unit + } + + public interface G1 { + public abstract fun foo(/*0*/ p0: R!): kotlin.Unit + } +} diff --git a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/BaseClassTypeArguments.java b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/BaseClassTypeArguments.java new file mode 100644 index 00000000000..b99084103bc --- /dev/null +++ b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/BaseClassTypeArguments.java @@ -0,0 +1,26 @@ +package test; + +import java.lang.annotation.*; + +@Target(ElementType.TYPE_USE) +@interface A { + String value() default ""; +} + +interface I1 {} +interface I2 {} +interface I3 {} + +class A2 {} +class A3 {} + +public class BaseClassTypeArguments extends A3<@A B [][][][][], I1>, A2> implements I1<@A Integer @A [][][]>, I2<@A B, B>, I3<@A B [][][][][], B, @A B> { + class ImplementedInterfacesTypeArguments implements I1, I1<@A int [] @A []>>>, I2<@A B, B>, I3<@A B [][][][][], I1>, I2> { + public class BaseClassTypeArguments1 extends A3<@A B [][][][][], I1>, A2> { + + } + } + static class BaseClassTypeArguments2 extends A3<@A B [][][][][], I1>, A2> { + + } +} \ No newline at end of file diff --git a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/BaseClassTypeArguments.txt b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/BaseClassTypeArguments.txt new file mode 100644 index 00000000000..46dd7dac980 --- /dev/null +++ b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/BaseClassTypeArguments.txt @@ -0,0 +1,39 @@ +package test + +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) public/*package*/ final annotation class A : kotlin.Annotation { + public/*package*/ constructor A(/*0*/ value: kotlin.String = ...) + public final val value: kotlin.String +} + +public/*package*/ open class A2 { + public/*package*/ constructor A2() +} + +public/*package*/ open class A3 { + public/*package*/ constructor A3() +} + +public open class BaseClassTypeArguments : test.A3!>!>!>!>!, test.I1..@test.A kotlin.Array?)>!>!, test.A2!>!>!>, test.I1<(@test.A kotlin.Array!>!>..@test.A kotlin.Array!>!>?)>, test.I2<@test.A B!, B!>, test.I3!>!>!>!>!, B!, @test.A B!> { + public constructor BaseClassTypeArguments() + + public/*package*/ open class BaseClassTypeArguments2 : test.A3!>!>!>!>!, test.I1..@test.A kotlin.Array?)>!>!, test.A2!>!>!> { + public/*package*/ constructor BaseClassTypeArguments2() + } + + public/*package*/ open inner class ImplementedInterfacesTypeArguments /*captured type parameters: /*1*/ B : kotlin.Any!*/ : test.I1!>!>..@test.A kotlin.Array!>!>?)>!, test.I1!>!>!>, test.I2<@test.A B!, B!>, test.I3!>!>!>!>!, test.I1..@test.A kotlin.Array?)>!>!, test.I2!>!>!> { + public/*package*/ constructor ImplementedInterfacesTypeArguments() + + public open inner class BaseClassTypeArguments1 /*captured type parameters: /*1*/ B : kotlin.Any!, /*2*/ B : kotlin.Any!*/ : test.A3!>!>!>!>!, test.I1..@test.A kotlin.Array?)>!>!, test.A2!>!>!> { + public constructor BaseClassTypeArguments1() + } + } +} + +public/*package*/ interface I1 { +} + +public/*package*/ interface I2 { +} + +public/*package*/ interface I3 { +} diff --git a/compiler/testData/loadJava8/sourceJava/TypeAnnotations.java b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic.java similarity index 91% rename from compiler/testData/loadJava8/sourceJava/TypeAnnotations.java rename to compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic.java index cffa9f44312..e2309dac755 100644 --- a/compiler/testData/loadJava8/sourceJava/TypeAnnotations.java +++ b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic.java @@ -1,7 +1,7 @@ package test; import java.lang.annotation.*; -public class TypeAnnotations { +public class Basic { @Target(ElementType.TYPE_USE) @interface A { String value() default ""; diff --git a/compiler/testData/loadJava8/sourceJava/TypeAnnotations.txt b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic.txt similarity index 57% rename from compiler/testData/loadJava8/sourceJava/TypeAnnotations.txt rename to compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic.txt index d5160b844ee..b5181c531f7 100644 --- a/compiler/testData/loadJava8/sourceJava/TypeAnnotations.txt +++ b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic.txt @@ -1,7 +1,7 @@ package test -public open class TypeAnnotations { - public constructor TypeAnnotations() +public open class Basic { + public constructor Basic() @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) public/*package*/ final annotation class A : kotlin.Annotation { public/*package*/ constructor A(/*0*/ value: kotlin.String = ...) @@ -15,7 +15,7 @@ public open class TypeAnnotations { } public interface MyClass { - public abstract fun f(/*0*/ p: test.TypeAnnotations.G2<@test.TypeAnnotations.A kotlin.String!, @test.TypeAnnotations.A(value = "abc") kotlin.Int!>!): kotlin.Unit - public abstract fun f(/*0*/ p: test.TypeAnnotations.G<@test.TypeAnnotations.A kotlin.String!>!): kotlin.Unit + public abstract fun f(/*0*/ p0: test.Basic.G2<@test.Basic.A kotlin.String!, @test.Basic.A(value = "abc") kotlin.Int!>!): kotlin.Unit + public abstract fun f(/*0*/ p0: test.Basic.G<@test.Basic.A kotlin.String!>!): kotlin.Unit } } diff --git a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ClassTypeParameterBounds.java b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ClassTypeParameterBounds.java new file mode 100644 index 00000000000..e8ed265b044 --- /dev/null +++ b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ClassTypeParameterBounds.java @@ -0,0 +1,33 @@ +// JAVAC_EXPECTED_FILE + +package test; + +import java.lang.annotation.*; + +@Target(ElementType.TYPE_USE) +@interface A { + String value() default ""; +} + +public class ClassTypeParameterBounds { + interface I1 {} + interface I2 {} + interface I3 {} + interface I4 {} + + interface G1 { } + class G2<_A, B extends @A Integer> { } + interface G3<_A, B extends Object & @A I1> { } + class G4<_A extends @A B, B> { } + interface G5<_A, B extends @A _A> { } + class G6<_A extends @A I1, B, C, D extends @A E, E, F> { } + interface G7<_A extends Object & I2<@A Integer> & @A I3> { } + interface G8<_A extends Object & I2 & @A I3> { } + + interface G9<_A extends I4 & I2 & @A I3> { } + interface G10<_A extends I4 & I2 & @A I3> { } + interface G11<_A extends I4 & I2 & @A I3> { } + interface G12<_A extends I4 & I2 & @A I3> { } + + // class G13<_A extends Object, B extends I3<@A _A> & @A I2<_A>> { } +} diff --git a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ClassTypeParameterBounds.txt b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ClassTypeParameterBounds.txt new file mode 100644 index 00000000000..c2664ce9824 --- /dev/null +++ b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ClassTypeParameterBounds.txt @@ -0,0 +1,61 @@ +package test + +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) public/*package*/ final annotation class A : kotlin.Annotation { + public/*package*/ constructor A(/*0*/ value: kotlin.String = ...) + public final val value: kotlin.String +} + +public open class ClassTypeParameterBounds { + public constructor ClassTypeParameterBounds() + + public/*package*/ interface G1 { + } + + public/*package*/ interface G10!> where _A : test.ClassTypeParameterBounds.I2!, _A : @test.A test.ClassTypeParameterBounds.I3! { + } + + public/*package*/ interface G11..@test.A kotlin.Array?)>!>!>!> where _A : test.ClassTypeParameterBounds.I2!>!>!>..@test.A kotlin.Array!>!>!>?)>!, _A : @test.A test.ClassTypeParameterBounds.I3..@test.A kotlin.Array?)>!>! { + } + + public/*package*/ interface G12..@test.A kotlin.Array?)>!> where _A : test.ClassTypeParameterBounds.I2!>!>!, _A : @test.A test.ClassTypeParameterBounds.I3..@test.A kotlin.Array?)>!>! { + } + + public/*package*/ open inner class G2 { + public/*package*/ constructor G2() + } + + public/*package*/ interface G3 where B : @test.A test.ClassTypeParameterBounds.I1! { + } + + public/*package*/ open inner class G4 { + public/*package*/ constructor G4() + } + + public/*package*/ interface G5 { + } + + public/*package*/ open inner class G6 { + public/*package*/ constructor G6() + } + + public/*package*/ interface G7 where _A : test.ClassTypeParameterBounds.I2<@test.A kotlin.Int!>!, _A : @test.A test.ClassTypeParameterBounds.I3! { + } + + public/*package*/ interface G8 where _A : test.ClassTypeParameterBounds.I2!, _A : @test.A test.ClassTypeParameterBounds.I3! { + } + + public/*package*/ interface G9..@test.A kotlin.Array?)>!> where _A : test.ClassTypeParameterBounds.I2..@test.A kotlin.Array?)>!, _A : @test.A test.ClassTypeParameterBounds.I3..@test.A kotlin.Array?)>! { + } + + public/*package*/ interface I1 { + } + + public/*package*/ interface I2 { + } + + public/*package*/ interface I3 { + } + + public/*package*/ interface I4 { + } +} diff --git a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodReceiver.java b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodReceiver.java new file mode 100644 index 00000000000..c26e08c0b33 --- /dev/null +++ b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodReceiver.java @@ -0,0 +1,23 @@ +// JAVAC_EXPECTED_FILE + +package test; + +import java.lang.annotation.*; + +@Target(ElementType.TYPE_USE) +@interface A { + String value() default ""; +} + +/* + * Note that a receiver type doesn't get into signatures used by the Kotlin compiler + * So in this test, annotated types shouldn't be reflected in the signatures dump + */ + +public class MethodReceiver { + public void f1(MethodReceiver<@A T> this) { } + + class MethodReceiver3 { + public void f1(@A MethodReceiver3<@A T, K, @A L> this) { } + } +} \ No newline at end of file diff --git a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodReceiver.txt b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodReceiver.txt new file mode 100644 index 00000000000..b966213b1d6 --- /dev/null +++ b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodReceiver.txt @@ -0,0 +1,16 @@ +package test + +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) public/*package*/ final annotation class A : kotlin.Annotation { + public/*package*/ constructor A(/*0*/ value: kotlin.String = ...) + public final val value: kotlin.String +} + +public open class MethodReceiver { + public constructor MethodReceiver() + public open fun f1(): kotlin.Unit + + public/*package*/ open inner class MethodReceiver3 /*captured type parameters: /*3*/ T : kotlin.Any!*/ { + public/*package*/ constructor MethodReceiver3() + public open fun f1(): kotlin.Unit + } +} diff --git a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodTypeParameterBounds.java b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodTypeParameterBounds.java new file mode 100644 index 00000000000..1ddc625116a --- /dev/null +++ b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodTypeParameterBounds.java @@ -0,0 +1,33 @@ +// JAVAC_EXPECTED_FILE + +package test; + +import java.lang.annotation.*; + +@Target(ElementType.TYPE_USE) +@interface A { + String value() default ""; +} + +abstract class MethodTypeParameterBounds { + interface I1 {} + interface I2 {} + interface I3 {} + interface I4 {} + + void f1(T x) { } + <_A, B extends @A Integer> void f2(_A x, B y) { } + <_A, B extends Object & @A I1> void f3(_A x, B y) { } + <_A extends @A B, B> void f4(_A x, B y) { } + <_A, B extends @A _A> void f5(_A x, B y) { } + <_A extends @A I1> void f6() { } + abstract <_A, B extends @A _A> void f7(_A x, B y); + abstract <_A extends @A I1, B, C, D extends @A E, E, F> void f8(_A x1, B x2, C x3, D x4, E x5, F x6); + <_A extends Object & I2<@A Integer> & @A I3> void f9(_A x) { } + <_A extends Object & I2 & @A I3> void f10(_A x) { } + <_A extends I4 & I2 & @A I3> void f11(_A x) { } + <_A extends I4 & I2 & @A I3> void f12(_A x) { } + <_A extends I4 & I2 & @A I3> void f13(_A x) { } + abstract <_A extends I4 & I2 & @A I3> void f14(_A x); + <_A extends Object, B extends I3<@A A> & @A I2> void f15(_A x) { } +} diff --git a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodTypeParameterBounds.txt b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodTypeParameterBounds.txt new file mode 100644 index 00000000000..43b77d4acaa --- /dev/null +++ b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodTypeParameterBounds.txt @@ -0,0 +1,37 @@ +package test + +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) public/*package*/ final annotation class A : kotlin.Annotation { + public/*package*/ constructor A(/*0*/ value: kotlin.String = ...) + public final val value: kotlin.String +} + +public/*package*/ abstract class MethodTypeParameterBounds { + public/*package*/ constructor MethodTypeParameterBounds() + public/*package*/ open fun f1(/*0*/ p0: T!): kotlin.Unit + public/*package*/ open fun f10(/*0*/ p0: _A!): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2!, _A : @test.A test.MethodTypeParameterBounds.I3! + public/*package*/ open fun ..@test.A kotlin.Array?)>!> f11(/*0*/ p0: _A!): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2..@test.A kotlin.Array?)>!, _A : @test.A test.MethodTypeParameterBounds.I3..@test.A kotlin.Array?)>! + public/*package*/ open fun !> f12(/*0*/ p0: _A!): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2!, _A : @test.A test.MethodTypeParameterBounds.I3! + public/*package*/ open fun ..@test.A kotlin.Array?)>!>!>!> f13(/*0*/ p0: _A!): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2!>!>!>..@test.A kotlin.Array!>!>!>?)>!, _A : @test.A test.MethodTypeParameterBounds.I3..@test.A kotlin.Array?)>!>! + public/*package*/ abstract fun ..@test.A kotlin.Array?)>!> f14(/*0*/ p0: _A!): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2!>!>!, _A : @test.A test.MethodTypeParameterBounds.I3..@test.A kotlin.Array?)>!>! + public/*package*/ open fun !> f15(/*0*/ p0: _A!): kotlin.Unit where B : @test.A test.MethodTypeParameterBounds.I2! + public/*package*/ open fun f2(/*0*/ p0: _A!, /*1*/ p1: B!): kotlin.Unit + public/*package*/ open fun f3(/*0*/ p0: _A!, /*1*/ p1: B!): kotlin.Unit where B : @test.A test.MethodTypeParameterBounds.I1! + public/*package*/ open fun f4(/*0*/ p0: _A!, /*1*/ p1: B!): kotlin.Unit + public/*package*/ open fun f5(/*0*/ p0: _A!, /*1*/ p1: B!): kotlin.Unit + public/*package*/ open fun f6(): kotlin.Unit + public/*package*/ abstract fun f7(/*0*/ p0: _A!, /*1*/ p1: B!): kotlin.Unit + public/*package*/ abstract fun f8(/*0*/ p0: _A!, /*1*/ p1: B!, /*2*/ p2: C!, /*3*/ p3: D!, /*4*/ p4: E!, /*5*/ p5: F!): kotlin.Unit + public/*package*/ open fun f9(/*0*/ p0: _A!): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2<@test.A kotlin.Int!>!, _A : @test.A test.MethodTypeParameterBounds.I3! + + public/*package*/ interface I1 { + } + + public/*package*/ interface I2 { + } + + public/*package*/ interface I3 { + } + + public/*package*/ interface I4 { + } +} diff --git a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ReturnType.java b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ReturnType.java new file mode 100644 index 00000000000..5c223aef06f --- /dev/null +++ b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ReturnType.java @@ -0,0 +1,95 @@ +package test; + +import java.lang.annotation.*; + +@Target(ElementType.TYPE_USE) +@interface A { + String value() default ""; +} + +interface G0 { } +interface G1 { } +interface G2 { } + +interface ReturnType { + // simplpe type arguments + G1<@A G0> f0(); + G1>>> f1(); + G1<@A String> f2(); + G2<@A String, G2<@A("abc") Integer, G2<@A("abc") G2, @A("abc") Integer>>> f3(); + + // wildcards + G1 f4 = null; + G1>>> f5(); + G1 f6(); + G2, ? extends @A("abc") Integer>>> f7(); + + G1 f8(); + G1>>> f9(); + G1 f10 = null; + G2, ? super @A("abc") Integer>>> f11(); + + G2, ? extends @A("abc") Integer>>> f12 = null; + + // arrays + Integer @A [] f13(); + int @A [] f14(); + @A Integer [] f15(); + @A int [] f16(); + @A Integer @A [] f17(); + @A int @A [] f18 = null; + + // multidementional arrays + Integer @A [] [] f19(); + int @A [] @A [] f20(); + @A Integer [] [] [] f21 = null; + @A int @A [] @A [] [] @A [] f22(); + @A Integer @A [] [] @A [] [] f23(); + @A int @A [] @A [] f24 = null; + int [] @A [] f25(); + Object [] @A [] f26(); + @A Object [] [] [] [] @A [] f27(); + + // arrays in type arguments + G1 f28(); + G2 f29(); + G1<@A Integer []> f30(); + G1> f31(); + G1, G1<@A int @A []>>> f32(); + G1<@A int @A []> f33(); + G1 f34(); + G2 f35 = null; + G1<@A Integer @A [] []> f36(); + G1> f37(); + G1, G1<@A int [] [] @A []>>> f38(); + G1<@A int @A [] @A [] []> f39(); + + // arrays in wildcard bounds + G1 f40(); + G2 f41(); + G1 f42(); + G1> f43(); + G1, G1>> f44(); + G1, G1>> f45 = null; + G1 f46(); + G1 f47(); + G2 f48 = null; + G1 f49(); + G1> f50(); + G1, G1>> f51(); + G1, G1>> f52 = null; + G1 f53(); + + class ReturnType2 { + G1 f4 = null; + G1 f10 = null; + G2, ? extends @A("abc") Integer>>> f12 = null; + @A int @A [] f18 = null; + @A Integer [] [] [] f21 = null; + @A int @A [] @A [] f24 = null; + G2 f35 = null; + G1, G1>> f45 = null; + G2 f48 = null; + G1, G1>> f52 = null; + } +} diff --git a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ReturnType.txt b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ReturnType.txt new file mode 100644 index 00000000000..cb7cc847e10 --- /dev/null +++ b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ReturnType.txt @@ -0,0 +1,88 @@ +package test + +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) public/*package*/ final annotation class A : kotlin.Annotation { + public/*package*/ constructor A(/*0*/ value: kotlin.String = ...) + public final val value: kotlin.String +} + +public/*package*/ interface G0 { +} + +public/*package*/ interface G1 { +} + +public/*package*/ interface G2 { +} + +public/*package*/ interface ReturnType { + public abstract fun f0(): test.G1<@test.A test.G0!>! + public abstract fun f1(): test.G1!>!>!>! + public abstract fun f11(): test.G2!, in @test.A(value = "abc") kotlin.Int!>!>!>! + public abstract fun f13(): (@test.A kotlin.Array..@test.A kotlin.Array?) + public abstract fun f14(): @test.A kotlin.IntArray! + public abstract fun f15(): kotlin.Array<(out) @test.A kotlin.Int!>! + public abstract fun f16(): kotlin.IntArray! + public abstract fun f17(): (@test.A kotlin.Array<@test.A kotlin.Int!>..@test.A kotlin.Array?) + public abstract fun f19(): (@test.A kotlin.Array!>..@test.A kotlin.Array!>?) + public abstract fun f2(): test.G1<@test.A kotlin.String!>! + public abstract fun f20(): (@test.A kotlin.Array<@test.A kotlin.IntArray!>..@test.A kotlin.Array?) + public abstract fun f22(): (@test.A kotlin.Array<(@test.A kotlin.Array!>..@test.A kotlin.Array!>?)>..@test.A kotlin.Array!>..@test.A kotlin.Array!>?)>?) + public abstract fun f23(): (@test.A kotlin.Array!>..@test.A kotlin.Array!>?)>!>..@test.A kotlin.Array!>..@test.A kotlin.Array!>?)>!>?) + public abstract fun f25(): kotlin.Array<(out) @test.A kotlin.IntArray!>! + public abstract fun f26(): kotlin.Array<(out) (@test.A kotlin.Array..@test.A kotlin.Array?)>! + public abstract fun f27(): kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) (@test.A kotlin.Array<@test.A kotlin.Any!>..@test.A kotlin.Array?)>!>!>!>! + public abstract fun f28(): test.G1<(@test.A kotlin.Array..@test.A kotlin.Array?)>! + public abstract fun f29(): test.G2! + public abstract fun f3(): test.G2<@test.A kotlin.String!, test.G2<@test.A(value = "abc") kotlin.Int!, test.G2<@test.A(value = "abc") test.G2!, @test.A(value = "abc") kotlin.Int!>!>!>! + public abstract fun f30(): test.G1!>! + public abstract fun f31(): test.G1!>! + public abstract fun f32(): test.G1..@test.A kotlin.Array?)>!, test.G1<@test.A kotlin.IntArray!>!>!>! + public abstract fun f33(): test.G1<@test.A kotlin.IntArray!>! + public abstract fun f34(): test.G1..@test.A kotlin.Array?)>!>! + public abstract fun f36(): test.G1<(@test.A kotlin.Array!>..@test.A kotlin.Array!>?)>! + public abstract fun f37(): test.G1!>!>!>! + public abstract fun f38(): test.G1..@test.A kotlin.Array?)>!, test.G1!>!>!>!>! + public abstract fun f39(): test.G1<(@test.A kotlin.Array<(@test.A kotlin.Array..@test.A kotlin.Array?)>..@test.A kotlin.Array..@test.A kotlin.Array?)>?)>! + public abstract fun f40(): test.G1..@test.A kotlin.Array?)>! + public abstract fun f41(): test.G2! + public abstract fun f42(): test.G1!>! + public abstract fun f43(): test.G1!>! + public abstract fun f44(): test.G1..@test.A kotlin.Array?)>!, test.G1!>!>! + public abstract fun f46(): test.G1! + public abstract fun f47(): test.G1..@test.A kotlin.Array?)>!>! + public abstract fun f49(): test.G1!>!>!>!>!>! + public abstract fun f5(): test.G1!>!>!>! + public abstract fun f50(): test.G1..@test.A kotlin.Array?)>!>! + public abstract fun f51(): test.G1..@test.A kotlin.Array?)>!>!>!, test.G1..@test.A kotlin.Array?)>..@test.A kotlin.Array..@test.A kotlin.Array?)>?)>!>!>! + public abstract fun f53(): test.G1..@test.A kotlin.Array?)>! + public abstract fun f6(): test.G1! + public abstract fun f7(): test.G2!, out @test.A(value = "abc") kotlin.Int!>!>!>! + public abstract fun f8(): test.G1! + public abstract fun f9(): test.G1!>!>!>! + + public open class ReturnType2 { + public constructor ReturnType2() + public/*package*/ final var f10: test.G1! + public/*package*/ final var f12: test.G2!, out kotlin.Int!>!>!>! + public/*package*/ final var f18: @test.A kotlin.IntArray! + public/*package*/ final var f21: kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Int!>!>!>! + public/*package*/ final var f24: (@test.A kotlin.Array..@test.A kotlin.Array?) + public/*package*/ final var f35: test.G2!>! + public/*package*/ final var f4: test.G1! + public/*package*/ final var f45: test.G1!>!, test.G1!>!>! + public/*package*/ final var f48: test.G2!>!>! + public/*package*/ final var f52: test.G1!>!>!>!, test.G1!>!>!>! + } + + // Static members + public final val f10: test.G1! + public final val f12: test.G2!, out kotlin.Int!>!>!>! + public final val f18: @test.A kotlin.IntArray! + public final val f21: kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Int!>!>!>! + public final val f24: (@test.A kotlin.Array..@test.A kotlin.Array?) + public final val f35: test.G2!>! + public final val f4: test.G1! + public final val f45: test.G1!>!, test.G1!>!>! + public final val f48: test.G2!>!>! + public final val f52: test.G1!>!>!>!, test.G1!>!>!>! +} diff --git a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ValueArguments.java b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ValueArguments.java new file mode 100644 index 00000000000..8d54ff5550d --- /dev/null +++ b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ValueArguments.java @@ -0,0 +1,117 @@ +package test; + +import java.lang.annotation.*; + +@Target(ElementType.TYPE_USE) +@interface A { + String value() default ""; +} + +interface G0 { } +interface G1 { } +interface G2 { } + +interface ValueArguments { + // simplpe type arguments + void f0(G1<@A G0> p); + void f1(G1>>> p); + void f2(G1<@A String> p); + void f3(G2<@A String, G2<@A("abc") Integer, G2<@A("abc") G2, @A("abc") Integer>>> p); + + // wildcards + void f4(G1 p); + void f5(G1>>> p); + void f6(G1 p1, G1>>> p2); + void f7(G2, ? extends @A("abc") Integer>>> p); + + void f8(G1 p); + void f9(G1>>> p); + void f10(G1 p); + void f11(G2, ? super @A("abc") Integer>>> p); + + void f12(G2, ? extends @A("abc") Integer>>> p); + + // arrays + void f13(Integer @A [] p); + void f14(int @A [] p); + void f15(@A Integer [] p); + void f16(@A int [] p); + void f17(@A Integer @A [] p); + void f18(@A int @A [] p1, Integer @A [] p2, @A int [] p3); + + // multidementional arrays + void f19(Integer @A [] [] p); + void f20(int @A [] @A [] p); + void f21(@A Integer [] [] [] p); + void f22(@A int @A [] @A [] [] @A [] p); + void f23(@A Integer @A [] [] @A [] [] p); + void f24(@A int @A [] @A [] p); + void f25(int [] @A [] p); + void f26(Object [] @A [] p1, int [] @A [] p2, @A int @A [] @A [] [] @A [] p3); + void f27(@A Object [] [] [] [] @A [] p); + + // arrays in type arguments + void f28(G1 p); + void f29(G2 p); + void f30(G1<@A Integer []> p); + void f31(G1> p); + void f32(G1, G1<@A int @A []>>> p); + void f33(G1<@A int @A []> p); + void f34(G1 p); + void f35(G2 p1, G1<@A Integer @A [] []> p2, G1> p3); + void f36(G1<@A Integer @A [] []> p); + void f37(G1> p); + void f38(G1, G1<@A int [] [] @A []>>> p); + void f39(G1<@A int @A [] @A [] []> p); + + // arrays in wildcard bounds + void f40(G1 p); + void f41(G2 p); + void f42(G1 p); + void f43(G1> p); + void f44(G1, G1>> p); + void f45(G1, G1>> p); + void f46(G1 p); + void f47(G1 p); + void f48(G2 p); + void f49(G1 p1, G1> p2, G2 p3); + void f50(G1> p); + void f51(G1, G1>> p); + void f52(G1, G1>> p); + void f53(G1 p); + + void f54(G1, G1>> p1, G1<@A int @A [] @A [] []> p2, @A Object [] [] [] [] @A [] p3, @A int @A [] p4, G2, ? extends @A("abc") Integer>>> p5); + + // varargs + void f55(@A String ... x); + void f56(String @A ... x); + void f57(@A String @A ... x); + void f58(@A int ... x); + void f59(int @A ... x); + void f60(@A int @A ... x); + + // varargs + arrays + void f61(@A String [] ... x); + void f62(String @A [] ... x); + void f63(String [] @A ... x); + void f64(@A String @A [] @A ... x); + void f65(@A int [] ... x); + void f66(int @A [] ... x); + void f67(int [] @A ... x); + void f68(@A int @A [] @A ... x); + + void f69(@A String [] [] ... x); + void f70(String [] @A [] ... x); + void f71(String [] [] [] @A ... x); + void f72(@A String @A [] [] @A [] @A ... x); + void f73(@A int [] @A [] ... x); + void f74(int @A [][][] @A [] ... x); + void f75(int [] [] [] @A ... x); + void f76(@A int @A [] [] @A ... x); + + class Test { + public Test(G2, ? extends @A("abc") Integer>>> p1, Object [] @A [] p2, int [] @A [] p3, @A int @A [] @A [] [] @A [] p4, @A int @A [] [] @A ... p5) { + + } + } +} diff --git a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ValueArguments.txt b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ValueArguments.txt new file mode 100644 index 00000000000..e4ecaac4799 --- /dev/null +++ b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ValueArguments.txt @@ -0,0 +1,99 @@ +package test + +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) public/*package*/ final annotation class A : kotlin.Annotation { + public/*package*/ constructor A(/*0*/ value: kotlin.String = ...) + public final val value: kotlin.String +} + +public/*package*/ interface G0 { +} + +public/*package*/ interface G1 { +} + +public/*package*/ interface G2 { +} + +public/*package*/ interface ValueArguments { + public abstract fun f0(/*0*/ p0: test.G1<@test.A test.G0!>!): kotlin.Unit + public abstract fun f1(/*0*/ p0: test.G1!>!>!>!): kotlin.Unit + public abstract fun f10(/*0*/ p0: test.G1!): kotlin.Unit + public abstract fun f11(/*0*/ p0: test.G2!, in @test.A(value = "abc") kotlin.Int!>!>!>!): kotlin.Unit + public abstract fun f12(/*0*/ p0: test.G2!, out @test.A(value = "abc") kotlin.Int!>!>!>!): kotlin.Unit + public abstract fun f13(/*0*/ p0: (@test.A kotlin.Array..@test.A kotlin.Array?)): kotlin.Unit + public abstract fun f14(/*0*/ p0: @test.A kotlin.IntArray!): kotlin.Unit + public abstract fun f15(/*0*/ p0: kotlin.Array<(out) @test.A kotlin.Int!>!): kotlin.Unit + public abstract fun f16(/*0*/ p0: kotlin.IntArray!): kotlin.Unit + public abstract fun f17(/*0*/ p0: (@test.A kotlin.Array<@test.A kotlin.Int!>..@test.A kotlin.Array?)): kotlin.Unit + public abstract fun f18(/*0*/ p0: @test.A kotlin.IntArray!, /*1*/ p1: (@test.A kotlin.Array..@test.A kotlin.Array?), /*2*/ p2: kotlin.IntArray!): kotlin.Unit + public abstract fun f19(/*0*/ p0: (@test.A kotlin.Array!>..@test.A kotlin.Array!>?)): kotlin.Unit + public abstract fun f2(/*0*/ p0: test.G1<@test.A kotlin.String!>!): kotlin.Unit + public abstract fun f20(/*0*/ p0: (@test.A kotlin.Array<@test.A kotlin.IntArray!>..@test.A kotlin.Array?)): kotlin.Unit + public abstract fun f21(/*0*/ p0: kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.Int!>!>!>!): kotlin.Unit + public abstract fun f22(/*0*/ p0: (@test.A kotlin.Array<(@test.A kotlin.Array!>..@test.A kotlin.Array!>?)>..@test.A kotlin.Array!>..@test.A kotlin.Array!>?)>?)): kotlin.Unit + public abstract fun f23(/*0*/ p0: (@test.A kotlin.Array!>..@test.A kotlin.Array!>?)>!>..@test.A kotlin.Array!>..@test.A kotlin.Array!>?)>!>?)): kotlin.Unit + public abstract fun f24(/*0*/ p0: (@test.A kotlin.Array<@test.A kotlin.IntArray!>..@test.A kotlin.Array?)): kotlin.Unit + public abstract fun f25(/*0*/ p0: kotlin.Array<(out) @test.A kotlin.IntArray!>!): kotlin.Unit + public abstract fun f26(/*0*/ p0: kotlin.Array<(out) (@test.A kotlin.Array..@test.A kotlin.Array?)>!, /*1*/ p1: kotlin.Array<(out) @test.A kotlin.IntArray!>!, /*2*/ p2: (@test.A kotlin.Array<(@test.A kotlin.Array!>..@test.A kotlin.Array!>?)>..@test.A kotlin.Array!>..@test.A kotlin.Array!>?)>?)): kotlin.Unit + public abstract fun f27(/*0*/ p0: kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) (@test.A kotlin.Array<@test.A kotlin.Any!>..@test.A kotlin.Array?)>!>!>!>!): kotlin.Unit + public abstract fun f28(/*0*/ p0: test.G1<(@test.A kotlin.Array..@test.A kotlin.Array?)>!): kotlin.Unit + public abstract fun f29(/*0*/ p0: test.G2!): kotlin.Unit + public abstract fun f3(/*0*/ p0: test.G2<@test.A kotlin.String!, test.G2<@test.A(value = "abc") kotlin.Int!, test.G2<@test.A(value = "abc") test.G2!, @test.A(value = "abc") kotlin.Int!>!>!>!): kotlin.Unit + public abstract fun f30(/*0*/ p0: test.G1!>!): kotlin.Unit + public abstract fun f31(/*0*/ p0: test.G1!>!): kotlin.Unit + public abstract fun f32(/*0*/ p0: test.G1..@test.A kotlin.Array?)>!, test.G1<@test.A kotlin.IntArray!>!>!>!): kotlin.Unit + public abstract fun f33(/*0*/ p0: test.G1<@test.A kotlin.IntArray!>!): kotlin.Unit + public abstract fun f34(/*0*/ p0: test.G1..@test.A kotlin.Array?)>!>!): kotlin.Unit + public abstract fun f35(/*0*/ p0: test.G2..@test.A kotlin.Array?)>!, /*1*/ p1: test.G1<(@test.A kotlin.Array!>..@test.A kotlin.Array!>?)>!, /*2*/ p2: test.G1!>!): kotlin.Unit + public abstract fun f36(/*0*/ p0: test.G1<(@test.A kotlin.Array!>..@test.A kotlin.Array!>?)>!): kotlin.Unit + public abstract fun f37(/*0*/ p0: test.G1!>!>!>!): kotlin.Unit + public abstract fun f38(/*0*/ p0: test.G1..@test.A kotlin.Array?)>!, test.G1!>!>!>!>!): kotlin.Unit + public abstract fun f39(/*0*/ p0: test.G1<(@test.A kotlin.Array<(@test.A kotlin.Array..@test.A kotlin.Array?)>..@test.A kotlin.Array..@test.A kotlin.Array?)>?)>!): kotlin.Unit + public abstract fun f4(/*0*/ p0: test.G1!): kotlin.Unit + public abstract fun f40(/*0*/ p0: test.G1..@test.A kotlin.Array?)>!): kotlin.Unit + public abstract fun f41(/*0*/ p0: test.G2!): kotlin.Unit + public abstract fun f42(/*0*/ p0: test.G1!>!): kotlin.Unit + public abstract fun f43(/*0*/ p0: test.G1!>!): kotlin.Unit + public abstract fun f44(/*0*/ p0: test.G1..@test.A kotlin.Array?)>!, test.G1!>!>!): kotlin.Unit + public abstract fun f45(/*0*/ p0: test.G1..@test.A kotlin.Array?)>!, test.G1!>!>!): kotlin.Unit + public abstract fun f46(/*0*/ p0: test.G1!): kotlin.Unit + public abstract fun f47(/*0*/ p0: test.G1..@test.A kotlin.Array?)>!>!): kotlin.Unit + public abstract fun f48(/*0*/ p0: test.G2!>!>!): kotlin.Unit + public abstract fun f49(/*0*/ p0: test.G1!>!>!>!>!>!, /*1*/ p1: test.G1..@test.A kotlin.Array?)>!>!, /*2*/ p2: test.G2!>!>!): kotlin.Unit + public abstract fun f5(/*0*/ p0: test.G1!>!>!>!): kotlin.Unit + public abstract fun f50(/*0*/ p0: test.G1..@test.A kotlin.Array?)>!>!): kotlin.Unit + public abstract fun f51(/*0*/ p0: test.G1..@test.A kotlin.Array?)>!>!>!, test.G1..@test.A kotlin.Array?)>..@test.A kotlin.Array..@test.A kotlin.Array?)>?)>!>!>!): kotlin.Unit + public abstract fun f52(/*0*/ p0: test.G1!>!>..@test.A kotlin.Array!>!>?)>!, test.G1!>!>!>!): kotlin.Unit + public abstract fun f53(/*0*/ p0: test.G1..@test.A kotlin.Array?)>!): kotlin.Unit + public abstract fun f54(/*0*/ p0: test.G1!>!>..@test.A kotlin.Array!>!>?)>!, test.G1!>!>!>!, /*1*/ p1: test.G1<(@test.A kotlin.Array<(@test.A kotlin.Array..@test.A kotlin.Array?)>..@test.A kotlin.Array..@test.A kotlin.Array?)>?)>!, /*2*/ p2: kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) (@test.A kotlin.Array<@test.A kotlin.Any!>..@test.A kotlin.Array?)>!>!>!>!, /*3*/ p3: @test.A kotlin.IntArray!, /*4*/ p4: test.G2!, out @test.A(value = "abc") kotlin.Int!>!>!>!): kotlin.Unit + public abstract fun f55(/*0*/ vararg p0: @test.A kotlin.String! /*kotlin.Array<(out) @test.A kotlin.String!>!*/): kotlin.Unit + public abstract fun f56(/*0*/ vararg p0: kotlin.String! /*(@test.A kotlin.Array..@test.A kotlin.Array?)*/): kotlin.Unit + public abstract fun f57(/*0*/ vararg p0: @test.A kotlin.String! /*(@test.A kotlin.Array<@test.A kotlin.String!>..@test.A kotlin.Array?)*/): kotlin.Unit + public abstract fun f58(/*0*/ vararg p0: kotlin.Int /*kotlin.IntArray!*/): kotlin.Unit + public abstract fun f59(/*0*/ vararg p0: kotlin.Int /*@test.A kotlin.IntArray!*/): kotlin.Unit + public abstract fun f6(/*0*/ p0: test.G1!, /*1*/ p1: test.G1!>!>!>!): kotlin.Unit + public abstract fun f60(/*0*/ vararg p0: kotlin.Int /*@test.A kotlin.IntArray!*/): kotlin.Unit + public abstract fun f61(/*0*/ vararg p0: kotlin.Array<(out) @test.A kotlin.String!>! /*kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.String!>!>!*/): kotlin.Unit + public abstract fun f62(/*0*/ vararg p0: kotlin.Array<(out) kotlin.String!>! /*(@test.A kotlin.Array!>..@test.A kotlin.Array!>?)*/): kotlin.Unit + public abstract fun f63(/*0*/ vararg p0: (@test.A kotlin.Array..@test.A kotlin.Array?) /*kotlin.Array<(out) (@test.A kotlin.Array..@test.A kotlin.Array?)>!*/): kotlin.Unit + public abstract fun f64(/*0*/ vararg p0: (@test.A kotlin.Array<@test.A kotlin.String!>..@test.A kotlin.Array?) /*(@test.A kotlin.Array<(@test.A kotlin.Array<@test.A kotlin.String!>..@test.A kotlin.Array?)>..@test.A kotlin.Array..@test.A kotlin.Array?)>?)*/): kotlin.Unit + public abstract fun f65(/*0*/ vararg p0: kotlin.IntArray! /*kotlin.Array<(out) kotlin.IntArray!>!*/): kotlin.Unit + public abstract fun f66(/*0*/ vararg p0: kotlin.IntArray! /*(@test.A kotlin.Array..@test.A kotlin.Array?)*/): kotlin.Unit + public abstract fun f67(/*0*/ vararg p0: @test.A kotlin.IntArray! /*kotlin.Array<(out) @test.A kotlin.IntArray!>!*/): kotlin.Unit + public abstract fun f68(/*0*/ vararg p0: @test.A kotlin.IntArray! /*(@test.A kotlin.Array<@test.A kotlin.IntArray!>..@test.A kotlin.Array?)*/): kotlin.Unit + public abstract fun f69(/*0*/ vararg p0: kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.String!>!>! /*kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.String!>!>!>!*/): kotlin.Unit + public abstract fun f7(/*0*/ p0: test.G2!, out @test.A(value = "abc") kotlin.Int!>!>!>!): kotlin.Unit + public abstract fun f70(/*0*/ vararg p0: (@test.A kotlin.Array!>..@test.A kotlin.Array!>?) /*kotlin.Array<(out) (@test.A kotlin.Array!>..@test.A kotlin.Array!>?)>!*/): kotlin.Unit + public abstract fun f71(/*0*/ vararg p0: kotlin.Array<(out) kotlin.Array<(out) (@test.A kotlin.Array..@test.A kotlin.Array?)>!>! /*kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) (@test.A kotlin.Array..@test.A kotlin.Array?)>!>!>!*/): kotlin.Unit + public abstract fun f72(/*0*/ vararg p0: kotlin.Array<(out) (@test.A kotlin.Array<(@test.A kotlin.Array<@test.A kotlin.String!>..@test.A kotlin.Array?)>..@test.A kotlin.Array..@test.A kotlin.Array?)>?)>! /*(@test.A kotlin.Array..@test.A kotlin.Array?)>..@test.A kotlin.Array..@test.A kotlin.Array?)>?)>!>..@test.A kotlin.Array..@test.A kotlin.Array?)>..@test.A kotlin.Array..@test.A kotlin.Array?)>?)>!>?)*/): kotlin.Unit + public abstract fun f73(/*0*/ vararg p0: (@test.A kotlin.Array..@test.A kotlin.Array?) /*kotlin.Array<(out) (@test.A kotlin.Array..@test.A kotlin.Array?)>!*/): kotlin.Unit + public abstract fun f74(/*0*/ vararg p0: kotlin.Array<(out) kotlin.Array<(out) (@test.A kotlin.Array..@test.A kotlin.Array?)>!>! /*(@test.A kotlin.Array..@test.A kotlin.Array?)>!>!>..@test.A kotlin.Array..@test.A kotlin.Array?)>!>!>?)*/): kotlin.Unit + public abstract fun f75(/*0*/ vararg p0: kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.IntArray!>!>! /*kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.IntArray!>!>!>!*/): kotlin.Unit + public abstract fun f76(/*0*/ vararg p0: kotlin.Array<(out) @test.A kotlin.IntArray!>! /*(@test.A kotlin.Array!>..@test.A kotlin.Array!>?)*/): kotlin.Unit + public abstract fun f8(/*0*/ p0: test.G1!): kotlin.Unit + public abstract fun f9(/*0*/ p0: test.G1!>!>!>!): kotlin.Unit + + public open class Test { + public constructor Test(/*0*/ p0: test.G2!, out @test.A(value = "abc") kotlin.Int!>!>!>!, /*1*/ p1: kotlin.Array<(out) (@test.A kotlin.Array..@test.A kotlin.Array?)>!, /*2*/ p2: kotlin.Array<(out) @test.A kotlin.IntArray!>!, /*3*/ p3: (@test.A kotlin.Array<(@test.A kotlin.Array!>..@test.A kotlin.Array!>?)>..@test.A kotlin.Array!>..@test.A kotlin.Array!>?)>?), /*4*/ vararg p4: kotlin.Array<(out) @test.A kotlin.IntArray!>! /*(@test.A kotlin.Array!>..@test.A kotlin.Array!>?)*/) + } +} diff --git a/compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic.java b/compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic.java new file mode 100644 index 00000000000..65420a47763 --- /dev/null +++ b/compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic.java @@ -0,0 +1,22 @@ +// JAVAC_EXPECTED_FILE +package test; + +import java.lang.annotation.*; +public class Basic { + @Target(ElementType.TYPE_PARAMETER) + public @interface A { + String value() default ""; + } + + public interface G<@A T> { + <@A("abc") R> void foo(R r); + } + + public interface G1 { + void foo(R r); + } + + void foo(R r) { + + } +} diff --git a/compiler/testData/loadJava8/compiledJava/TypeParameterAnnotations.txt b/compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic.javac.txt similarity index 54% rename from compiler/testData/loadJava8/compiledJava/TypeParameterAnnotations.txt rename to compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic.javac.txt index 1be3aa442f1..a9887657d0a 100644 --- a/compiler/testData/loadJava8/compiledJava/TypeParameterAnnotations.txt +++ b/compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic.javac.txt @@ -1,14 +1,14 @@ package test -public open class TypeParameterAnnotations { - public constructor TypeParameterAnnotations() +public open class Basic { + public constructor Basic() @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE_PARAMETER}) public final annotation class A : kotlin.Annotation { public constructor A(/*0*/ value: kotlin.String = ...) public final val value: kotlin.String } - public interface G { - public abstract fun foo(/*0*/ p0: R!): kotlin.Unit + public interface G { + public abstract fun foo(/*0*/ r: R!): kotlin.Unit } } diff --git a/compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic.runtime.txt b/compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic.runtime.txt new file mode 100644 index 00000000000..2a256fb0fdf --- /dev/null +++ b/compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic.runtime.txt @@ -0,0 +1,14 @@ +package test + +public open class Basic { + public constructor Basic() + + @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE_PARAMETER}) @kotlin.annotation.Retention(value = ...) public final annotation class A : kotlin.Annotation { + public final val value: kotlin.String + public final fun (): kotlin.String + } + + public interface G { + public abstract fun foo(/*0*/ R!): kotlin.Unit + } +} diff --git a/compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic.txt b/compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic.txt new file mode 100644 index 00000000000..462a7a3341e --- /dev/null +++ b/compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic.txt @@ -0,0 +1,19 @@ +package test + +public open class Basic { + public constructor Basic() + public/*package*/ open fun foo(/*0*/ r: R!): kotlin.Unit + + @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE_PARAMETER}) public final annotation class A : kotlin.Annotation { + public constructor A(/*0*/ value: kotlin.String = ...) + public final val value: kotlin.String + } + + public interface G { + public abstract fun foo(/*0*/ r: R!): kotlin.Unit + } + + public interface G1 { + public abstract fun foo(/*0*/ r: R!): kotlin.Unit + } +} diff --git a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/BaseClassTypeArguments.java b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/BaseClassTypeArguments.java new file mode 100644 index 00000000000..b99084103bc --- /dev/null +++ b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/BaseClassTypeArguments.java @@ -0,0 +1,26 @@ +package test; + +import java.lang.annotation.*; + +@Target(ElementType.TYPE_USE) +@interface A { + String value() default ""; +} + +interface I1 {} +interface I2 {} +interface I3 {} + +class A2 {} +class A3 {} + +public class BaseClassTypeArguments extends A3<@A B [][][][][], I1>, A2> implements I1<@A Integer @A [][][]>, I2<@A B, B>, I3<@A B [][][][][], B, @A B> { + class ImplementedInterfacesTypeArguments implements I1, I1<@A int [] @A []>>>, I2<@A B, B>, I3<@A B [][][][][], I1>, I2> { + public class BaseClassTypeArguments1 extends A3<@A B [][][][][], I1>, A2> { + + } + } + static class BaseClassTypeArguments2 extends A3<@A B [][][][][], I1>, A2> { + + } +} \ No newline at end of file diff --git a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/BaseClassTypeArguments.txt b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/BaseClassTypeArguments.txt new file mode 100644 index 00000000000..09f9e522c1c --- /dev/null +++ b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/BaseClassTypeArguments.txt @@ -0,0 +1,17 @@ +package test + +public open class BaseClassTypeArguments : test.A3!>!>!>!>!, test.I1!>!>!, test.A2!>..@test.A kotlin.Array!>?)>!>, test.I1..@test.A kotlin.Array?)>!>!>, test.I2<@test.A B!, B!>, test.I3!>!>!>!>!, B!, @test.A B!> { + public constructor BaseClassTypeArguments() + + public/*package*/ open class BaseClassTypeArguments2 : test.A3!>!>!>!>!, test.I1!>!>!, test.A2!>..@test.A kotlin.Array!>?)>!> { + public/*package*/ constructor BaseClassTypeArguments2() + } + + public/*package*/ open inner class ImplementedInterfacesTypeArguments /*captured type parameters: /*1*/ B : kotlin.Any!*/ : test.I1..@test.A kotlin.Array?)>!>!>!, test.I1<(@test.A kotlin.Array..@test.A kotlin.Array?)>!>!>, test.I2<@test.A B!, B!>, test.I3!>!>!>!>!, test.I1!>!>!, test.I2!>..@test.A kotlin.Array!>?)>!> { + public/*package*/ constructor ImplementedInterfacesTypeArguments() + + public open inner class BaseClassTypeArguments1 /*captured type parameters: /*1*/ B : kotlin.Any!, /*2*/ B : kotlin.Any!*/ : test.A3!>!>!>!>!, test.I1!>!>!, test.A2!>..@test.A kotlin.Array!>?)>!> { + public constructor BaseClassTypeArguments1() + } + } +} diff --git a/compiler/testData/loadJava8/compiledJava/TypeAnnotations.java b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic.java similarity index 59% rename from compiler/testData/loadJava8/compiledJava/TypeAnnotations.java rename to compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic.java index c62ead65755..e2309dac755 100644 --- a/compiler/testData/loadJava8/compiledJava/TypeAnnotations.java +++ b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic.java @@ -1,7 +1,7 @@ package test; import java.lang.annotation.*; -public class TypeAnnotations { +public class Basic { @Target(ElementType.TYPE_USE) @interface A { String value() default ""; @@ -13,8 +13,6 @@ public class TypeAnnotations { interface G2 { } - // Currently annotations on type parameters and arguments are not loaded from compiled code because of IDEA-153093 - // Once it will be fixed check if KT-11454 is ready to be resolved public interface MyClass { void f(G<@A String> p); diff --git a/compiler/testData/loadJava8/compiledJava/TypeAnnotations.txt b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic.txt similarity index 62% rename from compiler/testData/loadJava8/compiledJava/TypeAnnotations.txt rename to compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic.txt index 9fa9870de7f..ce0f47c771f 100644 --- a/compiler/testData/loadJava8/compiledJava/TypeAnnotations.txt +++ b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic.txt @@ -1,7 +1,7 @@ package test -public open class TypeAnnotations { - public constructor TypeAnnotations() +public open class Basic { + public constructor Basic() @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) public/*package*/ final annotation class A : kotlin.Annotation { public/*package*/ constructor A(/*0*/ value: kotlin.String = ...) @@ -15,7 +15,7 @@ public open class TypeAnnotations { } public interface MyClass { - public abstract fun f(/*0*/ p0: test.TypeAnnotations.G2!): kotlin.Unit - public abstract fun f(/*0*/ p0: test.TypeAnnotations.G!): kotlin.Unit + public abstract fun f(/*0*/ p: test.Basic.G2<@test.Basic.A kotlin.String!, @test.Basic.A(value = "abc") kotlin.Int!>!): kotlin.Unit + public abstract fun f(/*0*/ p: test.Basic.G<@test.Basic.A kotlin.String!>!): kotlin.Unit } } diff --git a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ClassTypeParameterBounds.java b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ClassTypeParameterBounds.java new file mode 100644 index 00000000000..e8ed265b044 --- /dev/null +++ b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ClassTypeParameterBounds.java @@ -0,0 +1,33 @@ +// JAVAC_EXPECTED_FILE + +package test; + +import java.lang.annotation.*; + +@Target(ElementType.TYPE_USE) +@interface A { + String value() default ""; +} + +public class ClassTypeParameterBounds { + interface I1 {} + interface I2 {} + interface I3 {} + interface I4 {} + + interface G1 { } + class G2<_A, B extends @A Integer> { } + interface G3<_A, B extends Object & @A I1> { } + class G4<_A extends @A B, B> { } + interface G5<_A, B extends @A _A> { } + class G6<_A extends @A I1, B, C, D extends @A E, E, F> { } + interface G7<_A extends Object & I2<@A Integer> & @A I3> { } + interface G8<_A extends Object & I2 & @A I3> { } + + interface G9<_A extends I4 & I2 & @A I3> { } + interface G10<_A extends I4 & I2 & @A I3> { } + interface G11<_A extends I4 & I2 & @A I3> { } + interface G12<_A extends I4 & I2 & @A I3> { } + + // class G13<_A extends Object, B extends I3<@A _A> & @A I2<_A>> { } +} diff --git a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ClassTypeParameterBounds.txt b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ClassTypeParameterBounds.txt new file mode 100644 index 00000000000..7cb5d93800e --- /dev/null +++ b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ClassTypeParameterBounds.txt @@ -0,0 +1,56 @@ +package test + +public open class ClassTypeParameterBounds { + public constructor ClassTypeParameterBounds() + + public/*package*/ interface G1 { + } + + public/*package*/ interface G10!> where _A : test.ClassTypeParameterBounds.I2!, _A : @test.A test.ClassTypeParameterBounds.I3! { + } + + public/*package*/ interface G11!>!>..@test.A kotlin.Array!>!>?)>!> where _A : test.ClassTypeParameterBounds.I2..@test.A kotlin.Array?)>!>!>!>!, _A : @test.A test.ClassTypeParameterBounds.I3!>..@test.A kotlin.Array!>?)>! { + } + + public/*package*/ interface G12!>!> where _A : test.ClassTypeParameterBounds.I2!>..@test.A kotlin.Array!>?)>!, _A : @test.A test.ClassTypeParameterBounds.I3..@test.A kotlin.Array?)>!>! { + } + + public/*package*/ open inner class G2 { + public/*package*/ constructor G2() + } + + public/*package*/ interface G3 where B : @test.A test.ClassTypeParameterBounds.I1! { + } + + public/*package*/ open inner class G4 { + public/*package*/ constructor G4() + } + + public/*package*/ interface G5 { + } + + public/*package*/ open inner class G6 { + public/*package*/ constructor G6() + } + + public/*package*/ interface G7 where _A : test.ClassTypeParameterBounds.I2<@test.A kotlin.Int!>!, _A : @test.A test.ClassTypeParameterBounds.I3! { + } + + public/*package*/ interface G8 where _A : test.ClassTypeParameterBounds.I2!, _A : @test.A test.ClassTypeParameterBounds.I3! { + } + + public/*package*/ interface G9..@test.A kotlin.Array?)>!> where _A : test.ClassTypeParameterBounds.I2..@test.A kotlin.Array?)>!, _A : @test.A test.ClassTypeParameterBounds.I3..@test.A kotlin.Array?)>! { + } + + public/*package*/ interface I1 { + } + + public/*package*/ interface I2 { + } + + public/*package*/ interface I3 { + } + + public/*package*/ interface I4 { + } +} diff --git a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodReceiver.java b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodReceiver.java new file mode 100644 index 00000000000..c26e08c0b33 --- /dev/null +++ b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodReceiver.java @@ -0,0 +1,23 @@ +// JAVAC_EXPECTED_FILE + +package test; + +import java.lang.annotation.*; + +@Target(ElementType.TYPE_USE) +@interface A { + String value() default ""; +} + +/* + * Note that a receiver type doesn't get into signatures used by the Kotlin compiler + * So in this test, annotated types shouldn't be reflected in the signatures dump + */ + +public class MethodReceiver { + public void f1(MethodReceiver<@A T> this) { } + + class MethodReceiver3 { + public void f1(@A MethodReceiver3<@A T, K, @A L> this) { } + } +} \ No newline at end of file diff --git a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodReceiver.txt b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodReceiver.txt new file mode 100644 index 00000000000..1964dcde5ba --- /dev/null +++ b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodReceiver.txt @@ -0,0 +1,11 @@ +package test + +public open class MethodReceiver { + public constructor MethodReceiver() + public open fun f1(): kotlin.Unit + + public/*package*/ open inner class MethodReceiver3 /*captured type parameters: /*3*/ T : kotlin.Any!*/ { + public/*package*/ constructor MethodReceiver3() + public open fun f1(): kotlin.Unit + } +} diff --git a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodTypeParameterBounds.java b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodTypeParameterBounds.java new file mode 100644 index 00000000000..1ddc625116a --- /dev/null +++ b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodTypeParameterBounds.java @@ -0,0 +1,33 @@ +// JAVAC_EXPECTED_FILE + +package test; + +import java.lang.annotation.*; + +@Target(ElementType.TYPE_USE) +@interface A { + String value() default ""; +} + +abstract class MethodTypeParameterBounds { + interface I1 {} + interface I2 {} + interface I3 {} + interface I4 {} + + void f1(T x) { } + <_A, B extends @A Integer> void f2(_A x, B y) { } + <_A, B extends Object & @A I1> void f3(_A x, B y) { } + <_A extends @A B, B> void f4(_A x, B y) { } + <_A, B extends @A _A> void f5(_A x, B y) { } + <_A extends @A I1> void f6() { } + abstract <_A, B extends @A _A> void f7(_A x, B y); + abstract <_A extends @A I1, B, C, D extends @A E, E, F> void f8(_A x1, B x2, C x3, D x4, E x5, F x6); + <_A extends Object & I2<@A Integer> & @A I3> void f9(_A x) { } + <_A extends Object & I2 & @A I3> void f10(_A x) { } + <_A extends I4 & I2 & @A I3> void f11(_A x) { } + <_A extends I4 & I2 & @A I3> void f12(_A x) { } + <_A extends I4 & I2 & @A I3> void f13(_A x) { } + abstract <_A extends I4 & I2 & @A I3> void f14(_A x); + <_A extends Object, B extends I3<@A A> & @A I2> void f15(_A x) { } +} diff --git a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodTypeParameterBounds.txt b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodTypeParameterBounds.txt new file mode 100644 index 00000000000..8189a35c39f --- /dev/null +++ b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodTypeParameterBounds.txt @@ -0,0 +1,32 @@ +package test + +public/*package*/ abstract class MethodTypeParameterBounds { + public/*package*/ constructor MethodTypeParameterBounds() + public/*package*/ open fun f1(/*0*/ x: T!): kotlin.Unit + public/*package*/ open fun f10(/*0*/ x: _A!): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2!, _A : @test.A test.MethodTypeParameterBounds.I3! + public/*package*/ open fun ..@test.A kotlin.Array?)>!> f11(/*0*/ x: _A!): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2..@test.A kotlin.Array?)>!, _A : @test.A test.MethodTypeParameterBounds.I3..@test.A kotlin.Array?)>! + public/*package*/ open fun !> f12(/*0*/ x: _A!): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2!, _A : @test.A test.MethodTypeParameterBounds.I3! + public/*package*/ open fun !>!>..@test.A kotlin.Array!>!>?)>!> f13(/*0*/ x: _A!): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2..@test.A kotlin.Array?)>!>!>!>!, _A : @test.A test.MethodTypeParameterBounds.I3!>..@test.A kotlin.Array!>?)>! + public/*package*/ abstract fun !>!> f14(/*0*/ x: _A!): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2!>..@test.A kotlin.Array!>?)>!, _A : @test.A test.MethodTypeParameterBounds.I3..@test.A kotlin.Array?)>!>! + public/*package*/ open fun !> f15(/*0*/ x: _A!): kotlin.Unit where B : @test.A test.MethodTypeParameterBounds.I2! + public/*package*/ open fun f2(/*0*/ x: _A!, /*1*/ y: B!): kotlin.Unit + public/*package*/ open fun f3(/*0*/ x: _A!, /*1*/ y: B!): kotlin.Unit where B : @test.A test.MethodTypeParameterBounds.I1! + public/*package*/ open fun f4(/*0*/ x: _A!, /*1*/ y: B!): kotlin.Unit + public/*package*/ open fun f5(/*0*/ x: _A!, /*1*/ y: B!): kotlin.Unit + public/*package*/ open fun f6(): kotlin.Unit + public/*package*/ abstract fun f7(/*0*/ x: _A!, /*1*/ y: B!): kotlin.Unit + public/*package*/ abstract fun f8(/*0*/ x1: _A!, /*1*/ x2: B!, /*2*/ x3: C!, /*3*/ x4: D!, /*4*/ x5: E!, /*5*/ x6: F!): kotlin.Unit + public/*package*/ open fun f9(/*0*/ x: _A!): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2<@test.A kotlin.Int!>!, _A : @test.A test.MethodTypeParameterBounds.I3! + + public/*package*/ interface I1 { + } + + public/*package*/ interface I2 { + } + + public/*package*/ interface I3 { + } + + public/*package*/ interface I4 { + } +} diff --git a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ReturnType.java b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ReturnType.java new file mode 100644 index 00000000000..5c223aef06f --- /dev/null +++ b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ReturnType.java @@ -0,0 +1,95 @@ +package test; + +import java.lang.annotation.*; + +@Target(ElementType.TYPE_USE) +@interface A { + String value() default ""; +} + +interface G0 { } +interface G1 { } +interface G2 { } + +interface ReturnType { + // simplpe type arguments + G1<@A G0> f0(); + G1>>> f1(); + G1<@A String> f2(); + G2<@A String, G2<@A("abc") Integer, G2<@A("abc") G2, @A("abc") Integer>>> f3(); + + // wildcards + G1 f4 = null; + G1>>> f5(); + G1 f6(); + G2, ? extends @A("abc") Integer>>> f7(); + + G1 f8(); + G1>>> f9(); + G1 f10 = null; + G2, ? super @A("abc") Integer>>> f11(); + + G2, ? extends @A("abc") Integer>>> f12 = null; + + // arrays + Integer @A [] f13(); + int @A [] f14(); + @A Integer [] f15(); + @A int [] f16(); + @A Integer @A [] f17(); + @A int @A [] f18 = null; + + // multidementional arrays + Integer @A [] [] f19(); + int @A [] @A [] f20(); + @A Integer [] [] [] f21 = null; + @A int @A [] @A [] [] @A [] f22(); + @A Integer @A [] [] @A [] [] f23(); + @A int @A [] @A [] f24 = null; + int [] @A [] f25(); + Object [] @A [] f26(); + @A Object [] [] [] [] @A [] f27(); + + // arrays in type arguments + G1 f28(); + G2 f29(); + G1<@A Integer []> f30(); + G1> f31(); + G1, G1<@A int @A []>>> f32(); + G1<@A int @A []> f33(); + G1 f34(); + G2 f35 = null; + G1<@A Integer @A [] []> f36(); + G1> f37(); + G1, G1<@A int [] [] @A []>>> f38(); + G1<@A int @A [] @A [] []> f39(); + + // arrays in wildcard bounds + G1 f40(); + G2 f41(); + G1 f42(); + G1> f43(); + G1, G1>> f44(); + G1, G1>> f45 = null; + G1 f46(); + G1 f47(); + G2 f48 = null; + G1 f49(); + G1> f50(); + G1, G1>> f51(); + G1, G1>> f52 = null; + G1 f53(); + + class ReturnType2 { + G1 f4 = null; + G1 f10 = null; + G2, ? extends @A("abc") Integer>>> f12 = null; + @A int @A [] f18 = null; + @A Integer [] [] [] f21 = null; + @A int @A [] @A [] f24 = null; + G2 f35 = null; + G1, G1>> f45 = null; + G2 f48 = null; + G1, G1>> f52 = null; + } +} diff --git a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ReturnType.txt b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ReturnType.txt new file mode 100644 index 00000000000..923b2caa9a1 --- /dev/null +++ b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ReturnType.txt @@ -0,0 +1,74 @@ +package test + +public/*package*/ interface ReturnType { + public abstract fun f0(): test.G1<@test.A test.G0!>! + public abstract fun f1(): test.G1!>!>!>! + public abstract fun f11(): test.G2!, in @test.A(value = "abc") kotlin.Int!>!>!>! + public abstract fun f13(): (@test.A kotlin.Array..@test.A kotlin.Array?) + public abstract fun f14(): @test.A kotlin.IntArray! + @test.A public abstract fun f15(): kotlin.Array<(out) @test.A kotlin.Int!>! + @test.A public abstract fun f16(): kotlin.IntArray! + @test.A public abstract fun f17(): (@test.A kotlin.Array<@test.A kotlin.Int!>..@test.A kotlin.Array?) + public abstract fun f19(): kotlin.Array<(out) (@test.A kotlin.Array..@test.A kotlin.Array?)>! + public abstract fun f2(): test.G1<@test.A kotlin.String!>! + public abstract fun f20(): (@test.A kotlin.Array<@test.A kotlin.IntArray!>..@test.A kotlin.Array?) + @test.A public abstract fun f22(): (@test.A kotlin.Array..@test.A kotlin.Array?)>!>..@test.A kotlin.Array..@test.A kotlin.Array?)>!>?) + @test.A public abstract fun f23(): kotlin.Array<(out) (@test.A kotlin.Array..@test.A kotlin.Array?)>!>..@test.A kotlin.Array..@test.A kotlin.Array?)>!>?)>! + public abstract fun f25(): (@test.A kotlin.Array..@test.A kotlin.Array?) + public abstract fun f26(): (@test.A kotlin.Array!>..@test.A kotlin.Array!>?) + @test.A public abstract fun f27(): (@test.A kotlin.Array!>!>!>!>..@test.A kotlin.Array!>!>!>!>?) + public abstract fun f28(): test.G1<(@test.A kotlin.Array..@test.A kotlin.Array?)>! + public abstract fun f29(): test.G2! + public abstract fun f3(): test.G2<@test.A kotlin.String!, test.G2<@test.A(value = "abc") kotlin.Int!, test.G2<@test.A(value = "abc") test.G2!, @test.A(value = "abc") kotlin.Int!>!>!>! + public abstract fun f30(): test.G1!>! + public abstract fun f31(): test.G1!>! + public abstract fun f32(): test.G1..@test.A kotlin.Array?)>!, test.G1<@test.A kotlin.IntArray!>!>!>! + public abstract fun f33(): test.G1<@test.A kotlin.IntArray!>! + public abstract fun f34(): test.G1<(@test.A kotlin.Array!>..@test.A kotlin.Array!>?)>! + public abstract fun f36(): test.G1..@test.A kotlin.Array?)>!>! + public abstract fun f37(): test.G1!>!>!>! + public abstract fun f38(): test.G1..@test.A kotlin.Array?)>!, test.G1<(@test.A kotlin.Array!>..@test.A kotlin.Array!>?)>!>!>! + public abstract fun f39(): test.G1..@test.A kotlin.Array?)>!>! + public abstract fun f40(): test.G1..@test.A kotlin.Array?)>! + public abstract fun f41(): test.G2! + public abstract fun f42(): test.G1!>! + public abstract fun f43(): test.G1!>! + public abstract fun f44(): test.G1..@test.A kotlin.Array?)>!, test.G1!>!>! + public abstract fun f46(): test.G1! + public abstract fun f47(): test.G1!>..@test.A kotlin.Array!>?)>! + public abstract fun f49(): test.G1!>!>!>!>!>! + public abstract fun f5(): test.G1!>!>!>! + public abstract fun f50(): test.G1!>!>! + public abstract fun f51(): test.G1!>!>..@test.A kotlin.Array!>!>?)>!, test.G1..@test.A kotlin.Array?)>..@test.A kotlin.Array..@test.A kotlin.Array?)>?)>!>!>! + public abstract fun f53(): test.G1!>! + public abstract fun f6(): test.G1! + public abstract fun f7(): test.G2!, out @test.A(value = "abc") kotlin.Int!>!>!>! + public abstract fun f8(): test.G1! + public abstract fun f9(): test.G1!>!>!>! + + public open class ReturnType2 { + public constructor ReturnType2() + public/*package*/ final var f10: test.G1! + public/*package*/ final var f12: test.G2!, out @test.A(value = "abc") kotlin.Int!>!>!>! + @test.A public/*package*/ final var f18: @test.A kotlin.IntArray! + @test.A public/*package*/ final var f21: kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.Int!>!>!>! + @test.A public/*package*/ final var f24: (@test.A kotlin.Array<@test.A kotlin.IntArray!>..@test.A kotlin.Array?) + public/*package*/ final var f35: test.G2!>! + public/*package*/ final var f4: test.G1! + public/*package*/ final var f45: test.G1..@test.A kotlin.Array?)>!, test.G1!>!>! + public/*package*/ final var f48: test.G2!>..@test.A kotlin.Array!>?)>! + public/*package*/ final var f52: test.G1..@test.A kotlin.Array?)>!>!>!, test.G1..@test.A kotlin.Array?)>!>!>! + } + + // Static members + public final val f10: test.G1! + public final val f12: test.G2!, out @test.A(value = "abc") kotlin.Int!>!>!>! + @test.A public final val f18: @test.A kotlin.IntArray! + @test.A public final val f21: kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.Int!>!>!>! + @test.A public final val f24: (@test.A kotlin.Array<@test.A kotlin.IntArray!>..@test.A kotlin.Array?) + public final val f35: test.G2!>! + public final val f4: test.G1! + public final val f45: test.G1..@test.A kotlin.Array?)>!, test.G1!>!>! + public final val f48: test.G2!>..@test.A kotlin.Array!>?)>! + public final val f52: test.G1..@test.A kotlin.Array?)>!>!>!, test.G1..@test.A kotlin.Array?)>!>!>! +} diff --git a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ValueArguments.java b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ValueArguments.java new file mode 100644 index 00000000000..8d54ff5550d --- /dev/null +++ b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ValueArguments.java @@ -0,0 +1,117 @@ +package test; + +import java.lang.annotation.*; + +@Target(ElementType.TYPE_USE) +@interface A { + String value() default ""; +} + +interface G0 { } +interface G1 { } +interface G2 { } + +interface ValueArguments { + // simplpe type arguments + void f0(G1<@A G0> p); + void f1(G1>>> p); + void f2(G1<@A String> p); + void f3(G2<@A String, G2<@A("abc") Integer, G2<@A("abc") G2, @A("abc") Integer>>> p); + + // wildcards + void f4(G1 p); + void f5(G1>>> p); + void f6(G1 p1, G1>>> p2); + void f7(G2, ? extends @A("abc") Integer>>> p); + + void f8(G1 p); + void f9(G1>>> p); + void f10(G1 p); + void f11(G2, ? super @A("abc") Integer>>> p); + + void f12(G2, ? extends @A("abc") Integer>>> p); + + // arrays + void f13(Integer @A [] p); + void f14(int @A [] p); + void f15(@A Integer [] p); + void f16(@A int [] p); + void f17(@A Integer @A [] p); + void f18(@A int @A [] p1, Integer @A [] p2, @A int [] p3); + + // multidementional arrays + void f19(Integer @A [] [] p); + void f20(int @A [] @A [] p); + void f21(@A Integer [] [] [] p); + void f22(@A int @A [] @A [] [] @A [] p); + void f23(@A Integer @A [] [] @A [] [] p); + void f24(@A int @A [] @A [] p); + void f25(int [] @A [] p); + void f26(Object [] @A [] p1, int [] @A [] p2, @A int @A [] @A [] [] @A [] p3); + void f27(@A Object [] [] [] [] @A [] p); + + // arrays in type arguments + void f28(G1 p); + void f29(G2 p); + void f30(G1<@A Integer []> p); + void f31(G1> p); + void f32(G1, G1<@A int @A []>>> p); + void f33(G1<@A int @A []> p); + void f34(G1 p); + void f35(G2 p1, G1<@A Integer @A [] []> p2, G1> p3); + void f36(G1<@A Integer @A [] []> p); + void f37(G1> p); + void f38(G1, G1<@A int [] [] @A []>>> p); + void f39(G1<@A int @A [] @A [] []> p); + + // arrays in wildcard bounds + void f40(G1 p); + void f41(G2 p); + void f42(G1 p); + void f43(G1> p); + void f44(G1, G1>> p); + void f45(G1, G1>> p); + void f46(G1 p); + void f47(G1 p); + void f48(G2 p); + void f49(G1 p1, G1> p2, G2 p3); + void f50(G1> p); + void f51(G1, G1>> p); + void f52(G1, G1>> p); + void f53(G1 p); + + void f54(G1, G1>> p1, G1<@A int @A [] @A [] []> p2, @A Object [] [] [] [] @A [] p3, @A int @A [] p4, G2, ? extends @A("abc") Integer>>> p5); + + // varargs + void f55(@A String ... x); + void f56(String @A ... x); + void f57(@A String @A ... x); + void f58(@A int ... x); + void f59(int @A ... x); + void f60(@A int @A ... x); + + // varargs + arrays + void f61(@A String [] ... x); + void f62(String @A [] ... x); + void f63(String [] @A ... x); + void f64(@A String @A [] @A ... x); + void f65(@A int [] ... x); + void f66(int @A [] ... x); + void f67(int [] @A ... x); + void f68(@A int @A [] @A ... x); + + void f69(@A String [] [] ... x); + void f70(String [] @A [] ... x); + void f71(String [] [] [] @A ... x); + void f72(@A String @A [] [] @A [] @A ... x); + void f73(@A int [] @A [] ... x); + void f74(int @A [][][] @A [] ... x); + void f75(int [] [] [] @A ... x); + void f76(@A int @A [] [] @A ... x); + + class Test { + public Test(G2, ? extends @A("abc") Integer>>> p1, Object [] @A [] p2, int [] @A [] p3, @A int @A [] @A [] [] @A [] p4, @A int @A [] [] @A ... p5) { + + } + } +} diff --git a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ValueArguments.txt b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ValueArguments.txt new file mode 100644 index 00000000000..96ff61a326e --- /dev/null +++ b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ValueArguments.txt @@ -0,0 +1,85 @@ +package test + +public/*package*/ interface ValueArguments { + public abstract fun f0(/*0*/ p: test.G1<@test.A test.G0!>!): kotlin.Unit + public abstract fun f1(/*0*/ p: test.G1!>!>!>!): kotlin.Unit + public abstract fun f10(/*0*/ p: test.G1!): kotlin.Unit + public abstract fun f11(/*0*/ p: test.G2!, in @test.A(value = "abc") kotlin.Int!>!>!>!): kotlin.Unit + public abstract fun f12(/*0*/ p: test.G2!, out @test.A(value = "abc") kotlin.Int!>!>!>!): kotlin.Unit + public abstract fun f13(/*0*/ p: (@test.A kotlin.Array..@test.A kotlin.Array?)): kotlin.Unit + public abstract fun f14(/*0*/ p: @test.A kotlin.IntArray!): kotlin.Unit + public abstract fun f15(/*0*/ @test.A p: kotlin.Array<(out) @test.A kotlin.Int!>!): kotlin.Unit + public abstract fun f16(/*0*/ @test.A p: kotlin.IntArray!): kotlin.Unit + public abstract fun f17(/*0*/ @test.A p: (@test.A kotlin.Array<@test.A kotlin.Int!>..@test.A kotlin.Array?)): kotlin.Unit + public abstract fun f18(/*0*/ @test.A p1: @test.A kotlin.IntArray!, /*1*/ p2: (@test.A kotlin.Array..@test.A kotlin.Array?), /*2*/ @test.A p3: kotlin.IntArray!): kotlin.Unit + public abstract fun f19(/*0*/ p: kotlin.Array<(out) (@test.A kotlin.Array..@test.A kotlin.Array?)>!): kotlin.Unit + public abstract fun f2(/*0*/ p: test.G1<@test.A kotlin.String!>!): kotlin.Unit + public abstract fun f20(/*0*/ p: (@test.A kotlin.Array<@test.A kotlin.IntArray!>..@test.A kotlin.Array?)): kotlin.Unit + public abstract fun f21(/*0*/ @test.A p: kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.Int!>!>!>!): kotlin.Unit + public abstract fun f22(/*0*/ @test.A p: (@test.A kotlin.Array..@test.A kotlin.Array?)>!>..@test.A kotlin.Array..@test.A kotlin.Array?)>!>?)): kotlin.Unit + public abstract fun f23(/*0*/ @test.A p: kotlin.Array<(out) (@test.A kotlin.Array..@test.A kotlin.Array?)>!>..@test.A kotlin.Array..@test.A kotlin.Array?)>!>?)>!): kotlin.Unit + public abstract fun f24(/*0*/ @test.A p: (@test.A kotlin.Array<@test.A kotlin.IntArray!>..@test.A kotlin.Array?)): kotlin.Unit + public abstract fun f25(/*0*/ p: (@test.A kotlin.Array..@test.A kotlin.Array?)): kotlin.Unit + public abstract fun f26(/*0*/ p1: (@test.A kotlin.Array!>..@test.A kotlin.Array!>?), /*1*/ p2: (@test.A kotlin.Array..@test.A kotlin.Array?), /*2*/ @test.A p3: (@test.A kotlin.Array..@test.A kotlin.Array?)>!>..@test.A kotlin.Array..@test.A kotlin.Array?)>!>?)): kotlin.Unit + public abstract fun f27(/*0*/ @test.A p: (@test.A kotlin.Array!>!>!>!>..@test.A kotlin.Array!>!>!>!>?)): kotlin.Unit + public abstract fun f28(/*0*/ p: test.G1<(@test.A kotlin.Array..@test.A kotlin.Array?)>!): kotlin.Unit + public abstract fun f29(/*0*/ p: test.G2!): kotlin.Unit + public abstract fun f3(/*0*/ p: test.G2<@test.A kotlin.String!, test.G2<@test.A(value = "abc") kotlin.Int!, test.G2<@test.A(value = "abc") test.G2!, @test.A(value = "abc") kotlin.Int!>!>!>!): kotlin.Unit + public abstract fun f30(/*0*/ p: test.G1!>!): kotlin.Unit + public abstract fun f31(/*0*/ p: test.G1!>!): kotlin.Unit + public abstract fun f32(/*0*/ p: test.G1..@test.A kotlin.Array?)>!, test.G1<@test.A kotlin.IntArray!>!>!>!): kotlin.Unit + public abstract fun f33(/*0*/ p: test.G1<@test.A kotlin.IntArray!>!): kotlin.Unit + public abstract fun f34(/*0*/ p: test.G1<(@test.A kotlin.Array!>..@test.A kotlin.Array!>?)>!): kotlin.Unit + public abstract fun f35(/*0*/ p1: test.G2!>!, /*1*/ p2: test.G1..@test.A kotlin.Array?)>!>!, /*2*/ p3: test.G1!>!): kotlin.Unit + public abstract fun f36(/*0*/ p: test.G1..@test.A kotlin.Array?)>!>!): kotlin.Unit + public abstract fun f37(/*0*/ p: test.G1!>!>!>!): kotlin.Unit + public abstract fun f38(/*0*/ p: test.G1..@test.A kotlin.Array?)>!, test.G1<(@test.A kotlin.Array!>..@test.A kotlin.Array!>?)>!>!>!): kotlin.Unit + public abstract fun f39(/*0*/ p: test.G1..@test.A kotlin.Array?)>!>!): kotlin.Unit + public abstract fun f4(/*0*/ p: test.G1!): kotlin.Unit + public abstract fun f40(/*0*/ p: test.G1..@test.A kotlin.Array?)>!): kotlin.Unit + public abstract fun f41(/*0*/ p: test.G2!): kotlin.Unit + public abstract fun f42(/*0*/ p: test.G1!>!): kotlin.Unit + public abstract fun f43(/*0*/ p: test.G1!>!): kotlin.Unit + public abstract fun f44(/*0*/ p: test.G1..@test.A kotlin.Array?)>!, test.G1!>!>!): kotlin.Unit + public abstract fun f45(/*0*/ p: test.G1..@test.A kotlin.Array?)>!, test.G1!>!>!): kotlin.Unit + public abstract fun f46(/*0*/ p: test.G1!): kotlin.Unit + public abstract fun f47(/*0*/ p: test.G1!>..@test.A kotlin.Array!>?)>!): kotlin.Unit + public abstract fun f48(/*0*/ p: test.G2!>..@test.A kotlin.Array!>?)>!): kotlin.Unit + public abstract fun f49(/*0*/ p1: test.G1!>!>!>!>!>!, /*1*/ p2: test.G1!>!>!, /*2*/ p3: test.G2!>..@test.A kotlin.Array!>?)>!): kotlin.Unit + public abstract fun f5(/*0*/ p: test.G1!>!>!>!): kotlin.Unit + public abstract fun f50(/*0*/ p: test.G1!>!>!): kotlin.Unit + public abstract fun f51(/*0*/ p: test.G1!>!>..@test.A kotlin.Array!>!>?)>!, test.G1..@test.A kotlin.Array?)>..@test.A kotlin.Array..@test.A kotlin.Array?)>?)>!>!>!): kotlin.Unit + public abstract fun f52(/*0*/ p: test.G1..@test.A kotlin.Array?)>!>!>!, test.G1..@test.A kotlin.Array?)>!>!>!): kotlin.Unit + public abstract fun f53(/*0*/ p: test.G1!>!): kotlin.Unit + public abstract fun f54(/*0*/ p1: test.G1..@test.A kotlin.Array?)>!>!>!, test.G1..@test.A kotlin.Array?)>!>!>!, /*1*/ p2: test.G1..@test.A kotlin.Array?)>!>!, /*2*/ @test.A p3: (@test.A kotlin.Array!>!>!>!>..@test.A kotlin.Array!>!>!>!>?), /*3*/ @test.A p4: @test.A kotlin.IntArray!, /*4*/ p5: test.G2!, out @test.A(value = "abc") kotlin.Int!>!>!>!): kotlin.Unit + public abstract fun f55(/*0*/ @test.A vararg x: @test.A kotlin.String! /*kotlin.Array<(out) @test.A kotlin.String!>!*/): kotlin.Unit + public abstract fun f56(/*0*/ vararg x: kotlin.String! /*(@test.A kotlin.Array..@test.A kotlin.Array?)*/): kotlin.Unit + public abstract fun f57(/*0*/ @test.A vararg x: @test.A kotlin.String! /*(@test.A kotlin.Array<@test.A kotlin.String!>..@test.A kotlin.Array?)*/): kotlin.Unit + public abstract fun f58(/*0*/ @test.A vararg x: kotlin.Int /*kotlin.IntArray!*/): kotlin.Unit + public abstract fun f59(/*0*/ vararg x: kotlin.Int /*@test.A kotlin.IntArray!*/): kotlin.Unit + public abstract fun f6(/*0*/ p1: test.G1!, /*1*/ p2: test.G1!>!>!>!): kotlin.Unit + public abstract fun f60(/*0*/ @test.A vararg x: kotlin.Int /*@test.A kotlin.IntArray!*/): kotlin.Unit + public abstract fun f61(/*0*/ @test.A vararg x: kotlin.Array<(out) @test.A kotlin.String!>! /*kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.String!>!>!*/): kotlin.Unit + public abstract fun f62(/*0*/ vararg x: (@test.A kotlin.Array..@test.A kotlin.Array?) /*kotlin.Array<(out) (@test.A kotlin.Array..@test.A kotlin.Array?)>!*/): kotlin.Unit + public abstract fun f63(/*0*/ vararg x: kotlin.Array<(out) kotlin.String!>! /*(@test.A kotlin.Array!>..@test.A kotlin.Array!>?)*/): kotlin.Unit + public abstract fun f64(/*0*/ @test.A vararg x: (@test.A kotlin.Array<@test.A kotlin.String!>..@test.A kotlin.Array?) /*(@test.A kotlin.Array<(@test.A kotlin.Array<@test.A kotlin.String!>..@test.A kotlin.Array?)>..@test.A kotlin.Array..@test.A kotlin.Array?)>?)*/): kotlin.Unit + public abstract fun f65(/*0*/ @test.A vararg x: kotlin.IntArray! /*kotlin.Array<(out) kotlin.IntArray!>!*/): kotlin.Unit + public abstract fun f66(/*0*/ vararg x: @test.A kotlin.IntArray! /*kotlin.Array<(out) @test.A kotlin.IntArray!>!*/): kotlin.Unit + public abstract fun f67(/*0*/ vararg x: kotlin.IntArray! /*(@test.A kotlin.Array..@test.A kotlin.Array?)*/): kotlin.Unit + public abstract fun f68(/*0*/ @test.A vararg x: @test.A kotlin.IntArray! /*(@test.A kotlin.Array<@test.A kotlin.IntArray!>..@test.A kotlin.Array?)*/): kotlin.Unit + public abstract fun f69(/*0*/ @test.A vararg x: kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.String!>!>! /*kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.String!>!>!>!*/): kotlin.Unit + public abstract fun f7(/*0*/ p: test.G2!, out @test.A(value = "abc") kotlin.Int!>!>!>!): kotlin.Unit + public abstract fun f70(/*0*/ vararg x: (@test.A kotlin.Array!>..@test.A kotlin.Array!>?) /*kotlin.Array<(out) (@test.A kotlin.Array!>..@test.A kotlin.Array!>?)>!*/): kotlin.Unit + public abstract fun f71(/*0*/ vararg x: kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.String!>!>!>! /*(@test.A kotlin.Array!>!>!>..@test.A kotlin.Array!>!>!>?)*/): kotlin.Unit + public abstract fun f72(/*0*/ @test.A vararg x: (@test.A kotlin.Array..@test.A kotlin.Array?)>!>..@test.A kotlin.Array..@test.A kotlin.Array?)>!>?) /*(@test.A kotlin.Array<(@test.A kotlin.Array..@test.A kotlin.Array?)>!>..@test.A kotlin.Array..@test.A kotlin.Array?)>!>?)>..@test.A kotlin.Array..@test.A kotlin.Array?)>!>..@test.A kotlin.Array..@test.A kotlin.Array?)>!>?)>?)*/): kotlin.Unit + public abstract fun f73(/*0*/ @test.A vararg x: (@test.A kotlin.Array..@test.A kotlin.Array?) /*kotlin.Array<(out) (@test.A kotlin.Array..@test.A kotlin.Array?)>!*/): kotlin.Unit + public abstract fun f74(/*0*/ vararg x: (@test.A kotlin.Array!>!>..@test.A kotlin.Array!>!>?) /*kotlin.Array<(out) (@test.A kotlin.Array!>!>..@test.A kotlin.Array!>!>?)>!*/): kotlin.Unit + public abstract fun f75(/*0*/ vararg x: kotlin.Array<(out) kotlin.Array<(out) kotlin.IntArray!>!>! /*(@test.A kotlin.Array!>!>..@test.A kotlin.Array!>!>?)*/): kotlin.Unit + public abstract fun f76(/*0*/ @test.A vararg x: kotlin.Array<(out) @test.A kotlin.IntArray!>! /*(@test.A kotlin.Array!>..@test.A kotlin.Array!>?)*/): kotlin.Unit + public abstract fun f8(/*0*/ p: test.G1!): kotlin.Unit + public abstract fun f9(/*0*/ p: test.G1!>!>!>!): kotlin.Unit + + public open class Test { + public constructor Test(/*0*/ p1: test.G2!, out @test.A(value = "abc") kotlin.Int!>!>!>!, /*1*/ p2: (@test.A kotlin.Array!>..@test.A kotlin.Array!>?), /*2*/ p3: (@test.A kotlin.Array..@test.A kotlin.Array?), /*3*/ @test.A p4: (@test.A kotlin.Array..@test.A kotlin.Array?)>!>..@test.A kotlin.Array..@test.A kotlin.Array?)>!>?), /*4*/ @test.A vararg p5: kotlin.Array<(out) @test.A kotlin.IntArray!>! /*(@test.A kotlin.Array!>..@test.A kotlin.Array!>?)*/) + } +} diff --git a/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/LoadJava8TestGenerated.java b/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/LoadJava8TestGenerated.java index 2262382181b..bb0a0cef3f3 100644 --- a/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/LoadJava8TestGenerated.java +++ b/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/LoadJava8TestGenerated.java @@ -46,14 +46,70 @@ public class LoadJava8TestGenerated extends AbstractLoadJava8Test { runTest("compiler/testData/loadJava8/compiledJava/ParameterNames.java"); } - @TestMetadata("TypeAnnotations.java") - public void testTypeAnnotations() throws Exception { - runTest("compiler/testData/loadJava8/compiledJava/TypeAnnotations.java"); + @TestMetadata("compiler/testData/loadJava8/compiledJava/typeParameterAnnotations") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TypeParameterAnnotations extends AbstractLoadJava8Test { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTestCompiledJava, this, testDataFilePath); + } + + public void testAllFilesPresentInTypeParameterAnnotations() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/compiledJava/typeParameterAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true); + } + + @TestMetadata("Basic.java") + public void testBasic() throws Exception { + runTest("compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic.java"); + } } - @TestMetadata("TypeParameterAnnotations.java") - public void testTypeParameterAnnotations() throws Exception { - runTest("compiler/testData/loadJava8/compiledJava/TypeParameterAnnotations.java"); + @TestMetadata("compiler/testData/loadJava8/compiledJava/typeUseAnnotations") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TypeUseAnnotations extends AbstractLoadJava8Test { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTestCompiledJava, this, testDataFilePath); + } + + public void testAllFilesPresentInTypeUseAnnotations() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/compiledJava/typeUseAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true); + } + + @TestMetadata("BaseClassTypeArguments.java") + public void testBaseClassTypeArguments() throws Exception { + runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/BaseClassTypeArguments.java"); + } + + @TestMetadata("Basic.java") + public void testBasic() throws Exception { + runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic.java"); + } + + @TestMetadata("ClassTypeParameterBounds.java") + public void testClassTypeParameterBounds() throws Exception { + runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ClassTypeParameterBounds.java"); + } + + @TestMetadata("MethodReceiver.java") + public void testMethodReceiver() throws Exception { + runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodReceiver.java"); + } + + @TestMetadata("MethodTypeParameterBounds.java") + public void testMethodTypeParameterBounds() throws Exception { + runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodTypeParameterBounds.java"); + } + + @TestMetadata("ReturnType.java") + public void testReturnType() throws Exception { + runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ReturnType.java"); + } + + @TestMetadata("ValueArguments.java") + public void testValueArguments() throws Exception { + runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ValueArguments.java"); + } } } @@ -74,14 +130,75 @@ public class LoadJava8TestGenerated extends AbstractLoadJava8Test { runTest("compiler/testData/loadJava8/sourceJava/MapRemove.java"); } - @TestMetadata("TypeAnnotations.java") - public void testTypeAnnotations() throws Exception { - runTest("compiler/testData/loadJava8/sourceJava/TypeAnnotations.java"); - } - @TestMetadata("TypeParameterAnnotations.java") public void testTypeParameterAnnotations() throws Exception { runTest("compiler/testData/loadJava8/sourceJava/TypeParameterAnnotations.java"); } + + @TestMetadata("compiler/testData/loadJava8/sourceJava/typeParameterAnnotations") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TypeParameterAnnotations extends AbstractLoadJava8Test { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTestSourceJava, this, testDataFilePath); + } + + public void testAllFilesPresentInTypeParameterAnnotations() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/sourceJava/typeParameterAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true); + } + + @TestMetadata("Basic.java") + public void testBasic() throws Exception { + runTest("compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic.java"); + } + } + + @TestMetadata("compiler/testData/loadJava8/sourceJava/typeUseAnnotations") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TypeUseAnnotations extends AbstractLoadJava8Test { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTestSourceJava, this, testDataFilePath); + } + + public void testAllFilesPresentInTypeUseAnnotations() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/sourceJava/typeUseAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true); + } + + @TestMetadata("BaseClassTypeArguments.java") + public void testBaseClassTypeArguments() throws Exception { + runTest("compiler/testData/loadJava8/sourceJava/typeUseAnnotations/BaseClassTypeArguments.java"); + } + + @TestMetadata("Basic.java") + public void testBasic() throws Exception { + runTest("compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic.java"); + } + + @TestMetadata("ClassTypeParameterBounds.java") + public void testClassTypeParameterBounds() throws Exception { + runTest("compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ClassTypeParameterBounds.java"); + } + + @TestMetadata("MethodReceiver.java") + public void testMethodReceiver() throws Exception { + runTest("compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodReceiver.java"); + } + + @TestMetadata("MethodTypeParameterBounds.java") + public void testMethodTypeParameterBounds() throws Exception { + runTest("compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodTypeParameterBounds.java"); + } + + @TestMetadata("ReturnType.java") + public void testReturnType() throws Exception { + runTest("compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ReturnType.java"); + } + + @TestMetadata("ValueArguments.java") + public void testValueArguments() throws Exception { + runTest("compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ValueArguments.java"); + } + } } } diff --git a/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/LoadJava8WithPsiClassReadingTestGenerated.java b/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/LoadJava8WithPsiClassReadingTestGenerated.java index b1d1f14a44e..4cf9cfb4590 100644 --- a/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/LoadJava8WithPsiClassReadingTestGenerated.java +++ b/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/LoadJava8WithPsiClassReadingTestGenerated.java @@ -44,13 +44,69 @@ public class LoadJava8WithPsiClassReadingTestGenerated extends AbstractLoadJava8 runTest("compiler/testData/loadJava8/compiledJava/ParameterNames.java"); } - @TestMetadata("TypeAnnotations.java") - public void testTypeAnnotations() throws Exception { - runTest("compiler/testData/loadJava8/compiledJava/TypeAnnotations.java"); + @TestMetadata("compiler/testData/loadJava8/compiledJava/typeParameterAnnotations") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TypeParameterAnnotations extends AbstractLoadJava8WithPsiClassReadingTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTestCompiledJava, this, testDataFilePath); + } + + public void testAllFilesPresentInTypeParameterAnnotations() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/compiledJava/typeParameterAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true); + } + + @TestMetadata("Basic.java") + public void testBasic() throws Exception { + runTest("compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic.java"); + } } - @TestMetadata("TypeParameterAnnotations.java") - public void testTypeParameterAnnotations() throws Exception { - runTest("compiler/testData/loadJava8/compiledJava/TypeParameterAnnotations.java"); + @TestMetadata("compiler/testData/loadJava8/compiledJava/typeUseAnnotations") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TypeUseAnnotations extends AbstractLoadJava8WithPsiClassReadingTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTestCompiledJava, this, testDataFilePath); + } + + public void testAllFilesPresentInTypeUseAnnotations() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/compiledJava/typeUseAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true); + } + + @TestMetadata("BaseClassTypeArguments.java") + public void testBaseClassTypeArguments() throws Exception { + runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/BaseClassTypeArguments.java"); + } + + @TestMetadata("Basic.java") + public void testBasic() throws Exception { + runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic.java"); + } + + @TestMetadata("ClassTypeParameterBounds.java") + public void testClassTypeParameterBounds() throws Exception { + runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ClassTypeParameterBounds.java"); + } + + @TestMetadata("MethodReceiver.java") + public void testMethodReceiver() throws Exception { + runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodReceiver.java"); + } + + @TestMetadata("MethodTypeParameterBounds.java") + public void testMethodTypeParameterBounds() throws Exception { + runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodTypeParameterBounds.java"); + } + + @TestMetadata("ReturnType.java") + public void testReturnType() throws Exception { + runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ReturnType.java"); + } + + @TestMetadata("ValueArguments.java") + public void testValueArguments() throws Exception { + runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ValueArguments.java"); + } } } diff --git a/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/javac/LoadJava8UsingJavacTestGenerated.java b/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/javac/LoadJava8UsingJavacTestGenerated.java index 248e50883db..6f3908dc8dc 100644 --- a/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/javac/LoadJava8UsingJavacTestGenerated.java +++ b/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/javac/LoadJava8UsingJavacTestGenerated.java @@ -46,14 +46,70 @@ public class LoadJava8UsingJavacTestGenerated extends AbstractLoadJava8UsingJava runTest("compiler/testData/loadJava8/compiledJava/ParameterNames.java"); } - @TestMetadata("TypeAnnotations.java") - public void testTypeAnnotations() throws Exception { - runTest("compiler/testData/loadJava8/compiledJava/TypeAnnotations.java"); + @TestMetadata("compiler/testData/loadJava8/compiledJava/typeParameterAnnotations") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TypeParameterAnnotations extends AbstractLoadJava8UsingJavacTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTestCompiledJava, this, testDataFilePath); + } + + public void testAllFilesPresentInTypeParameterAnnotations() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/compiledJava/typeParameterAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true); + } + + @TestMetadata("Basic.java") + public void testBasic() throws Exception { + runTest("compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic.java"); + } } - @TestMetadata("TypeParameterAnnotations.java") - public void testTypeParameterAnnotations() throws Exception { - runTest("compiler/testData/loadJava8/compiledJava/TypeParameterAnnotations.java"); + @TestMetadata("compiler/testData/loadJava8/compiledJava/typeUseAnnotations") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TypeUseAnnotations extends AbstractLoadJava8UsingJavacTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTestCompiledJava, this, testDataFilePath); + } + + public void testAllFilesPresentInTypeUseAnnotations() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/compiledJava/typeUseAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true); + } + + @TestMetadata("BaseClassTypeArguments.java") + public void testBaseClassTypeArguments() throws Exception { + runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/BaseClassTypeArguments.java"); + } + + @TestMetadata("Basic.java") + public void testBasic() throws Exception { + runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic.java"); + } + + @TestMetadata("ClassTypeParameterBounds.java") + public void testClassTypeParameterBounds() throws Exception { + runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ClassTypeParameterBounds.java"); + } + + @TestMetadata("MethodReceiver.java") + public void testMethodReceiver() throws Exception { + runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodReceiver.java"); + } + + @TestMetadata("MethodTypeParameterBounds.java") + public void testMethodTypeParameterBounds() throws Exception { + runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodTypeParameterBounds.java"); + } + + @TestMetadata("ReturnType.java") + public void testReturnType() throws Exception { + runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ReturnType.java"); + } + + @TestMetadata("ValueArguments.java") + public void testValueArguments() throws Exception { + runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ValueArguments.java"); + } } } @@ -74,14 +130,75 @@ public class LoadJava8UsingJavacTestGenerated extends AbstractLoadJava8UsingJava runTest("compiler/testData/loadJava8/sourceJava/MapRemove.java"); } - @TestMetadata("TypeAnnotations.java") - public void testTypeAnnotations() throws Exception { - runTest("compiler/testData/loadJava8/sourceJava/TypeAnnotations.java"); - } - @TestMetadata("TypeParameterAnnotations.java") public void testTypeParameterAnnotations() throws Exception { runTest("compiler/testData/loadJava8/sourceJava/TypeParameterAnnotations.java"); } + + @TestMetadata("compiler/testData/loadJava8/sourceJava/typeParameterAnnotations") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TypeParameterAnnotations extends AbstractLoadJava8UsingJavacTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTestSourceJava, this, testDataFilePath); + } + + public void testAllFilesPresentInTypeParameterAnnotations() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/sourceJava/typeParameterAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true); + } + + @TestMetadata("Basic.java") + public void testBasic() throws Exception { + runTest("compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic.java"); + } + } + + @TestMetadata("compiler/testData/loadJava8/sourceJava/typeUseAnnotations") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TypeUseAnnotations extends AbstractLoadJava8UsingJavacTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTestSourceJava, this, testDataFilePath); + } + + public void testAllFilesPresentInTypeUseAnnotations() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/sourceJava/typeUseAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true); + } + + @TestMetadata("BaseClassTypeArguments.java") + public void testBaseClassTypeArguments() throws Exception { + runTest("compiler/testData/loadJava8/sourceJava/typeUseAnnotations/BaseClassTypeArguments.java"); + } + + @TestMetadata("Basic.java") + public void testBasic() throws Exception { + runTest("compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic.java"); + } + + @TestMetadata("ClassTypeParameterBounds.java") + public void testClassTypeParameterBounds() throws Exception { + runTest("compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ClassTypeParameterBounds.java"); + } + + @TestMetadata("MethodReceiver.java") + public void testMethodReceiver() throws Exception { + runTest("compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodReceiver.java"); + } + + @TestMetadata("MethodTypeParameterBounds.java") + public void testMethodTypeParameterBounds() throws Exception { + runTest("compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodTypeParameterBounds.java"); + } + + @TestMetadata("ReturnType.java") + public void testReturnType() throws Exception { + runTest("compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ReturnType.java"); + } + + @TestMetadata("ValueArguments.java") + public void testValueArguments() throws Exception { + runTest("compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ValueArguments.java"); + } + } } } diff --git a/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/structure/javaElements.kt b/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/structure/javaElements.kt index 15d34def2c8..59ad273fb98 100644 --- a/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/structure/javaElements.kt +++ b/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/structure/javaElements.kt @@ -29,9 +29,9 @@ interface JavaNamedElement : JavaElement { interface JavaAnnotationOwner : JavaElement { val annotations: Collection - fun findAnnotation(fqName: FqName): JavaAnnotation? - val isDeprecatedInJavaDoc: Boolean + + fun findAnnotation(fqName: FqName): JavaAnnotation? } interface JavaModifierListOwner : JavaElement { @@ -56,9 +56,17 @@ interface JavaAnnotation : JavaElement { interface MapBasedJavaAnnotationOwner : JavaAnnotationOwner { val annotationsByFqName: Map + + override val isDeprecatedInJavaDoc: Boolean get() = false override fun findAnnotation(fqName: FqName) = annotationsByFqName[fqName] - override val isDeprecatedInJavaDoc: Boolean - get() = false +} + +interface ListBasedJavaAnnotationOwner : JavaAnnotationOwner { + override fun findAnnotation(fqName: FqName) = annotations.find { it.classId?.asSingleFqName() == fqName } +} + +interface MutableJavaAnnotationOwner : JavaAnnotationOwner { + override val annotations: MutableCollection } fun JavaAnnotationOwner.buildLazyValueForMap() = lazy { diff --git a/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/structure/javaTypes.kt b/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/structure/javaTypes.kt index 1e87b4edada..4c48535ba3a 100644 --- a/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/structure/javaTypes.kt +++ b/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/structure/javaTypes.kt @@ -18,13 +18,13 @@ package org.jetbrains.kotlin.load.java.structure import org.jetbrains.kotlin.builtins.PrimitiveType -interface JavaType +interface JavaType : ListBasedJavaAnnotationOwner interface JavaArrayType : JavaType { val componentType: JavaType } -interface JavaClassifierType : JavaType, JavaAnnotationOwner { +interface JavaClassifierType : JavaType { val classifier: JavaClassifier? val typeArguments: List diff --git a/core/descriptors.runtime/src/org/jetbrains/kotlin/descriptors/runtime/structure/ReflectJavaArrayType.kt b/core/descriptors.runtime/src/org/jetbrains/kotlin/descriptors/runtime/structure/ReflectJavaArrayType.kt index e4c3463e2a5..49435fec11f 100644 --- a/core/descriptors.runtime/src/org/jetbrains/kotlin/descriptors/runtime/structure/ReflectJavaArrayType.kt +++ b/core/descriptors.runtime/src/org/jetbrains/kotlin/descriptors/runtime/structure/ReflectJavaArrayType.kt @@ -16,6 +16,7 @@ package org.jetbrains.kotlin.descriptors.runtime.structure +import org.jetbrains.kotlin.load.java.structure.JavaAnnotation import org.jetbrains.kotlin.load.java.structure.JavaArrayType import java.lang.reflect.GenericArrayType import java.lang.reflect.Type @@ -28,4 +29,8 @@ class ReflectJavaArrayType(override val reflectType: Type) : ReflectJavaType(), else -> throw IllegalArgumentException("Not an array type (${reflectType::class.java}): $reflectType") } } + + // TODO: support type use annotations in reflection + override val annotations: Collection = emptyList() + override val isDeprecatedInJavaDoc = false } diff --git a/core/descriptors.runtime/src/org/jetbrains/kotlin/descriptors/runtime/structure/ReflectJavaPrimitiveType.kt b/core/descriptors.runtime/src/org/jetbrains/kotlin/descriptors/runtime/structure/ReflectJavaPrimitiveType.kt index 87cd7139058..774823072c3 100644 --- a/core/descriptors.runtime/src/org/jetbrains/kotlin/descriptors/runtime/structure/ReflectJavaPrimitiveType.kt +++ b/core/descriptors.runtime/src/org/jetbrains/kotlin/descriptors/runtime/structure/ReflectJavaPrimitiveType.kt @@ -17,6 +17,7 @@ package org.jetbrains.kotlin.descriptors.runtime.structure import org.jetbrains.kotlin.builtins.PrimitiveType +import org.jetbrains.kotlin.load.java.structure.JavaAnnotation import org.jetbrains.kotlin.load.java.structure.JavaPrimitiveType import org.jetbrains.kotlin.resolve.jvm.JvmPrimitiveType @@ -26,4 +27,8 @@ class ReflectJavaPrimitiveType(override val reflectType: Class<*>) : ReflectJava null else JvmPrimitiveType.get(reflectType.name).primitiveType + + // TODO: support type use annotations in reflection + override val annotations: Collection = emptyList() + override val isDeprecatedInJavaDoc = false } diff --git a/core/descriptors.runtime/src/org/jetbrains/kotlin/descriptors/runtime/structure/ReflectJavaWildcardType.kt b/core/descriptors.runtime/src/org/jetbrains/kotlin/descriptors/runtime/structure/ReflectJavaWildcardType.kt index 54f35496650..9df5f9ec6dc 100644 --- a/core/descriptors.runtime/src/org/jetbrains/kotlin/descriptors/runtime/structure/ReflectJavaWildcardType.kt +++ b/core/descriptors.runtime/src/org/jetbrains/kotlin/descriptors/runtime/structure/ReflectJavaWildcardType.kt @@ -16,6 +16,7 @@ package org.jetbrains.kotlin.descriptors.runtime.structure +import org.jetbrains.kotlin.load.java.structure.JavaAnnotation import org.jetbrains.kotlin.load.java.structure.JavaWildcardType import java.lang.reflect.WildcardType @@ -36,4 +37,8 @@ class ReflectJavaWildcardType(override val reflectType: WildcardType) : ReflectJ override val isExtends: Boolean get() = reflectType.upperBounds.firstOrNull() != Any::class.java + + // TODO: support type use annotations in reflection + override val annotations: Collection = emptyList() + override val isDeprecatedInJavaDoc = false } diff --git a/core/descriptors.runtime/tests/org/jetbrains/kotlin/jvm/runtime/Jvm8RuntimeDescriptorLoaderTestGenerated.java b/core/descriptors.runtime/tests/org/jetbrains/kotlin/jvm/runtime/Jvm8RuntimeDescriptorLoaderTestGenerated.java index f28d46f1df2..6d4f6f0646a 100644 --- a/core/descriptors.runtime/tests/org/jetbrains/kotlin/jvm/runtime/Jvm8RuntimeDescriptorLoaderTestGenerated.java +++ b/core/descriptors.runtime/tests/org/jetbrains/kotlin/jvm/runtime/Jvm8RuntimeDescriptorLoaderTestGenerated.java @@ -44,13 +44,69 @@ public class Jvm8RuntimeDescriptorLoaderTestGenerated extends AbstractJvm8Runtim runTest("compiler/testData/loadJava8/compiledJava/ParameterNames.java"); } - @TestMetadata("TypeAnnotations.java") - public void testTypeAnnotations() throws Exception { - runTest("compiler/testData/loadJava8/compiledJava/TypeAnnotations.java"); + @TestMetadata("compiler/testData/loadJava8/compiledJava/typeParameterAnnotations") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TypeParameterAnnotations extends AbstractJvm8RuntimeDescriptorLoaderTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); + } + + public void testAllFilesPresentInTypeParameterAnnotations() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/compiledJava/typeParameterAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true); + } + + @TestMetadata("Basic.java") + public void testBasic() throws Exception { + runTest("compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic.java"); + } } - @TestMetadata("TypeParameterAnnotations.java") - public void testTypeParameterAnnotations() throws Exception { - runTest("compiler/testData/loadJava8/compiledJava/TypeParameterAnnotations.java"); + @TestMetadata("compiler/testData/loadJava8/compiledJava/typeUseAnnotations") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TypeUseAnnotations extends AbstractJvm8RuntimeDescriptorLoaderTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); + } + + public void testAllFilesPresentInTypeUseAnnotations() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/compiledJava/typeUseAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true); + } + + @TestMetadata("BaseClassTypeArguments.java") + public void testBaseClassTypeArguments() throws Exception { + runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/BaseClassTypeArguments.java"); + } + + @TestMetadata("Basic.java") + public void testBasic() throws Exception { + runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic.java"); + } + + @TestMetadata("ClassTypeParameterBounds.java") + public void testClassTypeParameterBounds() throws Exception { + runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ClassTypeParameterBounds.java"); + } + + @TestMetadata("MethodReceiver.java") + public void testMethodReceiver() throws Exception { + runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodReceiver.java"); + } + + @TestMetadata("MethodTypeParameterBounds.java") + public void testMethodTypeParameterBounds() throws Exception { + runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodTypeParameterBounds.java"); + } + + @TestMetadata("ReturnType.java") + public void testReturnType() throws Exception { + runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ReturnType.java"); + } + + @TestMetadata("ValueArguments.java") + public void testValueArguments() throws Exception { + runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ValueArguments.java"); + } } } From 6f64e2c0360a8c760f188ac5286a3c117a7635ae Mon Sep 17 00:00:00 2001 From: Victor Petukhov Date: Tue, 8 Dec 2020 12:53:21 +0300 Subject: [PATCH 156/196] Avoid a cycle of analysing of type parameters via checking that it's a type parameter first --- .../kotlin/load/java/typeEnhancement/typeEnhancement.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/typeEnhancement.kt b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/typeEnhancement.kt index faf4b9202a3..359a900e96b 100644 --- a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/typeEnhancement.kt +++ b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/typeEnhancement.kt @@ -238,7 +238,7 @@ internal class NotNullTypeParameter(override val delegate: SimpleType) : NotNull override fun substitutionResult(replacement: KotlinType): KotlinType { val unwrappedType = replacement.unwrap() - if (!TypeUtils.isNullableType(unwrappedType) && !unwrappedType.isTypeParameter()) return unwrappedType + if (!unwrappedType.isTypeParameter() && !TypeUtils.isNullableType(unwrappedType)) return unwrappedType return when (unwrappedType) { is SimpleType -> unwrappedType.prepareReplacement() From 8777d28228d4c06811925f44b4f5f69b6bc8e03a Mon Sep 17 00:00:00 2001 From: Victor Petukhov Date: Tue, 8 Dec 2020 15:44:04 +0300 Subject: [PATCH 157/196] Use new jetbrains annotations with type use target for "load java 8" tests --- .../typeParameterAnnotations/Basic.java | 19 +- .../typeParameterAnnotations/Basic.txt | 15 +- .../BaseClassTypeArguments.java | 25 ++- .../BaseClassTypeArguments.txt | 21 ++- .../typeUseAnnotations/Basic.java | 15 +- .../compiledJava/typeUseAnnotations/Basic.txt | 9 +- .../ClassTypeParameterBounds.java | 33 ++-- .../ClassTypeParameterBounds.txt | 35 ++-- .../typeUseAnnotations/MethodReceiver.java | 11 +- .../typeUseAnnotations/MethodReceiver.txt | 5 - .../MethodTypeParameterBounds.java | 37 ++-- .../MethodTypeParameterBounds.txt | 35 ++-- .../typeUseAnnotations/ReturnType.java | 141 +++++++-------- .../typeUseAnnotations/ReturnType.txt | 127 +++++++------- .../typeUseAnnotations/ValueArguments.java | 163 +++++++++-------- .../typeUseAnnotations/ValueArguments.txt | 155 ++++++++-------- .../typeParameterAnnotations/Basic.java | 19 +- .../typeParameterAnnotations/Basic.javac.txt | 2 +- .../typeParameterAnnotations/Basic.txt | 15 +- .../BaseClassTypeArguments.java | 25 ++- .../BaseClassTypeArguments.javac.txt | 46 +++++ .../BaseClassTypeArguments.txt | 16 +- .../sourceJava/typeUseAnnotations/Basic.java | 15 +- .../typeUseAnnotations/Basic.javac.txt | 16 ++ .../sourceJava/typeUseAnnotations/Basic.txt | 9 +- .../ClassTypeParameterBounds.java | 33 ++-- .../ClassTypeParameterBounds.javac.txt | 56 ++++++ .../ClassTypeParameterBounds.txt | 30 ++-- .../typeUseAnnotations/MethodReceiver.java | 11 +- .../MethodReceiver.javac.txt | 11 ++ .../MethodTypeParameterBounds.java | 37 ++-- .../MethodTypeParameterBounds.javac.txt | 32 ++++ .../MethodTypeParameterBounds.txt | 30 ++-- .../typeUseAnnotations/ReturnType.java | 141 +++++++-------- .../typeUseAnnotations/ReturnType.javac.txt | 87 +++++++++ .../typeUseAnnotations/ReturnType.txt | 126 ++++++------- .../typeUseAnnotations/ValueArguments.java | 165 +++++++++--------- .../ValueArguments.javac.txt | 94 ++++++++++ .../typeUseAnnotations/ValueArguments.txt | 150 ++++++++-------- .../AbstractForeignAnnotationsTest.kt | 19 +- .../AbstractJspecifyAnnotationsTest.kt | 3 +- .../jetbrains/kotlin/cli/AbstractCliTest.java | 2 +- .../jvm/compiler/AbstractLoadJavaTest.java | 10 +- .../jvm/compiler/LoadDescriptorUtil.java | 19 +- .../jvm/compiler/AbstractLoadJava8Test.java | 5 + .../AbstractJvmRuntimeDescriptorLoaderTest.kt | 4 +- .../org/jetbrains/annotations/NotNull.java | 44 +++++ .../org/jetbrains/annotations/Nullable.java | 31 ++++ 48 files changed, 1254 insertions(+), 895 deletions(-) create mode 100644 compiler/testData/loadJava8/sourceJava/typeUseAnnotations/BaseClassTypeArguments.javac.txt create mode 100644 compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic.javac.txt create mode 100644 compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ClassTypeParameterBounds.javac.txt create mode 100644 compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodReceiver.javac.txt create mode 100644 compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodTypeParameterBounds.javac.txt create mode 100644 compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ReturnType.javac.txt create mode 100644 compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ValueArguments.javac.txt create mode 100644 third-party/jdk8-annotations/org/jetbrains/annotations/NotNull.java create mode 100644 third-party/jdk8-annotations/org/jetbrains/annotations/Nullable.java diff --git a/compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic.java b/compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic.java index 65420a47763..c363b13d82c 100644 --- a/compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic.java +++ b/compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic.java @@ -1,22 +1,19 @@ // JAVAC_EXPECTED_FILE + package test; -import java.lang.annotation.*; +import org.jetbrains.annotations.*; + public class Basic { - @Target(ElementType.TYPE_PARAMETER) - public @interface A { - String value() default ""; + public interface G<@NotNull T> { + <@NotNull R> void foo(R r); } - public interface G<@A T> { - <@A("abc") R> void foo(R r); + public interface G1 { + void foo(R r); } - public interface G1 { - void foo(R r); - } - - void foo(R r) { + void foo(R r) { } } diff --git a/compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic.txt b/compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic.txt index 5e35b2ed9cb..e87f9491336 100644 --- a/compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic.txt +++ b/compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic.txt @@ -2,18 +2,13 @@ package test public open class Basic { public constructor Basic() - public/*package*/ open fun foo(/*0*/ p0: R!): kotlin.Unit + public/*package*/ open fun foo(/*0*/ p0: R!): kotlin.Unit - @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE_PARAMETER}) public final annotation class A : kotlin.Annotation { - public constructor A(/*0*/ value: kotlin.String = ...) - public final val value: kotlin.String + public interface G { + public abstract fun foo(/*0*/ p0: R): kotlin.Unit } - public interface G { - public abstract fun foo(/*0*/ p0: R!): kotlin.Unit - } - - public interface G1 { - public abstract fun foo(/*0*/ p0: R!): kotlin.Unit + public interface G1 { + public abstract fun foo(/*0*/ p0: R!): kotlin.Unit } } diff --git a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/BaseClassTypeArguments.java b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/BaseClassTypeArguments.java index b99084103bc..27c4dff6bba 100644 --- a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/BaseClassTypeArguments.java +++ b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/BaseClassTypeArguments.java @@ -1,26 +1,23 @@ +// JAVAC_EXPECTED_FILE + package test; -import java.lang.annotation.*; - -@Target(ElementType.TYPE_USE) -@interface A { - String value() default ""; -} +import org.jetbrains.annotations.*; interface I1 {} interface I2 {} interface I3 {} +class A1 {} class A2 {} class A3 {} -public class BaseClassTypeArguments extends A3<@A B [][][][][], I1>, A2> implements I1<@A Integer @A [][][]>, I2<@A B, B>, I3<@A B [][][][][], B, @A B> { - class ImplementedInterfacesTypeArguments implements I1, I1<@A int [] @A []>>>, I2<@A B, B>, I3<@A B [][][][][], I1>, I2> { - public class BaseClassTypeArguments1 extends A3<@A B [][][][][], I1>, A2> { +public class BaseClassTypeArguments extends A3<@NotNull B [][][][][], I1>, A2> implements I1<@NotNull Integer @NotNull [][][]>, I2<@NotNull B, B>, I3<@NotNull B [][][][][], B, @NotNull B> { + class Basic1 implements I1<@NotNull String> { } + class Basic2 extends A1<@NotNull String> { } - } + class ImplementedInterfacesTypeArguments implements I1, I1<@NotNull int [] @NotNull []>>>, I2<@NotNull B, B>, I3<@NotNull B [][][][][], I1>, I2> { + public class BaseClassTypeArguments1 extends A3<@NotNull B [][][][][], I1>, A2> { } } - static class BaseClassTypeArguments2 extends A3<@A B [][][][][], I1>, A2> { - - } -} \ No newline at end of file + static class BaseClassTypeArguments2 extends A3<@NotNull B [][][][][], I1>, A2> { } +} diff --git a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/BaseClassTypeArguments.txt b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/BaseClassTypeArguments.txt index 46dd7dac980..051cdf9883b 100644 --- a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/BaseClassTypeArguments.txt +++ b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/BaseClassTypeArguments.txt @@ -1,8 +1,7 @@ package test -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) public/*package*/ final annotation class A : kotlin.Annotation { - public/*package*/ constructor A(/*0*/ value: kotlin.String = ...) - public final val value: kotlin.String +public/*package*/ open class A1 { + public/*package*/ constructor A1() } public/*package*/ open class A2 { @@ -13,17 +12,25 @@ public/*package*/ open class A3() } -public open class BaseClassTypeArguments : test.A3!>!>!>!>!, test.I1..@test.A kotlin.Array?)>!>!, test.A2!>!>!>, test.I1<(@test.A kotlin.Array!>!>..@test.A kotlin.Array!>!>?)>, test.I2<@test.A B!, B!>, test.I3!>!>!>!>!, B!, @test.A B!> { +public open class BaseClassTypeArguments : test.A3!>!>!>!>!, test.I1..@org.jetbrains.annotations.NotNull kotlin.Array)>!>!, test.A2!>!>!>, test.I1<(@org.jetbrains.annotations.NotNull kotlin.Array!>!>..@org.jetbrains.annotations.NotNull kotlin.Array!>!>)>, test.I2<@org.jetbrains.annotations.NotNull B, B!>, test.I3!>!>!>!>!, B!, @org.jetbrains.annotations.NotNull B> { public constructor BaseClassTypeArguments() - public/*package*/ open class BaseClassTypeArguments2 : test.A3!>!>!>!>!, test.I1..@test.A kotlin.Array?)>!>!, test.A2!>!>!> { + public/*package*/ open class BaseClassTypeArguments2 : test.A3!>!>!>!>!, test.I1..@org.jetbrains.annotations.NotNull kotlin.Array)>!>!, test.A2!>!>!> { public/*package*/ constructor BaseClassTypeArguments2() } - public/*package*/ open inner class ImplementedInterfacesTypeArguments /*captured type parameters: /*1*/ B : kotlin.Any!*/ : test.I1!>!>..@test.A kotlin.Array!>!>?)>!, test.I1!>!>!>, test.I2<@test.A B!, B!>, test.I3!>!>!>!>!, test.I1..@test.A kotlin.Array?)>!>!, test.I2!>!>!> { + public/*package*/ open inner class Basic1 /*captured type parameters: /*0*/ B : kotlin.Any!*/ : test.I1<@org.jetbrains.annotations.NotNull kotlin.String> { + public/*package*/ constructor Basic1() + } + + public/*package*/ open inner class Basic2 /*captured type parameters: /*0*/ B : kotlin.Any!*/ : test.A1<@org.jetbrains.annotations.NotNull kotlin.String> { + public/*package*/ constructor Basic2() + } + + public/*package*/ open inner class ImplementedInterfacesTypeArguments /*captured type parameters: /*1*/ B : kotlin.Any!*/ : test.I1!>!>..@org.jetbrains.annotations.NotNull kotlin.Array!>!>)>!, test.I1!>!>!>, test.I2<@org.jetbrains.annotations.NotNull B, B!>, test.I3!>!>!>!>!, test.I1..@org.jetbrains.annotations.NotNull kotlin.Array)>!>!, test.I2!>!>!> { public/*package*/ constructor ImplementedInterfacesTypeArguments() - public open inner class BaseClassTypeArguments1 /*captured type parameters: /*1*/ B : kotlin.Any!, /*2*/ B : kotlin.Any!*/ : test.A3!>!>!>!>!, test.I1..@test.A kotlin.Array?)>!>!, test.A2!>!>!> { + public open inner class BaseClassTypeArguments1 /*captured type parameters: /*1*/ B : kotlin.Any!, /*2*/ B : kotlin.Any!*/ : test.A3!>!>!>!>!, test.I1..@org.jetbrains.annotations.NotNull kotlin.Array)>!>!, test.A2!>!>!> { public constructor BaseClassTypeArguments1() } } diff --git a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic.java b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic.java index e2309dac755..8759772b49e 100644 --- a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic.java +++ b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic.java @@ -1,12 +1,10 @@ +// JAVAC_EXPECTED_FILE + package test; -import java.lang.annotation.*; -public class Basic { - @Target(ElementType.TYPE_USE) - @interface A { - String value() default ""; - } +import org.jetbrains.annotations.*; +public class Basic { interface G { } @@ -14,8 +12,7 @@ public class Basic { } public interface MyClass { - void f(G<@A String> p); - - void f(G2<@A String, @A("abc") Integer> p); + void f(G<@NotNull String> p); + void f(G2<@Nullable String, @NotNull Integer> p); } } diff --git a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic.txt b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic.txt index b5181c531f7..48ab6fa460e 100644 --- a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic.txt +++ b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic.txt @@ -3,11 +3,6 @@ package test public open class Basic { public constructor Basic() - @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) public/*package*/ final annotation class A : kotlin.Annotation { - public/*package*/ constructor A(/*0*/ value: kotlin.String = ...) - public final val value: kotlin.String - } - public/*package*/ interface G { } @@ -15,7 +10,7 @@ public open class Basic { } public interface MyClass { - public abstract fun f(/*0*/ p0: test.Basic.G2<@test.Basic.A kotlin.String!, @test.Basic.A(value = "abc") kotlin.Int!>!): kotlin.Unit - public abstract fun f(/*0*/ p0: test.Basic.G<@test.Basic.A kotlin.String!>!): kotlin.Unit + public abstract fun f(/*0*/ p0: test.Basic.G2<@org.jetbrains.annotations.Nullable kotlin.String?, @org.jetbrains.annotations.NotNull kotlin.Int>!): kotlin.Unit + public abstract fun f(/*0*/ p0: test.Basic.G<@org.jetbrains.annotations.NotNull kotlin.String>!): kotlin.Unit } } diff --git a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ClassTypeParameterBounds.java b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ClassTypeParameterBounds.java index e8ed265b044..1d6c9fadcec 100644 --- a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ClassTypeParameterBounds.java +++ b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ClassTypeParameterBounds.java @@ -2,12 +2,7 @@ package test; -import java.lang.annotation.*; - -@Target(ElementType.TYPE_USE) -@interface A { - String value() default ""; -} +import org.jetbrains.annotations.*; public class ClassTypeParameterBounds { interface I1 {} @@ -15,19 +10,19 @@ public class ClassTypeParameterBounds { interface I3 {} interface I4 {} - interface G1 { } - class G2<_A, B extends @A Integer> { } - interface G3<_A, B extends Object & @A I1> { } - class G4<_A extends @A B, B> { } - interface G5<_A, B extends @A _A> { } - class G6<_A extends @A I1, B, C, D extends @A E, E, F> { } - interface G7<_A extends Object & I2<@A Integer> & @A I3> { } - interface G8<_A extends Object & I2 & @A I3> { } + interface G1 { } + class G2<_A, B extends @Nullable Integer> { } + interface G3<_A, B extends Object & @NotNull I1> { } + class G4<_A extends @NotNull B, B> { } + interface G5<_A, B extends @Nullable _A> { } + class G6<_A extends @Nullable I1, B, C, D extends @NotNull E, E, F> { } + interface G7<_A extends Object & I2<@NotNull Integer> & @NotNull I3> { } + interface G8<_A extends Object & I2 & @Nullable I3> { } - interface G9<_A extends I4 & I2 & @A I3> { } - interface G10<_A extends I4 & I2 & @A I3> { } - interface G11<_A extends I4 & I2 & @A I3> { } - interface G12<_A extends I4 & I2 & @A I3> { } + interface G9<_A extends I4 & I2 & @NotNull I3> { } + interface G10<_A extends I4 & I2 & @NotNull I3> { } + interface G11<_A extends I4 & I2 & @NotNull I3> { } + interface G12<_A extends I4 & I2 & @NotNull I3> { } - // class G13<_A extends Object, B extends I3<@A _A> & @A I2<_A>> { } + // class G13<_A extends Object, B extends I3<@NotNull _A> & @NotNull I2<_A>> { } } diff --git a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ClassTypeParameterBounds.txt b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ClassTypeParameterBounds.txt index c2664ce9824..e6e83f7aa75 100644 --- a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ClassTypeParameterBounds.txt +++ b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ClassTypeParameterBounds.txt @@ -1,50 +1,45 @@ package test -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) public/*package*/ final annotation class A : kotlin.Annotation { - public/*package*/ constructor A(/*0*/ value: kotlin.String = ...) - public final val value: kotlin.String -} - public open class ClassTypeParameterBounds { public constructor ClassTypeParameterBounds() - public/*package*/ interface G1 { + public/*package*/ interface G1 { } - public/*package*/ interface G10!> where _A : test.ClassTypeParameterBounds.I2!, _A : @test.A test.ClassTypeParameterBounds.I3! { + public/*package*/ interface G10!> where _A : test.ClassTypeParameterBounds.I2!, _A : @org.jetbrains.annotations.NotNull test.ClassTypeParameterBounds.I3 { } - public/*package*/ interface G11..@test.A kotlin.Array?)>!>!>!> where _A : test.ClassTypeParameterBounds.I2!>!>!>..@test.A kotlin.Array!>!>!>?)>!, _A : @test.A test.ClassTypeParameterBounds.I3..@test.A kotlin.Array?)>!>! { + public/*package*/ interface G11..@org.jetbrains.annotations.NotNull kotlin.Array)>!>!>!> where _A : test.ClassTypeParameterBounds.I2!>!>!>..@org.jetbrains.annotations.NotNull kotlin.Array!>!>!>)>!, _A : @org.jetbrains.annotations.NotNull test.ClassTypeParameterBounds.I3..@org.jetbrains.annotations.NotNull kotlin.Array)>!> { } - public/*package*/ interface G12..@test.A kotlin.Array?)>!> where _A : test.ClassTypeParameterBounds.I2!>!>!, _A : @test.A test.ClassTypeParameterBounds.I3..@test.A kotlin.Array?)>!>! { + public/*package*/ interface G12?..@org.jetbrains.annotations.Nullable kotlin.Array?)>!> where _A : test.ClassTypeParameterBounds.I2!>!>!, _A : @org.jetbrains.annotations.NotNull test.ClassTypeParameterBounds.I3..@org.jetbrains.annotations.NotNull kotlin.Array)>!> { } - public/*package*/ open inner class G2 { - public/*package*/ constructor G2() + public/*package*/ open inner class G2 { + public/*package*/ constructor G2() } - public/*package*/ interface G3 where B : @test.A test.ClassTypeParameterBounds.I1! { + public/*package*/ interface G3 where B : @org.jetbrains.annotations.NotNull test.ClassTypeParameterBounds.I1 { } - public/*package*/ open inner class G4 { - public/*package*/ constructor G4() + public/*package*/ open inner class G4 { + public/*package*/ constructor G4() } - public/*package*/ interface G5 { + public/*package*/ interface G5 { } - public/*package*/ open inner class G6 { - public/*package*/ constructor G6() + public/*package*/ open inner class G6 { + public/*package*/ constructor G6() } - public/*package*/ interface G7 where _A : test.ClassTypeParameterBounds.I2<@test.A kotlin.Int!>!, _A : @test.A test.ClassTypeParameterBounds.I3! { + public/*package*/ interface G7 where _A : test.ClassTypeParameterBounds.I2<@org.jetbrains.annotations.NotNull kotlin.Int>!, _A : @org.jetbrains.annotations.NotNull test.ClassTypeParameterBounds.I3 { } - public/*package*/ interface G8 where _A : test.ClassTypeParameterBounds.I2!, _A : @test.A test.ClassTypeParameterBounds.I3! { + public/*package*/ interface G8 where _A : test.ClassTypeParameterBounds.I2!, _A : @org.jetbrains.annotations.Nullable test.ClassTypeParameterBounds.I3? { } - public/*package*/ interface G9..@test.A kotlin.Array?)>!> where _A : test.ClassTypeParameterBounds.I2..@test.A kotlin.Array?)>!, _A : @test.A test.ClassTypeParameterBounds.I3..@test.A kotlin.Array?)>! { + public/*package*/ interface G9..@org.jetbrains.annotations.NotNull kotlin.Array)>!> where _A : test.ClassTypeParameterBounds.I2..@org.jetbrains.annotations.NotNull kotlin.Array)>!, _A : @org.jetbrains.annotations.NotNull test.ClassTypeParameterBounds.I3..@org.jetbrains.annotations.NotNull kotlin.Array)> { } public/*package*/ interface I1 { diff --git a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodReceiver.java b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodReceiver.java index c26e08c0b33..2a43d23c233 100644 --- a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodReceiver.java +++ b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodReceiver.java @@ -2,12 +2,7 @@ package test; -import java.lang.annotation.*; - -@Target(ElementType.TYPE_USE) -@interface A { - String value() default ""; -} +import org.jetbrains.annotations.*; /* * Note that a receiver type doesn't get into signatures used by the Kotlin compiler @@ -15,9 +10,9 @@ import java.lang.annotation.*; */ public class MethodReceiver { - public void f1(MethodReceiver<@A T> this) { } + public void f1(MethodReceiver<@Nullable T> this) { } class MethodReceiver3 { - public void f1(@A MethodReceiver3<@A T, K, @A L> this) { } + public void f1(@Nullable MethodReceiver3<@Nullable T, K, @Nullable L> this) { } } } \ No newline at end of file diff --git a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodReceiver.txt b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodReceiver.txt index b966213b1d6..1964dcde5ba 100644 --- a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodReceiver.txt +++ b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodReceiver.txt @@ -1,10 +1,5 @@ package test -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) public/*package*/ final annotation class A : kotlin.Annotation { - public/*package*/ constructor A(/*0*/ value: kotlin.String = ...) - public final val value: kotlin.String -} - public open class MethodReceiver { public constructor MethodReceiver() public open fun f1(): kotlin.Unit diff --git a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodTypeParameterBounds.java b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodTypeParameterBounds.java index 1ddc625116a..16b4632069b 100644 --- a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodTypeParameterBounds.java +++ b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodTypeParameterBounds.java @@ -2,12 +2,7 @@ package test; -import java.lang.annotation.*; - -@Target(ElementType.TYPE_USE) -@interface A { - String value() default ""; -} +import org.jetbrains.annotations.*; abstract class MethodTypeParameterBounds { interface I1 {} @@ -15,19 +10,19 @@ abstract class MethodTypeParameterBounds { interface I3 {} interface I4 {} - void f1(T x) { } - <_A, B extends @A Integer> void f2(_A x, B y) { } - <_A, B extends Object & @A I1> void f3(_A x, B y) { } - <_A extends @A B, B> void f4(_A x, B y) { } - <_A, B extends @A _A> void f5(_A x, B y) { } - <_A extends @A I1> void f6() { } - abstract <_A, B extends @A _A> void f7(_A x, B y); - abstract <_A extends @A I1, B, C, D extends @A E, E, F> void f8(_A x1, B x2, C x3, D x4, E x5, F x6); - <_A extends Object & I2<@A Integer> & @A I3> void f9(_A x) { } - <_A extends Object & I2 & @A I3> void f10(_A x) { } - <_A extends I4 & I2 & @A I3> void f11(_A x) { } - <_A extends I4 & I2 & @A I3> void f12(_A x) { } - <_A extends I4 & I2 & @A I3> void f13(_A x) { } - abstract <_A extends I4 & I2 & @A I3> void f14(_A x); - <_A extends Object, B extends I3<@A A> & @A I2> void f15(_A x) { } + void f1(T x) { } + <_A, B extends @NotNull Integer> void f2(_A x, B y) { } + <_A, B extends Object & @Nullable I1> void f3(_A x, B y) { } + <_A extends @NotNull B, B> void f4(_A x, B y) { } + <_A, B extends @Nullable _A> void f5(_A x, B y) { } + <_A extends @Nullable I1> void f6() { } + abstract <_A, B extends @NotNull _A> void f7(_A x, B y); + abstract <_A extends @Nullable I1, B, C, D extends @NotNull E, E, F> void f8(_A x1, B x2, C x3, D x4, E x5, F x6); + <_A extends Object & I2<@Nullable Integer> & @Nullable I3> void f9(_A x) { } + <_A extends Object & I2 & @Nullable I3> void f10(_A x) { } + <_A extends I4 & I2 & @Nullable I3> void f11(_A x) { } + <_A extends I4 & I2 & @NotNull I3> void f12(_A x) { } + <_A extends I4 & I2 & @Nullable I3> void f13(_A x) { } + abstract <_A extends I4 & I2 & @Nullable I3> void f14(_A x); + <_A extends Object, B extends I3<@Nullable _A> & @NotNull I2<_A>> void f15(_A x) { } } diff --git a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodTypeParameterBounds.txt b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodTypeParameterBounds.txt index 43b77d4acaa..0f21e253c9b 100644 --- a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodTypeParameterBounds.txt +++ b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodTypeParameterBounds.txt @@ -1,27 +1,22 @@ package test -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) public/*package*/ final annotation class A : kotlin.Annotation { - public/*package*/ constructor A(/*0*/ value: kotlin.String = ...) - public final val value: kotlin.String -} - public/*package*/ abstract class MethodTypeParameterBounds { public/*package*/ constructor MethodTypeParameterBounds() - public/*package*/ open fun f1(/*0*/ p0: T!): kotlin.Unit - public/*package*/ open fun f10(/*0*/ p0: _A!): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2!, _A : @test.A test.MethodTypeParameterBounds.I3! - public/*package*/ open fun ..@test.A kotlin.Array?)>!> f11(/*0*/ p0: _A!): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2..@test.A kotlin.Array?)>!, _A : @test.A test.MethodTypeParameterBounds.I3..@test.A kotlin.Array?)>! - public/*package*/ open fun !> f12(/*0*/ p0: _A!): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2!, _A : @test.A test.MethodTypeParameterBounds.I3! - public/*package*/ open fun ..@test.A kotlin.Array?)>!>!>!> f13(/*0*/ p0: _A!): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2!>!>!>..@test.A kotlin.Array!>!>!>?)>!, _A : @test.A test.MethodTypeParameterBounds.I3..@test.A kotlin.Array?)>!>! - public/*package*/ abstract fun ..@test.A kotlin.Array?)>!> f14(/*0*/ p0: _A!): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2!>!>!, _A : @test.A test.MethodTypeParameterBounds.I3..@test.A kotlin.Array?)>!>! - public/*package*/ open fun !> f15(/*0*/ p0: _A!): kotlin.Unit where B : @test.A test.MethodTypeParameterBounds.I2! - public/*package*/ open fun f2(/*0*/ p0: _A!, /*1*/ p1: B!): kotlin.Unit - public/*package*/ open fun f3(/*0*/ p0: _A!, /*1*/ p1: B!): kotlin.Unit where B : @test.A test.MethodTypeParameterBounds.I1! - public/*package*/ open fun f4(/*0*/ p0: _A!, /*1*/ p1: B!): kotlin.Unit - public/*package*/ open fun f5(/*0*/ p0: _A!, /*1*/ p1: B!): kotlin.Unit - public/*package*/ open fun f6(): kotlin.Unit - public/*package*/ abstract fun f7(/*0*/ p0: _A!, /*1*/ p1: B!): kotlin.Unit - public/*package*/ abstract fun f8(/*0*/ p0: _A!, /*1*/ p1: B!, /*2*/ p2: C!, /*3*/ p3: D!, /*4*/ p4: E!, /*5*/ p5: F!): kotlin.Unit - public/*package*/ open fun f9(/*0*/ p0: _A!): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2<@test.A kotlin.Int!>!, _A : @test.A test.MethodTypeParameterBounds.I3! + public/*package*/ open fun f1(/*0*/ p0: T): kotlin.Unit + public/*package*/ open fun f10(/*0*/ p0: _A): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2!, _A : @org.jetbrains.annotations.Nullable test.MethodTypeParameterBounds.I3? + public/*package*/ open fun ..@org.jetbrains.annotations.NotNull kotlin.Array)>!> f11(/*0*/ p0: _A): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2?..@org.jetbrains.annotations.Nullable kotlin.Array?)>!, _A : @org.jetbrains.annotations.Nullable test.MethodTypeParameterBounds.I3..@org.jetbrains.annotations.NotNull kotlin.Array)>? + public/*package*/ open fun !> f12(/*0*/ p0: _A): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2!, _A : @org.jetbrains.annotations.NotNull test.MethodTypeParameterBounds.I3 + public/*package*/ open fun ?..@org.jetbrains.annotations.Nullable kotlin.Array?)>!>!>!> f13(/*0*/ p0: _A): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2!>!>!>?..@org.jetbrains.annotations.Nullable kotlin.Array!>!>!>?)>!, _A : @org.jetbrains.annotations.Nullable test.MethodTypeParameterBounds.I3?..@org.jetbrains.annotations.Nullable kotlin.Array?)>!>? + public/*package*/ abstract fun ..@org.jetbrains.annotations.NotNull kotlin.Array)>!> f14(/*0*/ p0: _A): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2!>!>!, _A : @org.jetbrains.annotations.Nullable test.MethodTypeParameterBounds.I3?..@org.jetbrains.annotations.Nullable kotlin.Array?)>!>? + public/*package*/ open fun !> f15(/*0*/ p0: _A!): kotlin.Unit where B : @org.jetbrains.annotations.NotNull test.MethodTypeParameterBounds.I2<_A!> + public/*package*/ open fun f2(/*0*/ p0: _A!, /*1*/ p1: B): kotlin.Unit + public/*package*/ open fun f3(/*0*/ p0: _A!, /*1*/ p1: B): kotlin.Unit where B : @org.jetbrains.annotations.Nullable test.MethodTypeParameterBounds.I1? + public/*package*/ open fun f4(/*0*/ p0: _A, /*1*/ p1: B!): kotlin.Unit + public/*package*/ open fun f5(/*0*/ p0: _A!, /*1*/ p1: B): kotlin.Unit + public/*package*/ open fun f6(): kotlin.Unit + public/*package*/ abstract fun f7(/*0*/ p0: _A!, /*1*/ p1: B): kotlin.Unit + public/*package*/ abstract fun f8(/*0*/ p0: _A, /*1*/ p1: B!, /*2*/ p2: C!, /*3*/ p3: D, /*4*/ p4: E!, /*5*/ p5: F!): kotlin.Unit + public/*package*/ open fun f9(/*0*/ p0: _A): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2<@org.jetbrains.annotations.Nullable kotlin.Int?>!, _A : @org.jetbrains.annotations.Nullable test.MethodTypeParameterBounds.I3? public/*package*/ interface I1 { } diff --git a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ReturnType.java b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ReturnType.java index 5c223aef06f..bad8d817886 100644 --- a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ReturnType.java +++ b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ReturnType.java @@ -1,11 +1,8 @@ +// JAVAC_EXPECTED_FILE + package test; -import java.lang.annotation.*; - -@Target(ElementType.TYPE_USE) -@interface A { - String value() default ""; -} +import org.jetbrains.annotations.*; interface G0 { } interface G1 { } @@ -13,83 +10,87 @@ interface G2 { } interface ReturnType { // simplpe type arguments - G1<@A G0> f0(); - G1>>> f1(); - G1<@A String> f2(); - G2<@A String, G2<@A("abc") Integer, G2<@A("abc") G2, @A("abc") Integer>>> f3(); + G1<@NotNull G0> f0(); + G1>>> f1(); + G1<@NotNull String> f2(); + G2<@NotNull String, G2<@NotNull Integer, G2<@NotNull G2, @NotNull Integer>>> f3(); // wildcards - G1 f4 = null; - G1>>> f5(); - G1 f6(); - G2, ? extends @A("abc") Integer>>> f7(); + G1 f4 = null; + G1>>> f5(); + G1 f6(); + G2, ? extends @NotNull Integer>>> f7(); - G1 f8(); - G1>>> f9(); - G1 f10 = null; - G2, ? super @A("abc") Integer>>> f11(); + G1 f8(); + G1>>> f9(); + G1 f10 = null; + G2, ? super @NotNull Integer>>> f11(); - G2, ? extends @A("abc") Integer>>> f12 = null; + G2, ? extends @NotNull Integer>>> f12 = null; // arrays - Integer @A [] f13(); - int @A [] f14(); - @A Integer [] f15(); - @A int [] f16(); - @A Integer @A [] f17(); - @A int @A [] f18 = null; + Integer @NotNull [] f13(); + int @NotNull [] f14(); + @NotNull Integer [] f15(); + @NotNull int [] f16(); + @NotNull int [] f161 = null; + @NotNull Integer @NotNull [] f17(); + @NotNull int @NotNull [] f18 = null; // multidementional arrays - Integer @A [] [] f19(); - int @A [] @A [] f20(); - @A Integer [] [] [] f21 = null; - @A int @A [] @A [] [] @A [] f22(); - @A Integer @A [] [] @A [] [] f23(); - @A int @A [] @A [] f24 = null; - int [] @A [] f25(); - Object [] @A [] f26(); - @A Object [] [] [] [] @A [] f27(); + Integer @NotNull [] [] f19(); + int @NotNull [] @NotNull [] f20(); + @NotNull Integer [] [] [] f21 = null; + @NotNull int @NotNull [] @NotNull [] [] @NotNull [] f22(); + @NotNull Integer @NotNull [] [] @NotNull [] [] f23(); + @NotNull int @NotNull [] @NotNull [] f24 = null; + int [] @NotNull [] f25(); + Object [] @NotNull [] f26(); + @NotNull Object [] [] [] [] @NotNull [] f27(); + @NotNull Object [] [] [] [] @NotNull [] f271 = null; // arrays in type arguments - G1 f28(); - G2 f29(); - G1<@A Integer []> f30(); - G1> f31(); - G1, G1<@A int @A []>>> f32(); - G1<@A int @A []> f33(); - G1 f34(); - G2 f35 = null; - G1<@A Integer @A [] []> f36(); - G1> f37(); - G1, G1<@A int [] [] @A []>>> f38(); - G1<@A int @A [] @A [] []> f39(); + G1 f28(); + G2 f29(); + G1<@NotNull Integer []> f30(); + G1> f31(); + G1, G1<@NotNull int @NotNull []>>> f32(); + G1<@NotNull int @NotNull []> f33(); + G1 f34(); + G2 f35 = null; + G1<@NotNull Integer @NotNull [] []> f36(); + G1> f37(); + G1, G1<@NotNull int [] [] @NotNull []>>> f38(); + G1<@NotNull int @NotNull [] @NotNull [] []> f39(); // arrays in wildcard bounds - G1 f40(); - G2 f41(); - G1 f42(); - G1> f43(); - G1, G1>> f44(); - G1, G1>> f45 = null; - G1 f46(); - G1 f47(); - G2 f48 = null; - G1 f49(); - G1> f50(); - G1, G1>> f51(); - G1, G1>> f52 = null; - G1 f53(); + G1 f40(); + G2 f41(); + G1 f42(); + G1> f43(); + G1, G1>> f44(); + G1, G1>> f45 = null; + G1 f46(); + G1 f47(); + G2 f48 = null; + G1 f49(); + G1> f50(); + G1, G1>> f51(); + G1, G1>> f52 = null; + G1 f53(); class ReturnType2 { - G1 f4 = null; - G1 f10 = null; - G2, ? extends @A("abc") Integer>>> f12 = null; - @A int @A [] f18 = null; - @A Integer [] [] [] f21 = null; - @A int @A [] @A [] f24 = null; - G2 f35 = null; - G1, G1>> f45 = null; - G2 f48 = null; - G1, G1>> f52 = null; + G1 f4 = null; + G1 f10 = null; + G2, ? extends @NotNull Integer>>> f12 = null; + @NotNull Integer [] f181 = null; + @NotNull Integer @NotNull [] f182 = null; + G1<@NotNull Integer> f183 = null; + @NotNull Integer [] [] [] f21 = null; + @NotNull int @NotNull [] @NotNull [] f24 = null; + G2 f35 = null; + G1, G1>> f45 = null; + G2 f48 = null; + G1, G1>> f52 = null; } } diff --git a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ReturnType.txt b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ReturnType.txt index cb7cc847e10..a46258d783e 100644 --- a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ReturnType.txt +++ b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ReturnType.txt @@ -1,10 +1,5 @@ package test -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) public/*package*/ final annotation class A : kotlin.Annotation { - public/*package*/ constructor A(/*0*/ value: kotlin.String = ...) - public final val value: kotlin.String -} - public/*package*/ interface G0 { } @@ -15,74 +10,78 @@ public/*package*/ interface G2 { } public/*package*/ interface ReturnType { - public abstract fun f0(): test.G1<@test.A test.G0!>! - public abstract fun f1(): test.G1!>!>!>! - public abstract fun f11(): test.G2!, in @test.A(value = "abc") kotlin.Int!>!>!>! - public abstract fun f13(): (@test.A kotlin.Array..@test.A kotlin.Array?) - public abstract fun f14(): @test.A kotlin.IntArray! - public abstract fun f15(): kotlin.Array<(out) @test.A kotlin.Int!>! - public abstract fun f16(): kotlin.IntArray! - public abstract fun f17(): (@test.A kotlin.Array<@test.A kotlin.Int!>..@test.A kotlin.Array?) - public abstract fun f19(): (@test.A kotlin.Array!>..@test.A kotlin.Array!>?) - public abstract fun f2(): test.G1<@test.A kotlin.String!>! - public abstract fun f20(): (@test.A kotlin.Array<@test.A kotlin.IntArray!>..@test.A kotlin.Array?) - public abstract fun f22(): (@test.A kotlin.Array<(@test.A kotlin.Array!>..@test.A kotlin.Array!>?)>..@test.A kotlin.Array!>..@test.A kotlin.Array!>?)>?) - public abstract fun f23(): (@test.A kotlin.Array!>..@test.A kotlin.Array!>?)>!>..@test.A kotlin.Array!>..@test.A kotlin.Array!>?)>!>?) - public abstract fun f25(): kotlin.Array<(out) @test.A kotlin.IntArray!>! - public abstract fun f26(): kotlin.Array<(out) (@test.A kotlin.Array..@test.A kotlin.Array?)>! - public abstract fun f27(): kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) (@test.A kotlin.Array<@test.A kotlin.Any!>..@test.A kotlin.Array?)>!>!>!>! - public abstract fun f28(): test.G1<(@test.A kotlin.Array..@test.A kotlin.Array?)>! - public abstract fun f29(): test.G2! - public abstract fun f3(): test.G2<@test.A kotlin.String!, test.G2<@test.A(value = "abc") kotlin.Int!, test.G2<@test.A(value = "abc") test.G2!, @test.A(value = "abc") kotlin.Int!>!>!>! - public abstract fun f30(): test.G1!>! + public abstract fun f0(): test.G1<@org.jetbrains.annotations.NotNull test.G0>! + public abstract fun f1(): test.G1!>!>!>! + public abstract fun f11(): test.G2, in @org.jetbrains.annotations.NotNull kotlin.Int>!>!>! + public abstract fun f13(): (@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array) + public abstract fun f14(): kotlin.IntArray! + @org.jetbrains.annotations.NotNull public abstract fun f15(): kotlin.Array<(out) @org.jetbrains.annotations.NotNull kotlin.Int>! + @org.jetbrains.annotations.NotNull public abstract fun f16(): kotlin.IntArray! + @org.jetbrains.annotations.NotNull public abstract fun f17(): (@org.jetbrains.annotations.NotNull kotlin.Array<@org.jetbrains.annotations.NotNull kotlin.Int>..@org.jetbrains.annotations.NotNull kotlin.Array) + public abstract fun f19(): (@org.jetbrains.annotations.NotNull kotlin.Array!>..@org.jetbrains.annotations.NotNull kotlin.Array!>) + public abstract fun f2(): test.G1<@org.jetbrains.annotations.NotNull kotlin.String>! + public abstract fun f20(): (@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array) + @org.jetbrains.annotations.NotNull public abstract fun f22(): (@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array!>..@org.jetbrains.annotations.NotNull kotlin.Array!>)>..@org.jetbrains.annotations.NotNull kotlin.Array!>..@org.jetbrains.annotations.NotNull kotlin.Array!>)>) + @org.jetbrains.annotations.NotNull public abstract fun f23(): (@org.jetbrains.annotations.NotNull kotlin.Array!>..@org.jetbrains.annotations.NotNull kotlin.Array!>)>!>..@org.jetbrains.annotations.NotNull kotlin.Array!>..@org.jetbrains.annotations.NotNull kotlin.Array!>)>!>) + public abstract fun f25(): kotlin.Array<(out) kotlin.IntArray!>! + public abstract fun f26(): kotlin.Array<(out) (@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>! + @org.jetbrains.annotations.NotNull public abstract fun f27(): kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) (@org.jetbrains.annotations.NotNull kotlin.Array<@org.jetbrains.annotations.NotNull kotlin.Any>..@org.jetbrains.annotations.NotNull kotlin.Array)>!>!>!>! + public abstract fun f28(): test.G1<(@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>! + public abstract fun f29(): test.G2! + public abstract fun f3(): test.G2<@org.jetbrains.annotations.NotNull kotlin.String, test.G2<@org.jetbrains.annotations.NotNull kotlin.Int, test.G2<@org.jetbrains.annotations.NotNull test.G2, @org.jetbrains.annotations.NotNull kotlin.Int>!>!>! + public abstract fun f30(): test.G1!>! public abstract fun f31(): test.G1!>! - public abstract fun f32(): test.G1..@test.A kotlin.Array?)>!, test.G1<@test.A kotlin.IntArray!>!>!>! - public abstract fun f33(): test.G1<@test.A kotlin.IntArray!>! - public abstract fun f34(): test.G1..@test.A kotlin.Array?)>!>! - public abstract fun f36(): test.G1<(@test.A kotlin.Array!>..@test.A kotlin.Array!>?)>! + public abstract fun f32(): test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!, test.G1!>!>! + public abstract fun f33(): test.G1! + public abstract fun f34(): test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!>! + public abstract fun f36(): test.G1<(@org.jetbrains.annotations.NotNull kotlin.Array!>..@org.jetbrains.annotations.NotNull kotlin.Array!>)>! public abstract fun f37(): test.G1!>!>!>! - public abstract fun f38(): test.G1..@test.A kotlin.Array?)>!, test.G1!>!>!>!>! - public abstract fun f39(): test.G1<(@test.A kotlin.Array<(@test.A kotlin.Array..@test.A kotlin.Array?)>..@test.A kotlin.Array..@test.A kotlin.Array?)>?)>! - public abstract fun f40(): test.G1..@test.A kotlin.Array?)>! - public abstract fun f41(): test.G2! - public abstract fun f42(): test.G1!>! + public abstract fun f38(): test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!, test.G1!>!>!>!>! + public abstract fun f39(): test.G1<(@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>! + public abstract fun f40(): test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>! + public abstract fun f41(): test.G2! + public abstract fun f42(): test.G1!>! public abstract fun f43(): test.G1!>! - public abstract fun f44(): test.G1..@test.A kotlin.Array?)>!, test.G1!>!>! - public abstract fun f46(): test.G1! - public abstract fun f47(): test.G1..@test.A kotlin.Array?)>!>! - public abstract fun f49(): test.G1!>!>!>!>!>! - public abstract fun f5(): test.G1!>!>!>! - public abstract fun f50(): test.G1..@test.A kotlin.Array?)>!>! - public abstract fun f51(): test.G1..@test.A kotlin.Array?)>!>!>!, test.G1..@test.A kotlin.Array?)>..@test.A kotlin.Array..@test.A kotlin.Array?)>?)>!>!>! - public abstract fun f53(): test.G1..@test.A kotlin.Array?)>! - public abstract fun f6(): test.G1! - public abstract fun f7(): test.G2!, out @test.A(value = "abc") kotlin.Int!>!>!>! - public abstract fun f8(): test.G1! - public abstract fun f9(): test.G1!>!>!>! + public abstract fun f44(): test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!, test.G1!>!>! + public abstract fun f46(): test.G1! + public abstract fun f47(): test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!>! + public abstract fun f49(): test.G1!>!>!>!>!>! + public abstract fun f5(): test.G1!>!>!>! + public abstract fun f50(): test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!>! + public abstract fun f51(): test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!>!>!, test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>!>!>! + public abstract fun f53(): test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>! + public abstract fun f6(): test.G1! + public abstract fun f7(): test.G2, out @org.jetbrains.annotations.NotNull kotlin.Int>!>!>! + public abstract fun f8(): test.G1! + public abstract fun f9(): test.G1!>!>!>! public open class ReturnType2 { public constructor ReturnType2() - public/*package*/ final var f10: test.G1! - public/*package*/ final var f12: test.G2!, out kotlin.Int!>!>!>! - public/*package*/ final var f18: @test.A kotlin.IntArray! - public/*package*/ final var f21: kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Int!>!>!>! - public/*package*/ final var f24: (@test.A kotlin.Array..@test.A kotlin.Array?) - public/*package*/ final var f35: test.G2!>! - public/*package*/ final var f4: test.G1! - public/*package*/ final var f45: test.G1!>!, test.G1!>!>! + public/*package*/ final var f10: test.G1! + public/*package*/ final var f12: test.G2, out @org.jetbrains.annotations.NotNull kotlin.Int>!>!>! + @org.jetbrains.annotations.NotNull public/*package*/ final var f181: kotlin.Array<(out) @org.jetbrains.annotations.NotNull kotlin.Int>! + @org.jetbrains.annotations.NotNull public/*package*/ final var f182: (@org.jetbrains.annotations.NotNull kotlin.Array<@org.jetbrains.annotations.NotNull kotlin.Int>..@org.jetbrains.annotations.NotNull kotlin.Array) + public/*package*/ final var f183: test.G1<@org.jetbrains.annotations.NotNull kotlin.Int>! + @org.jetbrains.annotations.NotNull public/*package*/ final var f21: kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @org.jetbrains.annotations.NotNull kotlin.Int>!>!>! + @org.jetbrains.annotations.NotNull public/*package*/ final var f24: (@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array) + public/*package*/ final var f35: test.G2..@org.jetbrains.annotations.NotNull kotlin.Array)>! + public/*package*/ final var f4: test.G1! + public/*package*/ final var f45: test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!, test.G1!>!>! public/*package*/ final var f48: test.G2!>!>! - public/*package*/ final var f52: test.G1!>!>!>!, test.G1!>!>!>! + public/*package*/ final var f52: test.G1!>!>..@org.jetbrains.annotations.NotNull kotlin.Array!>!>)>!, test.G1!>!>!>! } // Static members - public final val f10: test.G1! - public final val f12: test.G2!, out kotlin.Int!>!>!>! - public final val f18: @test.A kotlin.IntArray! - public final val f21: kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Int!>!>!>! - public final val f24: (@test.A kotlin.Array..@test.A kotlin.Array?) - public final val f35: test.G2!>! - public final val f4: test.G1! - public final val f45: test.G1!>!, test.G1!>!>! + public final val f10: test.G1! + public final val f12: test.G2, out @org.jetbrains.annotations.NotNull kotlin.Int>!>!>! + @org.jetbrains.annotations.NotNull public final val f161: kotlin.IntArray! + @org.jetbrains.annotations.NotNull public final val f18: kotlin.IntArray! + @org.jetbrains.annotations.NotNull public final val f21: kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @org.jetbrains.annotations.NotNull kotlin.Int>!>!>! + @org.jetbrains.annotations.NotNull public final val f24: (@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array) + @org.jetbrains.annotations.NotNull public final val f271: kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) (@org.jetbrains.annotations.NotNull kotlin.Array<@org.jetbrains.annotations.NotNull kotlin.Any>..@org.jetbrains.annotations.NotNull kotlin.Array)>!>!>!>! + public final val f35: test.G2..@org.jetbrains.annotations.NotNull kotlin.Array)>! + public final val f4: test.G1! + public final val f45: test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!, test.G1!>!>! public final val f48: test.G2!>!>! - public final val f52: test.G1!>!>!>!, test.G1!>!>!>! + public final val f52: test.G1!>!>..@org.jetbrains.annotations.NotNull kotlin.Array!>!>)>!, test.G1!>!>!>! } diff --git a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ValueArguments.java b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ValueArguments.java index 8d54ff5550d..7f4944a269a 100644 --- a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ValueArguments.java +++ b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ValueArguments.java @@ -1,11 +1,6 @@ package test; -import java.lang.annotation.*; - -@Target(ElementType.TYPE_USE) -@interface A { - String value() default ""; -} +import org.jetbrains.annotations.*; interface G0 { } interface G1 { } @@ -13,104 +8,104 @@ interface G2 { } interface ValueArguments { // simplpe type arguments - void f0(G1<@A G0> p); - void f1(G1>>> p); - void f2(G1<@A String> p); - void f3(G2<@A String, G2<@A("abc") Integer, G2<@A("abc") G2, @A("abc") Integer>>> p); + void f0(G1<@NotNull G0> p); + void f1(G1>>> p); + void f2(G1<@NotNull String> p); + void f3(G2<@NotNull String, G2<@NotNull Integer, G2<@NotNull G2, @NotNull Integer>>> p); // wildcards - void f4(G1 p); - void f5(G1>>> p); - void f6(G1 p1, G1>>> p2); - void f7(G2, ? extends @A("abc") Integer>>> p); + void f4(G1 p); + void f5(G1>>> p); + void f6(G1 p1, G1>>> p2); + void f7(G2, ? extends @NotNull Integer>>> p); - void f8(G1 p); - void f9(G1>>> p); - void f10(G1 p); - void f11(G2, ? super @A("abc") Integer>>> p); + void f8(G1 p); + void f9(G1>>> p); + void f10(G1 p); + void f11(G2, ? super @NotNull Integer>>> p); - void f12(G2, ? extends @A("abc") Integer>>> p); + void f12(G2, ? extends @NotNull Integer>>> p); // arrays - void f13(Integer @A [] p); - void f14(int @A [] p); - void f15(@A Integer [] p); - void f16(@A int [] p); - void f17(@A Integer @A [] p); - void f18(@A int @A [] p1, Integer @A [] p2, @A int [] p3); + void f13(Integer @NotNull [] p); + void f14(int @NotNull [] p); + void f15(@NotNull Integer [] p); + void f16(@Nullable int [] p); + void f17(@Nullable Integer @Nullable [] p); + void f18(@Nullable int @Nullable [] p1, Integer @Nullable [] p2, @Nullable int [] p3); // multidementional arrays - void f19(Integer @A [] [] p); - void f20(int @A [] @A [] p); - void f21(@A Integer [] [] [] p); - void f22(@A int @A [] @A [] [] @A [] p); - void f23(@A Integer @A [] [] @A [] [] p); - void f24(@A int @A [] @A [] p); - void f25(int [] @A [] p); - void f26(Object [] @A [] p1, int [] @A [] p2, @A int @A [] @A [] [] @A [] p3); - void f27(@A Object [] [] [] [] @A [] p); + void f19(Integer @NotNull [] [] p); + void f20(int @NotNull [] @NotNull [] p); + void f21(@NotNull Integer [] [] [] p); + void f22(@NotNull int @NotNull [] @NotNull [] [] @NotNull [] p); + void f23(@NotNull Integer @NotNull [] [] @NotNull [] [] p); + void f24(@NotNull int @NotNull [] @NotNull [] p); + void f25(int [] @Nullable [] p); + void f26(Object [] @Nullable [] p1, int [] @Nullable [] p2, @Nullable int @Nullable [] @Nullable [] [] @Nullable [] p3); + void f27(@Nullable Object [] [] [] [] @Nullable [] p); // arrays in type arguments - void f28(G1 p); - void f29(G2 p); - void f30(G1<@A Integer []> p); - void f31(G1> p); - void f32(G1, G1<@A int @A []>>> p); - void f33(G1<@A int @A []> p); - void f34(G1 p); - void f35(G2 p1, G1<@A Integer @A [] []> p2, G1> p3); - void f36(G1<@A Integer @A [] []> p); - void f37(G1> p); - void f38(G1, G1<@A int [] [] @A []>>> p); - void f39(G1<@A int @A [] @A [] []> p); + void f28(G1 p); + void f29(G2 p); + void f30(G1<@Nullable Integer []> p); + void f31(G1> p); + void f32(G1, G1<@NotNull int @NotNull []>>> p); + void f33(G1<@NotNull int @NotNull []> p); + void f34(G1 p); + void f35(G2 p1, G1<@NotNull Integer @NotNull [] []> p2, G1> p3); + void f36(G1<@NotNull Integer @NotNull [] []> p); + void f37(G1> p); + void f38(G1, G1<@NotNull int [] [] @NotNull []>>> p); + void f39(G1<@NotNull int @NotNull [] @NotNull [] []> p); // arrays in wildcard bounds - void f40(G1 p); - void f41(G2 p); - void f42(G1 p); - void f43(G1> p); - void f44(G1, G1>> p); - void f45(G1, G1>> p); - void f46(G1 p); - void f47(G1 p); - void f48(G2 p); - void f49(G1 p1, G1> p2, G2 p3); - void f50(G1> p); - void f51(G1, G1>> p); - void f52(G1, G1>> p); - void f53(G1 p); + void f40(G1 p); + void f41(G2 p); + void f42(G1 p); + void f43(G1> p); + void f44(G1, G1>> p); + void f45(G1, G1>> p); + void f46(G1 p); + void f47(G1 p); + void f48(G2 p); + void f49(G1 p1, G1> p2, G2 p3); + void f50(G1> p); + void f51(G1, G1>> p); + void f52(G1, G1>> p); + void f53(G1 p); - void f54(G1, G1>> p1, G1<@A int @A [] @A [] []> p2, @A Object [] [] [] [] @A [] p3, @A int @A [] p4, G2, ? extends @A("abc") Integer>>> p5); + void f54(G1, G1>> p1, G1<@NotNull int @NotNull [] @NotNull [] []> p2, @NotNull Object [] [] [] [] @NotNull [] p3, @NotNull int @NotNull [] p4, G2, ? extends @NotNull Integer>>> p5); // varargs - void f55(@A String ... x); - void f56(String @A ... x); - void f57(@A String @A ... x); - void f58(@A int ... x); - void f59(int @A ... x); - void f60(@A int @A ... x); + void f55(@NotNull String ... x); + void f56(String @NotNull ... x); + void f57(@NotNull String @NotNull ... x); + void f58(@NotNull int ... x); + void f59(int @NotNull ... x); + void f60(@NotNull int @Nullable ... x); // varargs + arrays - void f61(@A String [] ... x); - void f62(String @A [] ... x); - void f63(String [] @A ... x); - void f64(@A String @A [] @A ... x); - void f65(@A int [] ... x); - void f66(int @A [] ... x); - void f67(int [] @A ... x); - void f68(@A int @A [] @A ... x); + void f61(@Nullable String [] ... x); + void f62(String @Nullable [] ... x); + void f63(String [] @Nullable ... x); + void f64(@NotNull String @NotNull [] @NotNull ... x); + void f65(@NotNull int [] ... x); + void f66(int @NotNull [] ... x); + void f67(int [] @NotNull ... x); + void f68(@NotNull int @NotNull [] @NotNull ... x); - void f69(@A String [] [] ... x); - void f70(String [] @A [] ... x); - void f71(String [] [] [] @A ... x); - void f72(@A String @A [] [] @A [] @A ... x); - void f73(@A int [] @A [] ... x); - void f74(int @A [][][] @A [] ... x); - void f75(int [] [] [] @A ... x); - void f76(@A int @A [] [] @A ... x); + void f69(@NotNull String [] [] ... x); + void f70(String [] @Nullable [] ... x); + void f71(String [] [] [] @Nullable ... x); + void f72(@Nullable String @Nullable [] [] @NotNull [] @NotNull ... x); + void f73(@NotNull int [] @NotNull [] ... x); + void f74(int @NotNull [][][] @NotNull [] ... x); + void f75(int [] [] [] @NotNull ... x); + void f76(@NotNull int @NotNull [] [] @NotNull ... x); class Test { - public Test(G2, ? extends @A("abc") Integer>>> p1, Object [] @A [] p2, int [] @A [] p3, @A int @A [] @A [] [] @A [] p4, @A int @A [] [] @A ... p5) { + public Test(G2, ? extends @NotNull Integer>>> p1, Object [] @NotNull [] p2, int [] @NotNull [] p3, @NotNull int @NotNull [] @NotNull [] [] @NotNull [] p4, @NotNull int @NotNull [] [] @NotNull ... p5) { } } diff --git a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ValueArguments.txt b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ValueArguments.txt index e4ecaac4799..28bf56655b6 100644 --- a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ValueArguments.txt +++ b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ValueArguments.txt @@ -1,10 +1,5 @@ package test -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) public/*package*/ final annotation class A : kotlin.Annotation { - public/*package*/ constructor A(/*0*/ value: kotlin.String = ...) - public final val value: kotlin.String -} - public/*package*/ interface G0 { } @@ -15,85 +10,85 @@ public/*package*/ interface G2 { } public/*package*/ interface ValueArguments { - public abstract fun f0(/*0*/ p0: test.G1<@test.A test.G0!>!): kotlin.Unit - public abstract fun f1(/*0*/ p0: test.G1!>!>!>!): kotlin.Unit - public abstract fun f10(/*0*/ p0: test.G1!): kotlin.Unit - public abstract fun f11(/*0*/ p0: test.G2!, in @test.A(value = "abc") kotlin.Int!>!>!>!): kotlin.Unit - public abstract fun f12(/*0*/ p0: test.G2!, out @test.A(value = "abc") kotlin.Int!>!>!>!): kotlin.Unit - public abstract fun f13(/*0*/ p0: (@test.A kotlin.Array..@test.A kotlin.Array?)): kotlin.Unit - public abstract fun f14(/*0*/ p0: @test.A kotlin.IntArray!): kotlin.Unit - public abstract fun f15(/*0*/ p0: kotlin.Array<(out) @test.A kotlin.Int!>!): kotlin.Unit - public abstract fun f16(/*0*/ p0: kotlin.IntArray!): kotlin.Unit - public abstract fun f17(/*0*/ p0: (@test.A kotlin.Array<@test.A kotlin.Int!>..@test.A kotlin.Array?)): kotlin.Unit - public abstract fun f18(/*0*/ p0: @test.A kotlin.IntArray!, /*1*/ p1: (@test.A kotlin.Array..@test.A kotlin.Array?), /*2*/ p2: kotlin.IntArray!): kotlin.Unit - public abstract fun f19(/*0*/ p0: (@test.A kotlin.Array!>..@test.A kotlin.Array!>?)): kotlin.Unit - public abstract fun f2(/*0*/ p0: test.G1<@test.A kotlin.String!>!): kotlin.Unit - public abstract fun f20(/*0*/ p0: (@test.A kotlin.Array<@test.A kotlin.IntArray!>..@test.A kotlin.Array?)): kotlin.Unit - public abstract fun f21(/*0*/ p0: kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.Int!>!>!>!): kotlin.Unit - public abstract fun f22(/*0*/ p0: (@test.A kotlin.Array<(@test.A kotlin.Array!>..@test.A kotlin.Array!>?)>..@test.A kotlin.Array!>..@test.A kotlin.Array!>?)>?)): kotlin.Unit - public abstract fun f23(/*0*/ p0: (@test.A kotlin.Array!>..@test.A kotlin.Array!>?)>!>..@test.A kotlin.Array!>..@test.A kotlin.Array!>?)>!>?)): kotlin.Unit - public abstract fun f24(/*0*/ p0: (@test.A kotlin.Array<@test.A kotlin.IntArray!>..@test.A kotlin.Array?)): kotlin.Unit - public abstract fun f25(/*0*/ p0: kotlin.Array<(out) @test.A kotlin.IntArray!>!): kotlin.Unit - public abstract fun f26(/*0*/ p0: kotlin.Array<(out) (@test.A kotlin.Array..@test.A kotlin.Array?)>!, /*1*/ p1: kotlin.Array<(out) @test.A kotlin.IntArray!>!, /*2*/ p2: (@test.A kotlin.Array<(@test.A kotlin.Array!>..@test.A kotlin.Array!>?)>..@test.A kotlin.Array!>..@test.A kotlin.Array!>?)>?)): kotlin.Unit - public abstract fun f27(/*0*/ p0: kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) (@test.A kotlin.Array<@test.A kotlin.Any!>..@test.A kotlin.Array?)>!>!>!>!): kotlin.Unit - public abstract fun f28(/*0*/ p0: test.G1<(@test.A kotlin.Array..@test.A kotlin.Array?)>!): kotlin.Unit - public abstract fun f29(/*0*/ p0: test.G2!): kotlin.Unit - public abstract fun f3(/*0*/ p0: test.G2<@test.A kotlin.String!, test.G2<@test.A(value = "abc") kotlin.Int!, test.G2<@test.A(value = "abc") test.G2!, @test.A(value = "abc") kotlin.Int!>!>!>!): kotlin.Unit - public abstract fun f30(/*0*/ p0: test.G1!>!): kotlin.Unit + public abstract fun f0(/*0*/ p0: test.G1<@org.jetbrains.annotations.NotNull test.G0>!): kotlin.Unit + public abstract fun f1(/*0*/ p0: test.G1!>!>!>!): kotlin.Unit + public abstract fun f10(/*0*/ p0: test.G1!): kotlin.Unit + public abstract fun f11(/*0*/ p0: test.G2?, in @org.jetbrains.annotations.NotNull kotlin.Int>!>!>!): kotlin.Unit + public abstract fun f12(/*0*/ p0: test.G2, out @org.jetbrains.annotations.NotNull kotlin.Int>!>!>!): kotlin.Unit + public abstract fun f13(/*0*/ p0: (@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)): kotlin.Unit + public abstract fun f14(/*0*/ p0: kotlin.IntArray!): kotlin.Unit + public abstract fun f15(/*0*/ @org.jetbrains.annotations.NotNull p0: kotlin.Array<(out) @org.jetbrains.annotations.NotNull kotlin.Int>!): kotlin.Unit + public abstract fun f16(/*0*/ @org.jetbrains.annotations.Nullable p0: kotlin.IntArray!): kotlin.Unit + public abstract fun f17(/*0*/ @org.jetbrains.annotations.Nullable p0: (@org.jetbrains.annotations.Nullable kotlin.Array<@org.jetbrains.annotations.Nullable kotlin.Int?>?..@org.jetbrains.annotations.Nullable kotlin.Array?)): kotlin.Unit + public abstract fun f18(/*0*/ @org.jetbrains.annotations.Nullable p0: kotlin.IntArray!, /*1*/ p1: (@org.jetbrains.annotations.Nullable kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?), /*2*/ @org.jetbrains.annotations.Nullable p2: kotlin.IntArray!): kotlin.Unit + public abstract fun f19(/*0*/ p0: (@org.jetbrains.annotations.NotNull kotlin.Array!>..@org.jetbrains.annotations.NotNull kotlin.Array!>)): kotlin.Unit + public abstract fun f2(/*0*/ p0: test.G1<@org.jetbrains.annotations.NotNull kotlin.String>!): kotlin.Unit + public abstract fun f20(/*0*/ p0: (@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)): kotlin.Unit + public abstract fun f21(/*0*/ @org.jetbrains.annotations.NotNull p0: kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @org.jetbrains.annotations.NotNull kotlin.Int>!>!>!): kotlin.Unit + public abstract fun f22(/*0*/ @org.jetbrains.annotations.NotNull p0: (@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array!>..@org.jetbrains.annotations.NotNull kotlin.Array!>)>..@org.jetbrains.annotations.NotNull kotlin.Array!>..@org.jetbrains.annotations.NotNull kotlin.Array!>)>)): kotlin.Unit + public abstract fun f23(/*0*/ @org.jetbrains.annotations.NotNull p0: (@org.jetbrains.annotations.NotNull kotlin.Array!>..@org.jetbrains.annotations.NotNull kotlin.Array!>)>!>..@org.jetbrains.annotations.NotNull kotlin.Array!>..@org.jetbrains.annotations.NotNull kotlin.Array!>)>!>)): kotlin.Unit + public abstract fun f24(/*0*/ @org.jetbrains.annotations.NotNull p0: (@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)): kotlin.Unit + public abstract fun f25(/*0*/ p0: kotlin.Array<(out) kotlin.IntArray!>!): kotlin.Unit + public abstract fun f26(/*0*/ p0: kotlin.Array<(out) (@org.jetbrains.annotations.Nullable kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?)>!, /*1*/ p1: kotlin.Array<(out) kotlin.IntArray!>!, /*2*/ @org.jetbrains.annotations.Nullable p2: (@org.jetbrains.annotations.Nullable kotlin.Array<(@org.jetbrains.annotations.Nullable kotlin.Array!>?..@org.jetbrains.annotations.Nullable kotlin.Array!>?)>?..@org.jetbrains.annotations.Nullable kotlin.Array!>?..@org.jetbrains.annotations.Nullable kotlin.Array!>?)>?)): kotlin.Unit + public abstract fun f27(/*0*/ @org.jetbrains.annotations.Nullable p0: kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) (@org.jetbrains.annotations.Nullable kotlin.Array<@org.jetbrains.annotations.Nullable kotlin.Any?>?..@org.jetbrains.annotations.Nullable kotlin.Array?)>!>!>!>!): kotlin.Unit + public abstract fun f28(/*0*/ p0: test.G1<(@org.jetbrains.annotations.Nullable kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?)>!): kotlin.Unit + public abstract fun f29(/*0*/ p0: test.G2!): kotlin.Unit + public abstract fun f3(/*0*/ p0: test.G2<@org.jetbrains.annotations.NotNull kotlin.String, test.G2<@org.jetbrains.annotations.NotNull kotlin.Int, test.G2<@org.jetbrains.annotations.NotNull test.G2, @org.jetbrains.annotations.NotNull kotlin.Int>!>!>!): kotlin.Unit + public abstract fun f30(/*0*/ p0: test.G1!>!): kotlin.Unit public abstract fun f31(/*0*/ p0: test.G1!>!): kotlin.Unit - public abstract fun f32(/*0*/ p0: test.G1..@test.A kotlin.Array?)>!, test.G1<@test.A kotlin.IntArray!>!>!>!): kotlin.Unit - public abstract fun f33(/*0*/ p0: test.G1<@test.A kotlin.IntArray!>!): kotlin.Unit - public abstract fun f34(/*0*/ p0: test.G1..@test.A kotlin.Array?)>!>!): kotlin.Unit - public abstract fun f35(/*0*/ p0: test.G2..@test.A kotlin.Array?)>!, /*1*/ p1: test.G1<(@test.A kotlin.Array!>..@test.A kotlin.Array!>?)>!, /*2*/ p2: test.G1!>!): kotlin.Unit - public abstract fun f36(/*0*/ p0: test.G1<(@test.A kotlin.Array!>..@test.A kotlin.Array!>?)>!): kotlin.Unit + public abstract fun f32(/*0*/ p0: test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!, test.G1!>!>!): kotlin.Unit + public abstract fun f33(/*0*/ p0: test.G1!): kotlin.Unit + public abstract fun f34(/*0*/ p0: test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!>!): kotlin.Unit + public abstract fun f35(/*0*/ p0: test.G2..@org.jetbrains.annotations.NotNull kotlin.Array)>!, /*1*/ p1: test.G1<(@org.jetbrains.annotations.NotNull kotlin.Array!>..@org.jetbrains.annotations.NotNull kotlin.Array!>)>!, /*2*/ p2: test.G1!>!): kotlin.Unit + public abstract fun f36(/*0*/ p0: test.G1<(@org.jetbrains.annotations.NotNull kotlin.Array!>..@org.jetbrains.annotations.NotNull kotlin.Array!>)>!): kotlin.Unit public abstract fun f37(/*0*/ p0: test.G1!>!>!>!): kotlin.Unit - public abstract fun f38(/*0*/ p0: test.G1..@test.A kotlin.Array?)>!, test.G1!>!>!>!>!): kotlin.Unit - public abstract fun f39(/*0*/ p0: test.G1<(@test.A kotlin.Array<(@test.A kotlin.Array..@test.A kotlin.Array?)>..@test.A kotlin.Array..@test.A kotlin.Array?)>?)>!): kotlin.Unit - public abstract fun f4(/*0*/ p0: test.G1!): kotlin.Unit - public abstract fun f40(/*0*/ p0: test.G1..@test.A kotlin.Array?)>!): kotlin.Unit - public abstract fun f41(/*0*/ p0: test.G2!): kotlin.Unit - public abstract fun f42(/*0*/ p0: test.G1!>!): kotlin.Unit + public abstract fun f38(/*0*/ p0: test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!, test.G1!>!>!>!>!): kotlin.Unit + public abstract fun f39(/*0*/ p0: test.G1<(@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>!): kotlin.Unit + public abstract fun f4(/*0*/ p0: test.G1!): kotlin.Unit + public abstract fun f40(/*0*/ p0: test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!): kotlin.Unit + public abstract fun f41(/*0*/ p0: test.G2!): kotlin.Unit + public abstract fun f42(/*0*/ p0: test.G1!>!): kotlin.Unit public abstract fun f43(/*0*/ p0: test.G1!>!): kotlin.Unit - public abstract fun f44(/*0*/ p0: test.G1..@test.A kotlin.Array?)>!, test.G1!>!>!): kotlin.Unit - public abstract fun f45(/*0*/ p0: test.G1..@test.A kotlin.Array?)>!, test.G1!>!>!): kotlin.Unit - public abstract fun f46(/*0*/ p0: test.G1!): kotlin.Unit - public abstract fun f47(/*0*/ p0: test.G1..@test.A kotlin.Array?)>!>!): kotlin.Unit - public abstract fun f48(/*0*/ p0: test.G2!>!>!): kotlin.Unit - public abstract fun f49(/*0*/ p0: test.G1!>!>!>!>!>!, /*1*/ p1: test.G1..@test.A kotlin.Array?)>!>!, /*2*/ p2: test.G2!>!>!): kotlin.Unit - public abstract fun f5(/*0*/ p0: test.G1!>!>!>!): kotlin.Unit - public abstract fun f50(/*0*/ p0: test.G1..@test.A kotlin.Array?)>!>!): kotlin.Unit - public abstract fun f51(/*0*/ p0: test.G1..@test.A kotlin.Array?)>!>!>!, test.G1..@test.A kotlin.Array?)>..@test.A kotlin.Array..@test.A kotlin.Array?)>?)>!>!>!): kotlin.Unit - public abstract fun f52(/*0*/ p0: test.G1!>!>..@test.A kotlin.Array!>!>?)>!, test.G1!>!>!>!): kotlin.Unit - public abstract fun f53(/*0*/ p0: test.G1..@test.A kotlin.Array?)>!): kotlin.Unit - public abstract fun f54(/*0*/ p0: test.G1!>!>..@test.A kotlin.Array!>!>?)>!, test.G1!>!>!>!, /*1*/ p1: test.G1<(@test.A kotlin.Array<(@test.A kotlin.Array..@test.A kotlin.Array?)>..@test.A kotlin.Array..@test.A kotlin.Array?)>?)>!, /*2*/ p2: kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) (@test.A kotlin.Array<@test.A kotlin.Any!>..@test.A kotlin.Array?)>!>!>!>!, /*3*/ p3: @test.A kotlin.IntArray!, /*4*/ p4: test.G2!, out @test.A(value = "abc") kotlin.Int!>!>!>!): kotlin.Unit - public abstract fun f55(/*0*/ vararg p0: @test.A kotlin.String! /*kotlin.Array<(out) @test.A kotlin.String!>!*/): kotlin.Unit - public abstract fun f56(/*0*/ vararg p0: kotlin.String! /*(@test.A kotlin.Array..@test.A kotlin.Array?)*/): kotlin.Unit - public abstract fun f57(/*0*/ vararg p0: @test.A kotlin.String! /*(@test.A kotlin.Array<@test.A kotlin.String!>..@test.A kotlin.Array?)*/): kotlin.Unit - public abstract fun f58(/*0*/ vararg p0: kotlin.Int /*kotlin.IntArray!*/): kotlin.Unit - public abstract fun f59(/*0*/ vararg p0: kotlin.Int /*@test.A kotlin.IntArray!*/): kotlin.Unit - public abstract fun f6(/*0*/ p0: test.G1!, /*1*/ p1: test.G1!>!>!>!): kotlin.Unit - public abstract fun f60(/*0*/ vararg p0: kotlin.Int /*@test.A kotlin.IntArray!*/): kotlin.Unit - public abstract fun f61(/*0*/ vararg p0: kotlin.Array<(out) @test.A kotlin.String!>! /*kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.String!>!>!*/): kotlin.Unit - public abstract fun f62(/*0*/ vararg p0: kotlin.Array<(out) kotlin.String!>! /*(@test.A kotlin.Array!>..@test.A kotlin.Array!>?)*/): kotlin.Unit - public abstract fun f63(/*0*/ vararg p0: (@test.A kotlin.Array..@test.A kotlin.Array?) /*kotlin.Array<(out) (@test.A kotlin.Array..@test.A kotlin.Array?)>!*/): kotlin.Unit - public abstract fun f64(/*0*/ vararg p0: (@test.A kotlin.Array<@test.A kotlin.String!>..@test.A kotlin.Array?) /*(@test.A kotlin.Array<(@test.A kotlin.Array<@test.A kotlin.String!>..@test.A kotlin.Array?)>..@test.A kotlin.Array..@test.A kotlin.Array?)>?)*/): kotlin.Unit - public abstract fun f65(/*0*/ vararg p0: kotlin.IntArray! /*kotlin.Array<(out) kotlin.IntArray!>!*/): kotlin.Unit - public abstract fun f66(/*0*/ vararg p0: kotlin.IntArray! /*(@test.A kotlin.Array..@test.A kotlin.Array?)*/): kotlin.Unit - public abstract fun f67(/*0*/ vararg p0: @test.A kotlin.IntArray! /*kotlin.Array<(out) @test.A kotlin.IntArray!>!*/): kotlin.Unit - public abstract fun f68(/*0*/ vararg p0: @test.A kotlin.IntArray! /*(@test.A kotlin.Array<@test.A kotlin.IntArray!>..@test.A kotlin.Array?)*/): kotlin.Unit - public abstract fun f69(/*0*/ vararg p0: kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.String!>!>! /*kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.String!>!>!>!*/): kotlin.Unit - public abstract fun f7(/*0*/ p0: test.G2!, out @test.A(value = "abc") kotlin.Int!>!>!>!): kotlin.Unit - public abstract fun f70(/*0*/ vararg p0: (@test.A kotlin.Array!>..@test.A kotlin.Array!>?) /*kotlin.Array<(out) (@test.A kotlin.Array!>..@test.A kotlin.Array!>?)>!*/): kotlin.Unit - public abstract fun f71(/*0*/ vararg p0: kotlin.Array<(out) kotlin.Array<(out) (@test.A kotlin.Array..@test.A kotlin.Array?)>!>! /*kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) (@test.A kotlin.Array..@test.A kotlin.Array?)>!>!>!*/): kotlin.Unit - public abstract fun f72(/*0*/ vararg p0: kotlin.Array<(out) (@test.A kotlin.Array<(@test.A kotlin.Array<@test.A kotlin.String!>..@test.A kotlin.Array?)>..@test.A kotlin.Array..@test.A kotlin.Array?)>?)>! /*(@test.A kotlin.Array..@test.A kotlin.Array?)>..@test.A kotlin.Array..@test.A kotlin.Array?)>?)>!>..@test.A kotlin.Array..@test.A kotlin.Array?)>..@test.A kotlin.Array..@test.A kotlin.Array?)>?)>!>?)*/): kotlin.Unit - public abstract fun f73(/*0*/ vararg p0: (@test.A kotlin.Array..@test.A kotlin.Array?) /*kotlin.Array<(out) (@test.A kotlin.Array..@test.A kotlin.Array?)>!*/): kotlin.Unit - public abstract fun f74(/*0*/ vararg p0: kotlin.Array<(out) kotlin.Array<(out) (@test.A kotlin.Array..@test.A kotlin.Array?)>!>! /*(@test.A kotlin.Array..@test.A kotlin.Array?)>!>!>..@test.A kotlin.Array..@test.A kotlin.Array?)>!>!>?)*/): kotlin.Unit - public abstract fun f75(/*0*/ vararg p0: kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.IntArray!>!>! /*kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.IntArray!>!>!>!*/): kotlin.Unit - public abstract fun f76(/*0*/ vararg p0: kotlin.Array<(out) @test.A kotlin.IntArray!>! /*(@test.A kotlin.Array!>..@test.A kotlin.Array!>?)*/): kotlin.Unit - public abstract fun f8(/*0*/ p0: test.G1!): kotlin.Unit - public abstract fun f9(/*0*/ p0: test.G1!>!>!>!): kotlin.Unit + public abstract fun f44(/*0*/ p0: test.G1?..@org.jetbrains.annotations.Nullable kotlin.Array?)>!, test.G1!>!>!): kotlin.Unit + public abstract fun f45(/*0*/ p0: test.G1?..@org.jetbrains.annotations.Nullable kotlin.Array?)>!, test.G1!>!>!): kotlin.Unit + public abstract fun f46(/*0*/ p0: test.G1!): kotlin.Unit + public abstract fun f47(/*0*/ p0: test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!>!): kotlin.Unit + public abstract fun f48(/*0*/ p0: test.G2!>!>!): kotlin.Unit + public abstract fun f49(/*0*/ p0: test.G1!>!>!>!>!>!, /*1*/ p1: test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!>!, /*2*/ p2: test.G2!>!>!): kotlin.Unit + public abstract fun f5(/*0*/ p0: test.G1!>!>!>!): kotlin.Unit + public abstract fun f50(/*0*/ p0: test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!>!): kotlin.Unit + public abstract fun f51(/*0*/ p0: test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!>!>!, test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>!>!>!): kotlin.Unit + public abstract fun f52(/*0*/ p0: test.G1!>!>..@org.jetbrains.annotations.NotNull kotlin.Array!>!>)>!, test.G1!>!>!>!): kotlin.Unit + public abstract fun f53(/*0*/ p0: test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!): kotlin.Unit + public abstract fun f54(/*0*/ p0: test.G1!>!>..@org.jetbrains.annotations.NotNull kotlin.Array!>!>)>!, test.G1!>!>!>!, /*1*/ p1: test.G1<(@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>!, /*2*/ @org.jetbrains.annotations.NotNull p2: kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) (@org.jetbrains.annotations.NotNull kotlin.Array<@org.jetbrains.annotations.NotNull kotlin.Any>..@org.jetbrains.annotations.NotNull kotlin.Array)>!>!>!>!, /*3*/ @org.jetbrains.annotations.NotNull p3: kotlin.IntArray!, /*4*/ p4: test.G2, out @org.jetbrains.annotations.NotNull kotlin.Int>!>!>!): kotlin.Unit + public abstract fun f55(/*0*/ @org.jetbrains.annotations.NotNull vararg p0: @org.jetbrains.annotations.NotNull kotlin.String /*kotlin.Array<(out) @org.jetbrains.annotations.NotNull kotlin.String>!*/): kotlin.Unit + public abstract fun f56(/*0*/ vararg p0: kotlin.String! /*(@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)*/): kotlin.Unit + public abstract fun f57(/*0*/ @org.jetbrains.annotations.NotNull vararg p0: @org.jetbrains.annotations.NotNull kotlin.String /*(@org.jetbrains.annotations.NotNull kotlin.Array<@org.jetbrains.annotations.NotNull kotlin.String>..@org.jetbrains.annotations.NotNull kotlin.Array)*/): kotlin.Unit + public abstract fun f58(/*0*/ @org.jetbrains.annotations.NotNull vararg p0: kotlin.Int /*kotlin.IntArray!*/): kotlin.Unit + public abstract fun f59(/*0*/ vararg p0: kotlin.Int /*kotlin.IntArray!*/): kotlin.Unit + public abstract fun f6(/*0*/ p0: test.G1!, /*1*/ p1: test.G1!>!>!>!): kotlin.Unit + public abstract fun f60(/*0*/ @org.jetbrains.annotations.NotNull vararg p0: kotlin.Int /*kotlin.IntArray!*/): kotlin.Unit + public abstract fun f61(/*0*/ @org.jetbrains.annotations.Nullable vararg p0: kotlin.Array<(out) @org.jetbrains.annotations.Nullable kotlin.String?>! /*kotlin.Array<(out) kotlin.Array<(out) @org.jetbrains.annotations.Nullable kotlin.String?>!>!*/): kotlin.Unit + public abstract fun f62(/*0*/ vararg p0: kotlin.Array<(out) kotlin.String!>! /*(@org.jetbrains.annotations.Nullable kotlin.Array!>..@org.jetbrains.annotations.Nullable kotlin.Array!>?)*/): kotlin.Unit + public abstract fun f63(/*0*/ vararg p0: (@org.jetbrains.annotations.Nullable kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?) /*kotlin.Array<(out) (@org.jetbrains.annotations.Nullable kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?)>!*/): kotlin.Unit + public abstract fun f64(/*0*/ @org.jetbrains.annotations.NotNull vararg p0: (@org.jetbrains.annotations.NotNull kotlin.Array<@org.jetbrains.annotations.NotNull kotlin.String>..@org.jetbrains.annotations.NotNull kotlin.Array) /*(@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array<@org.jetbrains.annotations.NotNull kotlin.String>..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)*/): kotlin.Unit + public abstract fun f65(/*0*/ @org.jetbrains.annotations.NotNull vararg p0: kotlin.IntArray! /*kotlin.Array<(out) kotlin.IntArray!>!*/): kotlin.Unit + public abstract fun f66(/*0*/ vararg p0: kotlin.IntArray! /*(@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)*/): kotlin.Unit + public abstract fun f67(/*0*/ vararg p0: kotlin.IntArray! /*kotlin.Array<(out) kotlin.IntArray!>!*/): kotlin.Unit + public abstract fun f68(/*0*/ @org.jetbrains.annotations.NotNull vararg p0: kotlin.IntArray! /*(@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)*/): kotlin.Unit + public abstract fun f69(/*0*/ @org.jetbrains.annotations.NotNull vararg p0: kotlin.Array<(out) kotlin.Array<(out) @org.jetbrains.annotations.NotNull kotlin.String>!>! /*kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @org.jetbrains.annotations.NotNull kotlin.String>!>!>!*/): kotlin.Unit + public abstract fun f7(/*0*/ p0: test.G2, out @org.jetbrains.annotations.NotNull kotlin.Int>!>!>!): kotlin.Unit + public abstract fun f70(/*0*/ vararg p0: (@org.jetbrains.annotations.Nullable kotlin.Array!>?..@org.jetbrains.annotations.Nullable kotlin.Array!>?) /*kotlin.Array<(out) (@org.jetbrains.annotations.Nullable kotlin.Array!>?..@org.jetbrains.annotations.Nullable kotlin.Array!>?)>!*/): kotlin.Unit + public abstract fun f71(/*0*/ vararg p0: kotlin.Array<(out) kotlin.Array<(out) (@org.jetbrains.annotations.Nullable kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?)>!>! /*kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) (@org.jetbrains.annotations.Nullable kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?)>!>!>!*/): kotlin.Unit + public abstract fun f72(/*0*/ @org.jetbrains.annotations.Nullable vararg p0: kotlin.Array<(out) (@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array<@org.jetbrains.annotations.Nullable kotlin.String?>..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>! /*(@org.jetbrains.annotations.Nullable kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>!>..@org.jetbrains.annotations.Nullable kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>!>?)*/): kotlin.Unit + public abstract fun f73(/*0*/ @org.jetbrains.annotations.NotNull vararg p0: (@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array) /*kotlin.Array<(out) (@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>!*/): kotlin.Unit + public abstract fun f74(/*0*/ vararg p0: kotlin.Array<(out) kotlin.Array<(out) (@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>!>! /*(@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>!>!>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>!>!>)*/): kotlin.Unit + public abstract fun f75(/*0*/ vararg p0: kotlin.Array<(out) kotlin.Array<(out) kotlin.IntArray!>!>! /*kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.IntArray!>!>!>!*/): kotlin.Unit + public abstract fun f76(/*0*/ @org.jetbrains.annotations.NotNull vararg p0: kotlin.Array<(out) kotlin.IntArray!>! /*(@org.jetbrains.annotations.NotNull kotlin.Array!>..@org.jetbrains.annotations.NotNull kotlin.Array!>)*/): kotlin.Unit + public abstract fun f8(/*0*/ p0: test.G1!): kotlin.Unit + public abstract fun f9(/*0*/ p0: test.G1!>!>!>!): kotlin.Unit public open class Test { - public constructor Test(/*0*/ p0: test.G2!, out @test.A(value = "abc") kotlin.Int!>!>!>!, /*1*/ p1: kotlin.Array<(out) (@test.A kotlin.Array..@test.A kotlin.Array?)>!, /*2*/ p2: kotlin.Array<(out) @test.A kotlin.IntArray!>!, /*3*/ p3: (@test.A kotlin.Array<(@test.A kotlin.Array!>..@test.A kotlin.Array!>?)>..@test.A kotlin.Array!>..@test.A kotlin.Array!>?)>?), /*4*/ vararg p4: kotlin.Array<(out) @test.A kotlin.IntArray!>! /*(@test.A kotlin.Array!>..@test.A kotlin.Array!>?)*/) + public constructor Test(/*0*/ p0: test.G2?, out @org.jetbrains.annotations.NotNull kotlin.Int>!>!>!, /*1*/ p1: kotlin.Array<(out) (@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>!, /*2*/ p2: kotlin.Array<(out) kotlin.IntArray!>!, /*3*/ @org.jetbrains.annotations.NotNull p3: (@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array!>..@org.jetbrains.annotations.NotNull kotlin.Array!>)>..@org.jetbrains.annotations.NotNull kotlin.Array!>..@org.jetbrains.annotations.NotNull kotlin.Array!>)>), /*4*/ @org.jetbrains.annotations.NotNull vararg p4: kotlin.Array<(out) kotlin.IntArray!>! /*(@org.jetbrains.annotations.NotNull kotlin.Array!>..@org.jetbrains.annotations.NotNull kotlin.Array!>)*/) } } diff --git a/compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic.java b/compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic.java index 65420a47763..c363b13d82c 100644 --- a/compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic.java +++ b/compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic.java @@ -1,22 +1,19 @@ // JAVAC_EXPECTED_FILE + package test; -import java.lang.annotation.*; +import org.jetbrains.annotations.*; + public class Basic { - @Target(ElementType.TYPE_PARAMETER) - public @interface A { - String value() default ""; + public interface G<@NotNull T> { + <@NotNull R> void foo(R r); } - public interface G<@A T> { - <@A("abc") R> void foo(R r); + public interface G1 { + void foo(R r); } - public interface G1 { - void foo(R r); - } - - void foo(R r) { + void foo(R r) { } } diff --git a/compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic.javac.txt b/compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic.javac.txt index a9887657d0a..900f301900d 100644 --- a/compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic.javac.txt +++ b/compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic.javac.txt @@ -9,6 +9,6 @@ public open class Basic { } public interface G { - public abstract fun foo(/*0*/ r: R!): kotlin.Unit + public abstract fun foo(/*0*/ p0: R!): kotlin.Unit } } diff --git a/compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic.txt b/compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic.txt index 462a7a3341e..80bfb3d426f 100644 --- a/compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic.txt +++ b/compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic.txt @@ -2,18 +2,13 @@ package test public open class Basic { public constructor Basic() - public/*package*/ open fun foo(/*0*/ r: R!): kotlin.Unit + public/*package*/ open fun foo(/*0*/ r: R!): kotlin.Unit - @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE_PARAMETER}) public final annotation class A : kotlin.Annotation { - public constructor A(/*0*/ value: kotlin.String = ...) - public final val value: kotlin.String + public interface G { + public abstract fun foo(/*0*/ r: R): kotlin.Unit } - public interface G { - public abstract fun foo(/*0*/ r: R!): kotlin.Unit - } - - public interface G1 { - public abstract fun foo(/*0*/ r: R!): kotlin.Unit + public interface G1 { + public abstract fun foo(/*0*/ r: R!): kotlin.Unit } } diff --git a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/BaseClassTypeArguments.java b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/BaseClassTypeArguments.java index b99084103bc..27c4dff6bba 100644 --- a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/BaseClassTypeArguments.java +++ b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/BaseClassTypeArguments.java @@ -1,26 +1,23 @@ +// JAVAC_EXPECTED_FILE + package test; -import java.lang.annotation.*; - -@Target(ElementType.TYPE_USE) -@interface A { - String value() default ""; -} +import org.jetbrains.annotations.*; interface I1 {} interface I2 {} interface I3 {} +class A1 {} class A2 {} class A3 {} -public class BaseClassTypeArguments extends A3<@A B [][][][][], I1>, A2> implements I1<@A Integer @A [][][]>, I2<@A B, B>, I3<@A B [][][][][], B, @A B> { - class ImplementedInterfacesTypeArguments implements I1, I1<@A int [] @A []>>>, I2<@A B, B>, I3<@A B [][][][][], I1>, I2> { - public class BaseClassTypeArguments1 extends A3<@A B [][][][][], I1>, A2> { +public class BaseClassTypeArguments extends A3<@NotNull B [][][][][], I1>, A2> implements I1<@NotNull Integer @NotNull [][][]>, I2<@NotNull B, B>, I3<@NotNull B [][][][][], B, @NotNull B> { + class Basic1 implements I1<@NotNull String> { } + class Basic2 extends A1<@NotNull String> { } - } + class ImplementedInterfacesTypeArguments implements I1, I1<@NotNull int [] @NotNull []>>>, I2<@NotNull B, B>, I3<@NotNull B [][][][][], I1>, I2> { + public class BaseClassTypeArguments1 extends A3<@NotNull B [][][][][], I1>, A2> { } } - static class BaseClassTypeArguments2 extends A3<@A B [][][][][], I1>, A2> { - - } -} \ No newline at end of file + static class BaseClassTypeArguments2 extends A3<@NotNull B [][][][][], I1>, A2> { } +} diff --git a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/BaseClassTypeArguments.javac.txt b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/BaseClassTypeArguments.javac.txt new file mode 100644 index 00000000000..8ee5f909517 --- /dev/null +++ b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/BaseClassTypeArguments.javac.txt @@ -0,0 +1,46 @@ +package test + +public/*package*/ open class A1 { + public/*package*/ constructor A1() +} + +public/*package*/ open class A2 { + public/*package*/ constructor A2() +} + +public/*package*/ open class A3 { + public/*package*/ constructor A3() +} + +public open class BaseClassTypeArguments : test.A3!>!>!>!>!, test.I1..@org.jetbrains.annotations.NotNull kotlin.Array)>!>!, test.A2!>!>!>, test.I1<(@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array<@org.jetbrains.annotations.NotNull kotlin.Int>..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>)>, test.I2<@org.jetbrains.annotations.NotNull B, B!>, test.I3!>!>!>!>!, B!, @org.jetbrains.annotations.NotNull B> { + public constructor BaseClassTypeArguments() + + public/*package*/ open class BaseClassTypeArguments2 : test.A3!>!>!>!>!, test.I1..@org.jetbrains.annotations.NotNull kotlin.Array)>!>!, test.A2!>!>!> { + public/*package*/ constructor BaseClassTypeArguments2() + } + + public/*package*/ open inner class Basic1 /*captured type parameters: /*0*/ B : kotlin.Any!*/ : test.I1<@org.jetbrains.annotations.NotNull kotlin.String> { + public/*package*/ constructor Basic1() + } + + public/*package*/ open inner class Basic2 /*captured type parameters: /*0*/ B : kotlin.Any!*/ : test.A1<@org.jetbrains.annotations.NotNull kotlin.String> { + public/*package*/ constructor Basic2() + } + + public/*package*/ open inner class ImplementedInterfacesTypeArguments /*captured type parameters: /*1*/ B : kotlin.Any!*/ : test.I1..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>)>!, test.I1!>!>!>, test.I2<@org.jetbrains.annotations.NotNull B, B!>, test.I3!>!>!>!>!, test.I1..@org.jetbrains.annotations.NotNull kotlin.Array)>!>!, test.I2!>!>!> { + public/*package*/ constructor ImplementedInterfacesTypeArguments() + + public open inner class BaseClassTypeArguments1 /*captured type parameters: /*1*/ B : kotlin.Any!, /*2*/ B : kotlin.Any!*/ : test.A3!>!>!>!>!, test.I1..@org.jetbrains.annotations.NotNull kotlin.Array)>!>!, test.A2!>!>!> { + public constructor BaseClassTypeArguments1() + } + } +} + +public/*package*/ interface I1 { +} + +public/*package*/ interface I2 { +} + +public/*package*/ interface I3 { +} diff --git a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/BaseClassTypeArguments.txt b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/BaseClassTypeArguments.txt index 09f9e522c1c..8f8ce569162 100644 --- a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/BaseClassTypeArguments.txt +++ b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/BaseClassTypeArguments.txt @@ -1,16 +1,24 @@ package test -public open class BaseClassTypeArguments : test.A3!>!>!>!>!, test.I1!>!>!, test.A2!>..@test.A kotlin.Array!>?)>!>, test.I1..@test.A kotlin.Array?)>!>!>, test.I2<@test.A B!, B!>, test.I3!>!>!>!>!, B!, @test.A B!> { +public open class BaseClassTypeArguments : test.A3!>!>!>!>!, test.I1!>!>!, test.A2!>..@org.jetbrains.annotations.NotNull kotlin.Array!>)>!>, test.I1..@org.jetbrains.annotations.NotNull kotlin.Array)>!>!>, test.I2<@org.jetbrains.annotations.NotNull B, B!>, test.I3!>!>!>!>!, B!, @org.jetbrains.annotations.NotNull B> { public constructor BaseClassTypeArguments() - public/*package*/ open class BaseClassTypeArguments2 : test.A3!>!>!>!>!, test.I1!>!>!, test.A2!>..@test.A kotlin.Array!>?)>!> { + public/*package*/ open class BaseClassTypeArguments2 : test.A3!>!>!>!>!, test.I1!>!>!, test.A2!>..@org.jetbrains.annotations.NotNull kotlin.Array!>)>!> { public/*package*/ constructor BaseClassTypeArguments2() } - public/*package*/ open inner class ImplementedInterfacesTypeArguments /*captured type parameters: /*1*/ B : kotlin.Any!*/ : test.I1..@test.A kotlin.Array?)>!>!>!, test.I1<(@test.A kotlin.Array..@test.A kotlin.Array?)>!>!>, test.I2<@test.A B!, B!>, test.I3!>!>!>!>!, test.I1!>!>!, test.I2!>..@test.A kotlin.Array!>?)>!> { + public/*package*/ open inner class Basic1 /*captured type parameters: /*0*/ B : kotlin.Any!*/ : test.I1<@org.jetbrains.annotations.NotNull kotlin.String> { + public/*package*/ constructor Basic1() + } + + public/*package*/ open inner class Basic2 /*captured type parameters: /*0*/ B : kotlin.Any!*/ : test.A1<@org.jetbrains.annotations.NotNull kotlin.String> { + public/*package*/ constructor Basic2() + } + + public/*package*/ open inner class ImplementedInterfacesTypeArguments /*captured type parameters: /*1*/ B : kotlin.Any!*/ : test.I1..@org.jetbrains.annotations.NotNull kotlin.Array)>!>!>!, test.I1<(@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>!>!>, test.I2<@org.jetbrains.annotations.NotNull B, B!>, test.I3!>!>!>!>!, test.I1!>!>!, test.I2!>..@org.jetbrains.annotations.NotNull kotlin.Array!>)>!> { public/*package*/ constructor ImplementedInterfacesTypeArguments() - public open inner class BaseClassTypeArguments1 /*captured type parameters: /*1*/ B : kotlin.Any!, /*2*/ B : kotlin.Any!*/ : test.A3!>!>!>!>!, test.I1!>!>!, test.A2!>..@test.A kotlin.Array!>?)>!> { + public open inner class BaseClassTypeArguments1 /*captured type parameters: /*1*/ B : kotlin.Any!, /*2*/ B : kotlin.Any!*/ : test.A3!>!>!>!>!, test.I1!>!>!, test.A2!>..@org.jetbrains.annotations.NotNull kotlin.Array!>)>!> { public constructor BaseClassTypeArguments1() } } diff --git a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic.java b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic.java index e2309dac755..8759772b49e 100644 --- a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic.java +++ b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic.java @@ -1,12 +1,10 @@ +// JAVAC_EXPECTED_FILE + package test; -import java.lang.annotation.*; -public class Basic { - @Target(ElementType.TYPE_USE) - @interface A { - String value() default ""; - } +import org.jetbrains.annotations.*; +public class Basic { interface G { } @@ -14,8 +12,7 @@ public class Basic { } public interface MyClass { - void f(G<@A String> p); - - void f(G2<@A String, @A("abc") Integer> p); + void f(G<@NotNull String> p); + void f(G2<@Nullable String, @NotNull Integer> p); } } diff --git a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic.javac.txt b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic.javac.txt new file mode 100644 index 00000000000..5d7173d954b --- /dev/null +++ b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic.javac.txt @@ -0,0 +1,16 @@ +package test + +public open class Basic { + public constructor Basic() + + public/*package*/ interface G { + } + + public/*package*/ interface G2 { + } + + public interface MyClass { + public abstract fun f(/*0*/ p: test.Basic.G2<@org.jetbrains.annotations.Nullable kotlin.String?, @org.jetbrains.annotations.NotNull kotlin.Int>!): kotlin.Unit + public abstract fun f(/*0*/ p: test.Basic.G<@org.jetbrains.annotations.NotNull kotlin.String>!): kotlin.Unit + } +} diff --git a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic.txt b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic.txt index ce0f47c771f..5d7173d954b 100644 --- a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic.txt +++ b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic.txt @@ -3,11 +3,6 @@ package test public open class Basic { public constructor Basic() - @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) public/*package*/ final annotation class A : kotlin.Annotation { - public/*package*/ constructor A(/*0*/ value: kotlin.String = ...) - public final val value: kotlin.String - } - public/*package*/ interface G { } @@ -15,7 +10,7 @@ public open class Basic { } public interface MyClass { - public abstract fun f(/*0*/ p: test.Basic.G2<@test.Basic.A kotlin.String!, @test.Basic.A(value = "abc") kotlin.Int!>!): kotlin.Unit - public abstract fun f(/*0*/ p: test.Basic.G<@test.Basic.A kotlin.String!>!): kotlin.Unit + public abstract fun f(/*0*/ p: test.Basic.G2<@org.jetbrains.annotations.Nullable kotlin.String?, @org.jetbrains.annotations.NotNull kotlin.Int>!): kotlin.Unit + public abstract fun f(/*0*/ p: test.Basic.G<@org.jetbrains.annotations.NotNull kotlin.String>!): kotlin.Unit } } diff --git a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ClassTypeParameterBounds.java b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ClassTypeParameterBounds.java index e8ed265b044..1d6c9fadcec 100644 --- a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ClassTypeParameterBounds.java +++ b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ClassTypeParameterBounds.java @@ -2,12 +2,7 @@ package test; -import java.lang.annotation.*; - -@Target(ElementType.TYPE_USE) -@interface A { - String value() default ""; -} +import org.jetbrains.annotations.*; public class ClassTypeParameterBounds { interface I1 {} @@ -15,19 +10,19 @@ public class ClassTypeParameterBounds { interface I3 {} interface I4 {} - interface G1 { } - class G2<_A, B extends @A Integer> { } - interface G3<_A, B extends Object & @A I1> { } - class G4<_A extends @A B, B> { } - interface G5<_A, B extends @A _A> { } - class G6<_A extends @A I1, B, C, D extends @A E, E, F> { } - interface G7<_A extends Object & I2<@A Integer> & @A I3> { } - interface G8<_A extends Object & I2 & @A I3> { } + interface G1 { } + class G2<_A, B extends @Nullable Integer> { } + interface G3<_A, B extends Object & @NotNull I1> { } + class G4<_A extends @NotNull B, B> { } + interface G5<_A, B extends @Nullable _A> { } + class G6<_A extends @Nullable I1, B, C, D extends @NotNull E, E, F> { } + interface G7<_A extends Object & I2<@NotNull Integer> & @NotNull I3> { } + interface G8<_A extends Object & I2 & @Nullable I3> { } - interface G9<_A extends I4 & I2 & @A I3> { } - interface G10<_A extends I4 & I2 & @A I3> { } - interface G11<_A extends I4 & I2 & @A I3> { } - interface G12<_A extends I4 & I2 & @A I3> { } + interface G9<_A extends I4 & I2 & @NotNull I3> { } + interface G10<_A extends I4 & I2 & @NotNull I3> { } + interface G11<_A extends I4 & I2 & @NotNull I3> { } + interface G12<_A extends I4 & I2 & @NotNull I3> { } - // class G13<_A extends Object, B extends I3<@A _A> & @A I2<_A>> { } + // class G13<_A extends Object, B extends I3<@NotNull _A> & @NotNull I2<_A>> { } } diff --git a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ClassTypeParameterBounds.javac.txt b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ClassTypeParameterBounds.javac.txt new file mode 100644 index 00000000000..bb30ad96647 --- /dev/null +++ b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ClassTypeParameterBounds.javac.txt @@ -0,0 +1,56 @@ +package test + +public open class ClassTypeParameterBounds { + public constructor ClassTypeParameterBounds() + + public/*package*/ interface G1 { + } + + public/*package*/ interface G10!> where _A : test.ClassTypeParameterBounds.I2!, _A : @org.jetbrains.annotations.NotNull test.ClassTypeParameterBounds.I3 { + } + + public/*package*/ interface G11..@org.jetbrains.annotations.NotNull kotlin.Array)>!>!>!> where _A : test.ClassTypeParameterBounds.I2..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>)>)>!, _A : @org.jetbrains.annotations.NotNull test.ClassTypeParameterBounds.I3..@org.jetbrains.annotations.NotNull kotlin.Array)>!> { + } + + public/*package*/ interface G12?..@org.jetbrains.annotations.Nullable kotlin.Array?)>!> where _A : test.ClassTypeParameterBounds.I2!>!>!, _A : @org.jetbrains.annotations.NotNull test.ClassTypeParameterBounds.I3..@org.jetbrains.annotations.NotNull kotlin.Array)>!> { + } + + public/*package*/ open inner class G2 { + public/*package*/ constructor G2() + } + + public/*package*/ interface G3 where B : @org.jetbrains.annotations.NotNull test.ClassTypeParameterBounds.I1 { + } + + public/*package*/ open inner class G4 { + public/*package*/ constructor G4() + } + + public/*package*/ interface G5 { + } + + public/*package*/ open inner class G6 { + public/*package*/ constructor G6() + } + + public/*package*/ interface G7 where _A : test.ClassTypeParameterBounds.I2<@org.jetbrains.annotations.NotNull kotlin.Int>!, _A : @org.jetbrains.annotations.NotNull test.ClassTypeParameterBounds.I3 { + } + + public/*package*/ interface G8 where _A : test.ClassTypeParameterBounds.I2!, _A : @org.jetbrains.annotations.Nullable test.ClassTypeParameterBounds.I3? { + } + + public/*package*/ interface G9..@org.jetbrains.annotations.NotNull kotlin.Array)>!> where _A : test.ClassTypeParameterBounds.I2..@org.jetbrains.annotations.NotNull kotlin.Array)>!, _A : @org.jetbrains.annotations.NotNull test.ClassTypeParameterBounds.I3..@org.jetbrains.annotations.NotNull kotlin.Array)> { + } + + public/*package*/ interface I1 { + } + + public/*package*/ interface I2 { + } + + public/*package*/ interface I3 { + } + + public/*package*/ interface I4 { + } +} diff --git a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ClassTypeParameterBounds.txt b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ClassTypeParameterBounds.txt index 7cb5d93800e..853e3add154 100644 --- a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ClassTypeParameterBounds.txt +++ b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ClassTypeParameterBounds.txt @@ -3,43 +3,43 @@ package test public open class ClassTypeParameterBounds { public constructor ClassTypeParameterBounds() - public/*package*/ interface G1 { + public/*package*/ interface G1 { } - public/*package*/ interface G10!> where _A : test.ClassTypeParameterBounds.I2!, _A : @test.A test.ClassTypeParameterBounds.I3! { + public/*package*/ interface G10!> where _A : test.ClassTypeParameterBounds.I2!, _A : @org.jetbrains.annotations.NotNull test.ClassTypeParameterBounds.I3 { } - public/*package*/ interface G11!>!>..@test.A kotlin.Array!>!>?)>!> where _A : test.ClassTypeParameterBounds.I2..@test.A kotlin.Array?)>!>!>!>!, _A : @test.A test.ClassTypeParameterBounds.I3!>..@test.A kotlin.Array!>?)>! { + public/*package*/ interface G11!>!>..@org.jetbrains.annotations.NotNull kotlin.Array!>!>)>!> where _A : test.ClassTypeParameterBounds.I2..@org.jetbrains.annotations.NotNull kotlin.Array)>!>!>!>!, _A : @org.jetbrains.annotations.NotNull test.ClassTypeParameterBounds.I3!>..@org.jetbrains.annotations.NotNull kotlin.Array!>)> { } - public/*package*/ interface G12!>!> where _A : test.ClassTypeParameterBounds.I2!>..@test.A kotlin.Array!>?)>!, _A : @test.A test.ClassTypeParameterBounds.I3..@test.A kotlin.Array?)>!>! { + public/*package*/ interface G12!>!> where _A : test.ClassTypeParameterBounds.I2!>..@org.jetbrains.annotations.NotNull kotlin.Array!>)>!, _A : @org.jetbrains.annotations.NotNull test.ClassTypeParameterBounds.I3..@org.jetbrains.annotations.NotNull kotlin.Array)>!> { } - public/*package*/ open inner class G2 { - public/*package*/ constructor G2() + public/*package*/ open inner class G2 { + public/*package*/ constructor G2() } - public/*package*/ interface G3 where B : @test.A test.ClassTypeParameterBounds.I1! { + public/*package*/ interface G3 where B : @org.jetbrains.annotations.NotNull test.ClassTypeParameterBounds.I1 { } - public/*package*/ open inner class G4 { - public/*package*/ constructor G4() + public/*package*/ open inner class G4 { + public/*package*/ constructor G4() } - public/*package*/ interface G5 { + public/*package*/ interface G5 { } - public/*package*/ open inner class G6 { - public/*package*/ constructor G6() + public/*package*/ open inner class G6 { + public/*package*/ constructor G6() } - public/*package*/ interface G7 where _A : test.ClassTypeParameterBounds.I2<@test.A kotlin.Int!>!, _A : @test.A test.ClassTypeParameterBounds.I3! { + public/*package*/ interface G7 where _A : test.ClassTypeParameterBounds.I2<@org.jetbrains.annotations.NotNull kotlin.Int>!, _A : @org.jetbrains.annotations.NotNull test.ClassTypeParameterBounds.I3 { } - public/*package*/ interface G8 where _A : test.ClassTypeParameterBounds.I2!, _A : @test.A test.ClassTypeParameterBounds.I3! { + public/*package*/ interface G8 where _A : test.ClassTypeParameterBounds.I2!, _A : @org.jetbrains.annotations.Nullable test.ClassTypeParameterBounds.I3? { } - public/*package*/ interface G9..@test.A kotlin.Array?)>!> where _A : test.ClassTypeParameterBounds.I2..@test.A kotlin.Array?)>!, _A : @test.A test.ClassTypeParameterBounds.I3..@test.A kotlin.Array?)>! { + public/*package*/ interface G9..@org.jetbrains.annotations.NotNull kotlin.Array)>!> where _A : test.ClassTypeParameterBounds.I2..@org.jetbrains.annotations.NotNull kotlin.Array)>!, _A : @org.jetbrains.annotations.NotNull test.ClassTypeParameterBounds.I3..@org.jetbrains.annotations.NotNull kotlin.Array)> { } public/*package*/ interface I1 { diff --git a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodReceiver.java b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodReceiver.java index c26e08c0b33..2a43d23c233 100644 --- a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodReceiver.java +++ b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodReceiver.java @@ -2,12 +2,7 @@ package test; -import java.lang.annotation.*; - -@Target(ElementType.TYPE_USE) -@interface A { - String value() default ""; -} +import org.jetbrains.annotations.*; /* * Note that a receiver type doesn't get into signatures used by the Kotlin compiler @@ -15,9 +10,9 @@ import java.lang.annotation.*; */ public class MethodReceiver { - public void f1(MethodReceiver<@A T> this) { } + public void f1(MethodReceiver<@Nullable T> this) { } class MethodReceiver3 { - public void f1(@A MethodReceiver3<@A T, K, @A L> this) { } + public void f1(@Nullable MethodReceiver3<@Nullable T, K, @Nullable L> this) { } } } \ No newline at end of file diff --git a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodReceiver.javac.txt b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodReceiver.javac.txt new file mode 100644 index 00000000000..1964dcde5ba --- /dev/null +++ b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodReceiver.javac.txt @@ -0,0 +1,11 @@ +package test + +public open class MethodReceiver { + public constructor MethodReceiver() + public open fun f1(): kotlin.Unit + + public/*package*/ open inner class MethodReceiver3 /*captured type parameters: /*3*/ T : kotlin.Any!*/ { + public/*package*/ constructor MethodReceiver3() + public open fun f1(): kotlin.Unit + } +} diff --git a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodTypeParameterBounds.java b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodTypeParameterBounds.java index 1ddc625116a..16b4632069b 100644 --- a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodTypeParameterBounds.java +++ b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodTypeParameterBounds.java @@ -2,12 +2,7 @@ package test; -import java.lang.annotation.*; - -@Target(ElementType.TYPE_USE) -@interface A { - String value() default ""; -} +import org.jetbrains.annotations.*; abstract class MethodTypeParameterBounds { interface I1 {} @@ -15,19 +10,19 @@ abstract class MethodTypeParameterBounds { interface I3 {} interface I4 {} - void f1(T x) { } - <_A, B extends @A Integer> void f2(_A x, B y) { } - <_A, B extends Object & @A I1> void f3(_A x, B y) { } - <_A extends @A B, B> void f4(_A x, B y) { } - <_A, B extends @A _A> void f5(_A x, B y) { } - <_A extends @A I1> void f6() { } - abstract <_A, B extends @A _A> void f7(_A x, B y); - abstract <_A extends @A I1, B, C, D extends @A E, E, F> void f8(_A x1, B x2, C x3, D x4, E x5, F x6); - <_A extends Object & I2<@A Integer> & @A I3> void f9(_A x) { } - <_A extends Object & I2 & @A I3> void f10(_A x) { } - <_A extends I4 & I2 & @A I3> void f11(_A x) { } - <_A extends I4 & I2 & @A I3> void f12(_A x) { } - <_A extends I4 & I2 & @A I3> void f13(_A x) { } - abstract <_A extends I4 & I2 & @A I3> void f14(_A x); - <_A extends Object, B extends I3<@A A> & @A I2> void f15(_A x) { } + void f1(T x) { } + <_A, B extends @NotNull Integer> void f2(_A x, B y) { } + <_A, B extends Object & @Nullable I1> void f3(_A x, B y) { } + <_A extends @NotNull B, B> void f4(_A x, B y) { } + <_A, B extends @Nullable _A> void f5(_A x, B y) { } + <_A extends @Nullable I1> void f6() { } + abstract <_A, B extends @NotNull _A> void f7(_A x, B y); + abstract <_A extends @Nullable I1, B, C, D extends @NotNull E, E, F> void f8(_A x1, B x2, C x3, D x4, E x5, F x6); + <_A extends Object & I2<@Nullable Integer> & @Nullable I3> void f9(_A x) { } + <_A extends Object & I2 & @Nullable I3> void f10(_A x) { } + <_A extends I4 & I2 & @Nullable I3> void f11(_A x) { } + <_A extends I4 & I2 & @NotNull I3> void f12(_A x) { } + <_A extends I4 & I2 & @Nullable I3> void f13(_A x) { } + abstract <_A extends I4 & I2 & @Nullable I3> void f14(_A x); + <_A extends Object, B extends I3<@Nullable _A> & @NotNull I2<_A>> void f15(_A x) { } } diff --git a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodTypeParameterBounds.javac.txt b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodTypeParameterBounds.javac.txt new file mode 100644 index 00000000000..d27179d5a6a --- /dev/null +++ b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodTypeParameterBounds.javac.txt @@ -0,0 +1,32 @@ +package test + +public/*package*/ abstract class MethodTypeParameterBounds { + public/*package*/ constructor MethodTypeParameterBounds() + public/*package*/ open fun f1(/*0*/ x: T): kotlin.Unit + public/*package*/ open fun f10(/*0*/ x: _A): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2!, _A : @org.jetbrains.annotations.Nullable test.MethodTypeParameterBounds.I3? + public/*package*/ open fun ..@org.jetbrains.annotations.NotNull kotlin.Array)>!> f11(/*0*/ x: _A): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2?..@org.jetbrains.annotations.Nullable kotlin.Array?)>!, _A : @org.jetbrains.annotations.Nullable test.MethodTypeParameterBounds.I3..@org.jetbrains.annotations.NotNull kotlin.Array)>? + public/*package*/ open fun !> f12(/*0*/ x: _A): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2!, _A : @org.jetbrains.annotations.NotNull test.MethodTypeParameterBounds.I3 + public/*package*/ open fun ?..@org.jetbrains.annotations.Nullable kotlin.Array?)>!>!>!> f13(/*0*/ x: _A): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2?..@org.jetbrains.annotations.Nullable kotlin.Array?)>?..@org.jetbrains.annotations.Nullable kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?)>?)>?..@org.jetbrains.annotations.Nullable kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?)>?..@org.jetbrains.annotations.Nullable kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?)>?)>?)>?..@org.jetbrains.annotations.Nullable kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?)>?..@org.jetbrains.annotations.Nullable kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?)>?)>?..@org.jetbrains.annotations.Nullable kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?)>?..@org.jetbrains.annotations.Nullable kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?)>?)>?)>?)>!, _A : @org.jetbrains.annotations.Nullable test.MethodTypeParameterBounds.I3?..@org.jetbrains.annotations.Nullable kotlin.Array?)>!>? + public/*package*/ abstract fun ..@org.jetbrains.annotations.NotNull kotlin.Array)>!> f14(/*0*/ x: _A): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2!>!>!, _A : @org.jetbrains.annotations.Nullable test.MethodTypeParameterBounds.I3?..@org.jetbrains.annotations.Nullable kotlin.Array?)>!>? + public/*package*/ open fun !> f15(/*0*/ x: _A!): kotlin.Unit where B : @org.jetbrains.annotations.NotNull test.MethodTypeParameterBounds.I2<_A!> + public/*package*/ open fun f2(/*0*/ x: _A!, /*1*/ y: B): kotlin.Unit + public/*package*/ open fun f3(/*0*/ x: _A!, /*1*/ y: B): kotlin.Unit where B : @org.jetbrains.annotations.Nullable test.MethodTypeParameterBounds.I1? + public/*package*/ open fun f4(/*0*/ x: _A, /*1*/ y: B!): kotlin.Unit + public/*package*/ open fun f5(/*0*/ x: _A!, /*1*/ y: B): kotlin.Unit + public/*package*/ open fun f6(): kotlin.Unit + public/*package*/ abstract fun f7(/*0*/ x: _A!, /*1*/ y: B): kotlin.Unit + public/*package*/ abstract fun f8(/*0*/ x1: _A, /*1*/ x2: B!, /*2*/ x3: C!, /*3*/ x4: D, /*4*/ x5: E!, /*5*/ x6: F!): kotlin.Unit + public/*package*/ open fun f9(/*0*/ x: _A): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2<@org.jetbrains.annotations.Nullable kotlin.Int?>!, _A : @org.jetbrains.annotations.Nullable test.MethodTypeParameterBounds.I3? + + public/*package*/ interface I1 { + } + + public/*package*/ interface I2 { + } + + public/*package*/ interface I3 { + } + + public/*package*/ interface I4 { + } +} diff --git a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodTypeParameterBounds.txt b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodTypeParameterBounds.txt index 8189a35c39f..16767d0660a 100644 --- a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodTypeParameterBounds.txt +++ b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodTypeParameterBounds.txt @@ -2,21 +2,21 @@ package test public/*package*/ abstract class MethodTypeParameterBounds { public/*package*/ constructor MethodTypeParameterBounds() - public/*package*/ open fun f1(/*0*/ x: T!): kotlin.Unit - public/*package*/ open fun f10(/*0*/ x: _A!): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2!, _A : @test.A test.MethodTypeParameterBounds.I3! - public/*package*/ open fun ..@test.A kotlin.Array?)>!> f11(/*0*/ x: _A!): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2..@test.A kotlin.Array?)>!, _A : @test.A test.MethodTypeParameterBounds.I3..@test.A kotlin.Array?)>! - public/*package*/ open fun !> f12(/*0*/ x: _A!): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2!, _A : @test.A test.MethodTypeParameterBounds.I3! - public/*package*/ open fun !>!>..@test.A kotlin.Array!>!>?)>!> f13(/*0*/ x: _A!): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2..@test.A kotlin.Array?)>!>!>!>!, _A : @test.A test.MethodTypeParameterBounds.I3!>..@test.A kotlin.Array!>?)>! - public/*package*/ abstract fun !>!> f14(/*0*/ x: _A!): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2!>..@test.A kotlin.Array!>?)>!, _A : @test.A test.MethodTypeParameterBounds.I3..@test.A kotlin.Array?)>!>! - public/*package*/ open fun !> f15(/*0*/ x: _A!): kotlin.Unit where B : @test.A test.MethodTypeParameterBounds.I2! - public/*package*/ open fun f2(/*0*/ x: _A!, /*1*/ y: B!): kotlin.Unit - public/*package*/ open fun f3(/*0*/ x: _A!, /*1*/ y: B!): kotlin.Unit where B : @test.A test.MethodTypeParameterBounds.I1! - public/*package*/ open fun f4(/*0*/ x: _A!, /*1*/ y: B!): kotlin.Unit - public/*package*/ open fun f5(/*0*/ x: _A!, /*1*/ y: B!): kotlin.Unit - public/*package*/ open fun f6(): kotlin.Unit - public/*package*/ abstract fun f7(/*0*/ x: _A!, /*1*/ y: B!): kotlin.Unit - public/*package*/ abstract fun f8(/*0*/ x1: _A!, /*1*/ x2: B!, /*2*/ x3: C!, /*3*/ x4: D!, /*4*/ x5: E!, /*5*/ x6: F!): kotlin.Unit - public/*package*/ open fun f9(/*0*/ x: _A!): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2<@test.A kotlin.Int!>!, _A : @test.A test.MethodTypeParameterBounds.I3! + public/*package*/ open fun f1(/*0*/ x: T): kotlin.Unit + public/*package*/ open fun f10(/*0*/ x: _A): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2!, _A : @org.jetbrains.annotations.Nullable test.MethodTypeParameterBounds.I3? + public/*package*/ open fun ..@org.jetbrains.annotations.NotNull kotlin.Array)>!> f11(/*0*/ x: _A): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2?..@org.jetbrains.annotations.Nullable kotlin.Array?)>!, _A : @org.jetbrains.annotations.Nullable test.MethodTypeParameterBounds.I3..@org.jetbrains.annotations.NotNull kotlin.Array)>? + public/*package*/ open fun !> f12(/*0*/ x: _A): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2!, _A : @org.jetbrains.annotations.NotNull test.MethodTypeParameterBounds.I3 + public/*package*/ open fun !>!>?..@org.jetbrains.annotations.Nullable kotlin.Array!>!>?)>!> f13(/*0*/ x: _A): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2?..@org.jetbrains.annotations.Nullable kotlin.Array?)>!>!>!>!, _A : @org.jetbrains.annotations.Nullable test.MethodTypeParameterBounds.I3!>?..@org.jetbrains.annotations.Nullable kotlin.Array!>?)>? + public/*package*/ abstract fun !>!> f14(/*0*/ x: _A): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2!>?..@org.jetbrains.annotations.Nullable kotlin.Array!>?)>!, _A : @org.jetbrains.annotations.Nullable test.MethodTypeParameterBounds.I3?..@org.jetbrains.annotations.Nullable kotlin.Array?)>!>? + public/*package*/ open fun !> f15(/*0*/ x: _A!): kotlin.Unit where B : @org.jetbrains.annotations.NotNull test.MethodTypeParameterBounds.I2<_A!> + public/*package*/ open fun f2(/*0*/ x: _A!, /*1*/ y: B): kotlin.Unit + public/*package*/ open fun f3(/*0*/ x: _A!, /*1*/ y: B): kotlin.Unit where B : @org.jetbrains.annotations.Nullable test.MethodTypeParameterBounds.I1? + public/*package*/ open fun f4(/*0*/ x: _A, /*1*/ y: B!): kotlin.Unit + public/*package*/ open fun f5(/*0*/ x: _A!, /*1*/ y: B): kotlin.Unit + public/*package*/ open fun f6(): kotlin.Unit + public/*package*/ abstract fun f7(/*0*/ x: _A!, /*1*/ y: B): kotlin.Unit + public/*package*/ abstract fun f8(/*0*/ x1: _A, /*1*/ x2: B!, /*2*/ x3: C!, /*3*/ x4: D, /*4*/ x5: E!, /*5*/ x6: F!): kotlin.Unit + public/*package*/ open fun f9(/*0*/ x: _A): kotlin.Unit where _A : test.MethodTypeParameterBounds.I2<@org.jetbrains.annotations.Nullable kotlin.Int?>!, _A : @org.jetbrains.annotations.Nullable test.MethodTypeParameterBounds.I3? public/*package*/ interface I1 { } diff --git a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ReturnType.java b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ReturnType.java index 5c223aef06f..bad8d817886 100644 --- a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ReturnType.java +++ b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ReturnType.java @@ -1,11 +1,8 @@ +// JAVAC_EXPECTED_FILE + package test; -import java.lang.annotation.*; - -@Target(ElementType.TYPE_USE) -@interface A { - String value() default ""; -} +import org.jetbrains.annotations.*; interface G0 { } interface G1 { } @@ -13,83 +10,87 @@ interface G2 { } interface ReturnType { // simplpe type arguments - G1<@A G0> f0(); - G1>>> f1(); - G1<@A String> f2(); - G2<@A String, G2<@A("abc") Integer, G2<@A("abc") G2, @A("abc") Integer>>> f3(); + G1<@NotNull G0> f0(); + G1>>> f1(); + G1<@NotNull String> f2(); + G2<@NotNull String, G2<@NotNull Integer, G2<@NotNull G2, @NotNull Integer>>> f3(); // wildcards - G1 f4 = null; - G1>>> f5(); - G1 f6(); - G2, ? extends @A("abc") Integer>>> f7(); + G1 f4 = null; + G1>>> f5(); + G1 f6(); + G2, ? extends @NotNull Integer>>> f7(); - G1 f8(); - G1>>> f9(); - G1 f10 = null; - G2, ? super @A("abc") Integer>>> f11(); + G1 f8(); + G1>>> f9(); + G1 f10 = null; + G2, ? super @NotNull Integer>>> f11(); - G2, ? extends @A("abc") Integer>>> f12 = null; + G2, ? extends @NotNull Integer>>> f12 = null; // arrays - Integer @A [] f13(); - int @A [] f14(); - @A Integer [] f15(); - @A int [] f16(); - @A Integer @A [] f17(); - @A int @A [] f18 = null; + Integer @NotNull [] f13(); + int @NotNull [] f14(); + @NotNull Integer [] f15(); + @NotNull int [] f16(); + @NotNull int [] f161 = null; + @NotNull Integer @NotNull [] f17(); + @NotNull int @NotNull [] f18 = null; // multidementional arrays - Integer @A [] [] f19(); - int @A [] @A [] f20(); - @A Integer [] [] [] f21 = null; - @A int @A [] @A [] [] @A [] f22(); - @A Integer @A [] [] @A [] [] f23(); - @A int @A [] @A [] f24 = null; - int [] @A [] f25(); - Object [] @A [] f26(); - @A Object [] [] [] [] @A [] f27(); + Integer @NotNull [] [] f19(); + int @NotNull [] @NotNull [] f20(); + @NotNull Integer [] [] [] f21 = null; + @NotNull int @NotNull [] @NotNull [] [] @NotNull [] f22(); + @NotNull Integer @NotNull [] [] @NotNull [] [] f23(); + @NotNull int @NotNull [] @NotNull [] f24 = null; + int [] @NotNull [] f25(); + Object [] @NotNull [] f26(); + @NotNull Object [] [] [] [] @NotNull [] f27(); + @NotNull Object [] [] [] [] @NotNull [] f271 = null; // arrays in type arguments - G1 f28(); - G2 f29(); - G1<@A Integer []> f30(); - G1> f31(); - G1, G1<@A int @A []>>> f32(); - G1<@A int @A []> f33(); - G1 f34(); - G2 f35 = null; - G1<@A Integer @A [] []> f36(); - G1> f37(); - G1, G1<@A int [] [] @A []>>> f38(); - G1<@A int @A [] @A [] []> f39(); + G1 f28(); + G2 f29(); + G1<@NotNull Integer []> f30(); + G1> f31(); + G1, G1<@NotNull int @NotNull []>>> f32(); + G1<@NotNull int @NotNull []> f33(); + G1 f34(); + G2 f35 = null; + G1<@NotNull Integer @NotNull [] []> f36(); + G1> f37(); + G1, G1<@NotNull int [] [] @NotNull []>>> f38(); + G1<@NotNull int @NotNull [] @NotNull [] []> f39(); // arrays in wildcard bounds - G1 f40(); - G2 f41(); - G1 f42(); - G1> f43(); - G1, G1>> f44(); - G1, G1>> f45 = null; - G1 f46(); - G1 f47(); - G2 f48 = null; - G1 f49(); - G1> f50(); - G1, G1>> f51(); - G1, G1>> f52 = null; - G1 f53(); + G1 f40(); + G2 f41(); + G1 f42(); + G1> f43(); + G1, G1>> f44(); + G1, G1>> f45 = null; + G1 f46(); + G1 f47(); + G2 f48 = null; + G1 f49(); + G1> f50(); + G1, G1>> f51(); + G1, G1>> f52 = null; + G1 f53(); class ReturnType2 { - G1 f4 = null; - G1 f10 = null; - G2, ? extends @A("abc") Integer>>> f12 = null; - @A int @A [] f18 = null; - @A Integer [] [] [] f21 = null; - @A int @A [] @A [] f24 = null; - G2 f35 = null; - G1, G1>> f45 = null; - G2 f48 = null; - G1, G1>> f52 = null; + G1 f4 = null; + G1 f10 = null; + G2, ? extends @NotNull Integer>>> f12 = null; + @NotNull Integer [] f181 = null; + @NotNull Integer @NotNull [] f182 = null; + G1<@NotNull Integer> f183 = null; + @NotNull Integer [] [] [] f21 = null; + @NotNull int @NotNull [] @NotNull [] f24 = null; + G2 f35 = null; + G1, G1>> f45 = null; + G2 f48 = null; + G1, G1>> f52 = null; } } diff --git a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ReturnType.javac.txt b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ReturnType.javac.txt new file mode 100644 index 00000000000..ebb07a32bc3 --- /dev/null +++ b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ReturnType.javac.txt @@ -0,0 +1,87 @@ +package test + +public/*package*/ interface G0 { +} + +public/*package*/ interface G1 { +} + +public/*package*/ interface G2 { +} + +public/*package*/ interface ReturnType { + public abstract fun f0(): test.G1<@org.jetbrains.annotations.NotNull test.G0>! + public abstract fun f1(): test.G1!>!>!>! + public abstract fun f11(): test.G2, in @org.jetbrains.annotations.NotNull kotlin.Int>!>!>! + public abstract fun f13(): (@org.jetbrains.annotations.NotNull kotlin.Array<@org.jetbrains.annotations.NotNull kotlin.Int>..@org.jetbrains.annotations.NotNull kotlin.Array) + public abstract fun f14(): kotlin.IntArray! + @org.jetbrains.annotations.NotNull public abstract fun f15(): (@org.jetbrains.annotations.NotNull kotlin.Array<@org.jetbrains.annotations.NotNull kotlin.Int>..@org.jetbrains.annotations.NotNull kotlin.Array) + @org.jetbrains.annotations.NotNull public abstract fun f16(): kotlin.IntArray! + @org.jetbrains.annotations.NotNull public abstract fun f17(): (@org.jetbrains.annotations.NotNull kotlin.Array<@org.jetbrains.annotations.NotNull kotlin.Int>..@org.jetbrains.annotations.NotNull kotlin.Array) + public abstract fun f19(): (@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array<@org.jetbrains.annotations.NotNull kotlin.Int>..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>) + public abstract fun f2(): test.G1<@org.jetbrains.annotations.NotNull kotlin.String>! + public abstract fun f20(): (@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array) + @org.jetbrains.annotations.NotNull public abstract fun f22(): (@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>) + @org.jetbrains.annotations.NotNull public abstract fun f23(): (@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array<@org.jetbrains.annotations.NotNull kotlin.Int>..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>)>) + public abstract fun f25(): kotlin.Array<(out) kotlin.IntArray!>! + public abstract fun f26(): kotlin.Array<(out) (@org.jetbrains.annotations.NotNull kotlin.Array<@org.jetbrains.annotations.NotNull kotlin.Any>..@org.jetbrains.annotations.NotNull kotlin.Array)>! + @org.jetbrains.annotations.NotNull public abstract fun f27(): (@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array<@org.jetbrains.annotations.NotNull kotlin.Any>..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>)>)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>)>)>) + public abstract fun f28(): test.G1<(@org.jetbrains.annotations.NotNull kotlin.Array<@org.jetbrains.annotations.NotNull kotlin.Int>..@org.jetbrains.annotations.NotNull kotlin.Array)>! + public abstract fun f29(): test.G2! + public abstract fun f3(): test.G2<@org.jetbrains.annotations.NotNull kotlin.String, test.G2<@org.jetbrains.annotations.NotNull kotlin.Int, test.G2<@org.jetbrains.annotations.NotNull test.G2, @org.jetbrains.annotations.NotNull kotlin.Int>!>!>! + public abstract fun f30(): test.G1!>! + public abstract fun f31(): test.G1!>! + public abstract fun f32(): test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!, test.G1!>!>! + public abstract fun f33(): test.G1! + public abstract fun f34(): test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!>! + public abstract fun f36(): test.G1<(@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array<@org.jetbrains.annotations.NotNull kotlin.Int>..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>! + public abstract fun f37(): test.G1!>!>!>! + public abstract fun f38(): test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!, test.G1!>!>!>!>! + public abstract fun f39(): test.G1<(@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>! + public abstract fun f40(): test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>! + public abstract fun f41(): test.G2! + public abstract fun f42(): test.G1!>! + public abstract fun f43(): test.G1!>! + public abstract fun f44(): test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!, test.G1!>!>! + public abstract fun f46(): test.G1! + public abstract fun f47(): test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!>! + public abstract fun f49(): test.G1!>!>!>!>!>! + public abstract fun f5(): test.G1!>!>!>! + public abstract fun f50(): test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!>! + public abstract fun f51(): test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!>!>!, test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>!>!>! + public abstract fun f53(): test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>! + public abstract fun f6(): test.G1! + public abstract fun f7(): test.G2, out @org.jetbrains.annotations.NotNull kotlin.Int>!>!>! + public abstract fun f8(): test.G1! + public abstract fun f9(): test.G1!>!>!>! + + public open class ReturnType2 { + public constructor ReturnType2() + public/*package*/ final var f10: test.G1! + public/*package*/ final var f12: test.G2, out @org.jetbrains.annotations.NotNull kotlin.Int>!>!>! + @org.jetbrains.annotations.NotNull public/*package*/ final var f181: (@org.jetbrains.annotations.NotNull kotlin.Array<@org.jetbrains.annotations.NotNull kotlin.Int>..@org.jetbrains.annotations.NotNull kotlin.Array) + @org.jetbrains.annotations.NotNull public/*package*/ final var f182: (@org.jetbrains.annotations.NotNull kotlin.Array<@org.jetbrains.annotations.NotNull kotlin.Int>..@org.jetbrains.annotations.NotNull kotlin.Array) + public/*package*/ final var f183: test.G1<@org.jetbrains.annotations.NotNull kotlin.Int>! + @org.jetbrains.annotations.NotNull public/*package*/ final var f21: (@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array<@org.jetbrains.annotations.NotNull kotlin.Int>..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>) + @org.jetbrains.annotations.NotNull public/*package*/ final var f24: (@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array) + public/*package*/ final var f35: test.G2..@org.jetbrains.annotations.NotNull kotlin.Array)>! + public/*package*/ final var f4: test.G1! + public/*package*/ final var f45: test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!, test.G1!>!>! + public/*package*/ final var f48: test.G2!>!>! + public/*package*/ final var f52: test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>)>!, test.G1!>!>!>! + } + + // Static members + public final val f10: test.G1! + public final val f12: test.G2, out @org.jetbrains.annotations.NotNull kotlin.Int>!>!>! + @org.jetbrains.annotations.NotNull public final val f161: kotlin.IntArray! + @org.jetbrains.annotations.NotNull public final val f18: kotlin.IntArray! + @org.jetbrains.annotations.NotNull public final val f21: (@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array<@org.jetbrains.annotations.NotNull kotlin.Int>..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>) + @org.jetbrains.annotations.NotNull public final val f24: (@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array) + @org.jetbrains.annotations.NotNull public final val f271: (@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array<@org.jetbrains.annotations.NotNull kotlin.Any>..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>)>)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>)>)>) + public final val f35: test.G2..@org.jetbrains.annotations.NotNull kotlin.Array)>! + public final val f4: test.G1! + public final val f45: test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!, test.G1!>!>! + public final val f48: test.G2!>!>! + public final val f52: test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>)>!, test.G1!>!>!>! +} diff --git a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ReturnType.txt b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ReturnType.txt index 923b2caa9a1..8c42ff1aa7f 100644 --- a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ReturnType.txt +++ b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ReturnType.txt @@ -1,74 +1,78 @@ package test public/*package*/ interface ReturnType { - public abstract fun f0(): test.G1<@test.A test.G0!>! - public abstract fun f1(): test.G1!>!>!>! - public abstract fun f11(): test.G2!, in @test.A(value = "abc") kotlin.Int!>!>!>! - public abstract fun f13(): (@test.A kotlin.Array..@test.A kotlin.Array?) - public abstract fun f14(): @test.A kotlin.IntArray! - @test.A public abstract fun f15(): kotlin.Array<(out) @test.A kotlin.Int!>! - @test.A public abstract fun f16(): kotlin.IntArray! - @test.A public abstract fun f17(): (@test.A kotlin.Array<@test.A kotlin.Int!>..@test.A kotlin.Array?) - public abstract fun f19(): kotlin.Array<(out) (@test.A kotlin.Array..@test.A kotlin.Array?)>! - public abstract fun f2(): test.G1<@test.A kotlin.String!>! - public abstract fun f20(): (@test.A kotlin.Array<@test.A kotlin.IntArray!>..@test.A kotlin.Array?) - @test.A public abstract fun f22(): (@test.A kotlin.Array..@test.A kotlin.Array?)>!>..@test.A kotlin.Array..@test.A kotlin.Array?)>!>?) - @test.A public abstract fun f23(): kotlin.Array<(out) (@test.A kotlin.Array..@test.A kotlin.Array?)>!>..@test.A kotlin.Array..@test.A kotlin.Array?)>!>?)>! - public abstract fun f25(): (@test.A kotlin.Array..@test.A kotlin.Array?) - public abstract fun f26(): (@test.A kotlin.Array!>..@test.A kotlin.Array!>?) - @test.A public abstract fun f27(): (@test.A kotlin.Array!>!>!>!>..@test.A kotlin.Array!>!>!>!>?) - public abstract fun f28(): test.G1<(@test.A kotlin.Array..@test.A kotlin.Array?)>! - public abstract fun f29(): test.G2! - public abstract fun f3(): test.G2<@test.A kotlin.String!, test.G2<@test.A(value = "abc") kotlin.Int!, test.G2<@test.A(value = "abc") test.G2!, @test.A(value = "abc") kotlin.Int!>!>!>! - public abstract fun f30(): test.G1!>! + public abstract fun f0(): test.G1<@org.jetbrains.annotations.NotNull test.G0>! + public abstract fun f1(): test.G1!>!>!>! + public abstract fun f11(): test.G2, in @org.jetbrains.annotations.NotNull kotlin.Int>!>!>! + public abstract fun f13(): (@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array) + public abstract fun f14(): kotlin.IntArray! + @org.jetbrains.annotations.NotNull public abstract fun f15(): kotlin.Array<(out) @org.jetbrains.annotations.NotNull kotlin.Int>! + @org.jetbrains.annotations.NotNull public abstract fun f16(): kotlin.IntArray! + @org.jetbrains.annotations.NotNull public abstract fun f17(): (@org.jetbrains.annotations.NotNull kotlin.Array<@org.jetbrains.annotations.NotNull kotlin.Int>..@org.jetbrains.annotations.NotNull kotlin.Array) + public abstract fun f19(): kotlin.Array<(out) (@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>! + public abstract fun f2(): test.G1<@org.jetbrains.annotations.NotNull kotlin.String>! + public abstract fun f20(): (@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array) + @org.jetbrains.annotations.NotNull public abstract fun f22(): (@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>!>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>!>) + @org.jetbrains.annotations.NotNull public abstract fun f23(): kotlin.Array<(out) (@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>!>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>!>)>! + public abstract fun f25(): (@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array) + public abstract fun f26(): (@org.jetbrains.annotations.NotNull kotlin.Array!>..@org.jetbrains.annotations.NotNull kotlin.Array!>) + @org.jetbrains.annotations.NotNull public abstract fun f27(): (@org.jetbrains.annotations.NotNull kotlin.Array!>!>!>!>..@org.jetbrains.annotations.NotNull kotlin.Array!>!>!>!>) + public abstract fun f28(): test.G1<(@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>! + public abstract fun f29(): test.G2! + public abstract fun f3(): test.G2<@org.jetbrains.annotations.NotNull kotlin.String, test.G2<@org.jetbrains.annotations.NotNull kotlin.Int, test.G2<@org.jetbrains.annotations.NotNull test.G2, @org.jetbrains.annotations.NotNull kotlin.Int>!>!>! + public abstract fun f30(): test.G1!>! public abstract fun f31(): test.G1!>! - public abstract fun f32(): test.G1..@test.A kotlin.Array?)>!, test.G1<@test.A kotlin.IntArray!>!>!>! - public abstract fun f33(): test.G1<@test.A kotlin.IntArray!>! - public abstract fun f34(): test.G1<(@test.A kotlin.Array!>..@test.A kotlin.Array!>?)>! - public abstract fun f36(): test.G1..@test.A kotlin.Array?)>!>! + public abstract fun f32(): test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!, test.G1!>!>! + public abstract fun f33(): test.G1! + public abstract fun f34(): test.G1<(@org.jetbrains.annotations.NotNull kotlin.Array!>..@org.jetbrains.annotations.NotNull kotlin.Array!>)>! + public abstract fun f36(): test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!>! public abstract fun f37(): test.G1!>!>!>! - public abstract fun f38(): test.G1..@test.A kotlin.Array?)>!, test.G1<(@test.A kotlin.Array!>..@test.A kotlin.Array!>?)>!>!>! - public abstract fun f39(): test.G1..@test.A kotlin.Array?)>!>! - public abstract fun f40(): test.G1..@test.A kotlin.Array?)>! - public abstract fun f41(): test.G2! - public abstract fun f42(): test.G1!>! + public abstract fun f38(): test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!, test.G1<(@org.jetbrains.annotations.NotNull kotlin.Array!>..@org.jetbrains.annotations.NotNull kotlin.Array!>)>!>!>! + public abstract fun f39(): test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!>! + public abstract fun f40(): test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>! + public abstract fun f41(): test.G2! + public abstract fun f42(): test.G1!>! public abstract fun f43(): test.G1!>! - public abstract fun f44(): test.G1..@test.A kotlin.Array?)>!, test.G1!>!>! - public abstract fun f46(): test.G1! - public abstract fun f47(): test.G1!>..@test.A kotlin.Array!>?)>! - public abstract fun f49(): test.G1!>!>!>!>!>! - public abstract fun f5(): test.G1!>!>!>! - public abstract fun f50(): test.G1!>!>! - public abstract fun f51(): test.G1!>!>..@test.A kotlin.Array!>!>?)>!, test.G1..@test.A kotlin.Array?)>..@test.A kotlin.Array..@test.A kotlin.Array?)>?)>!>!>! - public abstract fun f53(): test.G1!>! - public abstract fun f6(): test.G1! - public abstract fun f7(): test.G2!, out @test.A(value = "abc") kotlin.Int!>!>!>! - public abstract fun f8(): test.G1! - public abstract fun f9(): test.G1!>!>!>! + public abstract fun f44(): test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!, test.G1!>!>! + public abstract fun f46(): test.G1! + public abstract fun f47(): test.G1!>..@org.jetbrains.annotations.NotNull kotlin.Array!>)>! + public abstract fun f49(): test.G1!>!>!>!>!>! + public abstract fun f5(): test.G1!>!>!>! + public abstract fun f50(): test.G1!>!>! + public abstract fun f51(): test.G1!>!>..@org.jetbrains.annotations.NotNull kotlin.Array!>!>)>!, test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>!>!>! + public abstract fun f53(): test.G1!>! + public abstract fun f6(): test.G1! + public abstract fun f7(): test.G2, out @org.jetbrains.annotations.NotNull kotlin.Int>!>!>! + public abstract fun f8(): test.G1! + public abstract fun f9(): test.G1!>!>!>! public open class ReturnType2 { public constructor ReturnType2() - public/*package*/ final var f10: test.G1! - public/*package*/ final var f12: test.G2!, out @test.A(value = "abc") kotlin.Int!>!>!>! - @test.A public/*package*/ final var f18: @test.A kotlin.IntArray! - @test.A public/*package*/ final var f21: kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.Int!>!>!>! - @test.A public/*package*/ final var f24: (@test.A kotlin.Array<@test.A kotlin.IntArray!>..@test.A kotlin.Array?) - public/*package*/ final var f35: test.G2!>! - public/*package*/ final var f4: test.G1! - public/*package*/ final var f45: test.G1..@test.A kotlin.Array?)>!, test.G1!>!>! - public/*package*/ final var f48: test.G2!>..@test.A kotlin.Array!>?)>! - public/*package*/ final var f52: test.G1..@test.A kotlin.Array?)>!>!>!, test.G1..@test.A kotlin.Array?)>!>!>! + public/*package*/ final var f10: test.G1! + public/*package*/ final var f12: test.G2, out @org.jetbrains.annotations.NotNull kotlin.Int>!>!>! + @org.jetbrains.annotations.NotNull public/*package*/ final var f181: kotlin.Array<(out) @org.jetbrains.annotations.NotNull kotlin.Int>! + @org.jetbrains.annotations.NotNull public/*package*/ final var f182: (@org.jetbrains.annotations.NotNull kotlin.Array<@org.jetbrains.annotations.NotNull kotlin.Int>..@org.jetbrains.annotations.NotNull kotlin.Array) + public/*package*/ final var f183: test.G1<@org.jetbrains.annotations.NotNull kotlin.Int>! + @org.jetbrains.annotations.NotNull public/*package*/ final var f21: kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @org.jetbrains.annotations.NotNull kotlin.Int>!>!>! + @org.jetbrains.annotations.NotNull public/*package*/ final var f24: (@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array) + public/*package*/ final var f35: test.G2!>! + public/*package*/ final var f4: test.G1! + public/*package*/ final var f45: test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!, test.G1!>!>! + public/*package*/ final var f48: test.G2!>..@org.jetbrains.annotations.NotNull kotlin.Array!>)>! + public/*package*/ final var f52: test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!>!>!, test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!>!>! } // Static members - public final val f10: test.G1! - public final val f12: test.G2!, out @test.A(value = "abc") kotlin.Int!>!>!>! - @test.A public final val f18: @test.A kotlin.IntArray! - @test.A public final val f21: kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.Int!>!>!>! - @test.A public final val f24: (@test.A kotlin.Array<@test.A kotlin.IntArray!>..@test.A kotlin.Array?) - public final val f35: test.G2!>! - public final val f4: test.G1! - public final val f45: test.G1..@test.A kotlin.Array?)>!, test.G1!>!>! - public final val f48: test.G2!>..@test.A kotlin.Array!>?)>! - public final val f52: test.G1..@test.A kotlin.Array?)>!>!>!, test.G1..@test.A kotlin.Array?)>!>!>! + public final val f10: test.G1! + public final val f12: test.G2, out @org.jetbrains.annotations.NotNull kotlin.Int>!>!>! + @org.jetbrains.annotations.NotNull public final val f161: kotlin.IntArray! + @org.jetbrains.annotations.NotNull public final val f18: kotlin.IntArray! + @org.jetbrains.annotations.NotNull public final val f21: kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @org.jetbrains.annotations.NotNull kotlin.Int>!>!>! + @org.jetbrains.annotations.NotNull public final val f24: (@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array) + @org.jetbrains.annotations.NotNull public final val f271: (@org.jetbrains.annotations.NotNull kotlin.Array!>!>!>!>..@org.jetbrains.annotations.NotNull kotlin.Array!>!>!>!>) + public final val f35: test.G2!>! + public final val f4: test.G1! + public final val f45: test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!, test.G1!>!>! + public final val f48: test.G2!>..@org.jetbrains.annotations.NotNull kotlin.Array!>)>! + public final val f52: test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!>!>!, test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!>!>! } diff --git a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ValueArguments.java b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ValueArguments.java index 8d54ff5550d..bcf47a05bc3 100644 --- a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ValueArguments.java +++ b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ValueArguments.java @@ -1,11 +1,8 @@ +// JAVAC_EXPECTED_FILE + package test; -import java.lang.annotation.*; - -@Target(ElementType.TYPE_USE) -@interface A { - String value() default ""; -} +import org.jetbrains.annotations.*; interface G0 { } interface G1 { } @@ -13,104 +10,104 @@ interface G2 { } interface ValueArguments { // simplpe type arguments - void f0(G1<@A G0> p); - void f1(G1>>> p); - void f2(G1<@A String> p); - void f3(G2<@A String, G2<@A("abc") Integer, G2<@A("abc") G2, @A("abc") Integer>>> p); + void f0(G1<@NotNull G0> p); + void f1(G1>>> p); + void f2(G1<@NotNull String> p); + void f3(G2<@NotNull String, G2<@NotNull Integer, G2<@NotNull G2, @NotNull Integer>>> p); // wildcards - void f4(G1 p); - void f5(G1>>> p); - void f6(G1 p1, G1>>> p2); - void f7(G2, ? extends @A("abc") Integer>>> p); + void f4(G1 p); + void f5(G1>>> p); + void f6(G1 p1, G1>>> p2); + void f7(G2, ? extends @NotNull Integer>>> p); - void f8(G1 p); - void f9(G1>>> p); - void f10(G1 p); - void f11(G2, ? super @A("abc") Integer>>> p); + void f8(G1 p); + void f9(G1>>> p); + void f10(G1 p); + void f11(G2, ? super @NotNull Integer>>> p); - void f12(G2, ? extends @A("abc") Integer>>> p); + void f12(G2, ? extends @NotNull Integer>>> p); // arrays - void f13(Integer @A [] p); - void f14(int @A [] p); - void f15(@A Integer [] p); - void f16(@A int [] p); - void f17(@A Integer @A [] p); - void f18(@A int @A [] p1, Integer @A [] p2, @A int [] p3); + void f13(Integer @NotNull [] p); + void f14(int @NotNull [] p); + void f15(@NotNull Integer [] p); + void f16(@Nullable int [] p); + void f17(@Nullable Integer @Nullable [] p); + void f18(@Nullable int @Nullable [] p1, Integer @Nullable [] p2, @Nullable int [] p3); // multidementional arrays - void f19(Integer @A [] [] p); - void f20(int @A [] @A [] p); - void f21(@A Integer [] [] [] p); - void f22(@A int @A [] @A [] [] @A [] p); - void f23(@A Integer @A [] [] @A [] [] p); - void f24(@A int @A [] @A [] p); - void f25(int [] @A [] p); - void f26(Object [] @A [] p1, int [] @A [] p2, @A int @A [] @A [] [] @A [] p3); - void f27(@A Object [] [] [] [] @A [] p); + void f19(Integer @NotNull [] [] p); + void f20(int @NotNull [] @NotNull [] p); + void f21(@NotNull Integer [] [] [] p); + void f22(@NotNull int @NotNull [] @NotNull [] [] @NotNull [] p); + void f23(@NotNull Integer @NotNull [] [] @NotNull [] [] p); + void f24(@NotNull int @NotNull [] @NotNull [] p); + void f25(int [] @Nullable [] p); + void f26(Object [] @Nullable [] p1, int [] @Nullable [] p2, @Nullable int @Nullable [] @Nullable [] [] @Nullable [] p3); + void f27(@Nullable Object [] [] [] [] @Nullable [] p); // arrays in type arguments - void f28(G1 p); - void f29(G2 p); - void f30(G1<@A Integer []> p); - void f31(G1> p); - void f32(G1, G1<@A int @A []>>> p); - void f33(G1<@A int @A []> p); - void f34(G1 p); - void f35(G2 p1, G1<@A Integer @A [] []> p2, G1> p3); - void f36(G1<@A Integer @A [] []> p); - void f37(G1> p); - void f38(G1, G1<@A int [] [] @A []>>> p); - void f39(G1<@A int @A [] @A [] []> p); + void f28(G1 p); + void f29(G2 p); + void f30(G1<@Nullable Integer []> p); + void f31(G1> p); + void f32(G1, G1<@NotNull int @NotNull []>>> p); + void f33(G1<@NotNull int @NotNull []> p); + void f34(G1 p); + void f35(G2 p1, G1<@NotNull Integer @NotNull [] []> p2, G1> p3); + void f36(G1<@NotNull Integer @NotNull [] []> p); + void f37(G1> p); + void f38(G1, G1<@NotNull int [] [] @NotNull []>>> p); + void f39(G1<@NotNull int @NotNull [] @NotNull [] []> p); // arrays in wildcard bounds - void f40(G1 p); - void f41(G2 p); - void f42(G1 p); - void f43(G1> p); - void f44(G1, G1>> p); - void f45(G1, G1>> p); - void f46(G1 p); - void f47(G1 p); - void f48(G2 p); - void f49(G1 p1, G1> p2, G2 p3); - void f50(G1> p); - void f51(G1, G1>> p); - void f52(G1, G1>> p); - void f53(G1 p); + void f40(G1 p); + void f41(G2 p); + void f42(G1 p); + void f43(G1> p); + void f44(G1, G1>> p); + void f45(G1, G1>> p); + void f46(G1 p); + void f47(G1 p); + void f48(G2 p); + void f49(G1 p1, G1> p2, G2 p3); + void f50(G1> p); + void f51(G1, G1>> p); + void f52(G1, G1>> p); + void f53(G1 p); - void f54(G1, G1>> p1, G1<@A int @A [] @A [] []> p2, @A Object [] [] [] [] @A [] p3, @A int @A [] p4, G2, ? extends @A("abc") Integer>>> p5); + void f54(G1, G1>> p1, G1<@NotNull int @NotNull [] @NotNull [] []> p2, @NotNull Object [] [] [] [] @NotNull [] p3, @NotNull int @NotNull [] p4, G2, ? extends @NotNull Integer>>> p5); // varargs - void f55(@A String ... x); - void f56(String @A ... x); - void f57(@A String @A ... x); - void f58(@A int ... x); - void f59(int @A ... x); - void f60(@A int @A ... x); + void f55(@NotNull String ... x); + void f56(String @NotNull ... x); + void f57(@NotNull String @NotNull ... x); + void f58(@NotNull int ... x); + void f59(int @NotNull ... x); + void f60(@NotNull int @Nullable ... x); // varargs + arrays - void f61(@A String [] ... x); - void f62(String @A [] ... x); - void f63(String [] @A ... x); - void f64(@A String @A [] @A ... x); - void f65(@A int [] ... x); - void f66(int @A [] ... x); - void f67(int [] @A ... x); - void f68(@A int @A [] @A ... x); + void f61(@Nullable String [] ... x); + void f62(String @Nullable [] ... x); + void f63(String [] @Nullable ... x); + void f64(@NotNull String @NotNull [] @NotNull ... x); + void f65(@NotNull int [] ... x); + void f66(int @NotNull [] ... x); + void f67(int [] @NotNull ... x); + void f68(@NotNull int @NotNull [] @NotNull ... x); - void f69(@A String [] [] ... x); - void f70(String [] @A [] ... x); - void f71(String [] [] [] @A ... x); - void f72(@A String @A [] [] @A [] @A ... x); - void f73(@A int [] @A [] ... x); - void f74(int @A [][][] @A [] ... x); - void f75(int [] [] [] @A ... x); - void f76(@A int @A [] [] @A ... x); + void f69(@NotNull String [] [] ... x); + void f70(String [] @Nullable [] ... x); + void f71(String [] [] [] @Nullable ... x); + void f72(@Nullable String @Nullable [] [] @NotNull [] @NotNull ... x); + void f73(@NotNull int [] @NotNull [] ... x); + void f74(int @NotNull [][][] @NotNull [] ... x); + void f75(int [] [] [] @NotNull ... x); + void f76(@NotNull int @NotNull [] [] @NotNull ... x); class Test { - public Test(G2, ? extends @A("abc") Integer>>> p1, Object [] @A [] p2, int [] @A [] p3, @A int @A [] @A [] [] @A [] p4, @A int @A [] [] @A ... p5) { + public Test(G2, ? extends @NotNull Integer>>> p1, Object [] @NotNull [] p2, int [] @NotNull [] p3, @NotNull int @NotNull [] @NotNull [] [] @NotNull [] p4, @NotNull int @NotNull [] [] @NotNull ... p5) { } } diff --git a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ValueArguments.javac.txt b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ValueArguments.javac.txt new file mode 100644 index 00000000000..c4187fbb8fc --- /dev/null +++ b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ValueArguments.javac.txt @@ -0,0 +1,94 @@ +package test + +public/*package*/ interface G0 { +} + +public/*package*/ interface G1 { +} + +public/*package*/ interface G2 { +} + +public/*package*/ interface ValueArguments { + public abstract fun f0(/*0*/ p: test.G1<@org.jetbrains.annotations.NotNull test.G0>!): kotlin.Unit + public abstract fun f1(/*0*/ p: test.G1!>!>!>!): kotlin.Unit + public abstract fun f10(/*0*/ p: test.G1!): kotlin.Unit + public abstract fun f11(/*0*/ p: test.G2?, in @org.jetbrains.annotations.NotNull kotlin.Int>!>!>!): kotlin.Unit + public abstract fun f12(/*0*/ p: test.G2, out @org.jetbrains.annotations.NotNull kotlin.Int>!>!>!): kotlin.Unit + public abstract fun f13(/*0*/ p: (@org.jetbrains.annotations.NotNull kotlin.Array<@org.jetbrains.annotations.NotNull kotlin.Int>..@org.jetbrains.annotations.NotNull kotlin.Array)): kotlin.Unit + public abstract fun f14(/*0*/ p: kotlin.IntArray!): kotlin.Unit + public abstract fun f15(/*0*/ @org.jetbrains.annotations.NotNull p: (@org.jetbrains.annotations.NotNull kotlin.Array<@org.jetbrains.annotations.NotNull kotlin.Int>..@org.jetbrains.annotations.NotNull kotlin.Array)): kotlin.Unit + public abstract fun f16(/*0*/ @org.jetbrains.annotations.Nullable p: kotlin.IntArray!): kotlin.Unit + public abstract fun f17(/*0*/ @org.jetbrains.annotations.Nullable p: (@org.jetbrains.annotations.Nullable kotlin.Array<@org.jetbrains.annotations.Nullable kotlin.Int?>?..@org.jetbrains.annotations.Nullable kotlin.Array?)): kotlin.Unit + public abstract fun f18(/*0*/ @org.jetbrains.annotations.Nullable p1: kotlin.IntArray!, /*1*/ p2: (@org.jetbrains.annotations.Nullable kotlin.Array<@org.jetbrains.annotations.Nullable kotlin.Int?>?..@org.jetbrains.annotations.Nullable kotlin.Array?), /*2*/ @org.jetbrains.annotations.Nullable p3: kotlin.IntArray!): kotlin.Unit + public abstract fun f19(/*0*/ p: (@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array<@org.jetbrains.annotations.NotNull kotlin.Int>..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)): kotlin.Unit + public abstract fun f2(/*0*/ p: test.G1<@org.jetbrains.annotations.NotNull kotlin.String>!): kotlin.Unit + public abstract fun f20(/*0*/ p: (@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)): kotlin.Unit + public abstract fun f21(/*0*/ @org.jetbrains.annotations.NotNull p: (@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array<@org.jetbrains.annotations.NotNull kotlin.Int>..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>)): kotlin.Unit + public abstract fun f22(/*0*/ @org.jetbrains.annotations.NotNull p: (@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>)): kotlin.Unit + public abstract fun f23(/*0*/ @org.jetbrains.annotations.NotNull p: (@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array<@org.jetbrains.annotations.NotNull kotlin.Int>..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>)>)): kotlin.Unit + public abstract fun f24(/*0*/ @org.jetbrains.annotations.NotNull p: (@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)): kotlin.Unit + public abstract fun f25(/*0*/ p: kotlin.Array<(out) kotlin.IntArray!>!): kotlin.Unit + public abstract fun f26(/*0*/ p1: kotlin.Array<(out) (@org.jetbrains.annotations.Nullable kotlin.Array<@org.jetbrains.annotations.Nullable kotlin.Any?>?..@org.jetbrains.annotations.Nullable kotlin.Array?)>!, /*1*/ p2: kotlin.Array<(out) kotlin.IntArray!>!, /*2*/ @org.jetbrains.annotations.Nullable p3: (@org.jetbrains.annotations.Nullable kotlin.Array<(@org.jetbrains.annotations.Nullable kotlin.Array<(@org.jetbrains.annotations.Nullable kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?)>?..@org.jetbrains.annotations.Nullable kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?)>?)>?..@org.jetbrains.annotations.Nullable kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?)>?..@org.jetbrains.annotations.Nullable kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?)>?)>?)): kotlin.Unit + public abstract fun f27(/*0*/ @org.jetbrains.annotations.Nullable p: (@org.jetbrains.annotations.Nullable kotlin.Array<(@org.jetbrains.annotations.Nullable kotlin.Array<(@org.jetbrains.annotations.Nullable kotlin.Array<(@org.jetbrains.annotations.Nullable kotlin.Array<(@org.jetbrains.annotations.Nullable kotlin.Array<@org.jetbrains.annotations.Nullable kotlin.Any?>?..@org.jetbrains.annotations.Nullable kotlin.Array?)>?..@org.jetbrains.annotations.Nullable kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?)>?)>?..@org.jetbrains.annotations.Nullable kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?)>?..@org.jetbrains.annotations.Nullable kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?)>?)>?)>?..@org.jetbrains.annotations.Nullable kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?)>?..@org.jetbrains.annotations.Nullable kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?)>?)>?..@org.jetbrains.annotations.Nullable kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?)>?..@org.jetbrains.annotations.Nullable kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?)>?)>?)>?)>?..@org.jetbrains.annotations.Nullable kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?)>?..@org.jetbrains.annotations.Nullable kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?)>?)>?..@org.jetbrains.annotations.Nullable kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?)>?..@org.jetbrains.annotations.Nullable kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?)>?)>?)>?..@org.jetbrains.annotations.Nullable kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?)>?..@org.jetbrains.annotations.Nullable kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?)>?)>?..@org.jetbrains.annotations.Nullable kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?)>?..@org.jetbrains.annotations.Nullable kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?)>?)>?)>?)>?)): kotlin.Unit + public abstract fun f28(/*0*/ p: test.G1<(@org.jetbrains.annotations.Nullable kotlin.Array<@org.jetbrains.annotations.Nullable kotlin.Int?>?..@org.jetbrains.annotations.Nullable kotlin.Array?)>!): kotlin.Unit + public abstract fun f29(/*0*/ p: test.G2!): kotlin.Unit + public abstract fun f3(/*0*/ p: test.G2<@org.jetbrains.annotations.NotNull kotlin.String, test.G2<@org.jetbrains.annotations.NotNull kotlin.Int, test.G2<@org.jetbrains.annotations.NotNull test.G2, @org.jetbrains.annotations.NotNull kotlin.Int>!>!>!): kotlin.Unit + public abstract fun f30(/*0*/ p: test.G1!>!): kotlin.Unit + public abstract fun f31(/*0*/ p: test.G1!>!): kotlin.Unit + public abstract fun f32(/*0*/ p: test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!, test.G1!>!>!): kotlin.Unit + public abstract fun f33(/*0*/ p: test.G1!): kotlin.Unit + public abstract fun f34(/*0*/ p: test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!>!): kotlin.Unit + public abstract fun f35(/*0*/ p1: test.G2..@org.jetbrains.annotations.NotNull kotlin.Array)>!, /*1*/ p2: test.G1<(@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array<@org.jetbrains.annotations.NotNull kotlin.Int>..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>!, /*2*/ p3: test.G1!>!): kotlin.Unit + public abstract fun f36(/*0*/ p: test.G1<(@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array<@org.jetbrains.annotations.NotNull kotlin.Int>..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>!): kotlin.Unit + public abstract fun f37(/*0*/ p: test.G1!>!>!>!): kotlin.Unit + public abstract fun f38(/*0*/ p: test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!, test.G1!>!>!>!>!): kotlin.Unit + public abstract fun f39(/*0*/ p: test.G1<(@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>!): kotlin.Unit + public abstract fun f4(/*0*/ p: test.G1!): kotlin.Unit + public abstract fun f40(/*0*/ p: test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!): kotlin.Unit + public abstract fun f41(/*0*/ p: test.G2!): kotlin.Unit + public abstract fun f42(/*0*/ p: test.G1!>!): kotlin.Unit + public abstract fun f43(/*0*/ p: test.G1!>!): kotlin.Unit + public abstract fun f44(/*0*/ p: test.G1?..@org.jetbrains.annotations.Nullable kotlin.Array?)>!, test.G1!>!>!): kotlin.Unit + public abstract fun f45(/*0*/ p: test.G1?..@org.jetbrains.annotations.Nullable kotlin.Array?)>!, test.G1!>!>!): kotlin.Unit + public abstract fun f46(/*0*/ p: test.G1!): kotlin.Unit + public abstract fun f47(/*0*/ p: test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!>!): kotlin.Unit + public abstract fun f48(/*0*/ p: test.G2!>!>!): kotlin.Unit + public abstract fun f49(/*0*/ p1: test.G1!>!>!>!>!>!, /*1*/ p2: test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!>!, /*2*/ p3: test.G2!>!>!): kotlin.Unit + public abstract fun f5(/*0*/ p: test.G1!>!>!>!): kotlin.Unit + public abstract fun f50(/*0*/ p: test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!>!): kotlin.Unit + public abstract fun f51(/*0*/ p: test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!>!>!, test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>!>!>!): kotlin.Unit + public abstract fun f52(/*0*/ p: test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>)>!, test.G1!>!>!>!): kotlin.Unit + public abstract fun f53(/*0*/ p: test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!): kotlin.Unit + public abstract fun f54(/*0*/ p1: test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>)>!, test.G1!>!>!>!, /*1*/ p2: test.G1<(@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>!, /*2*/ @org.jetbrains.annotations.NotNull p3: (@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array<@org.jetbrains.annotations.NotNull kotlin.Any>..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>)>)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>)>)>), /*3*/ @org.jetbrains.annotations.NotNull p4: kotlin.IntArray!, /*4*/ p5: test.G2, out @org.jetbrains.annotations.NotNull kotlin.Int>!>!>!): kotlin.Unit + public abstract fun f55(/*0*/ @org.jetbrains.annotations.NotNull vararg x: @org.jetbrains.annotations.NotNull kotlin.String /*(@org.jetbrains.annotations.NotNull kotlin.Array<@org.jetbrains.annotations.NotNull kotlin.String>..@org.jetbrains.annotations.NotNull kotlin.Array)*/): kotlin.Unit + public abstract fun f56(/*0*/ vararg x: @org.jetbrains.annotations.NotNull kotlin.String /*(@org.jetbrains.annotations.NotNull kotlin.Array<@org.jetbrains.annotations.NotNull kotlin.String>..@org.jetbrains.annotations.NotNull kotlin.Array)*/): kotlin.Unit + public abstract fun f57(/*0*/ @org.jetbrains.annotations.NotNull vararg x: @org.jetbrains.annotations.NotNull kotlin.String /*(@org.jetbrains.annotations.NotNull kotlin.Array<@org.jetbrains.annotations.NotNull kotlin.String>..@org.jetbrains.annotations.NotNull kotlin.Array)*/): kotlin.Unit + public abstract fun f58(/*0*/ @org.jetbrains.annotations.NotNull vararg x: kotlin.Int /*kotlin.IntArray!*/): kotlin.Unit + public abstract fun f59(/*0*/ vararg x: kotlin.Int /*kotlin.IntArray!*/): kotlin.Unit + public abstract fun f6(/*0*/ p1: test.G1!, /*1*/ p2: test.G1!>!>!>!): kotlin.Unit + public abstract fun f60(/*0*/ @org.jetbrains.annotations.NotNull vararg x: kotlin.Int /*kotlin.IntArray!*/): kotlin.Unit + public abstract fun f61(/*0*/ @org.jetbrains.annotations.Nullable vararg x: (@org.jetbrains.annotations.Nullable kotlin.Array<@org.jetbrains.annotations.Nullable kotlin.String?>?..@org.jetbrains.annotations.Nullable kotlin.Array?) /*(@org.jetbrains.annotations.Nullable kotlin.Array<(@org.jetbrains.annotations.Nullable kotlin.Array<@org.jetbrains.annotations.Nullable kotlin.String?>?..@org.jetbrains.annotations.Nullable kotlin.Array?)>..@org.jetbrains.annotations.Nullable kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?)>?)*/): kotlin.Unit + public abstract fun f62(/*0*/ vararg x: (@org.jetbrains.annotations.Nullable kotlin.Array<@org.jetbrains.annotations.Nullable kotlin.String?>?..@org.jetbrains.annotations.Nullable kotlin.Array?) /*(@org.jetbrains.annotations.Nullable kotlin.Array<(@org.jetbrains.annotations.Nullable kotlin.Array<@org.jetbrains.annotations.Nullable kotlin.String?>?..@org.jetbrains.annotations.Nullable kotlin.Array?)>..@org.jetbrains.annotations.Nullable kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?)>?)*/): kotlin.Unit + public abstract fun f63(/*0*/ vararg x: (@org.jetbrains.annotations.Nullable kotlin.Array<@org.jetbrains.annotations.Nullable kotlin.String?>?..@org.jetbrains.annotations.Nullable kotlin.Array?) /*kotlin.Array<(out) (@org.jetbrains.annotations.Nullable kotlin.Array<@org.jetbrains.annotations.Nullable kotlin.String?>?..@org.jetbrains.annotations.Nullable kotlin.Array?)>!*/): kotlin.Unit + public abstract fun f64(/*0*/ @org.jetbrains.annotations.NotNull vararg x: (@org.jetbrains.annotations.NotNull kotlin.Array<@org.jetbrains.annotations.NotNull kotlin.String>..@org.jetbrains.annotations.NotNull kotlin.Array) /*(@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array<@org.jetbrains.annotations.NotNull kotlin.String>..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)*/): kotlin.Unit + public abstract fun f65(/*0*/ @org.jetbrains.annotations.NotNull vararg x: kotlin.IntArray! /*(@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)*/): kotlin.Unit + public abstract fun f66(/*0*/ vararg x: kotlin.IntArray! /*(@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)*/): kotlin.Unit + public abstract fun f67(/*0*/ vararg x: kotlin.IntArray! /*kotlin.Array<(out) kotlin.IntArray!>!*/): kotlin.Unit + public abstract fun f68(/*0*/ @org.jetbrains.annotations.NotNull vararg x: kotlin.IntArray! /*(@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)*/): kotlin.Unit + public abstract fun f69(/*0*/ @org.jetbrains.annotations.NotNull vararg x: (@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array<@org.jetbrains.annotations.NotNull kotlin.String>..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>) /*(@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array<@org.jetbrains.annotations.NotNull kotlin.String>..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>)*/): kotlin.Unit + public abstract fun f7(/*0*/ p: test.G2, out @org.jetbrains.annotations.NotNull kotlin.Int>!>!>!): kotlin.Unit + public abstract fun f70(/*0*/ vararg x: (@org.jetbrains.annotations.Nullable kotlin.Array<(@org.jetbrains.annotations.Nullable kotlin.Array<@org.jetbrains.annotations.Nullable kotlin.String?>?..@org.jetbrains.annotations.Nullable kotlin.Array?)>?..@org.jetbrains.annotations.Nullable kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?)>?) /*kotlin.Array<(out) (@org.jetbrains.annotations.Nullable kotlin.Array<(@org.jetbrains.annotations.Nullable kotlin.Array<@org.jetbrains.annotations.Nullable kotlin.String?>?..@org.jetbrains.annotations.Nullable kotlin.Array?)>?..@org.jetbrains.annotations.Nullable kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?)>?)>!*/): kotlin.Unit + public abstract fun f71(/*0*/ vararg x: kotlin.Array<(out) kotlin.Array<(out) (@org.jetbrains.annotations.Nullable kotlin.Array<@org.jetbrains.annotations.Nullable kotlin.String?>?..@org.jetbrains.annotations.Nullable kotlin.Array?)>!>! /*kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) (@org.jetbrains.annotations.Nullable kotlin.Array<@org.jetbrains.annotations.Nullable kotlin.String?>?..@org.jetbrains.annotations.Nullable kotlin.Array?)>!>!>!*/): kotlin.Unit + public abstract fun f72(/*0*/ @org.jetbrains.annotations.Nullable vararg x: (@org.jetbrains.annotations.Nullable kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array<@org.jetbrains.annotations.NotNull kotlin.String>..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>?..@org.jetbrains.annotations.Nullable kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>?) /*(@org.jetbrains.annotations.Nullable kotlin.Array<(@org.jetbrains.annotations.Nullable kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array<@org.jetbrains.annotations.NotNull kotlin.String>..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>?..@org.jetbrains.annotations.Nullable kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>?)>..@org.jetbrains.annotations.Nullable kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>?..@org.jetbrains.annotations.Nullable kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>?)>?)*/): kotlin.Unit + public abstract fun f73(/*0*/ @org.jetbrains.annotations.NotNull vararg x: (@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array) /*(@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)*/): kotlin.Unit + public abstract fun f74(/*0*/ vararg x: (@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>) /*(@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>)>)*/): kotlin.Unit + public abstract fun f75(/*0*/ vararg x: kotlin.Array<(out) kotlin.Array<(out) kotlin.IntArray!>!>! /*kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.IntArray!>!>!>!*/): kotlin.Unit + public abstract fun f76(/*0*/ @org.jetbrains.annotations.NotNull vararg x: (@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array) /*(@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)*/): kotlin.Unit + public abstract fun f8(/*0*/ p: test.G1!): kotlin.Unit + public abstract fun f9(/*0*/ p: test.G1!>!>!>!): kotlin.Unit + + public open class Test { + public constructor Test(/*0*/ p1: test.G2?, out @org.jetbrains.annotations.NotNull kotlin.Int>!>!>!, /*1*/ p2: kotlin.Array<(out) (@org.jetbrains.annotations.NotNull kotlin.Array<@org.jetbrains.annotations.NotNull kotlin.Any>..@org.jetbrains.annotations.NotNull kotlin.Array)>!, /*2*/ p3: kotlin.Array<(out) kotlin.IntArray!>!, /*3*/ @org.jetbrains.annotations.NotNull p4: (@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>), /*4*/ @org.jetbrains.annotations.NotNull vararg p5: (@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array) /*(@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)*/) + } +} diff --git a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ValueArguments.txt b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ValueArguments.txt index 96ff61a326e..0563725504b 100644 --- a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ValueArguments.txt +++ b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ValueArguments.txt @@ -1,85 +1,85 @@ package test public/*package*/ interface ValueArguments { - public abstract fun f0(/*0*/ p: test.G1<@test.A test.G0!>!): kotlin.Unit - public abstract fun f1(/*0*/ p: test.G1!>!>!>!): kotlin.Unit - public abstract fun f10(/*0*/ p: test.G1!): kotlin.Unit - public abstract fun f11(/*0*/ p: test.G2!, in @test.A(value = "abc") kotlin.Int!>!>!>!): kotlin.Unit - public abstract fun f12(/*0*/ p: test.G2!, out @test.A(value = "abc") kotlin.Int!>!>!>!): kotlin.Unit - public abstract fun f13(/*0*/ p: (@test.A kotlin.Array..@test.A kotlin.Array?)): kotlin.Unit - public abstract fun f14(/*0*/ p: @test.A kotlin.IntArray!): kotlin.Unit - public abstract fun f15(/*0*/ @test.A p: kotlin.Array<(out) @test.A kotlin.Int!>!): kotlin.Unit - public abstract fun f16(/*0*/ @test.A p: kotlin.IntArray!): kotlin.Unit - public abstract fun f17(/*0*/ @test.A p: (@test.A kotlin.Array<@test.A kotlin.Int!>..@test.A kotlin.Array?)): kotlin.Unit - public abstract fun f18(/*0*/ @test.A p1: @test.A kotlin.IntArray!, /*1*/ p2: (@test.A kotlin.Array..@test.A kotlin.Array?), /*2*/ @test.A p3: kotlin.IntArray!): kotlin.Unit - public abstract fun f19(/*0*/ p: kotlin.Array<(out) (@test.A kotlin.Array..@test.A kotlin.Array?)>!): kotlin.Unit - public abstract fun f2(/*0*/ p: test.G1<@test.A kotlin.String!>!): kotlin.Unit - public abstract fun f20(/*0*/ p: (@test.A kotlin.Array<@test.A kotlin.IntArray!>..@test.A kotlin.Array?)): kotlin.Unit - public abstract fun f21(/*0*/ @test.A p: kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.Int!>!>!>!): kotlin.Unit - public abstract fun f22(/*0*/ @test.A p: (@test.A kotlin.Array..@test.A kotlin.Array?)>!>..@test.A kotlin.Array..@test.A kotlin.Array?)>!>?)): kotlin.Unit - public abstract fun f23(/*0*/ @test.A p: kotlin.Array<(out) (@test.A kotlin.Array..@test.A kotlin.Array?)>!>..@test.A kotlin.Array..@test.A kotlin.Array?)>!>?)>!): kotlin.Unit - public abstract fun f24(/*0*/ @test.A p: (@test.A kotlin.Array<@test.A kotlin.IntArray!>..@test.A kotlin.Array?)): kotlin.Unit - public abstract fun f25(/*0*/ p: (@test.A kotlin.Array..@test.A kotlin.Array?)): kotlin.Unit - public abstract fun f26(/*0*/ p1: (@test.A kotlin.Array!>..@test.A kotlin.Array!>?), /*1*/ p2: (@test.A kotlin.Array..@test.A kotlin.Array?), /*2*/ @test.A p3: (@test.A kotlin.Array..@test.A kotlin.Array?)>!>..@test.A kotlin.Array..@test.A kotlin.Array?)>!>?)): kotlin.Unit - public abstract fun f27(/*0*/ @test.A p: (@test.A kotlin.Array!>!>!>!>..@test.A kotlin.Array!>!>!>!>?)): kotlin.Unit - public abstract fun f28(/*0*/ p: test.G1<(@test.A kotlin.Array..@test.A kotlin.Array?)>!): kotlin.Unit - public abstract fun f29(/*0*/ p: test.G2!): kotlin.Unit - public abstract fun f3(/*0*/ p: test.G2<@test.A kotlin.String!, test.G2<@test.A(value = "abc") kotlin.Int!, test.G2<@test.A(value = "abc") test.G2!, @test.A(value = "abc") kotlin.Int!>!>!>!): kotlin.Unit - public abstract fun f30(/*0*/ p: test.G1!>!): kotlin.Unit + public abstract fun f0(/*0*/ p: test.G1<@org.jetbrains.annotations.NotNull test.G0>!): kotlin.Unit + public abstract fun f1(/*0*/ p: test.G1!>!>!>!): kotlin.Unit + public abstract fun f10(/*0*/ p: test.G1!): kotlin.Unit + public abstract fun f11(/*0*/ p: test.G2?, in @org.jetbrains.annotations.NotNull kotlin.Int>!>!>!): kotlin.Unit + public abstract fun f12(/*0*/ p: test.G2, out @org.jetbrains.annotations.NotNull kotlin.Int>!>!>!): kotlin.Unit + public abstract fun f13(/*0*/ p: (@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)): kotlin.Unit + public abstract fun f14(/*0*/ p: kotlin.IntArray!): kotlin.Unit + public abstract fun f15(/*0*/ @org.jetbrains.annotations.NotNull p: kotlin.Array<(out) @org.jetbrains.annotations.NotNull kotlin.Int>!): kotlin.Unit + public abstract fun f16(/*0*/ @org.jetbrains.annotations.Nullable p: kotlin.IntArray!): kotlin.Unit + public abstract fun f17(/*0*/ @org.jetbrains.annotations.Nullable p: (@org.jetbrains.annotations.Nullable kotlin.Array<@org.jetbrains.annotations.Nullable kotlin.Int?>?..@org.jetbrains.annotations.Nullable kotlin.Array?)): kotlin.Unit + public abstract fun f18(/*0*/ @org.jetbrains.annotations.Nullable p1: kotlin.IntArray!, /*1*/ p2: (@org.jetbrains.annotations.Nullable kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?), /*2*/ @org.jetbrains.annotations.Nullable p3: kotlin.IntArray!): kotlin.Unit + public abstract fun f19(/*0*/ p: kotlin.Array<(out) (@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>!): kotlin.Unit + public abstract fun f2(/*0*/ p: test.G1<@org.jetbrains.annotations.NotNull kotlin.String>!): kotlin.Unit + public abstract fun f20(/*0*/ p: (@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)): kotlin.Unit + public abstract fun f21(/*0*/ @org.jetbrains.annotations.NotNull p: kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @org.jetbrains.annotations.NotNull kotlin.Int>!>!>!): kotlin.Unit + public abstract fun f22(/*0*/ @org.jetbrains.annotations.NotNull p: (@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>!>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>!>)): kotlin.Unit + public abstract fun f23(/*0*/ @org.jetbrains.annotations.NotNull p: kotlin.Array<(out) (@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>!>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>!>)>!): kotlin.Unit + public abstract fun f24(/*0*/ @org.jetbrains.annotations.NotNull p: (@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)): kotlin.Unit + public abstract fun f25(/*0*/ p: (@org.jetbrains.annotations.Nullable kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?)): kotlin.Unit + public abstract fun f26(/*0*/ p1: (@org.jetbrains.annotations.Nullable kotlin.Array!>?..@org.jetbrains.annotations.Nullable kotlin.Array!>?), /*1*/ p2: (@org.jetbrains.annotations.Nullable kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?), /*2*/ @org.jetbrains.annotations.Nullable p3: (@org.jetbrains.annotations.Nullable kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?)>!>?..@org.jetbrains.annotations.Nullable kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?)>!>?)): kotlin.Unit + public abstract fun f27(/*0*/ @org.jetbrains.annotations.Nullable p: (@org.jetbrains.annotations.Nullable kotlin.Array!>!>!>!>?..@org.jetbrains.annotations.Nullable kotlin.Array!>!>!>!>?)): kotlin.Unit + public abstract fun f28(/*0*/ p: test.G1<(@org.jetbrains.annotations.Nullable kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?)>!): kotlin.Unit + public abstract fun f29(/*0*/ p: test.G2!): kotlin.Unit + public abstract fun f3(/*0*/ p: test.G2<@org.jetbrains.annotations.NotNull kotlin.String, test.G2<@org.jetbrains.annotations.NotNull kotlin.Int, test.G2<@org.jetbrains.annotations.NotNull test.G2, @org.jetbrains.annotations.NotNull kotlin.Int>!>!>!): kotlin.Unit + public abstract fun f30(/*0*/ p: test.G1!>!): kotlin.Unit public abstract fun f31(/*0*/ p: test.G1!>!): kotlin.Unit - public abstract fun f32(/*0*/ p: test.G1..@test.A kotlin.Array?)>!, test.G1<@test.A kotlin.IntArray!>!>!>!): kotlin.Unit - public abstract fun f33(/*0*/ p: test.G1<@test.A kotlin.IntArray!>!): kotlin.Unit - public abstract fun f34(/*0*/ p: test.G1<(@test.A kotlin.Array!>..@test.A kotlin.Array!>?)>!): kotlin.Unit - public abstract fun f35(/*0*/ p1: test.G2!>!, /*1*/ p2: test.G1..@test.A kotlin.Array?)>!>!, /*2*/ p3: test.G1!>!): kotlin.Unit - public abstract fun f36(/*0*/ p: test.G1..@test.A kotlin.Array?)>!>!): kotlin.Unit + public abstract fun f32(/*0*/ p: test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!, test.G1!>!>!): kotlin.Unit + public abstract fun f33(/*0*/ p: test.G1!): kotlin.Unit + public abstract fun f34(/*0*/ p: test.G1<(@org.jetbrains.annotations.NotNull kotlin.Array!>..@org.jetbrains.annotations.NotNull kotlin.Array!>)>!): kotlin.Unit + public abstract fun f35(/*0*/ p1: test.G2!>!, /*1*/ p2: test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!>!, /*2*/ p3: test.G1!>!): kotlin.Unit + public abstract fun f36(/*0*/ p: test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!>!): kotlin.Unit public abstract fun f37(/*0*/ p: test.G1!>!>!>!): kotlin.Unit - public abstract fun f38(/*0*/ p: test.G1..@test.A kotlin.Array?)>!, test.G1<(@test.A kotlin.Array!>..@test.A kotlin.Array!>?)>!>!>!): kotlin.Unit - public abstract fun f39(/*0*/ p: test.G1..@test.A kotlin.Array?)>!>!): kotlin.Unit - public abstract fun f4(/*0*/ p: test.G1!): kotlin.Unit - public abstract fun f40(/*0*/ p: test.G1..@test.A kotlin.Array?)>!): kotlin.Unit - public abstract fun f41(/*0*/ p: test.G2!): kotlin.Unit - public abstract fun f42(/*0*/ p: test.G1!>!): kotlin.Unit + public abstract fun f38(/*0*/ p: test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!, test.G1<(@org.jetbrains.annotations.NotNull kotlin.Array!>..@org.jetbrains.annotations.NotNull kotlin.Array!>)>!>!>!): kotlin.Unit + public abstract fun f39(/*0*/ p: test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!>!): kotlin.Unit + public abstract fun f4(/*0*/ p: test.G1!): kotlin.Unit + public abstract fun f40(/*0*/ p: test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!): kotlin.Unit + public abstract fun f41(/*0*/ p: test.G2!): kotlin.Unit + public abstract fun f42(/*0*/ p: test.G1!>!): kotlin.Unit public abstract fun f43(/*0*/ p: test.G1!>!): kotlin.Unit - public abstract fun f44(/*0*/ p: test.G1..@test.A kotlin.Array?)>!, test.G1!>!>!): kotlin.Unit - public abstract fun f45(/*0*/ p: test.G1..@test.A kotlin.Array?)>!, test.G1!>!>!): kotlin.Unit - public abstract fun f46(/*0*/ p: test.G1!): kotlin.Unit - public abstract fun f47(/*0*/ p: test.G1!>..@test.A kotlin.Array!>?)>!): kotlin.Unit - public abstract fun f48(/*0*/ p: test.G2!>..@test.A kotlin.Array!>?)>!): kotlin.Unit - public abstract fun f49(/*0*/ p1: test.G1!>!>!>!>!>!, /*1*/ p2: test.G1!>!>!, /*2*/ p3: test.G2!>..@test.A kotlin.Array!>?)>!): kotlin.Unit - public abstract fun f5(/*0*/ p: test.G1!>!>!>!): kotlin.Unit - public abstract fun f50(/*0*/ p: test.G1!>!>!): kotlin.Unit - public abstract fun f51(/*0*/ p: test.G1!>!>..@test.A kotlin.Array!>!>?)>!, test.G1..@test.A kotlin.Array?)>..@test.A kotlin.Array..@test.A kotlin.Array?)>?)>!>!>!): kotlin.Unit - public abstract fun f52(/*0*/ p: test.G1..@test.A kotlin.Array?)>!>!>!, test.G1..@test.A kotlin.Array?)>!>!>!): kotlin.Unit - public abstract fun f53(/*0*/ p: test.G1!>!): kotlin.Unit - public abstract fun f54(/*0*/ p1: test.G1..@test.A kotlin.Array?)>!>!>!, test.G1..@test.A kotlin.Array?)>!>!>!, /*1*/ p2: test.G1..@test.A kotlin.Array?)>!>!, /*2*/ @test.A p3: (@test.A kotlin.Array!>!>!>!>..@test.A kotlin.Array!>!>!>!>?), /*3*/ @test.A p4: @test.A kotlin.IntArray!, /*4*/ p5: test.G2!, out @test.A(value = "abc") kotlin.Int!>!>!>!): kotlin.Unit - public abstract fun f55(/*0*/ @test.A vararg x: @test.A kotlin.String! /*kotlin.Array<(out) @test.A kotlin.String!>!*/): kotlin.Unit - public abstract fun f56(/*0*/ vararg x: kotlin.String! /*(@test.A kotlin.Array..@test.A kotlin.Array?)*/): kotlin.Unit - public abstract fun f57(/*0*/ @test.A vararg x: @test.A kotlin.String! /*(@test.A kotlin.Array<@test.A kotlin.String!>..@test.A kotlin.Array?)*/): kotlin.Unit - public abstract fun f58(/*0*/ @test.A vararg x: kotlin.Int /*kotlin.IntArray!*/): kotlin.Unit - public abstract fun f59(/*0*/ vararg x: kotlin.Int /*@test.A kotlin.IntArray!*/): kotlin.Unit - public abstract fun f6(/*0*/ p1: test.G1!, /*1*/ p2: test.G1!>!>!>!): kotlin.Unit - public abstract fun f60(/*0*/ @test.A vararg x: kotlin.Int /*@test.A kotlin.IntArray!*/): kotlin.Unit - public abstract fun f61(/*0*/ @test.A vararg x: kotlin.Array<(out) @test.A kotlin.String!>! /*kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.String!>!>!*/): kotlin.Unit - public abstract fun f62(/*0*/ vararg x: (@test.A kotlin.Array..@test.A kotlin.Array?) /*kotlin.Array<(out) (@test.A kotlin.Array..@test.A kotlin.Array?)>!*/): kotlin.Unit - public abstract fun f63(/*0*/ vararg x: kotlin.Array<(out) kotlin.String!>! /*(@test.A kotlin.Array!>..@test.A kotlin.Array!>?)*/): kotlin.Unit - public abstract fun f64(/*0*/ @test.A vararg x: (@test.A kotlin.Array<@test.A kotlin.String!>..@test.A kotlin.Array?) /*(@test.A kotlin.Array<(@test.A kotlin.Array<@test.A kotlin.String!>..@test.A kotlin.Array?)>..@test.A kotlin.Array..@test.A kotlin.Array?)>?)*/): kotlin.Unit - public abstract fun f65(/*0*/ @test.A vararg x: kotlin.IntArray! /*kotlin.Array<(out) kotlin.IntArray!>!*/): kotlin.Unit - public abstract fun f66(/*0*/ vararg x: @test.A kotlin.IntArray! /*kotlin.Array<(out) @test.A kotlin.IntArray!>!*/): kotlin.Unit - public abstract fun f67(/*0*/ vararg x: kotlin.IntArray! /*(@test.A kotlin.Array..@test.A kotlin.Array?)*/): kotlin.Unit - public abstract fun f68(/*0*/ @test.A vararg x: @test.A kotlin.IntArray! /*(@test.A kotlin.Array<@test.A kotlin.IntArray!>..@test.A kotlin.Array?)*/): kotlin.Unit - public abstract fun f69(/*0*/ @test.A vararg x: kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.String!>!>! /*kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @test.A kotlin.String!>!>!>!*/): kotlin.Unit - public abstract fun f7(/*0*/ p: test.G2!, out @test.A(value = "abc") kotlin.Int!>!>!>!): kotlin.Unit - public abstract fun f70(/*0*/ vararg x: (@test.A kotlin.Array!>..@test.A kotlin.Array!>?) /*kotlin.Array<(out) (@test.A kotlin.Array!>..@test.A kotlin.Array!>?)>!*/): kotlin.Unit - public abstract fun f71(/*0*/ vararg x: kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.String!>!>!>! /*(@test.A kotlin.Array!>!>!>..@test.A kotlin.Array!>!>!>?)*/): kotlin.Unit - public abstract fun f72(/*0*/ @test.A vararg x: (@test.A kotlin.Array..@test.A kotlin.Array?)>!>..@test.A kotlin.Array..@test.A kotlin.Array?)>!>?) /*(@test.A kotlin.Array<(@test.A kotlin.Array..@test.A kotlin.Array?)>!>..@test.A kotlin.Array..@test.A kotlin.Array?)>!>?)>..@test.A kotlin.Array..@test.A kotlin.Array?)>!>..@test.A kotlin.Array..@test.A kotlin.Array?)>!>?)>?)*/): kotlin.Unit - public abstract fun f73(/*0*/ @test.A vararg x: (@test.A kotlin.Array..@test.A kotlin.Array?) /*kotlin.Array<(out) (@test.A kotlin.Array..@test.A kotlin.Array?)>!*/): kotlin.Unit - public abstract fun f74(/*0*/ vararg x: (@test.A kotlin.Array!>!>..@test.A kotlin.Array!>!>?) /*kotlin.Array<(out) (@test.A kotlin.Array!>!>..@test.A kotlin.Array!>!>?)>!*/): kotlin.Unit - public abstract fun f75(/*0*/ vararg x: kotlin.Array<(out) kotlin.Array<(out) kotlin.IntArray!>!>! /*(@test.A kotlin.Array!>!>..@test.A kotlin.Array!>!>?)*/): kotlin.Unit - public abstract fun f76(/*0*/ @test.A vararg x: kotlin.Array<(out) @test.A kotlin.IntArray!>! /*(@test.A kotlin.Array!>..@test.A kotlin.Array!>?)*/): kotlin.Unit - public abstract fun f8(/*0*/ p: test.G1!): kotlin.Unit - public abstract fun f9(/*0*/ p: test.G1!>!>!>!): kotlin.Unit + public abstract fun f44(/*0*/ p: test.G1?..@org.jetbrains.annotations.Nullable kotlin.Array?)>!, test.G1!>!>!): kotlin.Unit + public abstract fun f45(/*0*/ p: test.G1?..@org.jetbrains.annotations.Nullable kotlin.Array?)>!, test.G1!>!>!): kotlin.Unit + public abstract fun f46(/*0*/ p: test.G1!): kotlin.Unit + public abstract fun f47(/*0*/ p: test.G1!>..@org.jetbrains.annotations.NotNull kotlin.Array!>)>!): kotlin.Unit + public abstract fun f48(/*0*/ p: test.G2!>..@org.jetbrains.annotations.NotNull kotlin.Array!>)>!): kotlin.Unit + public abstract fun f49(/*0*/ p1: test.G1!>!>!>!>!>!, /*1*/ p2: test.G1!>!>!, /*2*/ p3: test.G2!>..@org.jetbrains.annotations.NotNull kotlin.Array!>)>!): kotlin.Unit + public abstract fun f5(/*0*/ p: test.G1!>!>!>!): kotlin.Unit + public abstract fun f50(/*0*/ p: test.G1!>!>!): kotlin.Unit + public abstract fun f51(/*0*/ p: test.G1!>!>..@org.jetbrains.annotations.NotNull kotlin.Array!>!>)>!, test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)>!>!>!): kotlin.Unit + public abstract fun f52(/*0*/ p: test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!>!>!, test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!>!>!): kotlin.Unit + public abstract fun f53(/*0*/ p: test.G1!>!): kotlin.Unit + public abstract fun f54(/*0*/ p1: test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!>!>!, test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!>!>!, /*1*/ p2: test.G1..@org.jetbrains.annotations.NotNull kotlin.Array)>!>!, /*2*/ @org.jetbrains.annotations.NotNull p3: (@org.jetbrains.annotations.NotNull kotlin.Array!>!>!>!>..@org.jetbrains.annotations.NotNull kotlin.Array!>!>!>!>), /*3*/ @org.jetbrains.annotations.NotNull p4: kotlin.IntArray!, /*4*/ p5: test.G2, out @org.jetbrains.annotations.NotNull kotlin.Int>!>!>!): kotlin.Unit + public abstract fun f55(/*0*/ @org.jetbrains.annotations.NotNull vararg x: @org.jetbrains.annotations.NotNull kotlin.String /*kotlin.Array<(out) @org.jetbrains.annotations.NotNull kotlin.String>!*/): kotlin.Unit + public abstract fun f56(/*0*/ vararg x: kotlin.String! /*(@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)*/): kotlin.Unit + public abstract fun f57(/*0*/ @org.jetbrains.annotations.NotNull vararg x: @org.jetbrains.annotations.NotNull kotlin.String /*(@org.jetbrains.annotations.NotNull kotlin.Array<@org.jetbrains.annotations.NotNull kotlin.String>..@org.jetbrains.annotations.NotNull kotlin.Array)*/): kotlin.Unit + public abstract fun f58(/*0*/ @org.jetbrains.annotations.NotNull vararg x: kotlin.Int /*kotlin.IntArray!*/): kotlin.Unit + public abstract fun f59(/*0*/ vararg x: kotlin.Int /*kotlin.IntArray!*/): kotlin.Unit + public abstract fun f6(/*0*/ p1: test.G1!, /*1*/ p2: test.G1!>!>!>!): kotlin.Unit + public abstract fun f60(/*0*/ @org.jetbrains.annotations.NotNull vararg x: kotlin.Int /*kotlin.IntArray!*/): kotlin.Unit + public abstract fun f61(/*0*/ @org.jetbrains.annotations.Nullable vararg x: kotlin.Array<(out) @org.jetbrains.annotations.Nullable kotlin.String?>! /*kotlin.Array<(out) kotlin.Array<(out) @org.jetbrains.annotations.Nullable kotlin.String?>!>!*/): kotlin.Unit + public abstract fun f62(/*0*/ vararg x: (@org.jetbrains.annotations.Nullable kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?) /*kotlin.Array<(out) (@org.jetbrains.annotations.Nullable kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?)>!*/): kotlin.Unit + public abstract fun f63(/*0*/ vararg x: kotlin.Array<(out) kotlin.String!>! /*(@org.jetbrains.annotations.Nullable kotlin.Array!>..@org.jetbrains.annotations.Nullable kotlin.Array!>?)*/): kotlin.Unit + public abstract fun f64(/*0*/ @org.jetbrains.annotations.NotNull vararg x: (@org.jetbrains.annotations.NotNull kotlin.Array<@org.jetbrains.annotations.NotNull kotlin.String>..@org.jetbrains.annotations.NotNull kotlin.Array) /*(@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array<@org.jetbrains.annotations.NotNull kotlin.String>..@org.jetbrains.annotations.NotNull kotlin.Array)>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>)*/): kotlin.Unit + public abstract fun f65(/*0*/ @org.jetbrains.annotations.NotNull vararg x: kotlin.IntArray! /*kotlin.Array<(out) kotlin.IntArray!>!*/): kotlin.Unit + public abstract fun f66(/*0*/ vararg x: kotlin.IntArray! /*kotlin.Array<(out) kotlin.IntArray!>!*/): kotlin.Unit + public abstract fun f67(/*0*/ vararg x: kotlin.IntArray! /*(@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)*/): kotlin.Unit + public abstract fun f68(/*0*/ @org.jetbrains.annotations.NotNull vararg x: kotlin.IntArray! /*(@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)*/): kotlin.Unit + public abstract fun f69(/*0*/ @org.jetbrains.annotations.NotNull vararg x: kotlin.Array<(out) kotlin.Array<(out) @org.jetbrains.annotations.NotNull kotlin.String>!>! /*kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) @org.jetbrains.annotations.NotNull kotlin.String>!>!>!*/): kotlin.Unit + public abstract fun f7(/*0*/ p: test.G2, out @org.jetbrains.annotations.NotNull kotlin.Int>!>!>!): kotlin.Unit + public abstract fun f70(/*0*/ vararg x: (@org.jetbrains.annotations.Nullable kotlin.Array!>?..@org.jetbrains.annotations.Nullable kotlin.Array!>?) /*kotlin.Array<(out) (@org.jetbrains.annotations.Nullable kotlin.Array!>?..@org.jetbrains.annotations.Nullable kotlin.Array!>?)>!*/): kotlin.Unit + public abstract fun f71(/*0*/ vararg x: kotlin.Array<(out) kotlin.Array<(out) kotlin.Array<(out) kotlin.String!>!>!>! /*(@org.jetbrains.annotations.Nullable kotlin.Array!>!>!>..@org.jetbrains.annotations.Nullable kotlin.Array!>!>!>?)*/): kotlin.Unit + public abstract fun f72(/*0*/ @org.jetbrains.annotations.Nullable vararg x: (@org.jetbrains.annotations.NotNull kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?)>!>..@org.jetbrains.annotations.NotNull kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?)>!>) /*(@org.jetbrains.annotations.NotNull kotlin.Array<(@org.jetbrains.annotations.NotNull kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?)>!>..@org.jetbrains.annotations.NotNull kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?)>!>)>..@org.jetbrains.annotations.NotNull kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?)>!>..@org.jetbrains.annotations.NotNull kotlin.Array?..@org.jetbrains.annotations.Nullable kotlin.Array?)>!>)>)*/): kotlin.Unit + public abstract fun f73(/*0*/ @org.jetbrains.annotations.NotNull vararg x: (@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array) /*kotlin.Array<(out) (@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>!*/): kotlin.Unit + public abstract fun f74(/*0*/ vararg x: (@org.jetbrains.annotations.NotNull kotlin.Array!>!>..@org.jetbrains.annotations.NotNull kotlin.Array!>!>) /*kotlin.Array<(out) (@org.jetbrains.annotations.NotNull kotlin.Array!>!>..@org.jetbrains.annotations.NotNull kotlin.Array!>!>)>!*/): kotlin.Unit + public abstract fun f75(/*0*/ vararg x: kotlin.Array<(out) kotlin.Array<(out) kotlin.IntArray!>!>! /*(@org.jetbrains.annotations.NotNull kotlin.Array!>!>..@org.jetbrains.annotations.NotNull kotlin.Array!>!>)*/): kotlin.Unit + public abstract fun f76(/*0*/ @org.jetbrains.annotations.NotNull vararg x: kotlin.Array<(out) kotlin.IntArray!>! /*(@org.jetbrains.annotations.NotNull kotlin.Array!>..@org.jetbrains.annotations.NotNull kotlin.Array!>)*/): kotlin.Unit + public abstract fun f8(/*0*/ p: test.G1!): kotlin.Unit + public abstract fun f9(/*0*/ p: test.G1!>!>!>!): kotlin.Unit public open class Test { - public constructor Test(/*0*/ p1: test.G2!, out @test.A(value = "abc") kotlin.Int!>!>!>!, /*1*/ p2: (@test.A kotlin.Array!>..@test.A kotlin.Array!>?), /*2*/ p3: (@test.A kotlin.Array..@test.A kotlin.Array?), /*3*/ @test.A p4: (@test.A kotlin.Array..@test.A kotlin.Array?)>!>..@test.A kotlin.Array..@test.A kotlin.Array?)>!>?), /*4*/ @test.A vararg p5: kotlin.Array<(out) @test.A kotlin.IntArray!>! /*(@test.A kotlin.Array!>..@test.A kotlin.Array!>?)*/) + public constructor Test(/*0*/ p1: test.G2?, out @org.jetbrains.annotations.NotNull kotlin.Int>!>!>!, /*1*/ p2: (@org.jetbrains.annotations.NotNull kotlin.Array!>..@org.jetbrains.annotations.NotNull kotlin.Array!>), /*2*/ p3: (@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array), /*3*/ @org.jetbrains.annotations.NotNull p4: (@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>!>..@org.jetbrains.annotations.NotNull kotlin.Array..@org.jetbrains.annotations.NotNull kotlin.Array)>!>), /*4*/ @org.jetbrains.annotations.NotNull vararg p5: kotlin.Array<(out) kotlin.IntArray!>! /*(@org.jetbrains.annotations.NotNull kotlin.Array!>..@org.jetbrains.annotations.NotNull kotlin.Array!>)*/) } } diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractForeignAnnotationsTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractForeignAnnotationsTest.kt index bca87670eb2..40b66d1a4ee 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractForeignAnnotationsTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractForeignAnnotationsTest.kt @@ -24,15 +24,11 @@ import org.jetbrains.kotlin.utils.JavaTypeEnhancementState import org.jetbrains.kotlin.utils.ReportLevel import java.io.File -val FOREIGN_ANNOTATIONS_SOURCES_PATH = "third-party/annotations" -val TEST_ANNOTATIONS_SOURCE_PATH = "compiler/testData/foreignAnnotations/testAnnotations" +const val FOREIGN_ANNOTATIONS_SOURCES_PATH = "third-party/annotations" +const val FOREIGN_JDK8_ANNOTATIONS_SOURCES_PATH = "third-party/jdk8-annotations" +const val TEST_ANNOTATIONS_SOURCE_PATH = "compiler/testData/foreignAnnotations/testAnnotations" abstract class AbstractForeignAnnotationsTest : AbstractDiagnosticsTest() { - private val JSR305_GLOBAL_DIRECTIVE = "JSR305_GLOBAL_REPORT" - private val JSR305_MIGRATION_DIRECTIVE = "JSR305_MIGRATION_REPORT" - private val JSR305_SPECIAL_DIRECTIVE = "JSR305_SPECIAL_REPORT" - private val JSPECIFY_STATE_SPECIAL_DIRECTIVE = "JSPECIFY_STATE" - override fun getExtraClasspath(): List { val foreignAnnotations = createJarWithForeignAnnotations() return foreignAnnotations + compileTestAnnotations(foreignAnnotations) @@ -51,7 +47,7 @@ abstract class AbstractForeignAnnotationsTest : AbstractDiagnosticsTest() { ForTestCompileRuntime.jvmAnnotationsForTests() ) - open protected val annotationsPath: String + protected open val annotationsPath: String get() = FOREIGN_ANNOTATIONS_SOURCES_PATH override fun loadLanguageVersionSettings(module: List): LanguageVersionSettings { @@ -92,4 +88,11 @@ abstract class AbstractForeignAnnotationsTest : AbstractDiagnosticsTest() { private fun List.getDirectiveValue(directive: String): ReportLevel? = mapNotNull { InTextDirectivesUtils.findLinesWithPrefixesRemoved(it.expectedText, directive).firstOrNull() }.firstOrNull().let { ReportLevel.findByDescription(it) } + + companion object { + private const val JSR305_GLOBAL_DIRECTIVE = "JSR305_GLOBAL_REPORT" + private const val JSR305_MIGRATION_DIRECTIVE = "JSR305_MIGRATION_REPORT" + private const val JSR305_SPECIAL_DIRECTIVE = "JSR305_SPECIAL_REPORT" + private const val JSPECIFY_STATE_SPECIAL_DIRECTIVE = "JSPECIFY_STATE" + } } diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractJspecifyAnnotationsTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractJspecifyAnnotationsTest.kt index 6f7bde486f1..7978bd93e43 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractJspecifyAnnotationsTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractJspecifyAnnotationsTest.kt @@ -27,7 +27,7 @@ abstract class AbstractJspecifyAnnotationsTest : AbstractDiagnosticsTest() { super.doMultiFileTest( wholeFile, files, - MockLibraryUtil.compileJavaFilesLibraryToJar(FOREIGN_ANNOTATIONS_SOURCES_PATH, "foreign-annotations") + MockLibraryUtil.compileJavaFilesLibraryToJar(FOREIGN_JDK8_ANNOTATIONS_SOURCES_PATH, "foreign-annotations") ) } @@ -149,7 +149,6 @@ abstract class AbstractJspecifyAnnotationsTest : AbstractDiagnosticsTest() { } companion object { - const val FOREIGN_ANNOTATIONS_SOURCES_PATH = "third-party/jdk8-annotations" const val JSPECIFY_JAVA_SOURCES_PATH = "compiler/testData/foreignAnnotationsJava8/tests/jspecify/java" const val MAIN_KT_FILE_DIRECTIVE = "// FILE: main.kt\n" diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/cli/AbstractCliTest.java b/compiler/tests-common/tests/org/jetbrains/kotlin/cli/AbstractCliTest.java index cfa44d4a3fe..b3a317824a6 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/cli/AbstractCliTest.java +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/cli/AbstractCliTest.java @@ -261,7 +261,7 @@ public abstract class AbstractCliTest extends TestCaseWithTmpdir { .replace(TESTDATA_DIR, testDataDir) .replace( "$FOREIGN_ANNOTATIONS_DIR$", - new File(AbstractForeignAnnotationsTestKt.getFOREIGN_ANNOTATIONS_SOURCES_PATH()).getPath() + new File(AbstractForeignAnnotationsTestKt.FOREIGN_ANNOTATIONS_SOURCES_PATH).getPath() ).replace( "$JDK_15$", KtTestUtil.getJdk15Home().getPath() diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java b/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java index cbbbe39d4a1..3e7d9b8e59e 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java @@ -59,6 +59,8 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { public static final Configuration COMPARATOR_CONFIGURATION = DONT_INCLUDE_METHODS_OF_OBJECT.renderDeclarationsFromOtherModules(true); + protected boolean withForeignAnnotations() { return false; } + protected void doTestCompiledJava(@NotNull String javaFileName) throws Exception { doTestCompiledJava(javaFileName, COMPARATOR_CONFIGURATION); } @@ -148,7 +150,7 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { PackageViewDescriptor packageFromBinary = LoadDescriptorUtil.loadTestPackageAndBindingContextFromJavaRoot( tmpdir, getTestRootDisposable(), getJdkKind(), configurationKind, true, false, useJavacWrapper(), - configuration.get(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS), + withForeignAnnotations(), configuration.get(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS), getExtraClasspath(), this::configureEnvironment ).first; @@ -274,7 +276,7 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { Pair javaPackageAndContext = loadTestPackageAndBindingContextFromJavaRoot( tmpdir, getTestRootDisposable(), getJdkKind(), ConfigurationKind.JDK_ONLY, false, - false, useJavacWrapper(), null); + false, useJavacWrapper(), withForeignAnnotations(), null); checkJavaPackage( expectedFile, javaPackageAndContext.first, javaPackageAndContext.second, @@ -329,9 +331,9 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { @NotNull File outDir, @NotNull ConfigurationKind configurationKind ) throws IOException { - compileJavaWithAnnotationsJar(javaFiles, outDir, getAdditionalJavacArgs(), getJdkHomeForJavac()); + compileJavaWithAnnotationsJar(javaFiles, outDir, getAdditionalJavacArgs(), getJdkHomeForJavac(), withForeignAnnotations()); return loadTestPackageAndBindingContextFromJavaRoot(outDir, getTestRootDisposable(), getJdkKind(), configurationKind, true, - usePsiClassFilesReading(), useJavacWrapper(), null, + usePsiClassFilesReading(), useJavacWrapper(), withForeignAnnotations(), null, getExtraClasspath(), this::configureEnvironment); } diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/LoadDescriptorUtil.java b/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/LoadDescriptorUtil.java index 0aae9989fa1..f387835d13f 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/LoadDescriptorUtil.java +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/LoadDescriptorUtil.java @@ -43,10 +43,7 @@ import org.jetbrains.kotlin.name.Name; import org.jetbrains.kotlin.psi.KtFile; import org.jetbrains.kotlin.resolve.BindingContext; import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil; -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.*; import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.utils.ExceptionUtilsKt; @@ -56,6 +53,8 @@ import java.util.*; import java.util.function.Consumer; import java.util.stream.Collectors; +import static org.jetbrains.kotlin.checkers.AbstractForeignAnnotationsTestKt.FOREIGN_JDK8_ANNOTATIONS_SOURCES_PATH; + public class LoadDescriptorUtil { @NotNull public static final FqName TEST_PACKAGE_FQNAME = FqName.topLevel(Name.identifier("test")); @@ -81,6 +80,7 @@ public class LoadDescriptorUtil { boolean isBinaryRoot, boolean usePsiClassReading, boolean useJavacWrapper, + boolean withForeignAnnotations, @Nullable LanguageVersionSettings explicitLanguageVersionSettings ) { return loadTestPackageAndBindingContextFromJavaRoot( @@ -91,6 +91,7 @@ public class LoadDescriptorUtil { isBinaryRoot, usePsiClassReading, useJavacWrapper, + withForeignAnnotations, explicitLanguageVersionSettings, Collections.emptyList(), (configuration) -> {} @@ -106,12 +107,16 @@ public class LoadDescriptorUtil { boolean isBinaryRoot, boolean usePsiClassReading, boolean useJavacWrapper, + boolean withForeignAnnotations, @Nullable LanguageVersionSettings explicitLanguageVersionSettings, @NotNull List additionalClasspath, @NotNull Consumer configureEnvironment ) { List javaBinaryRoots = new ArrayList<>(); // TODO: use the same additional binary roots as those were used for compilation + if (withForeignAnnotations) { + javaBinaryRoots.add(MockLibraryUtil.compileJavaFilesLibraryToJar(FOREIGN_JDK8_ANNOTATIONS_SOURCES_PATH, "foreign-annotations")); + } javaBinaryRoots.add(KtTestUtil.getAnnotationsJar()); javaBinaryRoots.add(ForTestCompileRuntime.jvmAnnotationsForTests()); javaBinaryRoots.addAll(additionalClasspath); @@ -147,7 +152,8 @@ public class LoadDescriptorUtil { @NotNull Collection javaFiles, @NotNull File outDir, @NotNull List additionalArgs, - @Nullable File customJdkHomeForJavac + @Nullable File customJdkHomeForJavac, + boolean useJetbrainsAnnotationsWithTypeUse ) throws IOException { List args = new ArrayList<>(Arrays.asList( "-sourcepath", "compiler/testData/loadJava/include", @@ -157,6 +163,9 @@ public class LoadDescriptorUtil { List classpath = new ArrayList<>(); classpath.add(ForTestCompileRuntime.runtimeJarForTests()); + if (useJetbrainsAnnotationsWithTypeUse) { + classpath.add(MockLibraryUtil.compileJavaFilesLibraryToJar(FOREIGN_JDK8_ANNOTATIONS_SOURCES_PATH, "foreign-annotations")); + } classpath.add(KtTestUtil.getAnnotationsJar()); for (File test : javaFiles) { diff --git a/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJava8Test.java b/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJava8Test.java index 88b2dcbcbf3..0e8fce9b1c1 100644 --- a/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJava8Test.java +++ b/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJava8Test.java @@ -25,4 +25,9 @@ public abstract class AbstractLoadJava8Test extends AbstractLoadJavaTest { protected TestJdkKind getJdkKind() { return TestJdkKind.FULL_JDK; } + + @Override + protected boolean withForeignAnnotations() { + return true; + } } diff --git a/core/descriptors.runtime/tests/org/jetbrains/kotlin/jvm/runtime/AbstractJvmRuntimeDescriptorLoaderTest.kt b/core/descriptors.runtime/tests/org/jetbrains/kotlin/jvm/runtime/AbstractJvmRuntimeDescriptorLoaderTest.kt index d86dbb8bfd7..91890835414 100644 --- a/core/descriptors.runtime/tests/org/jetbrains/kotlin/jvm/runtime/AbstractJvmRuntimeDescriptorLoaderTest.kt +++ b/core/descriptors.runtime/tests/org/jetbrains/kotlin/jvm/runtime/AbstractJvmRuntimeDescriptorLoaderTest.kt @@ -99,7 +99,7 @@ abstract class AbstractJvmRuntimeDescriptorLoaderTest : TestCaseWithTmpdir() { } val expected = LoadDescriptorUtil.loadTestPackageAndBindingContextFromJavaRoot( - tmpdir, testRootDisposable, jdkKind, ConfigurationKind.ALL, true, false, false, null + tmpdir, testRootDisposable, jdkKind, ConfigurationKind.ALL, true, false, false, false, null ).first RecursiveDescriptorComparatorAdaptor.validateAndCompareDescriptors(expected, actual, comparatorConfiguration, null) @@ -125,7 +125,7 @@ abstract class AbstractJvmRuntimeDescriptorLoaderTest : TestCaseWithTmpdir() { } } ) - LoadDescriptorUtil.compileJavaWithAnnotationsJar(sources, tmpdir, emptyList(), null) + LoadDescriptorUtil.compileJavaWithAnnotationsJar(sources, tmpdir, emptyList(), null, false) } fileName.endsWith(".kt") -> { val environment = KotlinTestUtils.createEnvironmentWithJdkAndNullabilityAnnotationsFromIdea( diff --git a/third-party/jdk8-annotations/org/jetbrains/annotations/NotNull.java b/third-party/jdk8-annotations/org/jetbrains/annotations/NotNull.java new file mode 100644 index 00000000000..a5fca75fe06 --- /dev/null +++ b/third-party/jdk8-annotations/org/jetbrains/annotations/NotNull.java @@ -0,0 +1,44 @@ +/* + * Copyright 2000-2020 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 + * + * https://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.annotations; + +import java.lang.annotation.*; + +/** + * An element annotated with NotNull claims {@code null} value is forbidden + * to return (for methods), pass to (parameters) and hold (local variables and fields). + * Apart from documentation purposes this annotation is intended to be used by static analysis tools + * to validate against probable runtime errors and element contract violations. + */ +@Documented +@Retention(RetentionPolicy.CLASS) +@Target({ElementType.METHOD, ElementType.FIELD, ElementType.PARAMETER, ElementType.LOCAL_VARIABLE, ElementType.TYPE_USE}) +public @interface NotNull { + /** + * @return Custom exception message + */ + String value() default ""; + + /** + * @return Custom exception type that should be thrown when not-nullity contract is violated. + * The exception class should have a constructor with one String argument (message). + * + * By default, {@link IllegalArgumentException} is thrown on null method arguments and + * {@link IllegalStateException} — on null return value. + */ + Class exception() default Exception.class; +} diff --git a/third-party/jdk8-annotations/org/jetbrains/annotations/Nullable.java b/third-party/jdk8-annotations/org/jetbrains/annotations/Nullable.java new file mode 100644 index 00000000000..14147afba8c --- /dev/null +++ b/third-party/jdk8-annotations/org/jetbrains/annotations/Nullable.java @@ -0,0 +1,31 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.annotations; + +import java.lang.annotation.*; + +/** + * An element annotated with {@link Nullable} claims {@code null} value is perfectly valid + * to return (for methods), pass to (parameters) or hold in (local variables and fields). + * Apart from documentation purposes this annotation is intended to be used by static analysis tools + * to validate against probable runtime errors or element contract violations. + *
+ * By convention, this annotation applied only when the value should always be checked against {@code null} + * because the developer could do nothing to prevent null from happening. + * Otherwise, too eager {@link Nullable} usage could lead to too many false positives from static analysis tools. + *
+ * For example, {@link java.util.Map#get(Object key)} should not be annotated {@link Nullable} because + * someone may have put not-null value in the map by this key and is expecting to find this value there ever since. + *
+ * On the other hand, the {@link java.lang.ref.Reference#get()} should be annotated {@link Nullable} because + * it returns {@code null} if object got collected which can happen at any time completely unexpectedly. + */ +@Documented +@Retention(RetentionPolicy.CLASS) +@Target({ElementType.METHOD, ElementType.FIELD, ElementType.PARAMETER, ElementType.LOCAL_VARIABLE, ElementType.TYPE_USE}) +public @interface Nullable { + @NonNls String value() default ""; +} From b0debbe4c97f18ddd6837cbda0b48edefa8314e6 Mon Sep 17 00:00:00 2001 From: Victor Petukhov Date: Tue, 8 Dec 2020 15:46:59 +0300 Subject: [PATCH 158/196] Add forced mark "isDeprecated" as false for missing types among javac types --- .../src/org/jetbrains/kotlin/javac/JavacWrapper.kt | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/JavacWrapper.kt b/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/JavacWrapper.kt index 7bbcbbedac1..1362c0624e1 100644 --- a/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/JavacWrapper.kt +++ b/compiler/javac-wrapper/src/org/jetbrains/kotlin/javac/JavacWrapper.kt @@ -274,7 +274,9 @@ class JavacWrapper( fun isDeprecated(element: Element) = elements.isDeprecated(element) - fun isDeprecated(typeMirror: TypeMirror) = isDeprecated(types.asElement(typeMirror)) + fun isDeprecated(typeMirror: TypeMirror): Boolean { + return isDeprecated(types.asElement(typeMirror) ?: return false) + } fun resolve(tree: JCTree, compilationUnit: CompilationUnitTree, containingElement: JavaElement): JavaClassifier? = classifierResolver.resolve(tree, compilationUnit, containingElement) From c91301d04cbf3737616e3a2f2d63e4a9fee03d15 Mon Sep 17 00:00:00 2001 From: Victor Petukhov Date: Tue, 8 Dec 2020 15:48:41 +0300 Subject: [PATCH 159/196] Support type use annotations on fields --- .../structure/impl/classFiles/Annotations.kt | 29 +++++++++++++++++++ .../impl/classFiles/BinaryJavaClass.kt | 17 ++--------- 2 files changed, 32 insertions(+), 14 deletions(-) diff --git a/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/Annotations.kt b/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/Annotations.kt index 2cae0ecc160..119d42ab717 100644 --- a/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/Annotations.kt +++ b/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/Annotations.kt @@ -25,6 +25,35 @@ import org.jetbrains.kotlin.utils.addToStdlib.safeAs import org.jetbrains.org.objectweb.asm.* import java.lang.reflect.Array +internal class AnnotationsCollectorFieldVisitor( + private val field: BinaryJavaField, + private val context: ClassifierResolutionContext, + private val signatureParser: BinaryClassSignatureParser, +) : FieldVisitor(ASM_API_VERSION_FOR_CLASS_READING) { + override fun visitAnnotation(desc: String, visible: Boolean) = + BinaryJavaAnnotation.addAnnotation(field, desc, context, signatureParser) + + override fun visitTypeAnnotation(typeRef: Int, typePath: TypePath?, desc: String, visible: Boolean): AnnotationVisitor? { + val typeReference = TypeReference(typeRef) + + if (typePath != null) { + val translatedPath = translatePath(typePath) + + when (typeReference.sort) { + TypeReference.FIELD -> { + val targetType = computeTargetType(field.type, translatedPath) + return BinaryJavaAnnotation.addAnnotation(targetType as JavaPlainType, desc, context, signatureParser) + } + } + } + + return when (typeReference.sort) { + TypeReference.FIELD -> BinaryJavaAnnotation.addAnnotation(field.type as JavaPlainType, desc, context, signatureParser) + else -> null + } + } +} + internal class AnnotationsAndParameterCollectorMethodVisitor( private val member: BinaryJavaMethodBase, private val context: ClassifierResolutionContext, diff --git a/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/BinaryJavaClass.kt b/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/BinaryJavaClass.kt index 06db541e6c2..171e53919f3 100644 --- a/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/BinaryJavaClass.kt +++ b/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/BinaryJavaClass.kt @@ -211,23 +211,12 @@ class BinaryJavaClass( if (access.isSet(Opcodes.ACC_SYNTHETIC)) return null val type = signatureParser.parseTypeString(StringCharacterIterator(signature ?: desc), context) - val processedValue = processValue(value, type) + val filed = BinaryJavaField(Name.identifier(name), access, this, access.isSet(Opcodes.ACC_ENUM), type, processedValue) - return BinaryJavaField(Name.identifier(name), access, this, access.isSet(Opcodes.ACC_ENUM), type, processedValue).run { - fields.add(this) + fields.add(filed) - object : FieldVisitor(ASM_API_VERSION_FOR_CLASS_READING) { - override fun visitAnnotation(desc: String, visible: Boolean) = - BinaryJavaAnnotation.addAnnotation(this@run, desc, context, signatureParser) - - override fun visitTypeAnnotation(typeRef: Int, typePath: TypePath?, desc: String, visible: Boolean) = - if (typePath == null) - BinaryJavaAnnotation.addAnnotation(type as JavaPlainType, desc, context, signatureParser) - else - null - } - } + return AnnotationsCollectorFieldVisitor(filed, context, signatureParser) } From 276498793f79729e8398dcbcad2b2f45f666286a Mon Sep 17 00:00:00 2001 From: Victor Petukhov Date: Tue, 8 Dec 2020 15:56:39 +0300 Subject: [PATCH 160/196] Support enhancement of type parameter's bound for all nullability annotations --- .../kotlin/load/java/lazy/context.kt | 5 +--- .../typeEnhancement/signatureEnhancement.kt | 29 +++++++------------ 2 files changed, 11 insertions(+), 23 deletions(-) diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/context.kt b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/context.kt index f4ed45af85a..69a032b4c6a 100644 --- a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/context.kt +++ b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/context.kt @@ -173,10 +173,7 @@ private fun LazyJavaResolverContext.extractDefaultNullabilityQualifier( } val nullabilityQualifier = - components - .signatureEnhancement - .extractNullability(typeQualifier, onlyForJspecify = false) - ?.copy(isForWarningOnly = jsr305State.isWarning) + components.signatureEnhancement.extractNullability(typeQualifier)?.copy(isForWarningOnly = jsr305State.isWarning) ?: return null return JavaDefaultQualifiers(nullabilityQualifier, applicability) diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/signatureEnhancement.kt b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/signatureEnhancement.kt index 70d2647afb5..5be3f2d4b27 100644 --- a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/signatureEnhancement.kt +++ b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/signatureEnhancement.kt @@ -65,11 +65,8 @@ class SignatureEnhancement( } } - fun extractNullability( - annotationDescriptor: AnnotationDescriptor, - onlyForJspecify: Boolean - ): NullabilityQualifierWithMigrationStatus? { - extractNullabilityFromKnownAnnotations(annotationDescriptor, onlyForJspecify)?.let { return it } + fun extractNullability(annotationDescriptor: AnnotationDescriptor): NullabilityQualifierWithMigrationStatus? { + extractNullabilityFromKnownAnnotations(annotationDescriptor)?.let { return it } val typeQualifierAnnotation = annotationTypeQualifierResolver.resolveTypeQualifierAnnotation(annotationDescriptor) @@ -78,28 +75,25 @@ class SignatureEnhancement( val jsr305State = annotationTypeQualifierResolver.resolveJsr305AnnotationState(annotationDescriptor) if (jsr305State.isIgnore) return null - return extractNullabilityFromKnownAnnotations( - typeQualifierAnnotation, onlyForJspecify - )?.copy(isForWarningOnly = jsr305State.isWarning) + return extractNullabilityFromKnownAnnotations(typeQualifierAnnotation)?.copy(isForWarningOnly = jsr305State.isWarning) } private fun extractNullabilityFromKnownAnnotations( - annotationDescriptor: AnnotationDescriptor, - onlyForJspecify: Boolean + annotationDescriptor: AnnotationDescriptor ): NullabilityQualifierWithMigrationStatus? { val annotationFqName = annotationDescriptor.fqName ?: return null val migrationStatus = jspecifyMigrationStatus(annotationFqName) - ?: (if (!onlyForJspecify) commonMigrationStatus(annotationFqName, annotationDescriptor) else null) + ?: commonMigrationStatus(annotationFqName, annotationDescriptor) ?: return null return if (!migrationStatus.isForWarningOnly && annotationDescriptor is PossiblyExternalAnnotationDescriptor && annotationDescriptor.isIdeExternalAnnotation - ) + ) { migrationStatus.copy(isForWarningOnly = true) - else migrationStatus + } else migrationStatus } private fun jspecifyMigrationStatus( @@ -251,15 +245,12 @@ class SignatureEnhancement( } } - private fun ValueParameterDescriptor.hasDefaultValueInAnnotation(type: KotlinType): Boolean { - val defaultValue = getDefaultValueFromAnnotation() - - return when (defaultValue) { + private fun ValueParameterDescriptor.hasDefaultValueInAnnotation(type: KotlinType) = + when (val defaultValue = getDefaultValueFromAnnotation()) { is StringDefaultValue -> type.lexicalCastFrom(defaultValue.value) != null NullDefaultValue -> TypeUtils.acceptsNullable(type) null -> declaresDefaultValue() } && overriddenDescriptors.isEmpty() - } private inner class SignatureParts( private val typeContainer: Annotated?, @@ -438,7 +429,7 @@ class SignatureEnhancement( } private fun Annotations.extractNullability(): NullabilityQualifierWithMigrationStatus? = - this.firstNotNullResult { extractNullability(it, onlyForJspecify = typeParameterBounds) } + this.firstNotNullResult { extractNullability(it) } private fun computeIndexedQualifiersForOverride(): (Int) -> JavaTypeQualifiers { From f389654fea37b9036d822f9940806e4726f54ffb Mon Sep 17 00:00:00 2001 From: Victor Petukhov Date: Tue, 8 Dec 2020 16:09:18 +0300 Subject: [PATCH 161/196] Support type enhancement for super classes' types --- .../java/structure/impl/classFiles/BinaryJavaClass.kt | 6 ++++++ .../java/lazy/descriptors/LazyJavaClassDescriptor.kt | 9 +++++---- .../load/java/typeEnhancement/signatureEnhancement.kt | 11 +++++++++++ 3 files changed, 22 insertions(+), 4 deletions(-) diff --git a/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/BinaryJavaClass.kt b/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/BinaryJavaClass.kt index 171e53919f3..9872e5c5d00 100644 --- a/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/BinaryJavaClass.kt +++ b/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/BinaryJavaClass.kt @@ -91,6 +91,12 @@ class BinaryJavaClass( val translatedPath = BinaryJavaAnnotation.translatePath(typePath) when (typeReference.sort) { + TypeReference.CLASS_EXTENDS -> { + val baseType: JavaType = if (typeReference.superTypeIndex == -1) superclass!! else interfaces[typeReference.superTypeIndex] + val targetType = BinaryJavaAnnotation.computeTargetType(baseType, translatedPath) + + return BinaryJavaAnnotation.addAnnotation(targetType as JavaPlainType, descriptor, context, signatureParser) + } TypeReference.CLASS_TYPE_PARAMETER_BOUND -> { val baseType = computeTypeParameterBound(typeParameters, typeReference) val targetType = BinaryJavaAnnotation.computeTargetType(baseType, translatedPath) diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassDescriptor.kt b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassDescriptor.kt index 233bf329a67..9658d39233b 100644 --- a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassDescriptor.kt +++ b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassDescriptor.kt @@ -208,16 +208,17 @@ class LazyJavaClassDescriptor( for (javaType in javaTypes) { val kotlinType = c.typeResolver.transformJavaType(javaType, TypeUsage.SUPERTYPE.toAttributes()) - if (kotlinType.constructor.declarationDescriptor is NotFoundClasses.MockClassDescriptor) { + val enhancedKotlinType = c.components.signatureEnhancement.enhanceSuperType(kotlinType, c) + if (enhancedKotlinType.constructor.declarationDescriptor is NotFoundClasses.MockClassDescriptor) { incomplete.add(javaType) } - if (kotlinType.constructor == purelyImplementedSupertype?.constructor) { + if (enhancedKotlinType.constructor == purelyImplementedSupertype?.constructor) { continue } - if (!KotlinBuiltIns.isAnyOrNullableAny(kotlinType)) { - result.add(kotlinType) + if (!KotlinBuiltIns.isAnyOrNullableAny(enhancedKotlinType)) { + result.add(enhancedKotlinType) } } diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/signatureEnhancement.kt b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/signatureEnhancement.kt index 5be3f2d4b27..38e6ecdbc04 100644 --- a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/signatureEnhancement.kt +++ b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/signatureEnhancement.kt @@ -245,6 +245,17 @@ class SignatureEnhancement( } } + /* + * This method should be only used for type enhancement of base classes' type arguments: + * class A extends B<@NotNull Integer> {} + */ + fun enhanceSuperType(type: KotlinType, context: LazyJavaResolverContext) = + SignatureParts( + null, type, emptyList(), false, context, + AnnotationQualifierApplicabilityType.TYPE_USE, + typeParameterBounds = true + ).enhance().type + private fun ValueParameterDescriptor.hasDefaultValueInAnnotation(type: KotlinType) = when (val defaultValue = getDefaultValueFromAnnotation()) { is StringDefaultValue -> type.lexicalCastFrom(defaultValue.value) != null From 69f31afecceb786d2adb9848eea3772c0cab3286 Mon Sep 17 00:00:00 2001 From: Victor Petukhov Date: Tue, 8 Dec 2020 16:24:19 +0300 Subject: [PATCH 162/196] Exclude tests for loading type use annotations and type enhancement based on them to pass using javac and psi class files reading --- .../generators/tests/GenerateJava8Tests.kt | 21 ++- ...Java8WithPsiClassReadingTestGenerated.java | 68 +-------- .../LoadJava8UsingJavacTestGenerated.java | 136 +----------------- 3 files changed, 21 insertions(+), 204 deletions(-) diff --git a/compiler/tests-java8/tests/org/jetbrains/kotlin/generators/tests/GenerateJava8Tests.kt b/compiler/tests-java8/tests/org/jetbrains/kotlin/generators/tests/GenerateJava8Tests.kt index 6e08b32fb75..e093f96c947 100644 --- a/compiler/tests-java8/tests/org/jetbrains/kotlin/generators/tests/GenerateJava8Tests.kt +++ b/compiler/tests-java8/tests/org/jetbrains/kotlin/generators/tests/GenerateJava8Tests.kt @@ -58,12 +58,27 @@ fun main(args: Array) { } testClass { - model("loadJava8/compiledJava", extension = "java", testMethod = "doTestCompiledJava") - model("loadJava8/sourceJava", extension = "java", testMethod = "doTestSourceJava") + model( + "loadJava8/compiledJava", + extension = "java", + testMethod = "doTestCompiledJava", + excludeDirs = listOf("typeUseAnnotations", "typeParameterAnnotations") + ) + model( + "loadJava8/sourceJava", + extension = "java", + testMethod = "doTestSourceJava", + excludeDirs = listOf("typeUseAnnotations", "typeParameterAnnotations") + ) } testClass { - model("loadJava8/compiledJava", extension = "java", testMethod = "doTestCompiledJava") + model( + "loadJava8/compiledJava", + extension = "java", + testMethod = "doTestCompiledJava", + excludeDirs = listOf("typeUseAnnotations", "typeParameterAnnotations") + ) } testClass { diff --git a/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/LoadJava8WithPsiClassReadingTestGenerated.java b/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/LoadJava8WithPsiClassReadingTestGenerated.java index 4cf9cfb4590..797cf2ac7a6 100644 --- a/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/LoadJava8WithPsiClassReadingTestGenerated.java +++ b/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/LoadJava8WithPsiClassReadingTestGenerated.java @@ -26,7 +26,7 @@ public class LoadJava8WithPsiClassReadingTestGenerated extends AbstractLoadJava8 } public void testAllFilesPresentInCompiledJava() throws Exception { - KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/compiledJava"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/compiledJava"), Pattern.compile("^(.+)\\.java$"), null, true, "typeUseAnnotations", "typeParameterAnnotations"); } @TestMetadata("InnerClassTypeAnnotation.java") @@ -43,70 +43,4 @@ public class LoadJava8WithPsiClassReadingTestGenerated extends AbstractLoadJava8 public void testParameterNames() throws Exception { runTest("compiler/testData/loadJava8/compiledJava/ParameterNames.java"); } - - @TestMetadata("compiler/testData/loadJava8/compiledJava/typeParameterAnnotations") - @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class TypeParameterAnnotations extends AbstractLoadJava8WithPsiClassReadingTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTestCompiledJava, this, testDataFilePath); - } - - public void testAllFilesPresentInTypeParameterAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/compiledJava/typeParameterAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true); - } - - @TestMetadata("Basic.java") - public void testBasic() throws Exception { - runTest("compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic.java"); - } - } - - @TestMetadata("compiler/testData/loadJava8/compiledJava/typeUseAnnotations") - @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class TypeUseAnnotations extends AbstractLoadJava8WithPsiClassReadingTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTestCompiledJava, this, testDataFilePath); - } - - public void testAllFilesPresentInTypeUseAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/compiledJava/typeUseAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true); - } - - @TestMetadata("BaseClassTypeArguments.java") - public void testBaseClassTypeArguments() throws Exception { - runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/BaseClassTypeArguments.java"); - } - - @TestMetadata("Basic.java") - public void testBasic() throws Exception { - runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic.java"); - } - - @TestMetadata("ClassTypeParameterBounds.java") - public void testClassTypeParameterBounds() throws Exception { - runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ClassTypeParameterBounds.java"); - } - - @TestMetadata("MethodReceiver.java") - public void testMethodReceiver() throws Exception { - runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodReceiver.java"); - } - - @TestMetadata("MethodTypeParameterBounds.java") - public void testMethodTypeParameterBounds() throws Exception { - runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodTypeParameterBounds.java"); - } - - @TestMetadata("ReturnType.java") - public void testReturnType() throws Exception { - runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ReturnType.java"); - } - - @TestMetadata("ValueArguments.java") - public void testValueArguments() throws Exception { - runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ValueArguments.java"); - } - } } diff --git a/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/javac/LoadJava8UsingJavacTestGenerated.java b/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/javac/LoadJava8UsingJavacTestGenerated.java index 6f3908dc8dc..e5a3d16e228 100644 --- a/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/javac/LoadJava8UsingJavacTestGenerated.java +++ b/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/javac/LoadJava8UsingJavacTestGenerated.java @@ -28,7 +28,7 @@ public class LoadJava8UsingJavacTestGenerated extends AbstractLoadJava8UsingJava } public void testAllFilesPresentInCompiledJava() throws Exception { - KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/compiledJava"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/compiledJava"), Pattern.compile("^(.+)\\.java$"), null, true, "typeUseAnnotations", "typeParameterAnnotations"); } @TestMetadata("InnerClassTypeAnnotation.java") @@ -45,72 +45,6 @@ public class LoadJava8UsingJavacTestGenerated extends AbstractLoadJava8UsingJava public void testParameterNames() throws Exception { runTest("compiler/testData/loadJava8/compiledJava/ParameterNames.java"); } - - @TestMetadata("compiler/testData/loadJava8/compiledJava/typeParameterAnnotations") - @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class TypeParameterAnnotations extends AbstractLoadJava8UsingJavacTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTestCompiledJava, this, testDataFilePath); - } - - public void testAllFilesPresentInTypeParameterAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/compiledJava/typeParameterAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true); - } - - @TestMetadata("Basic.java") - public void testBasic() throws Exception { - runTest("compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic.java"); - } - } - - @TestMetadata("compiler/testData/loadJava8/compiledJava/typeUseAnnotations") - @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class TypeUseAnnotations extends AbstractLoadJava8UsingJavacTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTestCompiledJava, this, testDataFilePath); - } - - public void testAllFilesPresentInTypeUseAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/compiledJava/typeUseAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true); - } - - @TestMetadata("BaseClassTypeArguments.java") - public void testBaseClassTypeArguments() throws Exception { - runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/BaseClassTypeArguments.java"); - } - - @TestMetadata("Basic.java") - public void testBasic() throws Exception { - runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic.java"); - } - - @TestMetadata("ClassTypeParameterBounds.java") - public void testClassTypeParameterBounds() throws Exception { - runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ClassTypeParameterBounds.java"); - } - - @TestMetadata("MethodReceiver.java") - public void testMethodReceiver() throws Exception { - runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodReceiver.java"); - } - - @TestMetadata("MethodTypeParameterBounds.java") - public void testMethodTypeParameterBounds() throws Exception { - runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodTypeParameterBounds.java"); - } - - @TestMetadata("ReturnType.java") - public void testReturnType() throws Exception { - runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ReturnType.java"); - } - - @TestMetadata("ValueArguments.java") - public void testValueArguments() throws Exception { - runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ValueArguments.java"); - } - } } @TestMetadata("compiler/testData/loadJava8/sourceJava") @@ -122,7 +56,7 @@ public class LoadJava8UsingJavacTestGenerated extends AbstractLoadJava8UsingJava } public void testAllFilesPresentInSourceJava() throws Exception { - KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/sourceJava"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/sourceJava"), Pattern.compile("^(.+)\\.java$"), null, true, "typeUseAnnotations", "typeParameterAnnotations"); } @TestMetadata("MapRemove.java") @@ -134,71 +68,5 @@ public class LoadJava8UsingJavacTestGenerated extends AbstractLoadJava8UsingJava public void testTypeParameterAnnotations() throws Exception { runTest("compiler/testData/loadJava8/sourceJava/TypeParameterAnnotations.java"); } - - @TestMetadata("compiler/testData/loadJava8/sourceJava/typeParameterAnnotations") - @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class TypeParameterAnnotations extends AbstractLoadJava8UsingJavacTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTestSourceJava, this, testDataFilePath); - } - - public void testAllFilesPresentInTypeParameterAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/sourceJava/typeParameterAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true); - } - - @TestMetadata("Basic.java") - public void testBasic() throws Exception { - runTest("compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic.java"); - } - } - - @TestMetadata("compiler/testData/loadJava8/sourceJava/typeUseAnnotations") - @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class TypeUseAnnotations extends AbstractLoadJava8UsingJavacTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTestSourceJava, this, testDataFilePath); - } - - public void testAllFilesPresentInTypeUseAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/sourceJava/typeUseAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true); - } - - @TestMetadata("BaseClassTypeArguments.java") - public void testBaseClassTypeArguments() throws Exception { - runTest("compiler/testData/loadJava8/sourceJava/typeUseAnnotations/BaseClassTypeArguments.java"); - } - - @TestMetadata("Basic.java") - public void testBasic() throws Exception { - runTest("compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic.java"); - } - - @TestMetadata("ClassTypeParameterBounds.java") - public void testClassTypeParameterBounds() throws Exception { - runTest("compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ClassTypeParameterBounds.java"); - } - - @TestMetadata("MethodReceiver.java") - public void testMethodReceiver() throws Exception { - runTest("compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodReceiver.java"); - } - - @TestMetadata("MethodTypeParameterBounds.java") - public void testMethodTypeParameterBounds() throws Exception { - runTest("compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodTypeParameterBounds.java"); - } - - @TestMetadata("ReturnType.java") - public void testReturnType() throws Exception { - runTest("compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ReturnType.java"); - } - - @TestMetadata("ValueArguments.java") - public void testValueArguments() throws Exception { - runTest("compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ValueArguments.java"); - } - } } } From 857cc92326cb52a1f1f5f9635e2683ad0bfa1c07 Mon Sep 17 00:00:00 2001 From: Victor Petukhov Date: Tue, 8 Dec 2020 18:32:33 +0300 Subject: [PATCH 163/196] Support preference of TYPE_USE annotations to enhance over others like METHOD, FIELD and VALUE_PARAMETER to avoid double applying them in case of arrays: @NotNull Integer [] (both to the array element and to the entire array) ^KT-24392 Fixed --- .../AdditionalClassAnnotationLowering.kt | 3 +- .../AnnotationQualifierApplicabilityType.kt | 9 +++- .../kotlin/load/java/JvmAnnotationNames.java | 11 +++++ .../java/AnnotationTypeQualifierResolver.kt | 37 ++++++++++------ .../java/components/JavaAnnotationMapper.kt | 42 ++++++++----------- .../typeEnhancement/signatureEnhancement.kt | 19 +++++++-- .../jetbrains/kotlin/SpecialJvmAnnotations.kt | 6 +-- .../conversions/JavaAnnotationsConversion.kt | 3 +- 8 files changed, 83 insertions(+), 47 deletions(-) diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/AdditionalClassAnnotationLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/AdditionalClassAnnotationLowering.kt index 32445fc7ecd..ae5a6c1eff5 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/AdditionalClassAnnotationLowering.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/AdditionalClassAnnotationLowering.kt @@ -37,6 +37,7 @@ import org.jetbrains.kotlin.ir.util.defaultType import org.jetbrains.kotlin.ir.util.getAnnotation import org.jetbrains.kotlin.ir.util.hasAnnotation import org.jetbrains.kotlin.ir.util.isAnnotationClass +import org.jetbrains.kotlin.load.java.JvmAnnotationNames import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.utils.addToStdlib.safeAs @@ -191,7 +192,7 @@ private class AdditionalClassAnnotationLowering(private val context: JvmBackendC } private fun generateTargetAnnotation(irClass: IrClass) { - if (irClass.hasAnnotation(FqName("java.lang.annotation.Target"))) return + if (irClass.hasAnnotation(JvmAnnotationNames.TARGET_ANNOTATION)) return val annotationTargetMap = annotationTargetMaps[jvmTarget] ?: throw AssertionError("No annotation target map for JVM target $jvmTarget") diff --git a/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/AnnotationQualifierApplicabilityType.kt b/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/AnnotationQualifierApplicabilityType.kt index a41346fd68f..8ef7e3bf738 100644 --- a/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/AnnotationQualifierApplicabilityType.kt +++ b/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/AnnotationQualifierApplicabilityType.kt @@ -5,6 +5,11 @@ package org.jetbrains.kotlin.load.java -enum class AnnotationQualifierApplicabilityType { - METHOD_RETURN_TYPE, VALUE_PARAMETER, FIELD, TYPE_USE, TYPE_PARAMETER_BOUNDS +enum class AnnotationQualifierApplicabilityType(val javaTarget: String) { + METHOD_RETURN_TYPE("METHOD"), + VALUE_PARAMETER("PARAMETER"), + FIELD("FIELD"), + TYPE_USE("TYPE_USE"), + TYPE_PARAMETER_BOUNDS("TYPE_USE"), + TYPE_PARAMETER("TYPE_PARAMETER") } diff --git a/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/JvmAnnotationNames.java b/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/JvmAnnotationNames.java index 76613d1744b..fbd565b2b17 100644 --- a/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/JvmAnnotationNames.java +++ b/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/JvmAnnotationNames.java @@ -16,10 +16,15 @@ package org.jetbrains.kotlin.load.java; +import kotlin.annotation.Repeatable; import org.jetbrains.kotlin.name.FqName; import org.jetbrains.kotlin.name.Name; import org.jetbrains.kotlin.resolve.jvm.JvmClassName; +import java.lang.annotation.Documented; +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + @SuppressWarnings("PointlessBitwiseExpression") public final class JvmAnnotationNames { public static final FqName METADATA_FQ_NAME = new FqName("kotlin.Metadata"); @@ -44,6 +49,12 @@ public final class JvmAnnotationNames { public static final Name DEFAULT_ANNOTATION_MEMBER_NAME = Name.identifier("value"); + public static final FqName TARGET_ANNOTATION = new FqName(Target.class.getCanonicalName()); + public static final FqName RETENTION_ANNOTATION = new FqName(Retention.class.getCanonicalName()); + public static final FqName DEPRECATED_ANNOTATION = new FqName(Deprecated.class.getCanonicalName()); + public static final FqName DOCUMENTED_ANNOTATION = new FqName(Documented.class.getCanonicalName()); + public static final FqName REPEATABLE_ANNOTATION = new FqName("java.lang.annotation.Repeatable"); + public static final FqName JETBRAINS_NOT_NULL_ANNOTATION = new FqName("org.jetbrains.annotations.NotNull"); public static final FqName JETBRAINS_NULLABLE_ANNOTATION = new FqName("org.jetbrains.annotations.Nullable"); public static final FqName JETBRAINS_MUTABLE_ANNOTATION = new FqName("org.jetbrains.annotations.Mutable"); diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/AnnotationTypeQualifierResolver.kt b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/AnnotationTypeQualifierResolver.kt index 44d84d0eb6d..a7917957232 100644 --- a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/AnnotationTypeQualifierResolver.kt +++ b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/AnnotationTypeQualifierResolver.kt @@ -19,6 +19,7 @@ package org.jetbrains.kotlin.load.java import org.jetbrains.kotlin.descriptors.ClassDescriptor import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor +import org.jetbrains.kotlin.load.java.components.JavaAnnotationTargetMapper import org.jetbrains.kotlin.resolve.constants.ArrayValue import org.jetbrains.kotlin.resolve.constants.ConstantValue import org.jetbrains.kotlin.resolve.constants.EnumValue @@ -114,7 +115,7 @@ class AnnotationTypeQualifierResolver(storageManager: StorageManager, private va .allValueArguments .flatMap { (parameter, argument) -> if (parameter == JvmAnnotationNames.DEFAULT_ANNOTATION_MEMBER_NAME) - argument.mapConstantToQualifierApplicabilityTypes() + argument.mapJavaConstantToQualifierApplicabilityTypes() else emptyList() } @@ -126,6 +127,16 @@ class AnnotationTypeQualifierResolver(storageManager: StorageManager, private va return TypeQualifierWithApplicability(typeQualifier, elementTypesMask) } + fun resolveAnnotation(annotationDescriptor: AnnotationDescriptor): TypeQualifierWithApplicability? { + val annotatedClass = annotationDescriptor.annotationClass ?: return null + val target = annotatedClass.annotations.findAnnotation(JvmAnnotationNames.TARGET_ANNOTATION) ?: return null + val elementTypesMask = target.allValueArguments + .flatMap { (_, argument) -> argument.mapKotlinConstantToQualifierApplicabilityTypes() } + .fold(0) { acc: Int, applicabilityType -> acc or (1 shl applicabilityType.ordinal) } + + return TypeQualifierWithApplicability(annotationDescriptor, elementTypesMask) + } + fun resolveJsr305AnnotationState(annotationDescriptor: AnnotationDescriptor): ReportLevel { resolveJsr305CustomState(annotationDescriptor)?.let { return it } return javaTypeEnhancementState.globalJsr305Level @@ -150,20 +161,22 @@ class AnnotationTypeQualifierResolver(storageManager: StorageManager, private va } } - private fun ConstantValue<*>.mapConstantToQualifierApplicabilityTypes(): List = + private fun String.toKotlinTargetNames() = JavaAnnotationTargetMapper.mapJavaTargetArgumentByName(this).map { it.name } + + private fun ConstantValue<*>.mapConstantToQualifierApplicabilityTypes( + findPredicate: EnumValue.(AnnotationQualifierApplicabilityType) -> Boolean + ): List = when (this) { - is ArrayValue -> value.flatMap { it.mapConstantToQualifierApplicabilityTypes() } - is EnumValue -> listOfNotNull( - when (enumEntryName.identifier) { - "METHOD" -> AnnotationQualifierApplicabilityType.METHOD_RETURN_TYPE - "FIELD" -> AnnotationQualifierApplicabilityType.FIELD - "PARAMETER" -> AnnotationQualifierApplicabilityType.VALUE_PARAMETER - "TYPE_USE" -> AnnotationQualifierApplicabilityType.TYPE_USE - else -> null - } - ) + is ArrayValue -> value.flatMap { it.mapConstantToQualifierApplicabilityTypes(findPredicate) } + is EnumValue -> listOfNotNull(AnnotationQualifierApplicabilityType.values().find { findPredicate(it) }) else -> emptyList() } + + private fun ConstantValue<*>.mapJavaConstantToQualifierApplicabilityTypes(): List = + mapConstantToQualifierApplicabilityTypes { enumEntryName.identifier == it.javaTarget } + + private fun ConstantValue<*>.mapKotlinConstantToQualifierApplicabilityTypes(): List = + mapConstantToQualifierApplicabilityTypes { enumEntryName.identifier in it.javaTarget.toKotlinTargetNames() } } private val ClassDescriptor.isAnnotatedWithTypeQualifier: Boolean diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/components/JavaAnnotationMapper.kt b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/components/JavaAnnotationMapper.kt index 00f7a14146b..442aa6f1ee8 100644 --- a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/components/JavaAnnotationMapper.kt +++ b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/components/JavaAnnotationMapper.kt @@ -21,6 +21,8 @@ import org.jetbrains.kotlin.descriptors.SourceElement import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor import org.jetbrains.kotlin.descriptors.annotations.KotlinRetention import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget +import org.jetbrains.kotlin.load.java.JvmAnnotationNames +import org.jetbrains.kotlin.load.java.JvmAnnotationNames.* import org.jetbrains.kotlin.load.java.descriptors.PossiblyExternalAnnotationDescriptor import org.jetbrains.kotlin.load.java.lazy.LazyJavaResolverContext import org.jetbrains.kotlin.load.java.lazy.descriptors.LazyJavaAnnotationDescriptor @@ -35,31 +37,21 @@ import org.jetbrains.kotlin.resolve.constants.StringValue import org.jetbrains.kotlin.storage.getValue import org.jetbrains.kotlin.types.ErrorUtils import org.jetbrains.kotlin.types.SimpleType -import java.lang.annotation.Documented -import java.lang.annotation.Retention -import java.lang.annotation.Target import java.util.* object JavaAnnotationMapper { - - private val JAVA_TARGET_FQ_NAME = FqName(Target::class.java.canonicalName) - private val JAVA_RETENTION_FQ_NAME = FqName(Retention::class.java.canonicalName) - private val JAVA_DEPRECATED_FQ_NAME = FqName(java.lang.Deprecated::class.java.canonicalName) - private val JAVA_DOCUMENTED_FQ_NAME = FqName(Documented::class.java.canonicalName) // Java8-specific thing - private val JAVA_REPEATABLE_FQ_NAME = FqName("java.lang.annotation.Repeatable") - internal val DEPRECATED_ANNOTATION_MESSAGE = Name.identifier("message") internal val TARGET_ANNOTATION_ALLOWED_TARGETS = Name.identifier("allowedTargets") internal val RETENTION_ANNOTATION_VALUE = Name.identifier("value") fun mapOrResolveJavaAnnotation(annotation: JavaAnnotation, c: LazyJavaResolverContext): AnnotationDescriptor? = when (annotation.classId) { - ClassId.topLevel(JAVA_TARGET_FQ_NAME) -> JavaTargetAnnotationDescriptor(annotation, c) - ClassId.topLevel(JAVA_RETENTION_FQ_NAME) -> JavaRetentionAnnotationDescriptor(annotation, c) - ClassId.topLevel(JAVA_REPEATABLE_FQ_NAME) -> JavaAnnotationDescriptor(c, annotation, StandardNames.FqNames.repeatable) - ClassId.topLevel(JAVA_DOCUMENTED_FQ_NAME) -> JavaAnnotationDescriptor(c, annotation, StandardNames.FqNames.mustBeDocumented) - ClassId.topLevel(JAVA_DEPRECATED_FQ_NAME) -> null + ClassId.topLevel(TARGET_ANNOTATION) -> JavaTargetAnnotationDescriptor(annotation, c) + ClassId.topLevel(RETENTION_ANNOTATION) -> JavaRetentionAnnotationDescriptor(annotation, c) + ClassId.topLevel(REPEATABLE_ANNOTATION) -> JavaAnnotationDescriptor(c, annotation, StandardNames.FqNames.repeatable) + ClassId.topLevel(DOCUMENTED_ANNOTATION) -> JavaAnnotationDescriptor(c, annotation, StandardNames.FqNames.mustBeDocumented) + ClassId.topLevel(DEPRECATED_ANNOTATION) -> null else -> LazyJavaAnnotationDescriptor(c, annotation) } @@ -69,7 +61,7 @@ object JavaAnnotationMapper { c: LazyJavaResolverContext ): AnnotationDescriptor? { if (kotlinName == StandardNames.FqNames.deprecated) { - val javaAnnotation = annotationOwner.findAnnotation(JAVA_DEPRECATED_FQ_NAME) + val javaAnnotation = annotationOwner.findAnnotation(DEPRECATED_ANNOTATION) if (javaAnnotation != null || annotationOwner.isDeprecatedInJavaDoc) { return JavaDeprecatedAnnotationDescriptor(javaAnnotation, c) } @@ -84,19 +76,19 @@ object JavaAnnotationMapper { // kotlin.annotation.annotation is treated separately private val kotlinToJavaNameMap: Map = mapOf( - StandardNames.FqNames.target to JAVA_TARGET_FQ_NAME, - StandardNames.FqNames.retention to JAVA_RETENTION_FQ_NAME, - StandardNames.FqNames.repeatable to JAVA_REPEATABLE_FQ_NAME, - StandardNames.FqNames.mustBeDocumented to JAVA_DOCUMENTED_FQ_NAME + StandardNames.FqNames.target to TARGET_ANNOTATION, + StandardNames.FqNames.retention to RETENTION_ANNOTATION, + StandardNames.FqNames.repeatable to REPEATABLE_ANNOTATION, + StandardNames.FqNames.mustBeDocumented to DOCUMENTED_ANNOTATION ) val javaToKotlinNameMap: Map = mapOf( - JAVA_TARGET_FQ_NAME to StandardNames.FqNames.target, - JAVA_RETENTION_FQ_NAME to StandardNames.FqNames.retention, - JAVA_DEPRECATED_FQ_NAME to StandardNames.FqNames.deprecated, - JAVA_REPEATABLE_FQ_NAME to StandardNames.FqNames.repeatable, - JAVA_DOCUMENTED_FQ_NAME to StandardNames.FqNames.mustBeDocumented + TARGET_ANNOTATION to StandardNames.FqNames.target, + RETENTION_ANNOTATION to StandardNames.FqNames.retention, + DEPRECATED_ANNOTATION to StandardNames.FqNames.deprecated, + REPEATABLE_ANNOTATION to StandardNames.FqNames.repeatable, + DOCUMENTED_ANNOTATION to StandardNames.FqNames.mustBeDocumented ) } diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/signatureEnhancement.kt b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/signatureEnhancement.kt index 38e6ecdbc04..908c98444fc 100644 --- a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/signatureEnhancement.kt +++ b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/signatureEnhancement.kt @@ -327,10 +327,23 @@ class SignatureEnhancement( isFromStarProjection: Boolean ): JavaTypeQualifiers { val composedAnnotation = - if (isHeadTypeConstructor && typeContainer != null) + if (isHeadTypeConstructor && typeContainer is TypeParameterDescriptor) { composeAnnotations(typeContainer.annotations, annotations) - else - annotations + } else if (isHeadTypeConstructor && typeContainer != null) { + val filteredContainerAnnotations = typeContainer.annotations.filter { + val (_, targets) = annotationTypeQualifierResolver.resolveAnnotation(it) ?: return@filter false + /* + * We don't apply container type use annotations to avoid double applying them like with arrays: + * @NotNull Integer [] f15(); + * Otherwise, in the example above we would apply `@NotNull` to `Integer` (i.e. array element; as TYPE_USE annotation) + * and to entire array (as METHOD annotation). + * In other words, we prefer TYPE_USE target of an annotation, and apply the annotation only according to it, if it's present. + * See KT-24392 for more details. + */ + AnnotationQualifierApplicabilityType.TYPE_USE !in targets + } + composeAnnotations(Annotations.create(filteredContainerAnnotations), annotations) + } else annotations fun List.ifPresent(qualifier: T) = if (any { composedAnnotation.findAnnotation(it) != null }) qualifier else null diff --git a/core/deserialization.common.jvm/src/org/jetbrains/kotlin/SpecialJvmAnnotations.kt b/core/deserialization.common.jvm/src/org/jetbrains/kotlin/SpecialJvmAnnotations.kt index 6479c5183cb..f2f2247ccfa 100644 --- a/core/deserialization.common.jvm/src/org/jetbrains/kotlin/SpecialJvmAnnotations.kt +++ b/core/deserialization.common.jvm/src/org/jetbrains/kotlin/SpecialJvmAnnotations.kt @@ -14,8 +14,8 @@ object SpecialJvmAnnotations { JvmAnnotationNames.METADATA_FQ_NAME, JvmAnnotationNames.JETBRAINS_NOT_NULL_ANNOTATION, JvmAnnotationNames.JETBRAINS_NULLABLE_ANNOTATION, - FqName("java.lang.annotation.Target"), - FqName("java.lang.annotation.Retention"), - FqName("java.lang.annotation.Documented") + JvmAnnotationNames.TARGET_ANNOTATION, + JvmAnnotationNames.RETENTION_ANNOTATION, + JvmAnnotationNames.DOCUMENTED_ANNOTATION ).mapTo(mutableSetOf(), ClassId::topLevel) } diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/JavaAnnotationsConversion.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/JavaAnnotationsConversion.kt index a40ac220f98..2fba5cc8e14 100644 --- a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/JavaAnnotationsConversion.kt +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/JavaAnnotationsConversion.kt @@ -5,6 +5,7 @@ package org.jetbrains.kotlin.nj2k.conversions +import org.jetbrains.kotlin.load.java.JvmAnnotationNames import org.jetbrains.kotlin.nj2k.NewJ2kConverterContext import org.jetbrains.kotlin.nj2k.tree.* @@ -30,7 +31,7 @@ class JavaAnnotationsConversion(context: NewJ2kConverterContext) : RecursiveAppl annotation.classSymbol = symbolProvider.provideClassSymbol("kotlin.Deprecated") annotation.arguments = listOf(JKAnnotationParameterImpl(JKLiteralExpression("\"\"", JKLiteralExpression.LiteralType.STRING))) } - if (annotation.classSymbol.fqName == "java.lang.annotation.Target") { + if (annotation.classSymbol.fqName == JvmAnnotationNames.TARGET_ANNOTATION.asString()) { annotation.classSymbol = symbolProvider.provideClassSymbol("kotlin.annotation.Target") val arguments = annotation.arguments.singleOrNull()?.let { parameter -> From 6f8f531d87c899c3f7b6ebbbd1a1dc940657d476 Mon Sep 17 00:00:00 2001 From: Victor Petukhov Date: Wed, 9 Dec 2020 12:16:26 +0300 Subject: [PATCH 164/196] Put type enhancement improvements under the compiler flag --- .../kotlin/frontend/java/di/injection.kt | 1 + .../typeParameterAnnotations/Basic.java | 2 +- .../Basic_DisabledImprovements.java | 19 ++++++ .../BaseClassTypeArguments.java | 2 +- .../typeUseAnnotations/Basic.java | 2 +- .../Basic_DisabledImprovements.java | 30 +++++++++ .../Basic_DisabledImprovements.txt | 32 +++++++++ .../ClassTypeParameterBounds.java | 2 +- .../typeUseAnnotations/MethodReceiver.java | 2 +- .../MethodTypeParameterBounds.java | 2 +- .../typeUseAnnotations/ReturnType.java | 2 +- .../typeUseAnnotations/ValueArguments.java | 2 + .../typeParameterAnnotations/Basic.java | 2 +- .../Basic_DisabledImprovements.java | 19 ++++++ .../BaseClassTypeArguments.java | 1 + .../sourceJava/typeUseAnnotations/Basic.java | 1 + .../Basic_DisabledImprovements.java | 30 +++++++++ .../Basic_DisabledImprovements.txt | 32 +++++++++ .../ClassTypeParameterBounds.java | 1 + .../typeUseAnnotations/MethodReceiver.java | 1 + .../MethodTypeParameterBounds.java | 1 + .../typeUseAnnotations/ReturnType.java | 1 + .../typeUseAnnotations/ValueArguments.java | 1 + .../jvm/compiler/AbstractLoadJavaTest.java | 23 +++++-- .../kotlin/config/LanguageVersionSettings.kt | 16 +++++ .../load/java/lazy/LazyJavaAnnotations.kt | 5 +- .../kotlin/load/java/lazy/context.kt | 17 +++-- .../descriptors/LazyJavaClassDescriptor.kt | 6 +- .../load/java/lazy/types/JavaTypeResolver.kt | 2 +- .../typeEnhancement/signatureEnhancement.kt | 67 ++++++++++++------- 30 files changed, 274 insertions(+), 50 deletions(-) create mode 100644 compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic_DisabledImprovements.java create mode 100644 compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic_DisabledImprovements.java create mode 100644 compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic_DisabledImprovements.txt create mode 100644 compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic_DisabledImprovements.java create mode 100644 compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic_DisabledImprovements.java create mode 100644 compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic_DisabledImprovements.txt diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt index 46a548bd6dd..097ed4e5f1d 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt @@ -137,6 +137,7 @@ fun StorageComponentContainer.configureJavaSpecificComponents( JavaResolverSettings.create( isReleaseCoroutines = languageVersionSettings.supportsFeature(LanguageFeature.ReleaseCoroutines), correctNullabilityForNotNullTypeParameter = languageVersionSettings.supportsFeature(LanguageFeature.ProhibitUsingNullableTypeParameterAgainstNotNullAnnotated), + enhancementImprovements = languageVersionSettings.supportsFeature(LanguageFeature.ImprovementsAroundTypeEnhancement), ) ) diff --git a/compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic.java b/compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic.java index c363b13d82c..d29ce251dc7 100644 --- a/compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic.java +++ b/compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic.java @@ -1,4 +1,4 @@ -// JAVAC_EXPECTED_FILE +// !LANGUAGE: +ImprovementsAroundTypeEnhancement package test; diff --git a/compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic_DisabledImprovements.java b/compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic_DisabledImprovements.java new file mode 100644 index 00000000000..20ae7c5392d --- /dev/null +++ b/compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic_DisabledImprovements.java @@ -0,0 +1,19 @@ +// !LANGUAGE: -ImprovementsAroundTypeEnhancement + +package test; + +import org.jetbrains.annotations.*; + +public class Basic_DisabledImprovements { + public interface G<@NotNull T> { + <@NotNull R> void foo(R r); + } + + public interface G1 { + void foo(R r); + } + + void foo(R r) { + + } +} diff --git a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/BaseClassTypeArguments.java b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/BaseClassTypeArguments.java index 27c4dff6bba..728df19f7de 100644 --- a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/BaseClassTypeArguments.java +++ b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/BaseClassTypeArguments.java @@ -1,4 +1,4 @@ -// JAVAC_EXPECTED_FILE +// !LANGUAGE: +ImprovementsAroundTypeEnhancement package test; diff --git a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic.java b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic.java index 8759772b49e..d559293052e 100644 --- a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic.java +++ b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic.java @@ -1,4 +1,4 @@ -// JAVAC_EXPECTED_FILE +// !LANGUAGE: +ImprovementsAroundTypeEnhancement package test; diff --git a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic_DisabledImprovements.java b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic_DisabledImprovements.java new file mode 100644 index 00000000000..feafd88d327 --- /dev/null +++ b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic_DisabledImprovements.java @@ -0,0 +1,30 @@ +// !LANGUAGE: -ImprovementsAroundTypeEnhancement + +package test; + +import org.jetbrains.annotations.*; + +public class Basic_DisabledImprovements { + interface G extends G2<@NotNull T, @NotNull String> { } + + interface G2 { } + + static class A { + class B {} + } + + public interface MyClass { + void f1(G<@NotNull String> p); + G2<@Nullable String, @NotNull Integer> f2(); + void f3(@NotNull T x); + void f4(G<@NotNull String @Nullable []> p); + void f5(G<@NotNull ?> p); + void f6(G<@NotNull ? extends @Nullable Object> p); + void f7(G<@NotNull A.B> p); + G> f81(); + G> f9(); + > void f10(T p); + } + + Basic_DisabledImprovements(G<@NotNull String> p) { } +} \ No newline at end of file diff --git a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic_DisabledImprovements.txt b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic_DisabledImprovements.txt new file mode 100644 index 00000000000..f75974d7c03 --- /dev/null +++ b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic_DisabledImprovements.txt @@ -0,0 +1,32 @@ +package test + +public open class Basic_DisabledImprovements { + public/*package*/ constructor Basic_DisabledImprovements(/*0*/ p0: test.Basic_DisabledImprovements.G<@org.jetbrains.annotations.NotNull kotlin.String!>!) + + public/*package*/ open class A { + public/*package*/ constructor A() + + public/*package*/ open inner class B { + public/*package*/ constructor B() + } + } + + public/*package*/ interface G : test.Basic_DisabledImprovements.G2<@org.jetbrains.annotations.NotNull T!, @org.jetbrains.annotations.NotNull kotlin.String!> { + } + + public/*package*/ interface G2 { + } + + public interface MyClass { + public abstract fun f1(/*0*/ p0: test.Basic_DisabledImprovements.G<@org.jetbrains.annotations.NotNull kotlin.String!>!): kotlin.Unit + public abstract fun !>!> f10(/*0*/ p0: T!): kotlin.Unit + public abstract fun f2(): test.Basic_DisabledImprovements.G2<@org.jetbrains.annotations.Nullable kotlin.String!, @org.jetbrains.annotations.NotNull kotlin.Int!>! + public abstract fun f3(/*0*/ @org.jetbrains.annotations.NotNull p0: @org.jetbrains.annotations.NotNull T): kotlin.Unit + public abstract fun f4(/*0*/ p0: test.Basic_DisabledImprovements.G<(@org.jetbrains.annotations.Nullable kotlin.Array<@org.jetbrains.annotations.NotNull kotlin.String!>..@org.jetbrains.annotations.Nullable kotlin.Array?)>!): kotlin.Unit + public abstract fun f5(/*0*/ p0: test.Basic_DisabledImprovements.G<*>!): kotlin.Unit + public abstract fun f6(/*0*/ p0: test.Basic_DisabledImprovements.G!): kotlin.Unit + public abstract fun f7(/*0*/ p0: test.Basic_DisabledImprovements.G<@org.jetbrains.annotations.NotNull test.Basic_DisabledImprovements.A.B<*, *>!>!): kotlin.Unit + public abstract fun f81(): test.Basic_DisabledImprovements.G<@org.jetbrains.annotations.Nullable test.Basic_DisabledImprovements.A.B<*, *>!>! + public abstract fun f9(): test.Basic_DisabledImprovements.G<@org.jetbrains.annotations.Nullable test.Basic_DisabledImprovements.A.B<*, *>!>! + } +} diff --git a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ClassTypeParameterBounds.java b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ClassTypeParameterBounds.java index 1d6c9fadcec..6bfe9356db4 100644 --- a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ClassTypeParameterBounds.java +++ b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ClassTypeParameterBounds.java @@ -1,4 +1,4 @@ -// JAVAC_EXPECTED_FILE +// !LANGUAGE: +ImprovementsAroundTypeEnhancement package test; diff --git a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodReceiver.java b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodReceiver.java index 2a43d23c233..161d317072b 100644 --- a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodReceiver.java +++ b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodReceiver.java @@ -1,4 +1,4 @@ -// JAVAC_EXPECTED_FILE +// !LANGUAGE: +ImprovementsAroundTypeEnhancement package test; diff --git a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodTypeParameterBounds.java b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodTypeParameterBounds.java index 16b4632069b..64f434238dd 100644 --- a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodTypeParameterBounds.java +++ b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/MethodTypeParameterBounds.java @@ -1,4 +1,4 @@ -// JAVAC_EXPECTED_FILE +// !LANGUAGE: +ImprovementsAroundTypeEnhancement package test; diff --git a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ReturnType.java b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ReturnType.java index bad8d817886..2e5e08f05d4 100644 --- a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ReturnType.java +++ b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ReturnType.java @@ -1,4 +1,4 @@ -// JAVAC_EXPECTED_FILE +// !LANGUAGE: +ImprovementsAroundTypeEnhancement package test; diff --git a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ValueArguments.java b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ValueArguments.java index 7f4944a269a..b45426a7e59 100644 --- a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ValueArguments.java +++ b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ValueArguments.java @@ -1,3 +1,5 @@ +// !LANGUAGE: +ImprovementsAroundTypeEnhancement + package test; import org.jetbrains.annotations.*; diff --git a/compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic.java b/compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic.java index c363b13d82c..d29ce251dc7 100644 --- a/compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic.java +++ b/compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic.java @@ -1,4 +1,4 @@ -// JAVAC_EXPECTED_FILE +// !LANGUAGE: +ImprovementsAroundTypeEnhancement package test; diff --git a/compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic_DisabledImprovements.java b/compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic_DisabledImprovements.java new file mode 100644 index 00000000000..3aa3ae514db --- /dev/null +++ b/compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic_DisabledImprovements.java @@ -0,0 +1,19 @@ +// !LANGUAGE: + +package test; + +import org.jetbrains.annotations.*; + +public class Basic_DisabledImprovements { + public interface G<@NotNull T> { + <@NotNull R> void foo(R r); + } + + public interface G1 { + void foo(R r); + } + + void foo(R r) { + + } +} diff --git a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/BaseClassTypeArguments.java b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/BaseClassTypeArguments.java index 27c4dff6bba..f4285d227e0 100644 --- a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/BaseClassTypeArguments.java +++ b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/BaseClassTypeArguments.java @@ -1,4 +1,5 @@ // JAVAC_EXPECTED_FILE +// !LANGUAGE: +ImprovementsAroundTypeEnhancement package test; diff --git a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic.java b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic.java index 8759772b49e..6d00a4e6999 100644 --- a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic.java +++ b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic.java @@ -1,4 +1,5 @@ // JAVAC_EXPECTED_FILE +// !LANGUAGE: +ImprovementsAroundTypeEnhancement package test; diff --git a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic_DisabledImprovements.java b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic_DisabledImprovements.java new file mode 100644 index 00000000000..feafd88d327 --- /dev/null +++ b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic_DisabledImprovements.java @@ -0,0 +1,30 @@ +// !LANGUAGE: -ImprovementsAroundTypeEnhancement + +package test; + +import org.jetbrains.annotations.*; + +public class Basic_DisabledImprovements { + interface G extends G2<@NotNull T, @NotNull String> { } + + interface G2 { } + + static class A { + class B {} + } + + public interface MyClass { + void f1(G<@NotNull String> p); + G2<@Nullable String, @NotNull Integer> f2(); + void f3(@NotNull T x); + void f4(G<@NotNull String @Nullable []> p); + void f5(G<@NotNull ?> p); + void f6(G<@NotNull ? extends @Nullable Object> p); + void f7(G<@NotNull A.B> p); + G> f81(); + G> f9(); + > void f10(T p); + } + + Basic_DisabledImprovements(G<@NotNull String> p) { } +} \ No newline at end of file diff --git a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic_DisabledImprovements.txt b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic_DisabledImprovements.txt new file mode 100644 index 00000000000..2ce1a78b2fb --- /dev/null +++ b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic_DisabledImprovements.txt @@ -0,0 +1,32 @@ +package test + +public open class Basic_DisabledImprovements { + public/*package*/ constructor Basic_DisabledImprovements(/*0*/ p: test.Basic_DisabledImprovements.G<@org.jetbrains.annotations.NotNull kotlin.String>!) + + public/*package*/ open class A { + public/*package*/ constructor A() + + public/*package*/ open inner class B { + public/*package*/ constructor B() + } + } + + public/*package*/ interface G : test.Basic_DisabledImprovements.G2<@org.jetbrains.annotations.NotNull T!, @org.jetbrains.annotations.NotNull kotlin.String!> { + } + + public/*package*/ interface G2 { + } + + public interface MyClass { + public abstract fun f1(/*0*/ p: test.Basic_DisabledImprovements.G<@org.jetbrains.annotations.NotNull kotlin.String>!): kotlin.Unit + public abstract fun !>!> f10(/*0*/ p: T!): kotlin.Unit + public abstract fun f2(): test.Basic_DisabledImprovements.G2<@org.jetbrains.annotations.Nullable kotlin.String?, @org.jetbrains.annotations.NotNull kotlin.Int>! + public abstract fun f3(/*0*/ @org.jetbrains.annotations.NotNull x: @org.jetbrains.annotations.NotNull T): kotlin.Unit + public abstract fun f4(/*0*/ p: test.Basic_DisabledImprovements.G<(@org.jetbrains.annotations.Nullable kotlin.Array<@org.jetbrains.annotations.NotNull kotlin.String!>..@org.jetbrains.annotations.Nullable kotlin.Array?)>!): kotlin.Unit + public abstract fun f5(/*0*/ p: test.Basic_DisabledImprovements.G<*>!): kotlin.Unit + public abstract fun f6(/*0*/ p: test.Basic_DisabledImprovements.G!): kotlin.Unit + public abstract fun f7(/*0*/ p: test.Basic_DisabledImprovements.G<@org.jetbrains.annotations.NotNull test.Basic_DisabledImprovements.A.B<*, *>>!): kotlin.Unit + public abstract fun f8(): test.Basic_DisabledImprovements.G!>! + public abstract fun f9(): test.Basic_DisabledImprovements.G<@org.jetbrains.annotations.Nullable test.Basic_DisabledImprovements.A.B<*, *>?>! + } +} diff --git a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ClassTypeParameterBounds.java b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ClassTypeParameterBounds.java index 1d6c9fadcec..481ba161f41 100644 --- a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ClassTypeParameterBounds.java +++ b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ClassTypeParameterBounds.java @@ -1,4 +1,5 @@ // JAVAC_EXPECTED_FILE +// !LANGUAGE: +ImprovementsAroundTypeEnhancement package test; diff --git a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodReceiver.java b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodReceiver.java index 2a43d23c233..891b7e09934 100644 --- a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodReceiver.java +++ b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodReceiver.java @@ -1,4 +1,5 @@ // JAVAC_EXPECTED_FILE +// !LANGUAGE: +ImprovementsAroundTypeEnhancement package test; diff --git a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodTypeParameterBounds.java b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodTypeParameterBounds.java index 16b4632069b..ecb6524dade 100644 --- a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodTypeParameterBounds.java +++ b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/MethodTypeParameterBounds.java @@ -1,4 +1,5 @@ // JAVAC_EXPECTED_FILE +// !LANGUAGE: +ImprovementsAroundTypeEnhancement package test; diff --git a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ReturnType.java b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ReturnType.java index bad8d817886..0ebea85fe4e 100644 --- a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ReturnType.java +++ b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ReturnType.java @@ -1,4 +1,5 @@ // JAVAC_EXPECTED_FILE +// !LANGUAGE: +ImprovementsAroundTypeEnhancement package test; diff --git a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ValueArguments.java b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ValueArguments.java index bcf47a05bc3..63335caaa14 100644 --- a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ValueArguments.java +++ b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ValueArguments.java @@ -1,4 +1,5 @@ // JAVAC_EXPECTED_FILE +// !LANGUAGE: +ImprovementsAroundTypeEnhancement package test; diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java b/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java index 3e7d9b8e59e..65efa2b6b6a 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java @@ -41,6 +41,7 @@ import java.io.IOException; import java.util.*; import java.util.regex.Pattern; +import static org.jetbrains.kotlin.checkers.CompilerTestLanguageVersionSettingsKt.parseLanguageVersionSettings; import static org.jetbrains.kotlin.jvm.compiler.LoadDescriptorUtil.*; import static org.jetbrains.kotlin.test.KotlinTestUtils.compileKotlinWithJava; import static org.jetbrains.kotlin.test.KotlinTestUtils.newConfiguration; @@ -85,7 +86,7 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { List javaSources = FileUtil.findFilesByMask(Pattern.compile(".+\\.java"), sourcesDir); Pair binaryPackageAndContext = compileJavaAndLoadTestPackageAndBindingContextFromBinary( - javaSources, tmpdir, ConfigurationKind.JDK_ONLY + javaSources, tmpdir, ConfigurationKind.JDK_ONLY, null ); checkJavaPackage(expectedFile, binaryPackageAndContext.first, binaryPackageAndContext.second, COMPARATOR_CONFIGURATION); @@ -175,7 +176,7 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { public static void updateConfigurationWithDirectives(String content, CompilerConfiguration configuration) { Directives directives = KotlinTestUtils.parseDirectives(content); - LanguageVersionSettings languageVersionSettings = CompilerTestLanguageVersionSettingsKt.parseLanguageVersionSettings(directives); + LanguageVersionSettings languageVersionSettings = parseLanguageVersionSettings(directives); if (languageVersionSettings == null) { languageVersionSettings = CompilerTestLanguageVersionSettingsKt.defaultLanguageVersionSettings(); } @@ -274,9 +275,12 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { assertTrue(testPackageDir.mkdir()); FileUtil.copy(originalJavaFile, new File(testPackageDir, originalJavaFile.getName())); + Directives directives = KotlinTestUtils.parseDirectives(FileUtil.loadFile(originalJavaFile)); + LanguageVersionSettings languageVersionSettings = parseLanguageVersionSettings(directives); + Pair javaPackageAndContext = loadTestPackageAndBindingContextFromJavaRoot( tmpdir, getTestRootDisposable(), getJdkKind(), ConfigurationKind.JDK_ONLY, false, - false, useJavacWrapper(), withForeignAnnotations(), null); + false, useJavacWrapper(), withForeignAnnotations(), languageVersionSettings); checkJavaPackage( expectedFile, javaPackageAndContext.first, javaPackageAndContext.second, @@ -289,9 +293,10 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { File compiledDir = new File(tmpdir, "compiled"); assertTrue(srcDir.mkdir()); assertTrue(compiledDir.mkdir()); + String fileContent = FileUtil.loadFile(new File(javaFileName)); List srcFiles = TestFiles.createTestFiles( - new File(javaFileName).getName(), FileUtil.loadFile(new File(javaFileName), true), + new File(javaFileName).getName(), fileContent, new TestFiles.TestFileFactoryNoModules() { @NotNull @Override @@ -307,8 +312,11 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { } }); + Directives directives = KotlinTestUtils.parseDirectives(fileContent); + LanguageVersionSettings languageVersionSettings = parseLanguageVersionSettings(directives); + Pair javaPackageAndContext = compileJavaAndLoadTestPackageAndBindingContextFromBinary( - srcFiles, compiledDir, ConfigurationKind.ALL + srcFiles, compiledDir, ConfigurationKind.ALL, languageVersionSettings ); @@ -329,11 +337,12 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { private Pair compileJavaAndLoadTestPackageAndBindingContextFromBinary( @NotNull Collection javaFiles, @NotNull File outDir, - @NotNull ConfigurationKind configurationKind + @NotNull ConfigurationKind configurationKind, + @Nullable LanguageVersionSettings explicitLanguageVersionSettings ) throws IOException { compileJavaWithAnnotationsJar(javaFiles, outDir, getAdditionalJavacArgs(), getJdkHomeForJavac(), withForeignAnnotations()); return loadTestPackageAndBindingContextFromJavaRoot(outDir, getTestRootDisposable(), getJdkKind(), configurationKind, true, - usePsiClassFilesReading(), useJavacWrapper(), withForeignAnnotations(), null, + usePsiClassFilesReading(), useJavacWrapper(), withForeignAnnotations(), explicitLanguageVersionSettings, getExtraClasspath(), this::configureEnvironment); } diff --git a/compiler/util/src/org/jetbrains/kotlin/config/LanguageVersionSettings.kt b/compiler/util/src/org/jetbrains/kotlin/config/LanguageVersionSettings.kt index 6c594382d31..c58faa1f7aa 100644 --- a/compiler/util/src/org/jetbrains/kotlin/config/LanguageVersionSettings.kt +++ b/compiler/util/src/org/jetbrains/kotlin/config/LanguageVersionSettings.kt @@ -145,6 +145,20 @@ enum class LanguageFeature( AllowSealedInheritorsInDifferentFilesOfSamePackage(KOTLIN_1_5), SealedInterfaces(KOTLIN_1_5), + /* + * Improvements include the following: + * - taking into account for type enhancement freshly supported type use annotations: KT-11454 + * - use annotations in the type parameter position to enhance corresponding types: KT-11454 + * - proper support of the type enhancement of the annotated java arrays: KT-24392 + * - proper support of the type enhancement of the annotated java varargs' elements: KT-18768 + * - type enhancement based on annotated bounds of type parameters + * - type enhancement within type arguments of the base classes and interfaces + * - support type enhancement based on type use annotations on java fields + * - preference of a type use annotation to annotation of another type: KT-24392 + * (if @NotNull has TYPE_USE and METHOD target, then `@NotNull Integer []` -> `Array..Array?` instead of `Array..Array`) + */ + ImprovementsAroundTypeEnhancement(KOTLIN_1_6), + // Temporarily disabled, see KT-27084/KT-22379 SoundSmartcastFromLoopConditionForLoopAssignedVariables(sinceVersion = null, kind = BUG_FIX), @@ -162,6 +176,7 @@ enum class LanguageFeature( MultiPlatformProjects(sinceVersion = null, defaultState = State.DISABLED), NewInference(sinceVersion = KOTLIN_1_4), + // In the next block, features can be enabled only along with new inference SamConversionForKotlinFunctions(sinceVersion = KOTLIN_1_4), SamConversionPerArgument(sinceVersion = KOTLIN_1_4), @@ -263,6 +278,7 @@ enum class LanguageVersion(val major: Int, val minor: Int) : DescriptionAware { KOTLIN_1_3(1, 3), KOTLIN_1_4(1, 4), KOTLIN_1_5(1, 5), + KOTLIN_1_6(1, 6), ; val isStable: Boolean diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/LazyJavaAnnotations.kt b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/LazyJavaAnnotations.kt index 5cb7ed23fbc..08a740606b8 100644 --- a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/LazyJavaAnnotations.kt +++ b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/LazyJavaAnnotations.kt @@ -25,10 +25,11 @@ import org.jetbrains.kotlin.name.FqName class LazyJavaAnnotations( private val c: LazyJavaResolverContext, - private val annotationOwner: JavaAnnotationOwner + private val annotationOwner: JavaAnnotationOwner, + private val areAnnotationsFreshlySupported: Boolean = false ) : Annotations { private val annotationDescriptors = c.components.storageManager.createMemoizedFunctionWithNullableValues { annotation: JavaAnnotation -> - JavaAnnotationMapper.mapOrResolveJavaAnnotation(annotation, c) + JavaAnnotationMapper.mapOrResolveJavaAnnotation(annotation, c, areAnnotationsFreshlySupported) } override fun findAnnotation(fqName: FqName) = diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/context.kt b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/context.kt index 69a032b4c6a..2b9cac7f802 100644 --- a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/context.kt +++ b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/context.kt @@ -31,8 +31,6 @@ import org.jetbrains.kotlin.load.java.components.SignaturePropagator import org.jetbrains.kotlin.load.java.lazy.types.JavaTypeResolver import org.jetbrains.kotlin.load.java.sources.JavaSourceElementFactory import org.jetbrains.kotlin.load.java.structure.JavaTypeParameterListOwner -import org.jetbrains.kotlin.load.java.typeEnhancement.NullabilityQualifier -import org.jetbrains.kotlin.load.java.typeEnhancement.NullabilityQualifierWithMigrationStatus import org.jetbrains.kotlin.load.java.typeEnhancement.SignatureEnhancement import org.jetbrains.kotlin.load.kotlin.DeserializedDescriptorResolver import org.jetbrains.kotlin.load.kotlin.KotlinClassFinder @@ -42,7 +40,6 @@ import org.jetbrains.kotlin.serialization.deserialization.ErrorReporter import org.jetbrains.kotlin.storage.StorageManager import org.jetbrains.kotlin.types.checker.NewKotlinTypeChecker import org.jetbrains.kotlin.utils.JavaTypeEnhancementState -import java.util.* class JavaResolverComponents( val storageManager: StorageManager, @@ -84,6 +81,7 @@ class JavaResolverComponents( interface JavaResolverSettings { val isReleaseCoroutines: Boolean val correctNullabilityForNotNullTypeParameter: Boolean + val enhancementImprovements: Boolean object Default : JavaResolverSettings { override val isReleaseCoroutines: Boolean @@ -91,16 +89,21 @@ interface JavaResolverSettings { override val correctNullabilityForNotNullTypeParameter: Boolean get() = false + + override val enhancementImprovements: Boolean + get() = false } companion object { fun create( isReleaseCoroutines: Boolean, - correctNullabilityForNotNullTypeParameter: Boolean + correctNullabilityForNotNullTypeParameter: Boolean, + enhancementImprovements: Boolean, ): JavaResolverSettings = object : JavaResolverSettings { override val isReleaseCoroutines get() = isReleaseCoroutines override val correctNullabilityForNotNullTypeParameter get() = correctNullabilityForNotNullTypeParameter + override val enhancementImprovements get() = enhancementImprovements } } } @@ -172,9 +175,11 @@ private fun LazyJavaResolverContext.extractDefaultNullabilityQualifier( return null } + val areImprovementsEnabled = components.settings.typeEnhancementImprovements + val nullabilityQualifier = - components.signatureEnhancement.extractNullability(typeQualifier)?.copy(isForWarningOnly = jsr305State.isWarning) - ?: return null + components.signatureEnhancement.extractNullability(typeQualifier, areImprovementsEnabled, typeParameterBounds = false) + ?.copy(isForWarningOnly = jsr305State.isWarning) ?: return null return JavaDefaultQualifiers(nullabilityQualifier, applicability) } diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassDescriptor.kt b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassDescriptor.kt index 9658d39233b..2b69d658fcb 100644 --- a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassDescriptor.kt +++ b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassDescriptor.kt @@ -208,7 +208,11 @@ class LazyJavaClassDescriptor( for (javaType in javaTypes) { val kotlinType = c.typeResolver.transformJavaType(javaType, TypeUsage.SUPERTYPE.toAttributes()) - val enhancedKotlinType = c.components.signatureEnhancement.enhanceSuperType(kotlinType, c) + val areImprovementsEnabled = c.components.settings.typeEnhancementImprovements + val enhancedKotlinType = if (areImprovementsEnabled) { + c.components.signatureEnhancement.enhanceSuperType(kotlinType, c) + } else kotlinType + if (enhancedKotlinType.constructor.declarationDescriptor is NotFoundClasses.MockClassDescriptor) { incomplete.add(javaType) } diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/types/JavaTypeResolver.kt b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/types/JavaTypeResolver.kt index 2bdc2baecda..d7c2e039958 100644 --- a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/types/JavaTypeResolver.kt +++ b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/types/JavaTypeResolver.kt @@ -62,7 +62,7 @@ class JavaTypeResolver( fun transformArrayType(arrayType: JavaArrayType, attr: JavaTypeAttributes, isVararg: Boolean = false): KotlinType { val javaComponentType = arrayType.componentType val primitiveType = (javaComponentType as? JavaPrimitiveType)?.type - val annotations = LazyJavaAnnotations(c, arrayType) + val annotations = LazyJavaAnnotations(c, arrayType, areAnnotationsFreshlySupported = true) if (primitiveType != null) { val jetType = c.module.builtIns.getPrimitiveArrayKotlinType(primitiveType) diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/signatureEnhancement.kt b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/signatureEnhancement.kt index 908c98444fc..06b40889420 100644 --- a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/signatureEnhancement.kt +++ b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/signatureEnhancement.kt @@ -27,6 +27,7 @@ import org.jetbrains.kotlin.load.java.* import org.jetbrains.kotlin.load.java.descriptors.* import org.jetbrains.kotlin.load.java.lazy.LazyJavaResolverContext import org.jetbrains.kotlin.load.java.lazy.copyWithNewDefaultTypeQualifiers +import org.jetbrains.kotlin.load.java.lazy.descriptors.LazyJavaAnnotationDescriptor import org.jetbrains.kotlin.load.java.lazy.descriptors.LazyJavaTypeParameterDescriptor import org.jetbrains.kotlin.load.java.lazy.descriptors.isJavaField import org.jetbrains.kotlin.load.kotlin.SignatureBuildingComponents @@ -52,21 +53,25 @@ class SignatureEnhancement( private val typeEnhancement: JavaTypeEnhancement ) { - private fun AnnotationDescriptor.extractNullabilityTypeFromArgument(): NullabilityQualifierWithMigrationStatus? { + private fun AnnotationDescriptor.extractNullabilityTypeFromArgument(isForWarningOnly: Boolean): NullabilityQualifierWithMigrationStatus? { val enumValue = firstArgument() as? EnumValue // if no argument is specified, use default value: NOT_NULL - ?: return NullabilityQualifierWithMigrationStatus(NullabilityQualifier.NOT_NULL) + ?: return NullabilityQualifierWithMigrationStatus(NullabilityQualifier.NOT_NULL, isForWarningOnly) return when (enumValue.enumEntryName.asString()) { - "ALWAYS" -> NullabilityQualifierWithMigrationStatus(NullabilityQualifier.NOT_NULL) - "MAYBE", "NEVER" -> NullabilityQualifierWithMigrationStatus(NullabilityQualifier.NULLABLE) - "UNKNOWN" -> NullabilityQualifierWithMigrationStatus(NullabilityQualifier.FORCE_FLEXIBILITY) + "ALWAYS" -> NullabilityQualifierWithMigrationStatus(NullabilityQualifier.NOT_NULL, isForWarningOnly) + "MAYBE", "NEVER" -> NullabilityQualifierWithMigrationStatus(NullabilityQualifier.NULLABLE, isForWarningOnly) + "UNKNOWN" -> NullabilityQualifierWithMigrationStatus(NullabilityQualifier.FORCE_FLEXIBILITY, isForWarningOnly) else -> null } } - fun extractNullability(annotationDescriptor: AnnotationDescriptor): NullabilityQualifierWithMigrationStatus? { - extractNullabilityFromKnownAnnotations(annotationDescriptor)?.let { return it } + fun extractNullability( + annotationDescriptor: AnnotationDescriptor, + areImprovementsEnabled: Boolean, + typeParameterBounds: Boolean + ): NullabilityQualifierWithMigrationStatus? { + extractNullabilityFromKnownAnnotations(annotationDescriptor, areImprovementsEnabled, typeParameterBounds)?.let { return it } val typeQualifierAnnotation = annotationTypeQualifierResolver.resolveTypeQualifierAnnotation(annotationDescriptor) @@ -75,18 +80,23 @@ class SignatureEnhancement( val jsr305State = annotationTypeQualifierResolver.resolveJsr305AnnotationState(annotationDescriptor) if (jsr305State.isIgnore) return null - return extractNullabilityFromKnownAnnotations(typeQualifierAnnotation)?.copy(isForWarningOnly = jsr305State.isWarning) + return extractNullabilityFromKnownAnnotations(typeQualifierAnnotation, areImprovementsEnabled, typeParameterBounds) + ?.copy(isForWarningOnly = jsr305State.isWarning) } private fun extractNullabilityFromKnownAnnotations( - annotationDescriptor: AnnotationDescriptor + annotationDescriptor: AnnotationDescriptor, + areImprovementsEnabled: Boolean, + typeParameterBounds: Boolean ): NullabilityQualifierWithMigrationStatus? { val annotationFqName = annotationDescriptor.fqName ?: return null + val isForWarningOnly = annotationDescriptor is LazyJavaAnnotationDescriptor + && (annotationDescriptor.isFreshlySupportedTypeUseAnnotation || typeParameterBounds) + && !areImprovementsEnabled - val migrationStatus = - jspecifyMigrationStatus(annotationFqName) - ?: commonMigrationStatus(annotationFqName, annotationDescriptor) - ?: return null + val migrationStatus = jspecifyMigrationStatus(annotationFqName) + ?: commonMigrationStatus(annotationFqName, annotationDescriptor, isForWarningOnly) + ?: return null return if (!migrationStatus.isForWarningOnly && annotationDescriptor is PossiblyExternalAnnotationDescriptor @@ -111,17 +121,18 @@ class SignatureEnhancement( private fun commonMigrationStatus( annotationFqName: FqName, - annotationDescriptor: AnnotationDescriptor + annotationDescriptor: AnnotationDescriptor, + isForWarningOnly: Boolean = false ): NullabilityQualifierWithMigrationStatus? = when { - annotationFqName in NULLABLE_ANNOTATIONS -> NullabilityQualifierWithMigrationStatus(NullabilityQualifier.NULLABLE) - annotationFqName in NOT_NULL_ANNOTATIONS -> NullabilityQualifierWithMigrationStatus(NullabilityQualifier.NOT_NULL) - annotationFqName == JAVAX_NONNULL_ANNOTATION -> annotationDescriptor.extractNullabilityTypeFromArgument() + annotationFqName in NULLABLE_ANNOTATIONS -> NullabilityQualifierWithMigrationStatus(NullabilityQualifier.NULLABLE, isForWarningOnly) + annotationFqName in NOT_NULL_ANNOTATIONS -> NullabilityQualifierWithMigrationStatus(NullabilityQualifier.NOT_NULL, isForWarningOnly) + annotationFqName == JAVAX_NONNULL_ANNOTATION -> annotationDescriptor.extractNullabilityTypeFromArgument(isForWarningOnly) annotationFqName == COMPATQUAL_NULLABLE_ANNOTATION && javaTypeEnhancementState.enableCompatqualCheckerFrameworkAnnotations -> - NullabilityQualifierWithMigrationStatus(NullabilityQualifier.NULLABLE) + NullabilityQualifierWithMigrationStatus(NullabilityQualifier.NULLABLE, isForWarningOnly) annotationFqName == COMPATQUAL_NONNULL_ANNOTATION && javaTypeEnhancementState.enableCompatqualCheckerFrameworkAnnotations -> - NullabilityQualifierWithMigrationStatus(NullabilityQualifier.NOT_NULL) + NullabilityQualifierWithMigrationStatus(NullabilityQualifier.NOT_NULL, isForWarningOnly) annotationFqName == ANDROIDX_RECENTLY_NON_NULL_ANNOTATION -> NullabilityQualifierWithMigrationStatus( NullabilityQualifier.NOT_NULL, @@ -326,10 +337,10 @@ class SignatureEnhancement( typeParameterForArgument: TypeParameterDescriptor?, isFromStarProjection: Boolean ): JavaTypeQualifiers { + val areImprovementsEnabled = containerContext.components.settings.typeEnhancementImprovements + val composedAnnotation = - if (isHeadTypeConstructor && typeContainer is TypeParameterDescriptor) { - composeAnnotations(typeContainer.annotations, annotations) - } else if (isHeadTypeConstructor && typeContainer != null) { + if (isHeadTypeConstructor && typeContainer != null && typeContainer !is TypeParameterDescriptor && areImprovementsEnabled) { val filteredContainerAnnotations = typeContainer.annotations.filter { val (_, targets) = annotationTypeQualifierResolver.resolveAnnotation(it) ?: return@filter false /* @@ -343,6 +354,8 @@ class SignatureEnhancement( AnnotationQualifierApplicabilityType.TYPE_USE !in targets } composeAnnotations(Annotations.create(filteredContainerAnnotations), annotations) + } else if (isHeadTypeConstructor && typeContainer != null) { + composeAnnotations(typeContainer.annotations, annotations) } else annotations fun List.ifPresent(qualifier: T) = @@ -361,7 +374,8 @@ class SignatureEnhancement( val (nullabilityFromBoundsForTypeBasedOnTypeParameter, isTypeParameterWithNotNullableBounds) = nullabilityInfoBoundsForTypeParameterUsage() - val annotationsNullability = composedAnnotation.extractNullability()?.takeUnless { isFromStarProjection } + val annotationsNullability = composedAnnotation.extractNullability(areImprovementsEnabled, typeParameterBounds) + ?.takeUnless { isFromStarProjection } val nullabilityInfo = annotationsNullability ?: computeNullabilityInfoInTheAbsenceOfExplicitAnnotation( @@ -452,8 +466,11 @@ class SignatureEnhancement( } } - private fun Annotations.extractNullability(): NullabilityQualifierWithMigrationStatus? = - this.firstNotNullResult { extractNullability(it) } + private fun Annotations.extractNullability( + areImprovementsEnabled: Boolean, + typeParameterBounds: Boolean + ): NullabilityQualifierWithMigrationStatus? = + this.firstNotNullResult { extractNullability(it, areImprovementsEnabled, typeParameterBounds) } private fun computeIndexedQualifiersForOverride(): (Int) -> JavaTypeQualifiers { From 71ca18e937baef552fe03761b6b6ea41069d78e1 Mon Sep 17 00:00:00 2001 From: Victor Petukhov Date: Fri, 11 Dec 2020 17:25:16 +0300 Subject: [PATCH 165/196] Support diagnostic tests with Kotlin against compiled Java --- ...gnAnnotationsCompiledJavaDiagnosticTest.kt | 43 +++++++++++++++++++ .../AbstractJspecifyAnnotationsTest.kt | 4 +- .../kotlin/checkers/BaseDiagnosticsTest.kt | 7 ++- .../checkers/KotlinMultiFileTestWithJava.kt | 19 +++++--- .../generators/tests/GenerateJava8Tests.kt | 9 ++-- 5 files changed, 68 insertions(+), 14 deletions(-) create mode 100644 compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractForeignAnnotationsCompiledJavaDiagnosticTest.kt diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractForeignAnnotationsCompiledJavaDiagnosticTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractForeignAnnotationsCompiledJavaDiagnosticTest.kt new file mode 100644 index 00000000000..2f06585782b --- /dev/null +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractForeignAnnotationsCompiledJavaDiagnosticTest.kt @@ -0,0 +1,43 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.checkers + +import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.MockLibraryUtil.compileJavaFilesLibraryToJar +import java.io.File +import kotlin.io.path.ExperimentalPathApi +import kotlin.io.path.createTempDirectory + +abstract class AbstractForeignAnnotationsCompiledJavaDiagnosticTest : AbstractDiagnosticsTest() { + @OptIn(ExperimentalPathApi::class) + override fun doMultiFileTest( + wholeFile: File, + files: List + ) { + val ktFiles = files.filter { !it.name.endsWith(".java") } + + val dir = createTempDirectory() + val javaFile = File("${wholeFile.parentFile.path}/${wholeFile.nameWithoutExtension}.java") + + File("$dir/${wholeFile.nameWithoutExtension}.java").apply { createNewFile() }.writeText(javaFile.readText()) + File(FOREIGN_JDK8_ANNOTATIONS_SOURCES_PATH).copyRecursively(File("$dir/annotations/")) + + super.doMultiFileTest( + wholeFile, + ktFiles, + compileJavaFilesLibraryToJar(dir.toString(), "foreign-annotations"), + usePsiClassFilesReading = false, + excludeNonTypeUseJetbrainsAnnotations = true + ) + } + + override fun doTest(filePath: String) { + val file = File(filePath) + val expectedText = KotlinTestUtils.doLoadFile(file) + + doMultiFileTest(file, createTestFilesFromFile(file, expectedText)) + } +} diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractJspecifyAnnotationsTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractJspecifyAnnotationsTest.kt index 7978bd93e43..f4e9707b930 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractJspecifyAnnotationsTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractJspecifyAnnotationsTest.kt @@ -27,7 +27,9 @@ abstract class AbstractJspecifyAnnotationsTest : AbstractDiagnosticsTest() { super.doMultiFileTest( wholeFile, files, - MockLibraryUtil.compileJavaFilesLibraryToJar(FOREIGN_JDK8_ANNOTATIONS_SOURCES_PATH, "foreign-annotations") + MockLibraryUtil.compileJavaFilesLibraryToJar(FOREIGN_JDK8_ANNOTATIONS_SOURCES_PATH, "foreign-annotations"), + usePsiClassFilesReading = false, + excludeNonTypeUseJetbrainsAnnotations = true ) } diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/BaseDiagnosticsTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/BaseDiagnosticsTest.kt index 5cd4b9a80c9..df464dec6f1 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/BaseDiagnosticsTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/BaseDiagnosticsTest.kt @@ -86,9 +86,12 @@ abstract class BaseDiagnosticsTest : KotlinMultiFileTestWithJava, - additionalClasspath: File? = null + additionalClasspath: File? = null, + usePsiClassFilesReading: Boolean = true, + excludeNonTypeUseJetbrainsAnnotations: Boolean = false ) { - environment = createEnvironment(wholeFile, files, additionalClasspath) + environment = + createEnvironment(wholeFile, files, additionalClasspath, usePsiClassFilesReading, excludeNonTypeUseJetbrainsAnnotations) //after environment initialization cause of `tearDown` logic, maybe it's obsolete if (shouldSkipTest(wholeFile, files)) { println("${wholeFile.name} test is skipped") diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/KotlinMultiFileTestWithJava.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/KotlinMultiFileTestWithJava.kt index 83f9942cde0..8f239d5fc43 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/KotlinMultiFileTestWithJava.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/KotlinMultiFileTestWithJava.kt @@ -46,13 +46,16 @@ abstract class KotlinMultiFileTestWithJava, - additionalClasspath: File? = null + additionalClasspath: File? = null, + usePsiClassFilesReading: Boolean = true, + excludeNonTypeUseJetbrainsAnnotations: Boolean = false ): KotlinCoreEnvironment { + val defaultClasspath = getClasspath(file, excludeNonTypeUseJetbrainsAnnotations) val configuration = createConfiguration( extractConfigurationKind(files), getTestJdkKind(files), backend, - if (additionalClasspath == null) getClasspath(file) else getClasspath(file) + additionalClasspath, + if (additionalClasspath == null) defaultClasspath else defaultClasspath + additionalClasspath, if (isJavaSourceRootNeeded()) listOf(javaFilesDir) else emptyList(), files ) @@ -63,9 +66,9 @@ abstract class KotlinMultiFileTestWithJava { + private fun getClasspath(file: File, excludeNonTypeUseJetbrainsAnnotations: Boolean): List { val result: MutableList = ArrayList() - result.add(KtTestUtil.getAnnotationsJar()) + if (!excludeNonTypeUseJetbrainsAnnotations) { + result.add(KtTestUtil.getAnnotationsJar()) + } result.addAll(getExtraClasspath()) val fileText = file.readText(Charsets.UTF_8) if (InTextDirectivesUtils.isDirectiveDefined(fileText, "ANDROID_ANNOTATIONS")) { @@ -129,7 +134,7 @@ abstract class KotlinMultiFileTestWithJava) { model("foreignAnnotationsJava8/tests/jspecify/kotlin") } + testClass { + model("foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava") + } + testClass { model("loadJava8/compiledJava", extension = "java", testMethod = "doTestCompiledJava") model("loadJava8/sourceJava", extension = "java", testMethod = "doTestSourceJava") From 9693ea19fb0cde04164cb3882960780d62b83737 Mon Sep 17 00:00:00 2001 From: Victor Petukhov Date: Wed, 9 Dec 2020 15:37:22 +0300 Subject: [PATCH 166/196] Add tests for type enhancement uncluding with compiled java --- .../kotlin/frontend/java/di/injection.kt | 2 +- .../structure/impl/classFiles/Annotations.kt | 45 ++++++++------ .../impl/classFiles/BinaryJavaClass.kt | 3 +- .../classFiles/ClassifierResolutionContext.kt | 10 ++-- .../ClassTypeParameterBound.java | 6 ++ .../ClassTypeParameterBound.kt | 14 +++++ .../ClassTypeParameterBoundWithWarnings.java | 6 ++ .../ClassTypeParameterBoundWithWarnings.kt | 15 +++++ .../ReturnType.java | 13 ++++ .../ReturnType.kt | 48 +++++++++++++++ .../ReturnTypeWithWarnings.java | 13 ++++ .../ReturnTypeWithWarnings.kt | 48 +++++++++++++++ .../ValueParameter.java | 13 ++++ .../ValueParameter.kt | 45 ++++++++++++++ .../ValueParameterWithWarnings.java | 13 ++++ .../ValueParameterWithWarnings.kt | 45 ++++++++++++++ .../Basic_DisabledImprovements.txt | 14 +++++ .../typeUseAnnotations/Basic.java | 13 ++-- .../compiledJava/typeUseAnnotations/Basic.txt | 11 ++-- .../Basic_DisabledImprovements.java | 2 +- .../Basic_DisabledImprovements.txt | 14 +++++ .../sourceJava/typeUseAnnotations/Basic.java | 13 ++-- .../sourceJava/typeUseAnnotations/Basic.txt | 9 +-- .../Basic_DisabledImprovements.txt | 2 +- ...nsCompiledJavaDiagnosticTestGenerated.java | 60 +++++++++++++++++++ ...sNoAnnotationInClasspathTestGenerated.java | 43 +++++++++++++ ...spathWithPsiClassReadingTestGenerated.java | 43 +++++++++++++ .../ForeignJava8AnnotationsTestGenerated.java | 43 +++++++++++++ ...cForeignJava8AnnotationsTestGenerated.java | 43 +++++++++++++ .../jvm/compiler/LoadJava8TestGenerated.java | 20 +++++++ .../cli/jvm/KotlinCliJavaFileManagerTest.kt | 10 ++-- .../kotlin/load/java/lazy/context.kt | 8 +-- ...8RuntimeDescriptorLoaderTestGenerated.java | 10 ++++ 33 files changed, 639 insertions(+), 58 deletions(-) create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ClassTypeParameterBound.java create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ClassTypeParameterBound.kt create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ClassTypeParameterBoundWithWarnings.java create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ClassTypeParameterBoundWithWarnings.kt create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ReturnType.java create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ReturnType.kt create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ReturnTypeWithWarnings.java create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ReturnTypeWithWarnings.kt create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ValueParameter.java create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ValueParameter.kt create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ValueParameterWithWarnings.java create mode 100644 compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ValueParameterWithWarnings.kt create mode 100644 compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic_DisabledImprovements.txt create mode 100644 compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic_DisabledImprovements.txt create mode 100644 compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignAnnotationsCompiledJavaDiagnosticTestGenerated.java diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt index 097ed4e5f1d..8c45cf0a20c 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt @@ -137,7 +137,7 @@ fun StorageComponentContainer.configureJavaSpecificComponents( JavaResolverSettings.create( isReleaseCoroutines = languageVersionSettings.supportsFeature(LanguageFeature.ReleaseCoroutines), correctNullabilityForNotNullTypeParameter = languageVersionSettings.supportsFeature(LanguageFeature.ProhibitUsingNullableTypeParameterAgainstNotNullAnnotated), - enhancementImprovements = languageVersionSettings.supportsFeature(LanguageFeature.ImprovementsAroundTypeEnhancement), + typeEnhancementImprovements = languageVersionSettings.supportsFeature(LanguageFeature.ImprovementsAroundTypeEnhancement) ) ) diff --git a/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/Annotations.kt b/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/Annotations.kt index 119d42ab717..b474fa1e2bf 100644 --- a/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/Annotations.kt +++ b/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/Annotations.kt @@ -18,6 +18,7 @@ package org.jetbrains.kotlin.load.java.structure.impl.classFiles import org.jetbrains.kotlin.load.java.structure.* import org.jetbrains.kotlin.load.java.structure.impl.classFiles.BinaryJavaAnnotation.Companion.computeTargetType +import org.jetbrains.kotlin.load.java.structure.impl.classFiles.BinaryJavaAnnotation.Companion.translatePath import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name @@ -33,7 +34,9 @@ internal class AnnotationsCollectorFieldVisitor( override fun visitAnnotation(desc: String, visible: Boolean) = BinaryJavaAnnotation.addAnnotation(field, desc, context, signatureParser) - override fun visitTypeAnnotation(typeRef: Int, typePath: TypePath?, desc: String, visible: Boolean): AnnotationVisitor? { + override fun visitTypeAnnotation(typeRef: Int, typePath: TypePath?, descriptor: String?, visible: Boolean): AnnotationVisitor? { + if (descriptor == null) return null + val typeReference = TypeReference(typeRef) if (typePath != null) { @@ -42,13 +45,13 @@ internal class AnnotationsCollectorFieldVisitor( when (typeReference.sort) { TypeReference.FIELD -> { val targetType = computeTargetType(field.type, translatedPath) - return BinaryJavaAnnotation.addAnnotation(targetType as JavaPlainType, desc, context, signatureParser) + return BinaryJavaAnnotation.addAnnotation(targetType as JavaPlainType, descriptor, context, signatureParser, true) } } } return when (typeReference.sort) { - TypeReference.FIELD -> BinaryJavaAnnotation.addAnnotation(field.type as JavaPlainType, desc, context, signatureParser) + TypeReference.FIELD -> BinaryJavaAnnotation.addAnnotation(field.type as JavaPlainType, descriptor, context, signatureParser, true) else -> null } } @@ -119,19 +122,23 @@ internal class AnnotationsAndParameterCollectorMethodVisitor( } ?: return null return BinaryJavaAnnotation.addAnnotation( - computeTargetType(baseType, translatePath(typePath)) as JavaPlainType, desc, context, signatureParser + computeTargetType(baseType, translatePath(typePath)) as JavaPlainType, desc, context, signatureParser, true ) } - val targetType = when (typeReference.sort) { - TypeReference.METHOD_RETURN -> (member as? BinaryJavaMethod)?.returnType as JavaPlainType - TypeReference.METHOD_TYPE_PARAMETER -> member.typeParameters[typeReference.typeParameterIndex] as BinaryJavaTypeParameter - TypeReference.METHOD_FORMAL_PARAMETER -> member.valueParameters[typeReference.formalParameterIndex].type as JavaPlainType - TypeReference.METHOD_TYPE_PARAMETER_BOUND -> BinaryJavaAnnotation.computeTypeParameterBound(member.typeParameters, typeReference) as JavaPlainType - else -> null - } ?: return null + val (targetType, isFreshlySupportedAnnotation) = when (typeReference.sort) { + TypeReference.METHOD_RETURN -> + (member as? BinaryJavaMethod)?.returnType as JavaPlainType to false + TypeReference.METHOD_TYPE_PARAMETER -> + member.typeParameters[typeReference.typeParameterIndex] as BinaryJavaTypeParameter to true + TypeReference.METHOD_FORMAL_PARAMETER -> + member.valueParameters[typeReference.formalParameterIndex].type as JavaPlainType to false + TypeReference.METHOD_TYPE_PARAMETER_BOUND -> + BinaryJavaAnnotation.computeTypeParameterBound(member.typeParameters, typeReference) as JavaPlainType to true + else -> return null + } - return BinaryJavaAnnotation.addAnnotation(targetType, desc, context, signatureParser) + return BinaryJavaAnnotation.addAnnotation(targetType, desc, context, signatureParser, isFreshlySupportedAnnotation) } enum class PathElementType { ARRAY_ELEMENT, WILDCARD_BOUND, ENCLOSING_CLASS, TYPE_ARGUMENT } @@ -140,7 +147,8 @@ internal class AnnotationsAndParameterCollectorMethodVisitor( class BinaryJavaAnnotation private constructor( desc: String, private val context: ClassifierResolutionContext, - override val arguments: Collection + override val arguments: Collection, + override val isFreshlySupportedTypeUseAnnotation: Boolean ) : JavaAnnotation { companion object { @@ -148,10 +156,11 @@ class BinaryJavaAnnotation private constructor( fun createAnnotationAndVisitor( desc: String, context: ClassifierResolutionContext, - signatureParser: BinaryClassSignatureParser + signatureParser: BinaryClassSignatureParser, + isFreshlySupportedTypeUseAnnotation: Boolean = false ): Pair { val arguments = mutableListOf() - val annotation = BinaryJavaAnnotation(desc, context, arguments) + val annotation = BinaryJavaAnnotation(desc, context, arguments, isFreshlySupportedTypeUseAnnotation) return annotation to BinaryJavaAnnotationVisitor(context, signatureParser, arguments) } @@ -160,9 +169,11 @@ class BinaryJavaAnnotation private constructor( annotationOwner: MutableJavaAnnotationOwner, desc: String, context: ClassifierResolutionContext, - signatureParser: BinaryClassSignatureParser + signatureParser: BinaryClassSignatureParser, + isFreshlySupportedAnnotation: Boolean = false ): AnnotationVisitor { - val (javaAnnotation, annotationVisitor) = createAnnotationAndVisitor(desc, context, signatureParser) + val (javaAnnotation, annotationVisitor) = + createAnnotationAndVisitor(desc, context, signatureParser, isFreshlySupportedAnnotation) annotationOwner.annotations.add(javaAnnotation) return annotationVisitor } diff --git a/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/BinaryJavaClass.kt b/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/BinaryJavaClass.kt index 9872e5c5d00..35b9f415a26 100644 --- a/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/BinaryJavaClass.kt +++ b/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/BinaryJavaClass.kt @@ -83,10 +83,11 @@ class BinaryJavaClass( override fun isFromSourceCodeInScope(scope: SearchScope): Boolean = false override fun visitTypeAnnotation(typeRef: Int, typePath: TypePath?, descriptor: String?, visible: Boolean): AnnotationVisitor? { - val typeReference = TypeReference(typeRef) if (descriptor == null) return null + val typeReference = TypeReference(typeRef) + if (typePath != null) { val translatedPath = BinaryJavaAnnotation.translatePath(typePath) diff --git a/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/ClassifierResolutionContext.kt b/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/ClassifierResolutionContext.kt index 67f3593021c..681d135f2bf 100644 --- a/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/ClassifierResolutionContext.kt +++ b/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/ClassifierResolutionContext.kt @@ -50,11 +50,9 @@ class ClassifierResolutionContext private constructor( internal fun addTypeParameters(newTypeParameters: Collection) { if (newTypeParameters.isEmpty()) return - typeParameters = - newTypeParameters - .fold(typeParameters) { acc, typeParameter -> - acc.put(typeParameter.name.identifier, typeParameter) - } + typeParameters = newTypeParameters.fold(typeParameters) { acc, typeParameter -> + acc.put(typeParameter.name.identifier, typeParameter) + } } private fun resolveClass(classId: ClassId) = Result(classesByQName(classId), classId.asSingleFqName().asString()) @@ -77,7 +75,7 @@ class ClassifierResolutionContext private constructor( // See com.intellij.psi.impl.compiled.StubBuildingVisitor.GUESSING_MAPPER private fun convertNestedClassInternalNameWithSimpleHeuristic(internalName: String): ClassId? { val splitPoints = SmartList() - for (p in 0 until internalName.length) { + for (p in internalName.indices) { val c = internalName[p] if (c == '$' && p > 0 && internalName[p - 1] != '/' && p < internalName.length - 1 && internalName[p + 1] != '$') { splitPoints.add(p) diff --git a/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ClassTypeParameterBound.java b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ClassTypeParameterBound.java new file mode 100644 index 00000000000..5269a0556e3 --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ClassTypeParameterBound.java @@ -0,0 +1,6 @@ +import org.jetbrains.annotations.NotNull; + +public class ClassTypeParameterBound { + ClassTypeParameterBound(T x) { } + ClassTypeParameterBound() { } +} diff --git a/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ClassTypeParameterBound.kt b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ClassTypeParameterBound.kt new file mode 100644 index 00000000000..424a5f7730c --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ClassTypeParameterBound.kt @@ -0,0 +1,14 @@ +// !LANGUAGE: +ImprovementsAroundTypeEnhancement +ProhibitUsingNullableTypeParameterAgainstNotNullAnnotated +// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE +// SKIP_TXT + +fun main(x: ClassTypeParameterBound<String?>, y: ClassTypeParameterBound, a: String?, b: String) { + val x2 = ClassTypeParameterBound<String?>() + val y2 = ClassTypeParameterBound() + + val x3 = ClassTypeParameterBound(a) + val y3 = ClassTypeParameterBound(b) + + val x4: ClassTypeParameterBound<String?> = ClassTypeParameterBound() + val y4: ClassTypeParameterBound = ClassTypeParameterBound() +} diff --git a/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ClassTypeParameterBoundWithWarnings.java b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ClassTypeParameterBoundWithWarnings.java new file mode 100644 index 00000000000..74e7708be28 --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ClassTypeParameterBoundWithWarnings.java @@ -0,0 +1,6 @@ +import org.jetbrains.annotations.NotNull; + +public class ClassTypeParameterBoundWithWarnings { + ClassTypeParameterBoundWithWarnings() { } + ClassTypeParameterBoundWithWarnings(T x) { } +} diff --git a/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ClassTypeParameterBoundWithWarnings.kt b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ClassTypeParameterBoundWithWarnings.kt new file mode 100644 index 00000000000..29f07a9f8e4 --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ClassTypeParameterBoundWithWarnings.kt @@ -0,0 +1,15 @@ +// !LANGUAGE: +ProhibitUsingNullableTypeParameterAgainstNotNullAnnotated +// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE +// SKIP_TXT + +// TODO: report warnings "UPPER_BOUND_VIOLATED" +fun main(x: ClassTypeParameterBoundWithWarnings, y: ClassTypeParameterBoundWithWarnings, a: String?, b: String) { + val x2 = ClassTypeParameterBoundWithWarnings() + val y2 = ClassTypeParameterBoundWithWarnings() + + val x3 = ClassTypeParameterBoundWithWarnings(a) + val y3 = ClassTypeParameterBoundWithWarnings(b) + + val x4: ClassTypeParameterBoundWithWarnings = ClassTypeParameterBoundWithWarnings() + val y4: ClassTypeParameterBoundWithWarnings = ClassTypeParameterBoundWithWarnings() +} diff --git a/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ReturnType.java b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ReturnType.java new file mode 100644 index 00000000000..bfe37d1e4f1 --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ReturnType.java @@ -0,0 +1,13 @@ +import org.jetbrains.annotations.*; + +public class ReturnType { + public interface A {} + + public A<@Nullable String, @Nullable T> foo1() { return null; } + public A<@Nullable String, @NotNull T> foo2() { return null; } + public A<@NotNull String, @NotNull T> foo3 = null; + public @NotNull T [] foo4 = null; + public ReturnType<@Nullable String> foo41 = null; + public T foo411 = null; + public @Nullable String [] foo5() { return null; } +} diff --git a/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ReturnType.kt b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ReturnType.kt new file mode 100644 index 00000000000..15e609df195 --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ReturnType.kt @@ -0,0 +1,48 @@ +// !LANGUAGE: +ImprovementsAroundTypeEnhancement +ProhibitUsingNullableTypeParameterAgainstNotNullAnnotated +// !DIAGNOSTICS: -UNUSED_PARAMETER +// SKIP_TXT + +fun takeNotNullStringAndKNullable(x: ReturnType.A) {} +fun takeNullableStringAndKNullable(x: ReturnType.A) {} +fun takeNotNullStringAndNotNullK(x: ReturnType.A) {} +fun takeNullableStringAndNotNullK(x: ReturnType.A) {} +fun takeNotNullString(x: String) {} + +fun takeArrayOfNotNullString(x: Array) {} +fun takeArrayOfNullableString(x: Array) {} +fun takeArrayOfNotNullK(x: Array) {} +fun takeArrayOfNullableK(x: Array) {} + +// FILE: main.kt +fun main(a: ReturnType) { + val x1 = ..ReturnType.A<@org.jetbrains.annotations.Nullable kotlin.String?, @org.jetbrains.annotations.Nullable R?>?)")!>a.foo1() + takeNotNullStringAndKNullable(x1) + takeNullableStringAndKNullable(x1) + takeNotNullStringAndNotNullK(", "ReturnType.A!")!>x1) + takeNullableStringAndNotNullK(x1) + takeNotNullString(a.foo41.foo411) + + val x2 = ..ReturnType.A<@org.jetbrains.annotations.Nullable kotlin.String?, @org.jetbrains.annotations.NotNull R!!>?)")!>a.foo2() + takeNotNullStringAndKNullable(x2) + takeNullableStringAndKNullable(x2) + takeNotNullStringAndNotNullK(", "ReturnType.A!")!>x2) + takeNullableStringAndNotNullK(x2) + + val x3 = ..ReturnType.A<@org.jetbrains.annotations.NotNull kotlin.String, @org.jetbrains.annotations.NotNull R!!>?)")!>a.foo3 + takeNotNullStringAndKNullable(x3) + takeNullableStringAndKNullable(x3) + takeNotNullStringAndNotNullK(x3) + takeNullableStringAndNotNullK(", "ReturnType.A!")!>x3) + + val x4 = ..kotlin.Array?)")!>a.foo4 + takeArrayOfNotNullString(x4) + takeArrayOfNullableString(x4) + takeArrayOfNotNullK(x4) + takeArrayOfNullableK(x4) + + val x5 = ..kotlin.Array?)")!>a.foo5() + takeArrayOfNotNullString(x5) + takeArrayOfNullableString(x5) + takeArrayOfNotNullK(x5) + takeArrayOfNullableK(x5) +} diff --git a/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ReturnTypeWithWarnings.java b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ReturnTypeWithWarnings.java new file mode 100644 index 00000000000..11f6a7d2e1d --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ReturnTypeWithWarnings.java @@ -0,0 +1,13 @@ +import org.jetbrains.annotations.*; + +public class ReturnTypeWithWarnings { + public interface A {} + + public A<@Nullable String, @Nullable T> foo1() { return null; } + public A<@Nullable String, @NotNull T> foo2() { return null; } + public A<@NotNull String, @NotNull T> foo3 = null; + public @NotNull T [] foo4 = null; + public ReturnTypeWithWarnings<@Nullable String> foo41 = null; + public T foo411 = null; + public @Nullable String [] foo5() { return null; } +} diff --git a/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ReturnTypeWithWarnings.kt b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ReturnTypeWithWarnings.kt new file mode 100644 index 00000000000..85355f00247 --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ReturnTypeWithWarnings.kt @@ -0,0 +1,48 @@ +// !LANGUAGE: +ProhibitUsingNullableTypeParameterAgainstNotNullAnnotated +// !DIAGNOSTICS: -UNUSED_PARAMETER +// SKIP_TXT + +fun takeNotNullStringAndKNullable(x: ReturnTypeWithWarnings.A) {} +fun takeNullableStringAndKNullable(x: ReturnTypeWithWarnings.A) {} +fun takeNotNullStringAndNotNullK(x: ReturnTypeWithWarnings.A) {} +fun takeNullableStringAndNotNullK(x: ReturnTypeWithWarnings.A) {} +fun takeNotNullString(x: String) {} + +fun takeArrayOfNotNullString(x: Array) {} +fun takeArrayOfNullableString(x: Array) {} +fun takeArrayOfNotNullK(x: Array) {} +fun takeArrayOfNullableK(x: Array) {} + +// FILE: main.kt +fun main(a: ReturnTypeWithWarnings) { + val x1 = ..ReturnTypeWithWarnings.A<(@org.jetbrains.annotations.Nullable kotlin.String..@org.jetbrains.annotations.Nullable kotlin.String?), (@org.jetbrains.annotations.Nullable R..@org.jetbrains.annotations.Nullable R?)>?)")!>a.foo1() + takeNotNullStringAndKNullable(", "ReturnTypeWithWarnings.A!")!>x1) + takeNullableStringAndKNullable(x1) + takeNotNullStringAndNotNullK(", "ReturnTypeWithWarnings.A!"), TYPE_MISMATCH("Any", "R!"), TYPE_MISMATCH("Any", "R!")!>x1) + takeNullableStringAndNotNullK(x1) + takeNotNullString(a.foo41.foo411) + + val x2 = ..ReturnTypeWithWarnings.A<(@org.jetbrains.annotations.Nullable kotlin.String..@org.jetbrains.annotations.Nullable kotlin.String?), (@org.jetbrains.annotations.NotNull R..@org.jetbrains.annotations.NotNull R?)>?)")!>a.foo2() + takeNotNullStringAndKNullable(", "ReturnTypeWithWarnings.A!")!>x2) + takeNullableStringAndKNullable(", "ReturnTypeWithWarnings.A!")!>x2) + takeNotNullStringAndNotNullK(", "ReturnTypeWithWarnings.A!"), TYPE_MISMATCH("Any", "R!"), TYPE_MISMATCH("Any", "R!")!>x2) + takeNullableStringAndNotNullK(x2) + + val x3 = ..ReturnTypeWithWarnings.A<(@org.jetbrains.annotations.NotNull kotlin.String..@org.jetbrains.annotations.NotNull kotlin.String?), (@org.jetbrains.annotations.NotNull R..@org.jetbrains.annotations.NotNull R?)>?)")!>a.foo3 + takeNotNullStringAndKNullable(", "ReturnTypeWithWarnings.A!")!>x3) + takeNullableStringAndKNullable(", "ReturnTypeWithWarnings.A!")!>x3) + takeNotNullStringAndNotNullK(x3) + takeNullableStringAndNotNullK(", "ReturnTypeWithWarnings.A!"), TYPE_MISMATCH("Any", "R!"), TYPE_MISMATCH("Any", "R!")!>x3) + + val x4 = ..kotlin.Array)")!>a.foo4 + takeArrayOfNotNullString(x4) + takeArrayOfNullableString(x4) + takeArrayOfNotNullK(x4) + takeArrayOfNullableK(", "Array<(out) R!!>")!>x4) + + val x5 = ?..kotlin.Array?)")!>a.foo5() + takeArrayOfNotNullString(x5) + takeArrayOfNullableString(x5) + takeArrayOfNotNullK(x5) + takeArrayOfNullableK(x5) +} diff --git a/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ValueParameter.java b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ValueParameter.java new file mode 100644 index 00000000000..322ff878d18 --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ValueParameter.java @@ -0,0 +1,13 @@ +import org.jetbrains.annotations.*; + +public class ValueParameter { + public interface A {} + + public void foo1(A<@Nullable String, @Nullable T> x) { } + public void foo2(A<@Nullable String, @NotNull T> x) { } + public void foo3(A<@NotNull String, @NotNull T> x) { } + public void foo4(@NotNull T [] x) { } + public void foo41(@Nullable String x) { } + public void foo411(T x) { } + public void foo5(@Nullable String [] x) { } +} diff --git a/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ValueParameter.kt b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ValueParameter.kt new file mode 100644 index 00000000000..7a7175a9522 --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ValueParameter.kt @@ -0,0 +1,45 @@ +// !LANGUAGE: +ImprovementsAroundTypeEnhancement +ProhibitUsingNullableTypeParameterAgainstNotNullAnnotated +// !DIAGNOSTICS: -UNUSED_PARAMETER -CAST_NEVER_SUCCEEDS +// SKIP_TXT + +fun getNotNullStringAndKNullable() = null as ValueParameter.A +fun getNullableStringAndKNullable() = null as ValueParameter.A +fun getNotNullStringAndNotNullK() = null as ValueParameter.A +fun getNullableStringAndNotNullK() = null as ValueParameter.A +fun getNotNullString() = null as String + +fun getArrayOfNotNullString() = null as Array +fun getArrayOfNullableString() = null as Array +fun getArrayOfNotNullK() = null as Array +fun getArrayOfNullableK() = null as Array + +// FILE: main.kt +fun main(a: ValueParameter) { + a.foo1(getNotNullStringAndKNullable()) + a.foo1(getNullableStringAndKNullable()) + a.foo1(getNotNullStringAndNotNullK()) + a.foo1(getNullableStringAndNotNullK()) + + a.foo2(getNotNullStringAndKNullable()) + a.foo2(getNullableStringAndKNullable()) + a.foo2(getNotNullStringAndNotNullK()) + a.foo2(getNullableStringAndNotNullK()) + + a.foo3(getNotNullStringAndKNullable()) + a.foo3(getNullableStringAndKNullable()) + a.foo3(getNotNullStringAndNotNullK()) + a.foo3(getNullableStringAndNotNullK()) + + a.foo4(getArrayOfNotNullString()) + a.foo4(getArrayOfNullableString()) + a.foo4(getArrayOfNotNullK()) + a.foo4(getArrayOfNullableK()) + + a.foo5(getArrayOfNotNullString()) + a.foo5(getArrayOfNullableString()) + a.foo5(getArrayOfNotNullK()) + a.foo5(getArrayOfNullableK()) + + a.foo41(getNotNullString()) + a.foo411(getNotNullString()) +} diff --git a/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ValueParameterWithWarnings.java b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ValueParameterWithWarnings.java new file mode 100644 index 00000000000..7fd49516069 --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ValueParameterWithWarnings.java @@ -0,0 +1,13 @@ +import org.jetbrains.annotations.*; + +public class ValueParameterWithWarnings { + public interface A {} + + public void foo1(A<@Nullable String, @Nullable T> x) { } + public void foo2(A<@Nullable String, @NotNull T> x) { } + public void foo3(A<@NotNull String, @NotNull T> x) { } + public void foo4(@NotNull T [] x) { } + public void foo41(@Nullable String x) { } + public void foo411(T x) { } + public void foo5(@Nullable String [] x) { } +} diff --git a/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ValueParameterWithWarnings.kt b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ValueParameterWithWarnings.kt new file mode 100644 index 00000000000..95819ad9598 --- /dev/null +++ b/compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ValueParameterWithWarnings.kt @@ -0,0 +1,45 @@ +// !LANGUAGE: +ProhibitUsingNullableTypeParameterAgainstNotNullAnnotated +// !DIAGNOSTICS: -UNUSED_PARAMETER -CAST_NEVER_SUCCEEDS +// SKIP_TXT + +fun getNotNullStringAndKNullable() = null as ValueParameterWithWarnings.A +fun getNullableStringAndKNullable() = null as ValueParameterWithWarnings.A +fun getNotNullStringAndNotNullK() = null as ValueParameterWithWarnings.A +fun getNullableStringAndNotNullK() = null as ValueParameterWithWarnings.A +fun getNotNullString() = null as String + +fun getArrayOfNotNullString() = null as Array +fun getArrayOfNullableString() = null as Array +fun getArrayOfNotNullK() = null as Array +fun getArrayOfNullableK() = null as Array + +// FILE: main.kt +fun main(a: ValueParameterWithWarnings) { + a.foo1(getNotNullStringAndKNullable()) + a.foo1(getNullableStringAndKNullable()) + a.foo1(getNotNullStringAndNotNullK()) + a.foo1(getNullableStringAndNotNullK()) + + a.foo2(getNotNullStringAndKNullable()) + a.foo2(getNullableStringAndKNullable()) + a.foo2(getNotNullStringAndNotNullK()) + a.foo2(getNullableStringAndNotNullK()) + + a.foo3(getNotNullStringAndKNullable()) + a.foo3(getNullableStringAndKNullable()) + a.foo3(getNotNullStringAndNotNullK()) + a.foo3(getNullableStringAndNotNullK()) + + a.foo4(getArrayOfNotNullString()) + a.foo4(getArrayOfNullableString()) + a.foo4(getArrayOfNotNullK()) + a.foo4(getArrayOfNullableK()) + + a.foo5(getArrayOfNotNullString()) + a.foo5(getArrayOfNullableString()) + a.foo5(getArrayOfNotNullK()) + a.foo5(getArrayOfNullableK()) + + a.foo41(getNotNullString()) + a.foo411(getNotNullString()) +} diff --git a/compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic_DisabledImprovements.txt b/compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic_DisabledImprovements.txt new file mode 100644 index 00000000000..49fe9fe9a8f --- /dev/null +++ b/compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic_DisabledImprovements.txt @@ -0,0 +1,14 @@ +package test + +public open class Basic_DisabledImprovements { + public constructor Basic_DisabledImprovements() + public/*package*/ open fun foo(/*0*/ p0: R!): kotlin.Unit + + public interface G { + public abstract fun foo(/*0*/ p0: R!): kotlin.Unit + } + + public interface G1 { + public abstract fun foo(/*0*/ p0: R!): kotlin.Unit + } +} diff --git a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic.java b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic.java index d559293052e..c95657b6586 100644 --- a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic.java +++ b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic.java @@ -4,15 +4,14 @@ package test; import org.jetbrains.annotations.*; -public class Basic { - interface G { - } +public class Basic { + interface G extends G2<@NotNull T, @NotNull String> { } - interface G2 { - } + interface G2 { } public interface MyClass { - void f(G<@NotNull String> p); - void f(G2<@Nullable String, @NotNull Integer> p); + void f1(G<@NotNull String> p); + G2<@Nullable String, @NotNull Integer> f2(); + void f3(@NotNull T x); } } diff --git a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic.txt b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic.txt index 48ab6fa460e..7ac5bd3fe4d 100644 --- a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic.txt +++ b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic.txt @@ -1,16 +1,17 @@ package test -public open class Basic { - public constructor Basic() +public open class Basic { + public constructor Basic() - public/*package*/ interface G { + public/*package*/ interface G : test.Basic.G2<@org.jetbrains.annotations.NotNull T, @org.jetbrains.annotations.NotNull kotlin.String> { } public/*package*/ interface G2 { } public interface MyClass { - public abstract fun f(/*0*/ p0: test.Basic.G2<@org.jetbrains.annotations.Nullable kotlin.String?, @org.jetbrains.annotations.NotNull kotlin.Int>!): kotlin.Unit - public abstract fun f(/*0*/ p0: test.Basic.G<@org.jetbrains.annotations.NotNull kotlin.String>!): kotlin.Unit + public abstract fun f1(/*0*/ p0: test.Basic.G<@org.jetbrains.annotations.NotNull kotlin.String>!): kotlin.Unit + public abstract fun f2(): test.Basic.G2<@org.jetbrains.annotations.Nullable kotlin.String?, @org.jetbrains.annotations.NotNull kotlin.Int>! + public abstract fun f3(/*0*/ @org.jetbrains.annotations.NotNull p0: @org.jetbrains.annotations.NotNull T): kotlin.Unit } } diff --git a/compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic_DisabledImprovements.java b/compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic_DisabledImprovements.java index 3aa3ae514db..20ae7c5392d 100644 --- a/compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic_DisabledImprovements.java +++ b/compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic_DisabledImprovements.java @@ -1,4 +1,4 @@ -// !LANGUAGE: +// !LANGUAGE: -ImprovementsAroundTypeEnhancement package test; diff --git a/compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic_DisabledImprovements.txt b/compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic_DisabledImprovements.txt new file mode 100644 index 00000000000..aaa86bc0d34 --- /dev/null +++ b/compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic_DisabledImprovements.txt @@ -0,0 +1,14 @@ +package test + +public open class Basic_DisabledImprovements { + public constructor Basic_DisabledImprovements() + public/*package*/ open fun foo(/*0*/ r: R!): kotlin.Unit + + public interface G { + public abstract fun foo(/*0*/ r: R!): kotlin.Unit + } + + public interface G1 { + public abstract fun foo(/*0*/ r: R!): kotlin.Unit + } +} diff --git a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic.java b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic.java index 6d00a4e6999..b476de95f1b 100644 --- a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic.java +++ b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic.java @@ -5,15 +5,14 @@ package test; import org.jetbrains.annotations.*; -public class Basic { - interface G { - } +public class Basic implements G2<@NotNull T, @NotNull String> { + interface G { } - interface G2 { - } + interface G2 { } public interface MyClass { - void f(G<@NotNull String> p); - void f(G2<@Nullable String, @NotNull Integer> p); + void f1(G<@NotNull String> p); + G2<@Nullable String, @NotNull Integer> f2(); + void f3(@NotNull T x) { }; } } diff --git a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic.txt b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic.txt index 5d7173d954b..aa62b4828b0 100644 --- a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic.txt +++ b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic.txt @@ -1,7 +1,7 @@ package test -public open class Basic { - public constructor Basic() +public open class Basic : G2 { + public constructor Basic() public/*package*/ interface G { } @@ -10,7 +10,8 @@ public open class Basic { } public interface MyClass { - public abstract fun f(/*0*/ p: test.Basic.G2<@org.jetbrains.annotations.Nullable kotlin.String?, @org.jetbrains.annotations.NotNull kotlin.Int>!): kotlin.Unit - public abstract fun f(/*0*/ p: test.Basic.G<@org.jetbrains.annotations.NotNull kotlin.String>!): kotlin.Unit + public abstract fun f1(/*0*/ p: test.Basic.G<@org.jetbrains.annotations.NotNull kotlin.String>!): kotlin.Unit + public abstract fun f2(): test.Basic.G2<@org.jetbrains.annotations.Nullable kotlin.String?, @org.jetbrains.annotations.NotNull kotlin.Int>! + public abstract fun f3(/*0*/ @org.jetbrains.annotations.NotNull x: @org.jetbrains.annotations.NotNull T): kotlin.Unit } } diff --git a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic_DisabledImprovements.txt b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic_DisabledImprovements.txt index 2ce1a78b2fb..9b6ffd2351f 100644 --- a/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic_DisabledImprovements.txt +++ b/compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic_DisabledImprovements.txt @@ -26,7 +26,7 @@ public open class Basic_DisabledImprovements!): kotlin.Unit public abstract fun f6(/*0*/ p: test.Basic_DisabledImprovements.G!): kotlin.Unit public abstract fun f7(/*0*/ p: test.Basic_DisabledImprovements.G<@org.jetbrains.annotations.NotNull test.Basic_DisabledImprovements.A.B<*, *>>!): kotlin.Unit - public abstract fun f8(): test.Basic_DisabledImprovements.G!>! + public abstract fun f81(): test.Basic_DisabledImprovements.G!>! public abstract fun f9(): test.Basic_DisabledImprovements.G<@org.jetbrains.annotations.Nullable test.Basic_DisabledImprovements.A.B<*, *>?>! } } diff --git a/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignAnnotationsCompiledJavaDiagnosticTestGenerated.java b/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignAnnotationsCompiledJavaDiagnosticTestGenerated.java new file mode 100644 index 00000000000..3d3e1d606f0 --- /dev/null +++ b/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignAnnotationsCompiledJavaDiagnosticTestGenerated.java @@ -0,0 +1,60 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.checkers; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; +import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.runner.RunWith; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava") +@TestDataPath("$PROJECT_ROOT") +@RunWith(JUnit3RunnerWithInners.class) +public class ForeignAnnotationsCompiledJavaDiagnosticTestGenerated extends AbstractForeignAnnotationsCompiledJavaDiagnosticTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); + } + + public void testAllFilesPresentInTypeEnhancementOnCompiledJava() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @TestMetadata("ClassTypeParameterBound.kt") + public void testClassTypeParameterBound() throws Exception { + runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ClassTypeParameterBound.kt"); + } + + @TestMetadata("ClassTypeParameterBoundWithWarnings.kt") + public void testClassTypeParameterBoundWithWarnings() throws Exception { + runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ClassTypeParameterBoundWithWarnings.kt"); + } + + @TestMetadata("ReturnType.kt") + public void testReturnType() throws Exception { + runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ReturnType.kt"); + } + + @TestMetadata("ReturnTypeWithWarnings.kt") + public void testReturnTypeWithWarnings() throws Exception { + runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ReturnTypeWithWarnings.kt"); + } + + @TestMetadata("ValueParameter.kt") + public void testValueParameter() throws Exception { + runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ValueParameter.kt"); + } + + @TestMetadata("ValueParameterWithWarnings.kt") + public void testValueParameterWithWarnings() throws Exception { + runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ValueParameterWithWarnings.kt"); + } +} diff --git a/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsNoAnnotationInClasspathTestGenerated.java b/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsNoAnnotationInClasspathTestGenerated.java index ad6569ce9f8..654e7666322 100644 --- a/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsNoAnnotationInClasspathTestGenerated.java +++ b/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsNoAnnotationInClasspathTestGenerated.java @@ -129,4 +129,47 @@ public class ForeignJava8AnnotationsNoAnnotationInClasspathTestGenerated extends runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/simple.kt"); } } + + @TestMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TypeEnhancementOnCompiledJava extends AbstractForeignJava8AnnotationsNoAnnotationInClasspathTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); + } + + public void testAllFilesPresentInTypeEnhancementOnCompiledJava() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @TestMetadata("ClassTypeParameterBound.kt") + public void testClassTypeParameterBound() throws Exception { + runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ClassTypeParameterBound.kt"); + } + + @TestMetadata("ClassTypeParameterBoundWithWarnings.kt") + public void testClassTypeParameterBoundWithWarnings() throws Exception { + runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ClassTypeParameterBoundWithWarnings.kt"); + } + + @TestMetadata("ReturnType.kt") + public void testReturnType() throws Exception { + runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ReturnType.kt"); + } + + @TestMetadata("ReturnTypeWithWarnings.kt") + public void testReturnTypeWithWarnings() throws Exception { + runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ReturnTypeWithWarnings.kt"); + } + + @TestMetadata("ValueParameter.kt") + public void testValueParameter() throws Exception { + runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ValueParameter.kt"); + } + + @TestMetadata("ValueParameterWithWarnings.kt") + public void testValueParameterWithWarnings() throws Exception { + runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ValueParameterWithWarnings.kt"); + } + } } diff --git a/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsNoAnnotationInClasspathWithPsiClassReadingTestGenerated.java b/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsNoAnnotationInClasspathWithPsiClassReadingTestGenerated.java index e30b43baf87..c1a3cf480ce 100644 --- a/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsNoAnnotationInClasspathWithPsiClassReadingTestGenerated.java +++ b/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsNoAnnotationInClasspathWithPsiClassReadingTestGenerated.java @@ -129,4 +129,47 @@ public class ForeignJava8AnnotationsNoAnnotationInClasspathWithPsiClassReadingTe runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/simple.kt"); } } + + @TestMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TypeEnhancementOnCompiledJava extends AbstractForeignJava8AnnotationsNoAnnotationInClasspathWithPsiClassReadingTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); + } + + public void testAllFilesPresentInTypeEnhancementOnCompiledJava() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @TestMetadata("ClassTypeParameterBound.kt") + public void testClassTypeParameterBound() throws Exception { + runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ClassTypeParameterBound.kt"); + } + + @TestMetadata("ClassTypeParameterBoundWithWarnings.kt") + public void testClassTypeParameterBoundWithWarnings() throws Exception { + runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ClassTypeParameterBoundWithWarnings.kt"); + } + + @TestMetadata("ReturnType.kt") + public void testReturnType() throws Exception { + runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ReturnType.kt"); + } + + @TestMetadata("ReturnTypeWithWarnings.kt") + public void testReturnTypeWithWarnings() throws Exception { + runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ReturnTypeWithWarnings.kt"); + } + + @TestMetadata("ValueParameter.kt") + public void testValueParameter() throws Exception { + runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ValueParameter.kt"); + } + + @TestMetadata("ValueParameterWithWarnings.kt") + public void testValueParameterWithWarnings() throws Exception { + runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ValueParameterWithWarnings.kt"); + } + } } diff --git a/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsTestGenerated.java b/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsTestGenerated.java index bdfef3aeeac..d63396f3bbe 100644 --- a/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsTestGenerated.java +++ b/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsTestGenerated.java @@ -129,4 +129,47 @@ public class ForeignJava8AnnotationsTestGenerated extends AbstractForeignJava8An runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/simple.kt"); } } + + @TestMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TypeEnhancementOnCompiledJava extends AbstractForeignJava8AnnotationsTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); + } + + public void testAllFilesPresentInTypeEnhancementOnCompiledJava() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @TestMetadata("ClassTypeParameterBound.kt") + public void testClassTypeParameterBound() throws Exception { + runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ClassTypeParameterBound.kt"); + } + + @TestMetadata("ClassTypeParameterBoundWithWarnings.kt") + public void testClassTypeParameterBoundWithWarnings() throws Exception { + runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ClassTypeParameterBoundWithWarnings.kt"); + } + + @TestMetadata("ReturnType.kt") + public void testReturnType() throws Exception { + runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ReturnType.kt"); + } + + @TestMetadata("ReturnTypeWithWarnings.kt") + public void testReturnTypeWithWarnings() throws Exception { + runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ReturnTypeWithWarnings.kt"); + } + + @TestMetadata("ValueParameter.kt") + public void testValueParameter() throws Exception { + runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ValueParameter.kt"); + } + + @TestMetadata("ValueParameterWithWarnings.kt") + public void testValueParameterWithWarnings() throws Exception { + runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ValueParameterWithWarnings.kt"); + } + } } diff --git a/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/javac/JavacForeignJava8AnnotationsTestGenerated.java b/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/javac/JavacForeignJava8AnnotationsTestGenerated.java index 18ec7c9c912..06657adadb2 100644 --- a/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/javac/JavacForeignJava8AnnotationsTestGenerated.java +++ b/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/javac/JavacForeignJava8AnnotationsTestGenerated.java @@ -129,4 +129,47 @@ public class JavacForeignJava8AnnotationsTestGenerated extends AbstractJavacFore runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/simple.kt"); } } + + @TestMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TypeEnhancementOnCompiledJava extends AbstractJavacForeignJava8AnnotationsTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); + } + + public void testAllFilesPresentInTypeEnhancementOnCompiledJava() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava"), Pattern.compile("^(.+)\\.kt$"), null, true); + } + + @TestMetadata("ClassTypeParameterBound.kt") + public void testClassTypeParameterBound() throws Exception { + runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ClassTypeParameterBound.kt"); + } + + @TestMetadata("ClassTypeParameterBoundWithWarnings.kt") + public void testClassTypeParameterBoundWithWarnings() throws Exception { + runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ClassTypeParameterBoundWithWarnings.kt"); + } + + @TestMetadata("ReturnType.kt") + public void testReturnType() throws Exception { + runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ReturnType.kt"); + } + + @TestMetadata("ReturnTypeWithWarnings.kt") + public void testReturnTypeWithWarnings() throws Exception { + runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ReturnTypeWithWarnings.kt"); + } + + @TestMetadata("ValueParameter.kt") + public void testValueParameter() throws Exception { + runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ValueParameter.kt"); + } + + @TestMetadata("ValueParameterWithWarnings.kt") + public void testValueParameterWithWarnings() throws Exception { + runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ValueParameterWithWarnings.kt"); + } + } } diff --git a/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/LoadJava8TestGenerated.java b/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/LoadJava8TestGenerated.java index bb0a0cef3f3..f02f9b91ef2 100644 --- a/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/LoadJava8TestGenerated.java +++ b/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/LoadJava8TestGenerated.java @@ -62,6 +62,11 @@ public class LoadJava8TestGenerated extends AbstractLoadJava8Test { public void testBasic() throws Exception { runTest("compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic.java"); } + + @TestMetadata("Basic_DisabledImprovements.java") + public void testBasic_DisabledImprovements() throws Exception { + runTest("compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic_DisabledImprovements.java"); + } } @TestMetadata("compiler/testData/loadJava8/compiledJava/typeUseAnnotations") @@ -86,6 +91,11 @@ public class LoadJava8TestGenerated extends AbstractLoadJava8Test { runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic.java"); } + @TestMetadata("Basic_DisabledImprovements.java") + public void testBasic_DisabledImprovements() throws Exception { + runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic_DisabledImprovements.java"); + } + @TestMetadata("ClassTypeParameterBounds.java") public void testClassTypeParameterBounds() throws Exception { runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ClassTypeParameterBounds.java"); @@ -151,6 +161,11 @@ public class LoadJava8TestGenerated extends AbstractLoadJava8Test { public void testBasic() throws Exception { runTest("compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic.java"); } + + @TestMetadata("Basic_DisabledImprovements.java") + public void testBasic_DisabledImprovements() throws Exception { + runTest("compiler/testData/loadJava8/sourceJava/typeParameterAnnotations/Basic_DisabledImprovements.java"); + } } @TestMetadata("compiler/testData/loadJava8/sourceJava/typeUseAnnotations") @@ -175,6 +190,11 @@ public class LoadJava8TestGenerated extends AbstractLoadJava8Test { runTest("compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic.java"); } + @TestMetadata("Basic_DisabledImprovements.java") + public void testBasic_DisabledImprovements() throws Exception { + runTest("compiler/testData/loadJava8/sourceJava/typeUseAnnotations/Basic_DisabledImprovements.java"); + } + @TestMetadata("ClassTypeParameterBounds.java") public void testClassTypeParameterBounds() throws Exception { runTest("compiler/testData/loadJava8/sourceJava/typeUseAnnotations/ClassTypeParameterBounds.java"); diff --git a/compiler/tests/org/jetbrains/kotlin/cli/jvm/KotlinCliJavaFileManagerTest.kt b/compiler/tests/org/jetbrains/kotlin/cli/jvm/KotlinCliJavaFileManagerTest.kt index f9f613fedac..275d5915a0f 100644 --- a/compiler/tests/org/jetbrains/kotlin/cli/jvm/KotlinCliJavaFileManagerTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/cli/jvm/KotlinCliJavaFileManagerTest.kt @@ -28,6 +28,8 @@ import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment import org.jetbrains.kotlin.cli.jvm.index.JavaRoot import org.jetbrains.kotlin.cli.jvm.index.JvmDependenciesIndexImpl import org.jetbrains.kotlin.cli.jvm.index.SingleJavaFileRootsIndex +import org.jetbrains.kotlin.config.LanguageFeature +import org.jetbrains.kotlin.config.languageVersionSettings import org.jetbrains.kotlin.load.java.structure.impl.JavaClassImpl import org.jetbrains.kotlin.load.kotlin.VirtualFileFinder import org.jetbrains.kotlin.name.ClassId @@ -204,10 +206,10 @@ class KotlinCliJavaFileManagerTest : KotlinTestWithEnvironment() { val root = StandardFileSystems.local().findFileByPath(javaFilesDir.path)!! coreJavaFileManager.initialize( - JvmDependenciesIndexImpl(listOf(JavaRoot(root, JavaRoot.RootType.SOURCE))), - emptyList(), - SingleJavaFileRootsIndex(emptyList()), - usePsiClassFilesReading = false + JvmDependenciesIndexImpl(listOf(JavaRoot(root, JavaRoot.RootType.SOURCE))), + emptyList(), + SingleJavaFileRootsIndex(emptyList()), + usePsiClassFilesReading = false ) return coreJavaFileManager diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/context.kt b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/context.kt index 2b9cac7f802..8f72c08ae9a 100644 --- a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/context.kt +++ b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/context.kt @@ -81,7 +81,7 @@ class JavaResolverComponents( interface JavaResolverSettings { val isReleaseCoroutines: Boolean val correctNullabilityForNotNullTypeParameter: Boolean - val enhancementImprovements: Boolean + val typeEnhancementImprovements: Boolean object Default : JavaResolverSettings { override val isReleaseCoroutines: Boolean @@ -90,7 +90,7 @@ interface JavaResolverSettings { override val correctNullabilityForNotNullTypeParameter: Boolean get() = false - override val enhancementImprovements: Boolean + override val typeEnhancementImprovements: Boolean get() = false } @@ -98,12 +98,12 @@ interface JavaResolverSettings { fun create( isReleaseCoroutines: Boolean, correctNullabilityForNotNullTypeParameter: Boolean, - enhancementImprovements: Boolean, + typeEnhancementImprovements: Boolean ): JavaResolverSettings = object : JavaResolverSettings { override val isReleaseCoroutines get() = isReleaseCoroutines override val correctNullabilityForNotNullTypeParameter get() = correctNullabilityForNotNullTypeParameter - override val enhancementImprovements get() = enhancementImprovements + override val typeEnhancementImprovements get() = typeEnhancementImprovements } } } diff --git a/core/descriptors.runtime/tests/org/jetbrains/kotlin/jvm/runtime/Jvm8RuntimeDescriptorLoaderTestGenerated.java b/core/descriptors.runtime/tests/org/jetbrains/kotlin/jvm/runtime/Jvm8RuntimeDescriptorLoaderTestGenerated.java index 6d4f6f0646a..b1d8877591d 100644 --- a/core/descriptors.runtime/tests/org/jetbrains/kotlin/jvm/runtime/Jvm8RuntimeDescriptorLoaderTestGenerated.java +++ b/core/descriptors.runtime/tests/org/jetbrains/kotlin/jvm/runtime/Jvm8RuntimeDescriptorLoaderTestGenerated.java @@ -60,6 +60,11 @@ public class Jvm8RuntimeDescriptorLoaderTestGenerated extends AbstractJvm8Runtim public void testBasic() throws Exception { runTest("compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic.java"); } + + @TestMetadata("Basic_DisabledImprovements.java") + public void testBasic_DisabledImprovements() throws Exception { + runTest("compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic_DisabledImprovements.java"); + } } @TestMetadata("compiler/testData/loadJava8/compiledJava/typeUseAnnotations") @@ -84,6 +89,11 @@ public class Jvm8RuntimeDescriptorLoaderTestGenerated extends AbstractJvm8Runtim runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic.java"); } + @TestMetadata("Basic_DisabledImprovements.java") + public void testBasic_DisabledImprovements() throws Exception { + runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic_DisabledImprovements.java"); + } + @TestMetadata("ClassTypeParameterBounds.java") public void testClassTypeParameterBounds() throws Exception { runTest("compiler/testData/loadJava8/compiledJava/typeUseAnnotations/ClassTypeParameterBounds.java"); From d6017420decc5bffcaf19adbec9cfe9ed9008464 Mon Sep 17 00:00:00 2001 From: Victor Petukhov Date: Fri, 11 Dec 2020 17:29:12 +0300 Subject: [PATCH 167/196] Mark freshly supported annotations to use that mark for reporting corresponding warnings --- .../load/java/structure/impl/JavaAnnotationImpl.java | 5 +++++ .../java/structure/impl/classFiles/BinaryJavaClass.kt | 8 ++++---- .../jetbrains/kotlin/load/java/structure/javaElements.kt | 4 ++-- .../kotlin/load/java/components/JavaAnnotationMapper.kt | 8 ++++++-- .../java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt | 5 ++++- 5 files changed, 21 insertions(+), 9 deletions(-) diff --git a/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/JavaAnnotationImpl.java b/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/JavaAnnotationImpl.java index 49598467704..0ca7930677e 100644 --- a/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/JavaAnnotationImpl.java +++ b/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/JavaAnnotationImpl.java @@ -94,4 +94,9 @@ public class JavaAnnotationImpl extends JavaElementImpl implement ExternalAnnotationsManager externalAnnotationManager = ExternalAnnotationsManager.getInstance(psi.getProject()); return externalAnnotationManager.isExternalAnnotation(psi); } + + @Override + public boolean isFreshlySupportedTypeUseAnnotation() { + return false; + } } diff --git a/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/BinaryJavaClass.kt b/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/BinaryJavaClass.kt index 35b9f415a26..f525228146c 100644 --- a/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/BinaryJavaClass.kt +++ b/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/BinaryJavaClass.kt @@ -96,13 +96,13 @@ class BinaryJavaClass( val baseType: JavaType = if (typeReference.superTypeIndex == -1) superclass!! else interfaces[typeReference.superTypeIndex] val targetType = BinaryJavaAnnotation.computeTargetType(baseType, translatedPath) - return BinaryJavaAnnotation.addAnnotation(targetType as JavaPlainType, descriptor, context, signatureParser) + return BinaryJavaAnnotation.addAnnotation(targetType as JavaPlainType, descriptor, context, signatureParser, true) } TypeReference.CLASS_TYPE_PARAMETER_BOUND -> { val baseType = computeTypeParameterBound(typeParameters, typeReference) val targetType = BinaryJavaAnnotation.computeTargetType(baseType, translatedPath) - return BinaryJavaAnnotation.addAnnotation(targetType as JavaPlainType, descriptor, context, signatureParser) + return BinaryJavaAnnotation.addAnnotation(targetType as JavaPlainType, descriptor, context, signatureParser, true) } } } @@ -110,11 +110,11 @@ class BinaryJavaClass( return when (typeReference.sort) { TypeReference.CLASS_TYPE_PARAMETER -> BinaryJavaAnnotation.addAnnotation( - typeParameters[typeReference.typeParameterIndex] as BinaryJavaTypeParameter, descriptor, context, signatureParser + typeParameters[typeReference.typeParameterIndex] as BinaryJavaTypeParameter, descriptor, context, signatureParser, true ) TypeReference.CLASS_TYPE_PARAMETER_BOUND -> BinaryJavaAnnotation.addAnnotation( - computeTypeParameterBound(typeParameters, typeReference) as JavaPlainType, descriptor, context, signatureParser + computeTypeParameterBound(typeParameters, typeReference) as JavaPlainType, descriptor, context, signatureParser, true ) else -> null } diff --git a/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/structure/javaElements.kt b/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/structure/javaElements.kt index 59ad273fb98..10fe0bc09bb 100644 --- a/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/structure/javaElements.kt +++ b/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/structure/javaElements.kt @@ -48,8 +48,8 @@ interface JavaTypeParameterListOwner : JavaElement { interface JavaAnnotation : JavaElement { val arguments: Collection val classId: ClassId? - val isIdeExternalAnnotation: Boolean - get() = false + val isIdeExternalAnnotation: Boolean get() = false + val isFreshlySupportedTypeUseAnnotation: Boolean get() = false fun resolve(): JavaClass? } diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/components/JavaAnnotationMapper.kt b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/components/JavaAnnotationMapper.kt index 442aa6f1ee8..64f86419be9 100644 --- a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/components/JavaAnnotationMapper.kt +++ b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/components/JavaAnnotationMapper.kt @@ -45,14 +45,18 @@ object JavaAnnotationMapper { internal val TARGET_ANNOTATION_ALLOWED_TARGETS = Name.identifier("allowedTargets") internal val RETENTION_ANNOTATION_VALUE = Name.identifier("value") - fun mapOrResolveJavaAnnotation(annotation: JavaAnnotation, c: LazyJavaResolverContext): AnnotationDescriptor? = + fun mapOrResolveJavaAnnotation( + annotation: JavaAnnotation, + c: LazyJavaResolverContext, + isFreshlySupportedAnnotation: Boolean = false + ): AnnotationDescriptor? = when (annotation.classId) { ClassId.topLevel(TARGET_ANNOTATION) -> JavaTargetAnnotationDescriptor(annotation, c) ClassId.topLevel(RETENTION_ANNOTATION) -> JavaRetentionAnnotationDescriptor(annotation, c) ClassId.topLevel(REPEATABLE_ANNOTATION) -> JavaAnnotationDescriptor(c, annotation, StandardNames.FqNames.repeatable) ClassId.topLevel(DOCUMENTED_ANNOTATION) -> JavaAnnotationDescriptor(c, annotation, StandardNames.FqNames.mustBeDocumented) ClassId.topLevel(DEPRECATED_ANNOTATION) -> null - else -> LazyJavaAnnotationDescriptor(c, annotation) + else -> LazyJavaAnnotationDescriptor(c, annotation, isFreshlySupportedAnnotation) } fun findMappedJavaAnnotation( diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt index dd0edcfd178..f37c80ddd3b 100644 --- a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt +++ b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaAnnotationDescriptor.kt @@ -39,7 +39,8 @@ import org.jetbrains.kotlin.types.isError class LazyJavaAnnotationDescriptor( private val c: LazyJavaResolverContext, - private val javaAnnotation: JavaAnnotation + private val javaAnnotation: JavaAnnotation, + isFreshlySupportedAnnotation: Boolean = false ) : AnnotationDescriptor, PossiblyExternalAnnotationDescriptor { override val fqName by c.storageManager.createNullableLazyValue { javaAnnotation.classId?.asSingleFqName() @@ -115,4 +116,6 @@ class LazyJavaAnnotationDescriptor( ) override val isIdeExternalAnnotation: Boolean = javaAnnotation.isIdeExternalAnnotation + + val isFreshlySupportedTypeUseAnnotation: Boolean = javaAnnotation.isFreshlySupportedTypeUseAnnotation || isFreshlySupportedAnnotation } From 9a52863fbda2fbd63707835bd2a198a0acc48173 Mon Sep 17 00:00:00 2001 From: Victor Petukhov Date: Fri, 11 Dec 2020 17:35:26 +0300 Subject: [PATCH 168/196] Report warnings about type mismatches based on freshly supported nullability annotations deeply --- .../jvm/checkers/JavaNullabilityChecker.kt | 86 ++++++++++++++----- .../kotlin/types/StarProjectionImpl.kt | 8 ++ .../kotlin/types/TypeProjection.java | 3 + .../kotlin/types/TypeProjectionImpl.java | 6 ++ .../kotlin/types/TypeSubstitution.kt | 54 +++++++----- 5 files changed, 111 insertions(+), 46 deletions(-) diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JavaNullabilityChecker.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JavaNullabilityChecker.kt index 3dd145f7d4d..65f3e09caff 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JavaNullabilityChecker.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JavaNullabilityChecker.kt @@ -37,8 +37,11 @@ import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue import org.jetbrains.kotlin.types.* import org.jetbrains.kotlin.types.checker.ClassicTypeCheckerContext +import org.jetbrains.kotlin.types.checker.KotlinTypeChecker import org.jetbrains.kotlin.types.expressions.SenselessComparisonChecker import org.jetbrains.kotlin.types.model.KotlinTypeMarker +import org.jetbrains.kotlin.types.typeUtil.contains +import org.jetbrains.kotlin.types.typeUtil.makeNotNullable class JavaNullabilityChecker : AdditionalTypeChecker { @@ -187,8 +190,7 @@ class JavaNullabilityChecker : AdditionalTypeChecker { receiverParameter.type, { dataFlowValue }, c.dataFlowInfo - ) { expectedType, - actualType -> + ) { expectedType, actualType -> val receiverExpression = (receiverArgument as? ExpressionReceiver)?.expression if (receiverExpression != null) { c.trace.report(ErrorsJvm.RECEIVER_NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONS.on(receiverExpression, actualType)) @@ -202,43 +204,81 @@ class JavaNullabilityChecker : AdditionalTypeChecker { private fun doCheckType( expressionType: KotlinType, expectedType: KotlinType, - dataFlowValue: () -> DataFlowValue, + expressionTypeDataFlowValue: () -> DataFlowValue, dataFlowInfo: DataFlowInfo, reportWarning: (expectedType: KotlinType, actualType: KotlinType) -> Unit ) { - if (TypeUtils.noExpectedType(expectedType)) { - return - } + if (TypeUtils.noExpectedType(expectedType)) return - val expectedMustNotBeNull = expectedType.mustNotBeNull() ?: return - val actualMayBeNull = expressionType.mayBeNull() ?: return - if (expectedMustNotBeNull.isFromKotlin && actualMayBeNull.isFromKotlin) { - // a type mismatch error will be reported elsewhere - return - } + val doesExpectedTypeContainsEnhancement = expectedType.contains { it is TypeWithEnhancement } + val doesExpressionTypeContainsEnhancement = expressionType.contains { it is TypeWithEnhancement } - if (dataFlowInfo.getStableNullability(dataFlowValue()) != Nullability.NOT_NULL) { - reportWarning(expectedMustNotBeNull.enhancedType, actualMayBeNull.enhancedType) + if (!doesExpectedTypeContainsEnhancement && !doesExpressionTypeContainsEnhancement) return + + val enhancedExpectedType = if (doesExpectedTypeContainsEnhancement) buildTypeWithEnhancement(expectedType) else expectedType + val enhancedExpressionType = enhanceExpressionTypeByDataFlowNullability( + if (doesExpressionTypeContainsEnhancement) buildTypeWithEnhancement(expressionType) else expressionType, + expressionTypeDataFlowValue, + dataFlowInfo + ) + + val isEnhancedExpectedTypeSubtypeOfExpressionType = + KotlinTypeChecker.DEFAULT.isSubtypeOf(enhancedExpressionType, enhancedExpectedType) + + if (isEnhancedExpectedTypeSubtypeOfExpressionType) return + + val isExpectedTypeSubtypeOfExpressionType = KotlinTypeChecker.DEFAULT.isSubtypeOf(expressionType, expectedType) + + if (!isEnhancedExpectedTypeSubtypeOfExpressionType && isExpectedTypeSubtypeOfExpressionType) { + reportWarning(enhancedExpectedType, enhancedExpressionType) } } + private fun enhanceExpressionTypeByDataFlowNullability( + expressionType: KotlinType, + expressionTypeDataFlowValue: () -> DataFlowValue, + dataFlowInfo: DataFlowInfo, + ): KotlinType { + val isNotNullByDataFlowInfo = dataFlowInfo.getStableNullability(expressionTypeDataFlowValue()) == Nullability.NOT_NULL + return if (expressionType.isNullable() && isNotNullByDataFlowInfo) expressionType.makeNotNullable() else expressionType + } + private fun doIfNotNull( type: KotlinType, dataFlowValue: () -> DataFlowValue, c: ResolutionContext<*>, body: () -> T - ) = if (type.mustNotBeNull()?.isFromJava == true && - c.dataFlowInfo.getStableNullability(dataFlowValue()).canBeNull() - ) + ) = if (type.mustNotBeNull()?.isFromJava == true && c.dataFlowInfo.getStableNullability(dataFlowValue()).canBeNull()) { body() - else + } else { null + } - private fun KotlinType.mayBeNull(): EnhancedNullabilityInfo? = when { - !isError && !isFlexible() && TypeUtils.acceptsNullable(this) -> enhancementFromKotlin() - isFlexible() && TypeUtils.acceptsNullable(asFlexibleType().lowerBound) -> enhancementFromKotlin() - this is TypeWithEnhancement && enhancement.mayBeNull() != null -> enhancementFromJava() - else -> null + @OptIn(ExperimentalStdlibApi::class) + private fun enhanceTypeArguments(arguments: List) = + buildList { + for (argument in arguments) { + // TODO: think about star projections with enhancement (e.g. came from Java: Foo<@NotNull ?>) + if (argument.isStarProjection) continue + val argumentType = argument.type + val enhancedArgumentType = if (argumentType is TypeWithEnhancement) argumentType.enhancement else argumentType + val enhancedDeeplyArgumentType = buildTypeWithEnhancement(enhancedArgumentType) + add(argument.replaceType(enhancedDeeplyArgumentType)) + } + } + + fun buildTypeWithEnhancement(type: KotlinType): KotlinType { + val newArguments = enhanceTypeArguments(type.arguments) + val newArgumentsForUpperBound = + if (type is FlexibleType) { + enhanceTypeArguments(type.upperBound.arguments) + } else newArguments + val enhancedType = if (type is TypeWithEnhancement) type.enhancement else type + + return enhancedType.replace( + newArguments = newArguments, + newArgumentsForUpperBound = newArgumentsForUpperBound + ) } } diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/StarProjectionImpl.kt b/core/descriptors/src/org/jetbrains/kotlin/types/StarProjectionImpl.kt index 0353d4019c2..79cc27f7f13 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/types/StarProjectionImpl.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/types/StarProjectionImpl.kt @@ -39,6 +39,10 @@ class StarProjectionImpl( @TypeRefinement override fun refine(kotlinTypeRefiner: KotlinTypeRefiner): TypeProjection = this + + override fun replaceType(type: KotlinType): TypeProjection { + throw UnsupportedOperationException("Replacing type for star projection is unsupported") + } } fun TypeParameterDescriptor.starProjectionType(): KotlinType { @@ -69,4 +73,8 @@ class StarProjectionForAbsentTypeParameter( @TypeRefinement override fun refine(kotlinTypeRefiner: KotlinTypeRefiner): TypeProjection = this + + override fun replaceType(type: KotlinType): TypeProjection { + throw UnsupportedOperationException("Replacing type for star projection is unsupported") + } } diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/TypeProjection.java b/core/descriptors/src/org/jetbrains/kotlin/types/TypeProjection.java index b31841fd09e..13480f55d69 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/types/TypeProjection.java +++ b/core/descriptors/src/org/jetbrains/kotlin/types/TypeProjection.java @@ -33,4 +33,7 @@ public interface TypeProjection extends TypeArgumentMarker { @NotNull @TypeRefinement TypeProjection refine(@NotNull KotlinTypeRefiner kotlinTypeRefiner); + + @NotNull + TypeProjection replaceType(@NotNull KotlinType type); } diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/TypeProjectionImpl.java b/core/descriptors/src/org/jetbrains/kotlin/types/TypeProjectionImpl.java index 9ae2b9c550e..e32aedf5adf 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/types/TypeProjectionImpl.java +++ b/core/descriptors/src/org/jetbrains/kotlin/types/TypeProjectionImpl.java @@ -33,6 +33,12 @@ public class TypeProjectionImpl extends TypeProjectionBase { this(Variance.INVARIANT, type); } + @Override + @NotNull + public TypeProjectionBase replaceType(@NotNull KotlinType type) { + return new TypeProjectionImpl(this.projection, type); + } + @Override @NotNull public Variance getProjectionKind() { diff --git a/core/descriptors/src/org/jetbrains/kotlin/types/TypeSubstitution.kt b/core/descriptors/src/org/jetbrains/kotlin/types/TypeSubstitution.kt index b5e75beb208..645874abcd1 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/types/TypeSubstitution.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/types/TypeSubstitution.kt @@ -21,8 +21,9 @@ import org.jetbrains.kotlin.descriptors.annotations.Annotations abstract class TypeSubstitution { companion object { - @JvmField val EMPTY: TypeSubstitution = object : TypeSubstitution() { - override fun get(key: KotlinType) = null + @JvmField + val EMPTY: TypeSubstitution = object : TypeSubstitution() { + override fun get(key: KotlinType): Nothing? = null override fun isEmpty() = true override fun toString() = "Empty TypeSubstitution" } @@ -52,8 +53,8 @@ abstract class TypeConstructorSubstitution : TypeSubstitution() { @JvmStatic @JvmOverloads fun createByConstructorsMap( - map: Map, - approximateCapturedTypes: Boolean = false + map: Map, + approximateCapturedTypes: Boolean = false ): TypeConstructorSubstitution = object : TypeConstructorSubstitution() { override fun get(key: TypeConstructor) = map[key] @@ -61,18 +62,21 @@ abstract class TypeConstructorSubstitution : TypeSubstitution() { override fun approximateCapturedTypes() = approximateCapturedTypes } - @JvmStatic fun createByParametersMap(map: Map): TypeConstructorSubstitution = + @JvmStatic + fun createByParametersMap(map: Map): TypeConstructorSubstitution = object : TypeConstructorSubstitution() { override fun get(key: TypeConstructor) = map[key.declarationDescriptor] override fun isEmpty() = map.isEmpty() } - @JvmStatic fun create(kotlinType: KotlinType) = create(kotlinType.constructor, kotlinType.arguments) + @JvmStatic + fun create(kotlinType: KotlinType) = create(kotlinType.constructor, kotlinType.arguments) - @JvmStatic fun create(typeConstructor: TypeConstructor, arguments: List): TypeSubstitution { + @JvmStatic + fun create(typeConstructor: TypeConstructor, arguments: List): TypeSubstitution { val parameters = typeConstructor.parameters - if (parameters.lastOrNull()?.isCapturedFromOuterDeclaration ?: false) { + if (parameters.lastOrNull()?.isCapturedFromOuterDeclaration == true) { return createByConstructorsMap(typeConstructor.parameters.map { it.typeConstructor }.zip(arguments).toMap()) } @@ -93,7 +97,8 @@ class IndexedParametersSubstitution( } constructor( - parameters: List, argumentsList: List + parameters: List, + argumentsList: List ) : this(parameters.toTypedArray(), argumentsList.toTypedArray()) override fun isEmpty(): Boolean = arguments.isEmpty() @@ -114,23 +119,25 @@ class IndexedParametersSubstitution( @JvmOverloads fun KotlinType.replace( - newArguments: List = arguments, - newAnnotations: Annotations = annotations + newArguments: List = arguments, + newAnnotations: Annotations = annotations, + newArgumentsForUpperBound: List = newArguments ): KotlinType { if ((newArguments.isEmpty() || newArguments === arguments) && newAnnotations === annotations) return this - val unwrapped = unwrap() - return when(unwrapped) { - is FlexibleType -> KotlinTypeFactory.flexibleType(unwrapped.lowerBound.replace(newArguments, newAnnotations), - unwrapped.upperBound.replace(newArguments, newAnnotations)) + return when (val unwrapped = unwrap()) { + is FlexibleType -> KotlinTypeFactory.flexibleType( + unwrapped.lowerBound.replace(newArguments, newAnnotations), + unwrapped.upperBound.replace(newArgumentsForUpperBound, newAnnotations) + ) is SimpleType -> unwrapped.replace(newArguments, newAnnotations) } } @JvmOverloads fun SimpleType.replace( - newArguments: List = arguments, - newAnnotations: Annotations = annotations + newArguments: List = arguments, + newAnnotations: Annotations = annotations ): SimpleType { if (newArguments.isEmpty() && newAnnotations === annotations) return this @@ -139,16 +146,17 @@ fun SimpleType.replace( } return KotlinTypeFactory.simpleType( - newAnnotations, - constructor, - newArguments, - isMarkedNullable + newAnnotations, + constructor, + newArguments, + isMarkedNullable ) } -open class DelegatedTypeSubstitution(val substitution: TypeSubstitution): TypeSubstitution() { +open class DelegatedTypeSubstitution(val substitution: TypeSubstitution) : TypeSubstitution() { override fun get(key: KotlinType) = substitution[key] - override fun prepareTopLevelType(topLevelType: KotlinType, position: Variance) = substitution.prepareTopLevelType(topLevelType, position) + override fun prepareTopLevelType(topLevelType: KotlinType, position: Variance) = + substitution.prepareTopLevelType(topLevelType, position) override fun isEmpty() = substitution.isEmpty() From 48d9812d9e379af7713d93833d7eceb5f6222b0f Mon Sep 17 00:00:00 2001 From: Victor Petukhov Date: Thu, 17 Dec 2020 15:37:16 +0300 Subject: [PATCH 169/196] Review fixes around type enhancement and loading type use annotations --- .../structure/impl/classFiles/Annotations.kt | 153 +++++++----------- .../impl/classFiles/BinaryJavaClass.kt | 42 ++--- .../java/structure/impl/classFiles/Other.kt | 1 + .../testData/cli/jvm/apiVersionInvalid.out | 2 +- .../cli/jvm/languageVersionInvalid.out | 2 +- .../Basic.runtime.txt | 10 +- .../Basic_DisabledImprovements.runtime.txt | 32 ++++ ...gnAnnotationsCompiledJavaDiagnosticTest.kt | 20 +-- ...nsCompiledJavaDiagnosticTestGenerated.java | 3 +- ...sNoAnnotationInClasspathTestGenerated.java | 45 +----- ...spathWithPsiClassReadingTestGenerated.java | 45 +----- .../ForeignJava8AnnotationsTestGenerated.java | 45 +----- ...cForeignJava8AnnotationsTestGenerated.java | 45 +----- .../generators/tests/GenerateJava8Tests.kt | 11 +- .../jvm/compiler/LoadJava8TestGenerated.java | 8 +- .../load/java/structure/javaElements.kt | 6 +- .../typeEnhancement/signatureEnhancement.kt | 6 +- ...8RuntimeDescriptorLoaderTestGenerated.java | 4 +- .../kotlin/gradle/dsl/KotlinCommonOptions.kt | 6 +- 19 files changed, 148 insertions(+), 338 deletions(-) create mode 100644 compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic_DisabledImprovements.runtime.txt diff --git a/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/Annotations.kt b/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/Annotations.kt index b474fa1e2bf..a6a5dd1e248 100644 --- a/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/Annotations.kt +++ b/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/Annotations.kt @@ -18,7 +18,6 @@ package org.jetbrains.kotlin.load.java.structure.impl.classFiles import org.jetbrains.kotlin.load.java.structure.* import org.jetbrains.kotlin.load.java.structure.impl.classFiles.BinaryJavaAnnotation.Companion.computeTargetType -import org.jetbrains.kotlin.load.java.structure.impl.classFiles.BinaryJavaAnnotation.Companion.translatePath import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name @@ -38,20 +37,14 @@ internal class AnnotationsCollectorFieldVisitor( if (descriptor == null) return null val typeReference = TypeReference(typeRef) + val targetType = if (typePath != null) computeTargetType(field.type, typePath) else field.type - if (typePath != null) { - val translatedPath = translatePath(typePath) - - when (typeReference.sort) { - TypeReference.FIELD -> { - val targetType = computeTargetType(field.type, translatedPath) - return BinaryJavaAnnotation.addAnnotation(targetType as JavaPlainType, descriptor, context, signatureParser, true) - } - } - } + if (targetType !is MutableJavaAnnotationOwner) return null return when (typeReference.sort) { - TypeReference.FIELD -> BinaryJavaAnnotation.addAnnotation(field.type as JavaPlainType, descriptor, context, signatureParser, true) + TypeReference.FIELD -> BinaryJavaAnnotation.addAnnotation( + targetType, descriptor, context, signatureParser, isFreshlySupportedAnnotation = true + ) else -> null } } @@ -69,7 +62,9 @@ internal class AnnotationsAndParameterCollectorMethodVisitor( private var visibleAnnotableParameterCount = parametersCountInMethodDesc private var invisibleAnnotableParameterCount = parametersCountInMethodDesc - override fun visitAnnotationDefault(): AnnotationVisitor? = + val freshlySupportedPositions = setOf(TypeReference.METHOD_TYPE_PARAMETER, TypeReference.METHOD_TYPE_PARAMETER_BOUND) + + override fun visitAnnotationDefault(): AnnotationVisitor = BinaryJavaAnnotationVisitor(context, signatureParser) { member.safeAs()?.annotationParameterDefaultValue = it } @@ -91,7 +86,6 @@ internal class AnnotationsAndParameterCollectorMethodVisitor( override fun visitAnnotation(desc: String, visible: Boolean) = BinaryJavaAnnotation.addAnnotation(member, desc, context, signatureParser) - @Suppress("NOTHING_TO_OVERRIDE") override fun visitAnnotableParameterCount(parameterCount: Int, visible: Boolean) { if (visible) { visibleAnnotableParameterCount = parameterCount @@ -109,39 +103,30 @@ internal class AnnotationsAndParameterCollectorMethodVisitor( return BinaryJavaAnnotation.addAnnotation(member.valueParameters[index], desc, context, signatureParser) } - override fun visitTypeAnnotation(typeRef: Int, typePath: TypePath?, desc: String, visible: Boolean): AnnotationVisitor? { + override fun visitTypeAnnotation(typeRef: Int, typePath: TypePath?, descriptor: String, visible: Boolean): AnnotationVisitor? { val typeReference = TypeReference(typeRef) - if (typePath != null) { - val baseType = when (typeReference.sort) { - TypeReference.METHOD_RETURN -> member.safeAs()?.returnType - TypeReference.METHOD_FORMAL_PARAMETER -> member.valueParameters[typeReference.formalParameterIndex].type - TypeReference.METHOD_TYPE_PARAMETER_BOUND -> - BinaryJavaAnnotation.computeTypeParameterBound(member.typeParameters, typeReference) - else -> null - } ?: return null + fun getTargetType(baseType: JavaType) = + if (typePath != null) { + computeTargetType(baseType, typePath) to true + } else { + baseType to (typeReference.sort in freshlySupportedPositions) + } - return BinaryJavaAnnotation.addAnnotation( - computeTargetType(baseType, translatePath(typePath)) as JavaPlainType, desc, context, signatureParser, true + val (annotationOwner, isFreshlySupportedAnnotation) = when (typeReference.sort) { + TypeReference.METHOD_RETURN -> getTargetType(member.safeAs()?.returnType ?: return null) + TypeReference.METHOD_TYPE_PARAMETER -> member.typeParameters[typeReference.typeParameterIndex] to true + TypeReference.METHOD_FORMAL_PARAMETER -> getTargetType(member.valueParameters[typeReference.formalParameterIndex].type) + TypeReference.METHOD_TYPE_PARAMETER_BOUND -> getTargetType( + BinaryJavaAnnotation.computeTypeParameterBound(member.typeParameters, typeReference) ) - } - - val (targetType, isFreshlySupportedAnnotation) = when (typeReference.sort) { - TypeReference.METHOD_RETURN -> - (member as? BinaryJavaMethod)?.returnType as JavaPlainType to false - TypeReference.METHOD_TYPE_PARAMETER -> - member.typeParameters[typeReference.typeParameterIndex] as BinaryJavaTypeParameter to true - TypeReference.METHOD_FORMAL_PARAMETER -> - member.valueParameters[typeReference.formalParameterIndex].type as JavaPlainType to false - TypeReference.METHOD_TYPE_PARAMETER_BOUND -> - BinaryJavaAnnotation.computeTypeParameterBound(member.typeParameters, typeReference) as JavaPlainType to true else -> return null } - return BinaryJavaAnnotation.addAnnotation(targetType, desc, context, signatureParser, isFreshlySupportedAnnotation) - } + if (annotationOwner !is MutableJavaAnnotationOwner) return null - enum class PathElementType { ARRAY_ELEMENT, WILDCARD_BOUND, ENCLOSING_CLASS, TYPE_ARGUMENT } + return BinaryJavaAnnotation.addAnnotation(annotationOwner, descriptor, context, signatureParser, isFreshlySupportedAnnotation) + } } class BinaryJavaAnnotation private constructor( @@ -150,9 +135,7 @@ class BinaryJavaAnnotation private constructor( override val arguments: Collection, override val isFreshlySupportedTypeUseAnnotation: Boolean ) : JavaAnnotation { - companion object { - fun createAnnotationAndVisitor( desc: String, context: ClassifierResolutionContext, @@ -178,66 +161,52 @@ class BinaryJavaAnnotation private constructor( return annotationVisitor } - internal fun translatePath(path: TypePath): List> { - val length = path.length - val list = mutableListOf>() - for (i in 0 until length) { - when (path.getStep(i)) { - TypePath.INNER_TYPE -> { - continue - } - TypePath.ARRAY_ELEMENT -> { - list.add(AnnotationsAndParameterCollectorMethodVisitor.PathElementType.ARRAY_ELEMENT to null) + @OptIn(ExperimentalStdlibApi::class) + private fun translatePath(path: TypePath) = buildList { + for (i in 0 until path.length) { + when (val step = path.getStep(i)) { + // TODO: process inner types and apply an annotation to the corresponding type component + TypePath.INNER_TYPE -> continue + TypePath.ARRAY_ELEMENT, TypePath.WILDCARD_BOUND -> add(step to 0) + TypePath.TYPE_ARGUMENT -> add(step to path.getStepArgument(i)) + } + } + } + + internal fun computeTargetType(baseType: JavaType, typePath: TypePath) = + translatePath(typePath).fold(baseType) { targetType, (typePathKind, typeArgumentIndex) -> + when (typePathKind) { + TypePath.TYPE_ARGUMENT -> { + require(targetType is JavaClassifierType) + targetType.typeArguments[typeArgumentIndex] + ?: throw IllegalArgumentException("There must be no less than ${typeArgumentIndex + 1} type arguments") } TypePath.WILDCARD_BOUND -> { - list.add(AnnotationsAndParameterCollectorMethodVisitor.PathElementType.WILDCARD_BOUND to null) + // TODO: think about processing annotated wildcards themselves + require(targetType is JavaWildcardType) + targetType.bound + ?: throw IllegalArgumentException("Wildcard mast have a bound for annotation of WILDCARD_BOUND position") } - TypePath.TYPE_ARGUMENT -> { - list.add(AnnotationsAndParameterCollectorMethodVisitor.PathElementType.TYPE_ARGUMENT to path.getStepArgument(i)) - } - } - } - return list - } - - internal fun computeTargetType( - baseType: JavaType, - typePath: List> - ): JavaType { - var targetType = baseType - - for (element in typePath) { - when (element.first) { - AnnotationsAndParameterCollectorMethodVisitor.PathElementType.TYPE_ARGUMENT -> { - if (targetType is JavaClassifierType) { - targetType = targetType.typeArguments[element.second!!]!! - } - } - AnnotationsAndParameterCollectorMethodVisitor.PathElementType.WILDCARD_BOUND -> { - if (targetType is JavaWildcardType) { - targetType = targetType.bound!! - } - } - AnnotationsAndParameterCollectorMethodVisitor.PathElementType.ARRAY_ELEMENT -> { - if (targetType is JavaArrayType) { - targetType = targetType.componentType - } + TypePath.ARRAY_ELEMENT -> { + require(targetType is JavaArrayType) + targetType.componentType } + else -> targetType } } - return targetType - } + internal fun computeTypeParameterBound(typeParameters: List, typeReference: TypeReference): JavaClassifierType { + val typeParameter = typeParameters[typeReference.typeParameterIndex] - internal fun computeTypeParameterBound( - typeParameters: List, - typeReference: TypeReference - ): JavaClassifierType { - val typeParameter = typeParameters[typeReference.typeParameterIndex] as BinaryJavaTypeParameter - val boundIndex = - if (typeParameter.hasImplicitObjectClassBound) typeReference.typeParameterBoundIndex - 1 else typeReference.typeParameterBoundIndex + require(typeParameter is BinaryJavaTypeParameter) { "Type parameter must be a binary type parameter" } - return typeParameters[typeReference.typeParameterIndex].upperBounds.toList()[boundIndex] + val boundIndex = if (typeParameter.hasImplicitObjectClassBound) { + typeReference.typeParameterBoundIndex - 1 + } else { + typeReference.typeParameterBoundIndex + } + + return typeParameter.upperBounds.elementAt(boundIndex) } } diff --git a/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/BinaryJavaClass.kt b/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/BinaryJavaClass.kt index f525228146c..48922713805 100644 --- a/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/BinaryJavaClass.kt +++ b/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/BinaryJavaClass.kt @@ -56,7 +56,7 @@ class BinaryJavaClass( // In accordance with JVMS, super class always comes before the interface list private val superclass: JavaClassifierType? get() = supertypes.firstOrNull() - private val interfaces: List get() = supertypes.drop(1) + private val implementedInterfaces: List get() = supertypes.drop(1) override val annotationsByFqName by buildLazyValueForMap() @@ -86,38 +86,22 @@ class BinaryJavaClass( if (descriptor == null) return null + fun getTargetType(baseType: JavaType) = + if (typePath != null) BinaryJavaAnnotation.computeTargetType(baseType, typePath) else baseType + val typeReference = TypeReference(typeRef) - if (typePath != null) { - val translatedPath = BinaryJavaAnnotation.translatePath(typePath) - - when (typeReference.sort) { - TypeReference.CLASS_EXTENDS -> { - val baseType: JavaType = if (typeReference.superTypeIndex == -1) superclass!! else interfaces[typeReference.superTypeIndex] - val targetType = BinaryJavaAnnotation.computeTargetType(baseType, translatedPath) - - return BinaryJavaAnnotation.addAnnotation(targetType as JavaPlainType, descriptor, context, signatureParser, true) - } - TypeReference.CLASS_TYPE_PARAMETER_BOUND -> { - val baseType = computeTypeParameterBound(typeParameters, typeReference) - val targetType = BinaryJavaAnnotation.computeTargetType(baseType, translatedPath) - - return BinaryJavaAnnotation.addAnnotation(targetType as JavaPlainType, descriptor, context, signatureParser, true) - } - } + val annotationOwner = when (typeReference.sort) { + TypeReference.CLASS_EXTENDS -> + getTargetType(if (typeReference.superTypeIndex == -1) superclass!! else implementedInterfaces[typeReference.superTypeIndex]) + TypeReference.CLASS_TYPE_PARAMETER -> typeParameters[typeReference.typeParameterIndex] + TypeReference.CLASS_TYPE_PARAMETER_BOUND -> getTargetType(computeTypeParameterBound(typeParameters, typeReference)) + else -> return null } - return when (typeReference.sort) { - TypeReference.CLASS_TYPE_PARAMETER -> - BinaryJavaAnnotation.addAnnotation( - typeParameters[typeReference.typeParameterIndex] as BinaryJavaTypeParameter, descriptor, context, signatureParser, true - ) - TypeReference.CLASS_TYPE_PARAMETER_BOUND -> - BinaryJavaAnnotation.addAnnotation( - computeTypeParameterBound(typeParameters, typeReference) as JavaPlainType, descriptor, context, signatureParser, true - ) - else -> null - } + if (annotationOwner !is MutableJavaAnnotationOwner) return null + + return BinaryJavaAnnotation.addAnnotation(annotationOwner, descriptor, context, signatureParser, isFreshlySupportedAnnotation = true) } override fun visitEnd() { diff --git a/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/Other.kt b/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/Other.kt index 975245f6c61..111ac9ac6b2 100644 --- a/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/Other.kt +++ b/compiler/resolution.common.jvm/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/Other.kt @@ -17,6 +17,7 @@ package org.jetbrains.kotlin.load.java.structure.impl.classFiles import org.jetbrains.kotlin.load.java.structure.* +import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.utils.SmartList import org.jetbrains.org.objectweb.asm.ClassReader diff --git a/compiler/testData/cli/jvm/apiVersionInvalid.out b/compiler/testData/cli/jvm/apiVersionInvalid.out index 5fea5778881..cd148e4175f 100644 --- a/compiler/testData/cli/jvm/apiVersionInvalid.out +++ b/compiler/testData/cli/jvm/apiVersionInvalid.out @@ -1,3 +1,3 @@ error: unknown API version: 239.42 -Supported API versions: 1.2 (DEPRECATED), 1.3, 1.4, 1.5 (EXPERIMENTAL) +Supported API versions: 1.2 (DEPRECATED), 1.3, 1.4, 1.5 (EXPERIMENTAL), 1.6 (EXPERIMENTAL) COMPILATION_ERROR diff --git a/compiler/testData/cli/jvm/languageVersionInvalid.out b/compiler/testData/cli/jvm/languageVersionInvalid.out index 150c7939bd9..27fe891bb92 100644 --- a/compiler/testData/cli/jvm/languageVersionInvalid.out +++ b/compiler/testData/cli/jvm/languageVersionInvalid.out @@ -1,3 +1,3 @@ error: unknown language version: 239.42 -Supported language versions: 1.2 (DEPRECATED), 1.3, 1.4, 1.5 (EXPERIMENTAL) +Supported language versions: 1.2 (DEPRECATED), 1.3, 1.4, 1.5 (EXPERIMENTAL), 1.6 (EXPERIMENTAL) COMPILATION_ERROR diff --git a/compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic.runtime.txt b/compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic.runtime.txt index 2a256fb0fdf..181650e0d52 100644 --- a/compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic.runtime.txt +++ b/compiler/testData/loadJava8/compiledJava/typeParameterAnnotations/Basic.runtime.txt @@ -2,13 +2,13 @@ package test public open class Basic { public constructor Basic() + public/*package*/ open fun foo(/*0*/ R!): kotlin.Unit - @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE_PARAMETER}) @kotlin.annotation.Retention(value = ...) public final annotation class A : kotlin.Annotation { - public final val value: kotlin.String - public final fun (): kotlin.String + public interface G { + public abstract fun foo(/*0*/ R!): kotlin.Unit } - public interface G { - public abstract fun foo(/*0*/ R!): kotlin.Unit + public interface G1 { + public abstract fun foo(/*0*/ R!): kotlin.Unit } } diff --git a/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic_DisabledImprovements.runtime.txt b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic_DisabledImprovements.runtime.txt new file mode 100644 index 00000000000..9db3a85acae --- /dev/null +++ b/compiler/testData/loadJava8/compiledJava/typeUseAnnotations/Basic_DisabledImprovements.runtime.txt @@ -0,0 +1,32 @@ +package test + +public open class Basic_DisabledImprovements { + public/*package*/ constructor Basic_DisabledImprovements(/*0*/ test.Basic_DisabledImprovements.G!) + + public/*package*/ open class A { + public/*package*/ constructor A() + + public/*package*/ open inner class B { + public/*package*/ constructor B() + } + } + + public/*package*/ interface G : test.Basic_DisabledImprovements.G2 { + } + + public/*package*/ interface G2 { + } + + public interface MyClass { + public abstract fun f1(/*0*/ test.Basic_DisabledImprovements.G!): kotlin.Unit + public abstract fun !>!> f10(/*0*/ T!): kotlin.Unit + public abstract fun f2(): test.Basic_DisabledImprovements.G2! + public abstract fun f3(/*0*/ T!): kotlin.Unit + public abstract fun f4(/*0*/ test.Basic_DisabledImprovements.G!>!): kotlin.Unit + public abstract fun f5(/*0*/ test.Basic_DisabledImprovements.G<*>!): kotlin.Unit + public abstract fun f6(/*0*/ test.Basic_DisabledImprovements.G<*>!): kotlin.Unit + public abstract fun f7(/*0*/ test.Basic_DisabledImprovements.G!>!): kotlin.Unit + public abstract fun f81(): test.Basic_DisabledImprovements.G!>! + public abstract fun f9(): test.Basic_DisabledImprovements.G!>! + } +} diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractForeignAnnotationsCompiledJavaDiagnosticTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractForeignAnnotationsCompiledJavaDiagnosticTest.kt index 2f06585782b..57be257095e 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractForeignAnnotationsCompiledJavaDiagnosticTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractForeignAnnotationsCompiledJavaDiagnosticTest.kt @@ -5,7 +5,6 @@ package org.jetbrains.kotlin.checkers -import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.test.MockLibraryUtil.compileJavaFilesLibraryToJar import java.io.File import kotlin.io.path.ExperimentalPathApi @@ -18,26 +17,21 @@ abstract class AbstractForeignAnnotationsCompiledJavaDiagnosticTest : AbstractDi files: List ) { val ktFiles = files.filter { !it.name.endsWith(".java") } - - val dir = createTempDirectory() val javaFile = File("${wholeFile.parentFile.path}/${wholeFile.nameWithoutExtension}.java") - File("$dir/${wholeFile.nameWithoutExtension}.java").apply { createNewFile() }.writeText(javaFile.readText()) - File(FOREIGN_JDK8_ANNOTATIONS_SOURCES_PATH).copyRecursively(File("$dir/annotations/")) + assertExists(javaFile) + + val javaFilesDir = createTempDirectory().toFile().also { + File(FOREIGN_JDK8_ANNOTATIONS_SOURCES_PATH).copyRecursively(File("$it/annotations/")) + javaFile.copyTo(File("$it/${javaFile.name}")) + } super.doMultiFileTest( wholeFile, ktFiles, - compileJavaFilesLibraryToJar(dir.toString(), "foreign-annotations"), + compileJavaFilesLibraryToJar(javaFilesDir.path, "java-files"), usePsiClassFilesReading = false, excludeNonTypeUseJetbrainsAnnotations = true ) } - - override fun doTest(filePath: String) { - val file = File(filePath) - val expectedText = KotlinTestUtils.doLoadFile(file) - - doMultiFileTest(file, createTestFilesFromFile(file, expectedText)) - } } diff --git a/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignAnnotationsCompiledJavaDiagnosticTestGenerated.java b/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignAnnotationsCompiledJavaDiagnosticTestGenerated.java index 3d3e1d606f0..4116daf3dd9 100644 --- a/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignAnnotationsCompiledJavaDiagnosticTestGenerated.java +++ b/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignAnnotationsCompiledJavaDiagnosticTestGenerated.java @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.checkers; import com.intellij.testFramework.TestDataPath; import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TestMetadata; import org.junit.runner.RunWith; @@ -25,7 +26,7 @@ public class ForeignAnnotationsCompiledJavaDiagnosticTestGenerated extends Abstr } public void testAllFilesPresentInTypeEnhancementOnCompiledJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava"), Pattern.compile("^(.+)\\.kt$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava"), Pattern.compile("^(.+)\\.kt$"), null, true); } @TestMetadata("ClassTypeParameterBound.kt") diff --git a/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsNoAnnotationInClasspathTestGenerated.java b/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsNoAnnotationInClasspathTestGenerated.java index 654e7666322..75fd2eb2ba1 100644 --- a/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsNoAnnotationInClasspathTestGenerated.java +++ b/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsNoAnnotationInClasspathTestGenerated.java @@ -26,7 +26,7 @@ public class ForeignJava8AnnotationsNoAnnotationInClasspathTestGenerated extends } public void testAllFilesPresentInTests() throws Exception { - KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests"), Pattern.compile("^(.+)\\.kt$"), null, true, "jspecify"); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests"), Pattern.compile("^(.+)\\.kt$"), null, true, "jspecify", "typeEnhancementOnCompiledJava"); } @TestMetadata("checkerFramework.kt") @@ -129,47 +129,4 @@ public class ForeignJava8AnnotationsNoAnnotationInClasspathTestGenerated extends runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/simple.kt"); } } - - @TestMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava") - @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class TypeEnhancementOnCompiledJava extends AbstractForeignJava8AnnotationsNoAnnotationInClasspathTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - - public void testAllFilesPresentInTypeEnhancementOnCompiledJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava"), Pattern.compile("^(.+)\\.kt$"), null, true); - } - - @TestMetadata("ClassTypeParameterBound.kt") - public void testClassTypeParameterBound() throws Exception { - runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ClassTypeParameterBound.kt"); - } - - @TestMetadata("ClassTypeParameterBoundWithWarnings.kt") - public void testClassTypeParameterBoundWithWarnings() throws Exception { - runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ClassTypeParameterBoundWithWarnings.kt"); - } - - @TestMetadata("ReturnType.kt") - public void testReturnType() throws Exception { - runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ReturnType.kt"); - } - - @TestMetadata("ReturnTypeWithWarnings.kt") - public void testReturnTypeWithWarnings() throws Exception { - runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ReturnTypeWithWarnings.kt"); - } - - @TestMetadata("ValueParameter.kt") - public void testValueParameter() throws Exception { - runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ValueParameter.kt"); - } - - @TestMetadata("ValueParameterWithWarnings.kt") - public void testValueParameterWithWarnings() throws Exception { - runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ValueParameterWithWarnings.kt"); - } - } } diff --git a/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsNoAnnotationInClasspathWithPsiClassReadingTestGenerated.java b/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsNoAnnotationInClasspathWithPsiClassReadingTestGenerated.java index c1a3cf480ce..ae58e4e1528 100644 --- a/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsNoAnnotationInClasspathWithPsiClassReadingTestGenerated.java +++ b/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsNoAnnotationInClasspathWithPsiClassReadingTestGenerated.java @@ -26,7 +26,7 @@ public class ForeignJava8AnnotationsNoAnnotationInClasspathWithPsiClassReadingTe } public void testAllFilesPresentInTests() throws Exception { - KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests"), Pattern.compile("^(.+)\\.kt$"), null, true, "jspecify"); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests"), Pattern.compile("^(.+)\\.kt$"), null, true, "jspecify", "typeEnhancementOnCompiledJava"); } @TestMetadata("checkerFramework.kt") @@ -129,47 +129,4 @@ public class ForeignJava8AnnotationsNoAnnotationInClasspathWithPsiClassReadingTe runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/simple.kt"); } } - - @TestMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava") - @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class TypeEnhancementOnCompiledJava extends AbstractForeignJava8AnnotationsNoAnnotationInClasspathWithPsiClassReadingTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - - public void testAllFilesPresentInTypeEnhancementOnCompiledJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava"), Pattern.compile("^(.+)\\.kt$"), null, true); - } - - @TestMetadata("ClassTypeParameterBound.kt") - public void testClassTypeParameterBound() throws Exception { - runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ClassTypeParameterBound.kt"); - } - - @TestMetadata("ClassTypeParameterBoundWithWarnings.kt") - public void testClassTypeParameterBoundWithWarnings() throws Exception { - runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ClassTypeParameterBoundWithWarnings.kt"); - } - - @TestMetadata("ReturnType.kt") - public void testReturnType() throws Exception { - runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ReturnType.kt"); - } - - @TestMetadata("ReturnTypeWithWarnings.kt") - public void testReturnTypeWithWarnings() throws Exception { - runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ReturnTypeWithWarnings.kt"); - } - - @TestMetadata("ValueParameter.kt") - public void testValueParameter() throws Exception { - runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ValueParameter.kt"); - } - - @TestMetadata("ValueParameterWithWarnings.kt") - public void testValueParameterWithWarnings() throws Exception { - runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ValueParameterWithWarnings.kt"); - } - } } diff --git a/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsTestGenerated.java b/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsTestGenerated.java index d63396f3bbe..4eb268efc01 100644 --- a/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsTestGenerated.java +++ b/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/ForeignJava8AnnotationsTestGenerated.java @@ -26,7 +26,7 @@ public class ForeignJava8AnnotationsTestGenerated extends AbstractForeignJava8An } public void testAllFilesPresentInTests() throws Exception { - KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests"), Pattern.compile("^(.+)\\.kt$"), null, true, "jspecify"); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests"), Pattern.compile("^(.+)\\.kt$"), null, true, "jspecify", "typeEnhancementOnCompiledJava"); } @TestMetadata("checkerFramework.kt") @@ -129,47 +129,4 @@ public class ForeignJava8AnnotationsTestGenerated extends AbstractForeignJava8An runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/simple.kt"); } } - - @TestMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava") - @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class TypeEnhancementOnCompiledJava extends AbstractForeignJava8AnnotationsTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - - public void testAllFilesPresentInTypeEnhancementOnCompiledJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava"), Pattern.compile("^(.+)\\.kt$"), null, true); - } - - @TestMetadata("ClassTypeParameterBound.kt") - public void testClassTypeParameterBound() throws Exception { - runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ClassTypeParameterBound.kt"); - } - - @TestMetadata("ClassTypeParameterBoundWithWarnings.kt") - public void testClassTypeParameterBoundWithWarnings() throws Exception { - runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ClassTypeParameterBoundWithWarnings.kt"); - } - - @TestMetadata("ReturnType.kt") - public void testReturnType() throws Exception { - runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ReturnType.kt"); - } - - @TestMetadata("ReturnTypeWithWarnings.kt") - public void testReturnTypeWithWarnings() throws Exception { - runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ReturnTypeWithWarnings.kt"); - } - - @TestMetadata("ValueParameter.kt") - public void testValueParameter() throws Exception { - runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ValueParameter.kt"); - } - - @TestMetadata("ValueParameterWithWarnings.kt") - public void testValueParameterWithWarnings() throws Exception { - runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ValueParameterWithWarnings.kt"); - } - } } diff --git a/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/javac/JavacForeignJava8AnnotationsTestGenerated.java b/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/javac/JavacForeignJava8AnnotationsTestGenerated.java index 06657adadb2..0f3fbf48add 100644 --- a/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/javac/JavacForeignJava8AnnotationsTestGenerated.java +++ b/compiler/tests-java8/tests/org/jetbrains/kotlin/checkers/javac/JavacForeignJava8AnnotationsTestGenerated.java @@ -26,7 +26,7 @@ public class JavacForeignJava8AnnotationsTestGenerated extends AbstractJavacFore } public void testAllFilesPresentInTests() throws Exception { - KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests"), Pattern.compile("^(.+)\\.kt$"), null, true, "jspecify"); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests"), Pattern.compile("^(.+)\\.kt$"), null, true, "jspecify", "typeEnhancementOnCompiledJava"); } @TestMetadata("checkerFramework.kt") @@ -129,47 +129,4 @@ public class JavacForeignJava8AnnotationsTestGenerated extends AbstractJavacFore runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancement/simple.kt"); } } - - @TestMetadata("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava") - @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class TypeEnhancementOnCompiledJava extends AbstractJavacForeignJava8AnnotationsTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest(this::doTest, this, testDataFilePath); - } - - public void testAllFilesPresentInTypeEnhancementOnCompiledJava() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava"), Pattern.compile("^(.+)\\.kt$"), null, true); - } - - @TestMetadata("ClassTypeParameterBound.kt") - public void testClassTypeParameterBound() throws Exception { - runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ClassTypeParameterBound.kt"); - } - - @TestMetadata("ClassTypeParameterBoundWithWarnings.kt") - public void testClassTypeParameterBoundWithWarnings() throws Exception { - runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ClassTypeParameterBoundWithWarnings.kt"); - } - - @TestMetadata("ReturnType.kt") - public void testReturnType() throws Exception { - runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ReturnType.kt"); - } - - @TestMetadata("ReturnTypeWithWarnings.kt") - public void testReturnTypeWithWarnings() throws Exception { - runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ReturnTypeWithWarnings.kt"); - } - - @TestMetadata("ValueParameter.kt") - public void testValueParameter() throws Exception { - runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ValueParameter.kt"); - } - - @TestMetadata("ValueParameterWithWarnings.kt") - public void testValueParameterWithWarnings() throws Exception { - runTest("compiler/testData/foreignAnnotationsJava8/tests/typeEnhancementOnCompiledJava/ValueParameterWithWarnings.kt"); - } - } } diff --git a/compiler/tests-java8/tests/org/jetbrains/kotlin/generators/tests/GenerateJava8Tests.kt b/compiler/tests-java8/tests/org/jetbrains/kotlin/generators/tests/GenerateJava8Tests.kt index 108602199d2..aead7323de0 100644 --- a/compiler/tests-java8/tests/org/jetbrains/kotlin/generators/tests/GenerateJava8Tests.kt +++ b/compiler/tests-java8/tests/org/jetbrains/kotlin/generators/tests/GenerateJava8Tests.kt @@ -30,19 +30,22 @@ fun main(args: Array) { generateTestGroupSuite(args) { testGroup("compiler/tests-java8/tests", "compiler/testData") { testClass { - model("foreignAnnotationsJava8/tests", excludeDirs = listOf("jspecify")) + model("foreignAnnotationsJava8/tests", excludeDirs = listOf("jspecify", "typeEnhancementOnCompiledJava")) } testClass { - model("foreignAnnotationsJava8/tests", excludeDirs = listOf("jspecify")) + model("foreignAnnotationsJava8/tests", excludeDirs = listOf("jspecify", "typeEnhancementOnCompiledJava")) } testClass { - model("foreignAnnotationsJava8/tests", excludeDirs = listOf("jspecify")) + model("foreignAnnotationsJava8/tests", excludeDirs = listOf("jspecify", "typeEnhancementOnCompiledJava")) } testClass { - model("foreignAnnotationsJava8/tests", excludeDirs = listOf("jspecify")) + model( + "foreignAnnotationsJava8/tests", + excludeDirs = listOf("jspecify", "typeEnhancementOnCompiledJava") + ) } testClass { diff --git a/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/LoadJava8TestGenerated.java b/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/LoadJava8TestGenerated.java index f02f9b91ef2..c285cf7b703 100644 --- a/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/LoadJava8TestGenerated.java +++ b/compiler/tests-java8/tests/org/jetbrains/kotlin/jvm/compiler/LoadJava8TestGenerated.java @@ -55,7 +55,7 @@ public class LoadJava8TestGenerated extends AbstractLoadJava8Test { } public void testAllFilesPresentInTypeParameterAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/compiledJava/typeParameterAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/compiledJava/typeParameterAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("Basic.java") @@ -78,7 +78,7 @@ public class LoadJava8TestGenerated extends AbstractLoadJava8Test { } public void testAllFilesPresentInTypeUseAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/compiledJava/typeUseAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/compiledJava/typeUseAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("BaseClassTypeArguments.java") @@ -154,7 +154,7 @@ public class LoadJava8TestGenerated extends AbstractLoadJava8Test { } public void testAllFilesPresentInTypeParameterAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/sourceJava/typeParameterAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/sourceJava/typeParameterAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("Basic.java") @@ -177,7 +177,7 @@ public class LoadJava8TestGenerated extends AbstractLoadJava8Test { } public void testAllFilesPresentInTypeUseAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/sourceJava/typeUseAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/sourceJava/typeUseAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("BaseClassTypeArguments.java") diff --git a/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/structure/javaElements.kt b/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/structure/javaElements.kt index 10fe0bc09bb..c32b9e35062 100644 --- a/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/structure/javaElements.kt +++ b/core/compiler.common.jvm/src/org/jetbrains/kotlin/load/java/structure/javaElements.kt @@ -48,8 +48,10 @@ interface JavaTypeParameterListOwner : JavaElement { interface JavaAnnotation : JavaElement { val arguments: Collection val classId: ClassId? - val isIdeExternalAnnotation: Boolean get() = false - val isFreshlySupportedTypeUseAnnotation: Boolean get() = false + val isIdeExternalAnnotation: Boolean + get() = false + val isFreshlySupportedTypeUseAnnotation: Boolean + get() = false fun resolve(): JavaClass? } diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/signatureEnhancement.kt b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/signatureEnhancement.kt index 06b40889420..6e4a1f372ac 100644 --- a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/signatureEnhancement.kt +++ b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/typeEnhancement/signatureEnhancement.kt @@ -261,11 +261,7 @@ class SignatureEnhancement( * class A extends B<@NotNull Integer> {} */ fun enhanceSuperType(type: KotlinType, context: LazyJavaResolverContext) = - SignatureParts( - null, type, emptyList(), false, context, - AnnotationQualifierApplicabilityType.TYPE_USE, - typeParameterBounds = true - ).enhance().type + SignatureParts(null, type, emptyList(), false, context, AnnotationQualifierApplicabilityType.TYPE_USE).enhance().type private fun ValueParameterDescriptor.hasDefaultValueInAnnotation(type: KotlinType) = when (val defaultValue = getDefaultValueFromAnnotation()) { diff --git a/core/descriptors.runtime/tests/org/jetbrains/kotlin/jvm/runtime/Jvm8RuntimeDescriptorLoaderTestGenerated.java b/core/descriptors.runtime/tests/org/jetbrains/kotlin/jvm/runtime/Jvm8RuntimeDescriptorLoaderTestGenerated.java index b1d8877591d..bb8b8b41209 100644 --- a/core/descriptors.runtime/tests/org/jetbrains/kotlin/jvm/runtime/Jvm8RuntimeDescriptorLoaderTestGenerated.java +++ b/core/descriptors.runtime/tests/org/jetbrains/kotlin/jvm/runtime/Jvm8RuntimeDescriptorLoaderTestGenerated.java @@ -53,7 +53,7 @@ public class Jvm8RuntimeDescriptorLoaderTestGenerated extends AbstractJvm8Runtim } public void testAllFilesPresentInTypeParameterAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/compiledJava/typeParameterAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/compiledJava/typeParameterAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("Basic.java") @@ -76,7 +76,7 @@ public class Jvm8RuntimeDescriptorLoaderTestGenerated extends AbstractJvm8Runtim } public void testAllFilesPresentInTypeUseAnnotations() throws Exception { - KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/compiledJava/typeUseAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true); + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/loadJava8/compiledJava/typeUseAnnotations"), Pattern.compile("^(.+)\\.java$"), null, true); } @TestMetadata("BaseClassTypeArguments.java") diff --git a/libraries/tools/kotlin-gradle-plugin-api/src/main/kotlin/org/jetbrains/kotlin/gradle/dsl/KotlinCommonOptions.kt b/libraries/tools/kotlin-gradle-plugin-api/src/main/kotlin/org/jetbrains/kotlin/gradle/dsl/KotlinCommonOptions.kt index 97e0e6dc889..ba5d1c01b53 100644 --- a/libraries/tools/kotlin-gradle-plugin-api/src/main/kotlin/org/jetbrains/kotlin/gradle/dsl/KotlinCommonOptions.kt +++ b/libraries/tools/kotlin-gradle-plugin-api/src/main/kotlin/org/jetbrains/kotlin/gradle/dsl/KotlinCommonOptions.kt @@ -6,15 +6,15 @@ interface KotlinCommonOptions : org.jetbrains.kotlin.gradle.dsl.KotlinCommonToo /** * Allow using declarations only from the specified version of bundled libraries - * Possible values: "1.2 (DEPRECATED)", "1.3", "1.4", "1.5 (EXPERIMENTAL)" + * Possible values: "1.2 (DEPRECATED)", "1.3", "1.4", "1.5 (EXPERIMENTAL)", "1.6 (EXPERIMENTAL)" * Default value: null */ var apiVersion: kotlin.String? /** * Provide source compatibility with the specified version of Kotlin - * Possible values: "1.2 (DEPRECATED)", "1.3", "1.4", "1.5 (EXPERIMENTAL)" + * Possible values: "1.2 (DEPRECATED)", "1.3", "1.4", "1.5 (EXPERIMENTAL)", "1.6 (EXPERIMENTAL)" * Default value: null */ var languageVersion: kotlin.String? -} +} \ No newline at end of file From f922ebbfc38e6647ba3e866c0372d55eaf761f22 Mon Sep 17 00:00:00 2001 From: Ilmir Usmanov Date: Thu, 17 Dec 2020 20:27:32 +0100 Subject: [PATCH 170/196] Value classes: Add JvmInlineValueClasses language feature --- .../kotlin/resolve/ModifiersChecker.kt | 4 ++-- .../checkers/InlineClassDeclarationChecker.kt | 24 ++++++++++++++++--- .../ResultClassInReturnTypeChecker.kt | 3 ++- .../basicValueClassDeclarationDisabled.kt | 2 +- .../testsWithJvmBackend/noWarningInLV1_5.kt | 9 +++++++ .../testsWithJvmBackend/noWarningInLV1_5.txt | 23 ++++++++++++++++++ ...gnosticsTestWithJvmIrBackendGenerated.java | 6 +++++ ...nosticsTestWithOldJvmBackendGenerated.java | 6 +++++ .../kotlin/config/LanguageVersionSettings.kt | 1 + 9 files changed, 71 insertions(+), 7 deletions(-) create mode 100644 compiler/testData/diagnostics/testsWithJvmBackend/noWarningInLV1_5.kt create mode 100644 compiler/testData/diagnostics/testsWithJvmBackend/noWarningInLV1_5.txt diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.kt index bed41c3165b..21053197d8f 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.kt @@ -119,8 +119,7 @@ object ModifierCheckerCore { EXPECT_KEYWORD to listOf(LanguageFeature.MultiPlatformProjects), ACTUAL_KEYWORD to listOf(LanguageFeature.MultiPlatformProjects), LATEINIT_KEYWORD to listOf(LanguageFeature.LateinitTopLevelProperties, LanguageFeature.LateinitLocalVariables), - FUN_KEYWORD to listOf(LanguageFeature.FunctionalInterfaceConversion), - VALUE_KEYWORD to listOf(LanguageFeature.InlineClasses) + FUN_KEYWORD to listOf(LanguageFeature.FunctionalInterfaceConversion) ) private val featureDependenciesTargets = mapOf( @@ -128,6 +127,7 @@ object ModifierCheckerCore { LanguageFeature.LateinitLocalVariables to setOf(LOCAL_VARIABLE), LanguageFeature.LateinitTopLevelProperties to setOf(TOP_LEVEL_PROPERTY), LanguageFeature.InlineClasses to setOf(CLASS_ONLY), + LanguageFeature.JvmInlineValueClasses to setOf(CLASS_ONLY), LanguageFeature.FunctionalInterfaceConversion to setOf(INTERFACE) ) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/InlineClassDeclarationChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/InlineClassDeclarationChecker.kt index b122fefe91b..e16ee31e38e 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/InlineClassDeclarationChecker.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/InlineClassDeclarationChecker.kt @@ -7,6 +7,7 @@ package org.jetbrains.kotlin.resolve.checkers import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.builtins.StandardNames +import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.diagnostics.Errors import org.jetbrains.kotlin.lexer.KtTokens @@ -32,11 +33,28 @@ object InlineClassDeclarationChecker : DeclarationChecker { if (descriptor !is ClassDescriptor || !descriptor.isInline && !descriptor.isValue) return if (descriptor.kind != ClassKind.CLASS) return - val inlineOrValueKeyword = declaration.modifierList?.getModifier(KtTokens.INLINE_KEYWORD) - ?: declaration.modifierList?.getModifier(KtTokens.VALUE_KEYWORD) + val trace = context.trace + + val valueKeyword = declaration.modifierList?.getModifier(KtTokens.VALUE_KEYWORD) + + // The check cannot be done in ModifierCheckerCore, since `value` keyword is enabled by one of two features, not by both of + // them simultaneously + if (valueKeyword != null) { + if (!context.languageVersionSettings.supportsFeature(LanguageFeature.JvmInlineValueClasses) && + !context.languageVersionSettings.supportsFeature(LanguageFeature.InlineClasses) + ) { + trace.report( + Errors.UNSUPPORTED_FEATURE.on( + valueKeyword, LanguageFeature.JvmInlineValueClasses to context.languageVersionSettings + ) + ) + return + } + } + + val inlineOrValueKeyword = declaration.modifierList?.getModifier(KtTokens.INLINE_KEYWORD) ?: valueKeyword require(inlineOrValueKeyword != null) { "Declaration of inline class must have 'inline' keyword" } - val trace = context.trace if (descriptor.isInner || DescriptorUtils.isLocal(descriptor)) { trace.report(Errors.INLINE_CLASS_NOT_TOP_LEVEL.on(inlineOrValueKeyword)) return diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ResultClassInReturnTypeChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ResultClassInReturnTypeChecker.kt index 04eb74373a2..44105ea956b 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ResultClassInReturnTypeChecker.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ResultClassInReturnTypeChecker.kt @@ -21,7 +21,8 @@ class ResultClassInReturnTypeChecker : DeclarationChecker { val languageVersionSettings = context.languageVersionSettings if ( languageVersionSettings.getFlag(AnalysisFlags.allowResultReturnType) || - languageVersionSettings.getFeatureSupport(LanguageFeature.InlineClasses) == LanguageFeature.State.ENABLED && + (languageVersionSettings.getFeatureSupport(LanguageFeature.InlineClasses) == LanguageFeature.State.ENABLED || + languageVersionSettings.supportsFeature(LanguageFeature.JvmInlineValueClasses)) && languageVersionSettings.supportsFeature(LanguageFeature.AllowResultInReturnType) ) return diff --git a/compiler/testData/diagnostics/tests/valueClasses/basicValueClassDeclarationDisabled.kt b/compiler/testData/diagnostics/tests/valueClasses/basicValueClassDeclarationDisabled.kt index 32b3ed08bd6..fc43d08330e 100644 --- a/compiler/testData/diagnostics/tests/valueClasses/basicValueClassDeclarationDisabled.kt +++ b/compiler/testData/diagnostics/tests/valueClasses/basicValueClassDeclarationDisabled.kt @@ -13,4 +13,4 @@ annotation class JvmInline value enum class InlineEnum @JvmInline -value class NotVal(x: Int) +value class NotVal(x: Int) diff --git a/compiler/testData/diagnostics/testsWithJvmBackend/noWarningInLV1_5.kt b/compiler/testData/diagnostics/testsWithJvmBackend/noWarningInLV1_5.kt new file mode 100644 index 00000000000..b2f80249614 --- /dev/null +++ b/compiler/testData/diagnostics/testsWithJvmBackend/noWarningInLV1_5.kt @@ -0,0 +1,9 @@ +// !LANGUAGE: +JvmInlineValueClasses +// WITH_RUNTIME + +package kotlin.jvm + +annotation class JvmInline + +@JvmInline +value class VC(val a: Any) \ No newline at end of file diff --git a/compiler/testData/diagnostics/testsWithJvmBackend/noWarningInLV1_5.txt b/compiler/testData/diagnostics/testsWithJvmBackend/noWarningInLV1_5.txt new file mode 100644 index 00000000000..6d7af7593f8 --- /dev/null +++ b/compiler/testData/diagnostics/testsWithJvmBackend/noWarningInLV1_5.txt @@ -0,0 +1,23 @@ +package + +package kotlin { + + package kotlin.jvm { + + public final annotation class JvmInline : kotlin.Annotation { + public constructor JvmInline() + public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String + } + + @kotlin.jvm.JvmInline public final value class VC { + public constructor VC(/*0*/ a: kotlin.Any) + public final val a: kotlin.Any + public open override /*1*/ /*synthesized*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean + public open override /*1*/ /*synthesized*/ fun hashCode(): kotlin.Int + public open override /*1*/ /*synthesized*/ fun toString(): kotlin.String + } + } +} + diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticsTestWithJvmIrBackendGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticsTestWithJvmIrBackendGenerated.java index 34721d6790f..d34cae2329b 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticsTestWithJvmIrBackendGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticsTestWithJvmIrBackendGenerated.java @@ -43,6 +43,12 @@ public class DiagnosticsTestWithJvmIrBackendGenerated extends AbstractDiagnostic runTest("compiler/testData/diagnostics/testsWithJvmBackend/multipleBigArityFunsImplemented_ir.kt"); } + @Test + @TestMetadata("noWarningInLV1_5.kt") + public void testNoWarningInLV1_5() throws Exception { + runTest("compiler/testData/diagnostics/testsWithJvmBackend/noWarningInLV1_5.kt"); + } + @Test @TestMetadata("suspendInlineCycle_ir.kt") public void testSuspendInlineCycle_ir() throws Exception { diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticsTestWithOldJvmBackendGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticsTestWithOldJvmBackendGenerated.java index 88ab881fcb9..74c5731f993 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticsTestWithOldJvmBackendGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticsTestWithOldJvmBackendGenerated.java @@ -43,6 +43,12 @@ public class DiagnosticsTestWithOldJvmBackendGenerated extends AbstractDiagnosti runTest("compiler/testData/diagnostics/testsWithJvmBackend/multipleBigArityFunsImplemented.kt"); } + @Test + @TestMetadata("noWarningInLV1_5.kt") + public void testNoWarningInLV1_5() throws Exception { + runTest("compiler/testData/diagnostics/testsWithJvmBackend/noWarningInLV1_5.kt"); + } + @Test @TestMetadata("suspendInlineCycle.kt") public void testSuspendInlineCycle() throws Exception { diff --git a/compiler/util/src/org/jetbrains/kotlin/config/LanguageVersionSettings.kt b/compiler/util/src/org/jetbrains/kotlin/config/LanguageVersionSettings.kt index c58faa1f7aa..f18abdfe537 100644 --- a/compiler/util/src/org/jetbrains/kotlin/config/LanguageVersionSettings.kt +++ b/compiler/util/src/org/jetbrains/kotlin/config/LanguageVersionSettings.kt @@ -194,6 +194,7 @@ enum class LanguageFeature( // Next features can be enabled regardless of new inference InlineClasses(sinceVersion = KOTLIN_1_3, defaultState = State.ENABLED_WITH_WARNING, kind = UNSTABLE_FEATURE), + JvmInlineValueClasses(sinceVersion = KOTLIN_1_5, defaultState = State.ENABLED, kind = OTHER), ; val presentableName: String From 18e7a1485c0a7fd423e3beee9362c00f6ae78b92 Mon Sep 17 00:00:00 2001 From: Leonid Startsev Date: Tue, 15 Dec 2020 18:32:32 +0300 Subject: [PATCH 171/196] Additional fix for Compose: directly search for fields in IR class w/o using the symbol table. Because Compose copies whole IR, fields got referenced incorrectly. In the end, bytecode generator thinks that this is a field from other class and creates a synthetic setter, which is prohibited in Java 9+ (Update to non-static final field ... attempted from a different method than ) --- .../compiler/backend/ir/GeneratorHelpers.kt | 19 +++++++++---------- .../backend/ir/SerializableIrGenerator.kt | 8 +++++--- .../backend/ir/SerializerIrGenerator.kt | 4 ++-- 3 files changed, 16 insertions(+), 15 deletions(-) diff --git a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/GeneratorHelpers.kt b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/GeneratorHelpers.kt index 9f8c2ec00c1..aa5f80cfd1e 100644 --- a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/GeneratorHelpers.kt +++ b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/GeneratorHelpers.kt @@ -214,17 +214,16 @@ interface IrBuilderExtension { // note: this method should be used only for properties from current module. Fields from other modules are private and inaccessible. val SerializableProperty.irField: IrField get() = compilerContext.symbolTable.referenceField(this.descriptor).owner - val SerializableProperty.irProp: IrProperty - get() { - val desc = this.descriptor - // this API is used to reference both current module descriptors and external ones (because serializable class can be in any of them), - // so we use descriptor api for current module because it is not possible to obtain FQname for e.g. local classes. - return if (desc.module == compilerContext.moduleDescriptor) { - compilerContext.symbolTable.referenceProperty(desc).owner - } else { - compilerContext.referenceProperties(this.descriptor.fqNameSafe).single().owner - } + fun SerializableProperty.getIrPropertyFrom(thisClass: IrClass): IrProperty { + val desc = this.descriptor + // this API is used to reference both current module descriptors and external ones (because serializable class can be in any of them), + // so we use descriptor api for current module because it is not possible to obtain FQname for e.g. local classes. + return thisClass.searchForDeclaration(desc) ?: if (desc.module == compilerContext.moduleDescriptor) { + compilerContext.symbolTable.referenceProperty(desc).owner + } else { + compilerContext.referenceProperties(desc.fqNameSafe).single().owner } + } fun IrBuilderWithScope.getProperty(receiver: IrExpression, property: IrProperty): IrExpression { return if (property.getter != null) diff --git a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializableIrGenerator.kt b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializableIrGenerator.kt index 96c7de0d3df..bd2a5650413 100644 --- a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializableIrGenerator.kt +++ b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializableIrGenerator.kt @@ -99,13 +99,15 @@ class SerializableIrGenerator( for (index in startPropOffset until serializableProperties.size) { val prop = serializableProperties[index] val paramRef = ctor.valueParameters[index + seenVarsOffset] - // assign this.a = a in else branch - val assignParamExpr = setProperty(irGet(thiz), prop.irProp, irGet(paramRef)) + // Assign this.a = a in else branch + // Set field directly w/o setter to match behavior of old backend plugin + val backingFieldToAssign = prop.getIrPropertyFrom(irClass).backingField!! + val assignParamExpr = irSetField(irGet(thiz), backingFieldToAssign, irGet(paramRef)) val ifNotSeenExpr: IrExpression = if (prop.optional) { val initializerBody = requireNotNull(transformFieldInitializer(prop.irField)) { "Optional value without an initializer" } // todo: filter abstract here - setProperty(irGet(thiz), prop.irProp, initializerBody) + irSetField(irGet(thiz), backingFieldToAssign, initializerBody) } else { // property required if (useFieldMissingOptimization) { diff --git a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializerIrGenerator.kt b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializerIrGenerator.kt index ad297605d38..fc2efe10b0d 100644 --- a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializerIrGenerator.kt +++ b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializerIrGenerator.kt @@ -138,7 +138,7 @@ open class SerializerIrGenerator( if (classProp.transient) continue +addFieldCall(classProp) // add property annotations - val property = classProp.irProp + val property = classProp.getIrPropertyFrom(serializableIrClass) copySerialInfoAnnotationsToDescriptor( property.annotations, localDescriptor, @@ -268,7 +268,7 @@ open class SerializerIrGenerator( irGet( type = ownerType, variable = objectToSerialize.symbol - ), irProp + ), getIrPropertyFrom(serializableIrClass) ) } From f671c27f27404c08f3fe43dd2178889f21589c13 Mon Sep 17 00:00:00 2001 From: Leonid Startsev Date: Wed, 16 Dec 2020 19:24:11 +0300 Subject: [PATCH 172/196] Adapt serialization exceptions constructor calls in legacy JS to signature change (see https://github.com/Kotlin/kotlinx.serialization/pull/1054 and commit eea4ff33a015c233a137cdf9c41c78d1b6084c84) --- .../backend/js/SerializableJsTranslator.kt | 20 +++++-------------- 1 file changed, 5 insertions(+), 15 deletions(-) diff --git a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/js/SerializableJsTranslator.kt b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/js/SerializableJsTranslator.kt index e0726e7a51d..d3ebe5ed418 100644 --- a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/js/SerializableJsTranslator.kt +++ b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/js/SerializableJsTranslator.kt @@ -1,17 +1,6 @@ /* - * Copyright 2010-2017 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. + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ package org.jetbrains.kotlinx.serialization.compiler.backend.js @@ -50,7 +39,8 @@ class SerializableJsTranslator( override fun generateInternalConstructor(constructorDescriptor: ClassConstructorDescriptor) { val missingExceptionClassRef = serializableDescriptor.getClassFromSerializationPackage(MISSING_FIELD_EXC) - .let { context.translateQualifiedReference(it) } + .constructors.single { it.valueParameters.size == 1 } + .let { context.getInnerNameForDescriptor(it).makeRef() } val f = context.buildFunction(constructorDescriptor) { jsFun, context -> val thiz = jsFun.scope.declareName(Namer.ANOTHER_THIS_PARAMETER_NAME).makeRef() @@ -98,7 +88,7 @@ class SerializableJsTranslator( val initExpr = Translation.translateAsExpression(initializer, context) TranslationUtils.assignmentToBackingField(context, prop.descriptor, initExpr).makeStmt() } else { - JsThrow(JsNew(missingExceptionClassRef, listOf(JsStringLiteral(prop.name)))) + JsThrow(JsInvocation(missingExceptionClassRef, listOf(JsStringLiteral(prop.name)))) } // (seen & 1 << i == 0) -- not seen val notSeenTest = propNotSeenTest(seenVars[bitMaskSlotAt(index)], index) From 631a72d14a889bdaf0e120b4faf32c540dba2cd1 Mon Sep 17 00:00:00 2001 From: Leonid Startsev Date: Sat, 19 Dec 2020 20:34:11 +0300 Subject: [PATCH 173/196] Support old serialization runtime versions (where exception signatures weren't changed) after f671c27f27404c08f3fe43dd2178889f21589c13 --- .../backend/js/SerializableJsTranslator.kt | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-) diff --git a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/js/SerializableJsTranslator.kt b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/js/SerializableJsTranslator.kt index d3ebe5ed418..8adb67a012e 100644 --- a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/js/SerializableJsTranslator.kt +++ b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/js/SerializableJsTranslator.kt @@ -40,7 +40,6 @@ class SerializableJsTranslator( val missingExceptionClassRef = serializableDescriptor.getClassFromSerializationPackage(MISSING_FIELD_EXC) .constructors.single { it.valueParameters.size == 1 } - .let { context.getInnerNameForDescriptor(it).makeRef() } val f = context.buildFunction(constructorDescriptor) { jsFun, context -> val thiz = jsFun.scope.declareName(Namer.ANOTHER_THIS_PARAMETER_NAME).makeRef() @@ -88,7 +87,19 @@ class SerializableJsTranslator( val initExpr = Translation.translateAsExpression(initializer, context) TranslationUtils.assignmentToBackingField(context, prop.descriptor, initExpr).makeStmt() } else { - JsThrow(JsInvocation(missingExceptionClassRef, listOf(JsStringLiteral(prop.name)))) + JsThrow( + if (missingExceptionClassRef.isPrimary) { + JsNew( + context.translateQualifiedReference(missingExceptionClassRef.containingDeclaration), + listOf(JsStringLiteral(prop.name)) + ) + } else { + JsInvocation( + context.getInnerNameForDescriptor(missingExceptionClassRef).makeRef(), + listOf(JsStringLiteral(prop.name)) + ) + } + ) } // (seen & 1 << i == 0) -- not seen val notSeenTest = propNotSeenTest(seenVars[bitMaskSlotAt(index)], index) From 272273baed7f2f769651f768ff6343e31e369d2f Mon Sep 17 00:00:00 2001 From: Leonid Startsev Date: Fri, 4 Dec 2020 20:10:59 +0300 Subject: [PATCH 174/196] Support serializable inline classes in IR plugin as well as standard unsigned types. --- .../backend/common/SerializableCodegen.kt | 22 +-- .../compiler/backend/common/TypeUtil.kt | 4 + .../compiler/backend/ir/GeneratorHelpers.kt | 2 +- .../ir/SerialInfoImplJvmIrGenerator.kt | 2 +- .../ir/SerializerForInlineClassGenerator.kt | 142 ++++++++++++++++++ .../backend/ir/SerializerIrGenerator.kt | 101 +++++++------ .../SerializationPluginDeclarationChecker.kt | 14 +- .../SerializationResolveExtension.kt | 17 +-- .../compiler/resolve/NamingConventions.kt | 3 + .../SerializationIDECodegenExtensions.kt | 9 +- .../idea/SerializationSwitchUtils.kt | 23 ++- 11 files changed, 245 insertions(+), 94 deletions(-) create mode 100644 plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializerForInlineClassGenerator.kt diff --git a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/common/SerializableCodegen.kt b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/common/SerializableCodegen.kt index 36537011385..9ee3b134375 100644 --- a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/common/SerializableCodegen.kt +++ b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/common/SerializableCodegen.kt @@ -1,17 +1,6 @@ /* - * Copyright 2010-2017 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. + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ package org.jetbrains.kotlinx.serialization.compiler.backend.common @@ -41,9 +30,12 @@ abstract class SerializableCodegen( generateSyntheticMethods() } + private inline fun ClassDescriptor.shouldHaveSpecificSyntheticMethods(functionPresenceChecker: () -> FunctionDescriptor?) = + !isInline && (isAbstractSerializableClass() || isSealedSerializableClass() || functionPresenceChecker() != null) + private fun generateSyntheticInternalConstructor() { val serializerDescriptor = serializableDescriptor.classSerializer ?: return - if (serializableDescriptor.isAbstractSerializableClass() || serializableDescriptor.isSealedSerializableClass() || SerializerCodegen.getSyntheticLoadMember(serializerDescriptor) != null) { + if (serializableDescriptor.shouldHaveSpecificSyntheticMethods { SerializerCodegen.getSyntheticLoadMember(serializerDescriptor) }) { val constrDesc = serializableDescriptor.secondaryConstructors.find(ClassConstructorDescriptor::isSerializationCtor) ?: return generateInternalConstructor(constrDesc) } @@ -51,7 +43,7 @@ abstract class SerializableCodegen( private fun generateSyntheticMethods() { val serializerDescriptor = serializableDescriptor.classSerializer ?: return - if (serializableDescriptor.isAbstractSerializableClass() || serializableDescriptor.isSealedSerializableClass() || SerializerCodegen.getSyntheticSaveMember(serializerDescriptor) != null) { + if (serializableDescriptor.shouldHaveSpecificSyntheticMethods { SerializerCodegen.getSyntheticSaveMember(serializerDescriptor) }) { val func = KSerializerDescriptorResolver.createWriteSelfFunctionDescriptor(serializableDescriptor) generateWriteSelfMethod(func) } diff --git a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/common/TypeUtil.kt b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/common/TypeUtil.kt index 48948665f6c..80eaf2f4afc 100644 --- a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/common/TypeUtil.kt +++ b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/common/TypeUtil.kt @@ -168,6 +168,10 @@ fun findStandardKotlinTypeSerializer(module: ModuleDescriptor, kType: KotlinType "F", "kotlin.Float" -> "FloatSerializer" "D", "kotlin.Double" -> "DoubleSerializer" "C", "kotlin.Char" -> "CharSerializer" + "kotlin.UInt" -> "UIntSerializer" + "kotlin.ULong" -> "ULongSerializer" + "kotlin.UByte" -> "UByteSerializer" + "kotlin.UShort" -> "UShortSerializer" "kotlin.String" -> "StringSerializer" "kotlin.Pair" -> "PairSerializer" "kotlin.Triple" -> "TripleSerializer" diff --git a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/GeneratorHelpers.kt b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/GeneratorHelpers.kt index aa5f80cfd1e..2acab1b6317 100644 --- a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/GeneratorHelpers.kt +++ b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/GeneratorHelpers.kt @@ -99,7 +99,7 @@ interface IrBuilderExtension { typeHint: IrType? = null ): IrMemberAccessExpression<*> { assert(callee.isBound) { "Symbol $callee expected to be bound" } - val returnType = typeHint ?: callee.run { owner.returnType } + val returnType = typeHint ?: callee.owner.returnType val call = irCall(callee, type = returnType) call.dispatchReceiver = dispatchReceiver args.forEachIndexed(call::putValueArgument) diff --git a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerialInfoImplJvmIrGenerator.kt b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerialInfoImplJvmIrGenerator.kt index 391d2a7f95f..e9de46f84f7 100644 --- a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerialInfoImplJvmIrGenerator.kt +++ b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerialInfoImplJvmIrGenerator.kt @@ -31,7 +31,7 @@ class SerialInfoImplJvmIrGenerator( override val compilerContext: SerializationPluginContext get() = context - private val jvmNameClass = context.referenceClass(DescriptorUtils.JVM_NAME)!!.owner + private val jvmNameClass get() = context.referenceClass(DescriptorUtils.JVM_NAME)!!.owner private val implGenerated = mutableSetOf() private val annotationToImpl = mutableMapOf() diff --git a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializerForInlineClassGenerator.kt b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializerForInlineClassGenerator.kt new file mode 100644 index 00000000000..9e3785d6f5e --- /dev/null +++ b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializerForInlineClassGenerator.kt @@ -0,0 +1,142 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlinx.serialization.compiler.backend.ir + +import org.jetbrains.kotlin.descriptors.ClassDescriptor +import org.jetbrains.kotlin.descriptors.FunctionDescriptor +import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET +import org.jetbrains.kotlin.ir.builders.* +import org.jetbrains.kotlin.ir.builders.declarations.addTypeParameter +import org.jetbrains.kotlin.ir.builders.declarations.addValueParameter +import org.jetbrains.kotlin.ir.builders.declarations.buildFun +import org.jetbrains.kotlin.ir.declarations.IrClass +import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin +import org.jetbrains.kotlin.ir.declarations.impl.IrExternalPackageFragmentImpl +import org.jetbrains.kotlin.ir.expressions.IrExpression +import org.jetbrains.kotlin.ir.expressions.impl.IrCallImpl +import org.jetbrains.kotlin.ir.expressions.impl.IrGetValueImpl +import org.jetbrains.kotlin.ir.types.IrSimpleType +import org.jetbrains.kotlin.ir.types.IrType +import org.jetbrains.kotlin.ir.types.defaultType +import org.jetbrains.kotlin.ir.types.typeOrNull +import org.jetbrains.kotlin.ir.util.constructors +import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.platform.jvm.isJvm +import org.jetbrains.kotlin.resolve.BindingContext +import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe +import org.jetbrains.kotlinx.serialization.compiler.extensions.SerializationPluginContext +import org.jetbrains.kotlinx.serialization.compiler.resolve.* + +private fun SerializationPluginContext.coerceInlineClasses(argument: IrExpression, from: IrType, to: IrType): IrExpression { + if (this.platform?.isJvm() != true) return argument.apply { type = to } + val unsafeCoerce = irFactory.buildFun { + name = Name.special("") + origin = IrDeclarationOrigin.IR_BUILTINS_STUB + }.apply { + parent = IrExternalPackageFragmentImpl.createEmptyExternalPackageFragment(moduleDescriptor, FqName("kotlin.jvm.internal")) + val src = addTypeParameter("T", irBuiltIns.anyNType) + val dst = addTypeParameter("R", irBuiltIns.anyNType) + addValueParameter("v", src.defaultType) + returnType = dst.defaultType + }.symbol + return IrCallImpl.fromSymbolOwner(UNDEFINED_OFFSET, UNDEFINED_OFFSET, to, unsafeCoerce).apply { + putTypeArgument(0, from) + putTypeArgument(1, to) + putValueArgument(0, argument) + } +} + +class SerializerForInlineClassGenerator( + irClass: IrClass, + compilerContext: SerializationPluginContext, + bindingContext: BindingContext, + serialInfoJvmGenerator: SerialInfoImplJvmIrGenerator, +) : SerializerIrGenerator(irClass, compilerContext, bindingContext, null, serialInfoJvmGenerator) { + override fun generateSave(function: FunctionDescriptor) = irClass.contributeFunction(function) { saveFunc -> + fun irThis(): IrExpression = + IrGetValueImpl(startOffset, endOffset, saveFunc.dispatchReceiverParameter!!.symbol) + + val encoderClass = serializerDescriptor.getClassFromSerializationPackage(SerialEntityNames.ENCODER_CLASS) + val descriptorGetterSymbol = irAnySerialDescProperty?.owner?.getter!!.symbol + val encodeInline = encoderClass.referenceMethod(CallingConventions.encodeInline) + val serialDescGetter = irGet(descriptorGetterSymbol.owner.returnType, irThis(), descriptorGetterSymbol) + + // val inlineEncoder = encoder.encodeInline() + val encodeInlineCall: IrExpression = irInvoke(irGet(saveFunc.valueParameters[0]), encodeInline, serialDescGetter) + val inlineEncoder = irTemporary(encodeInlineCall, nameHint = "inlineEncoder") + + val property = serializableProperties.first() + val value = getFromBox(irGet(saveFunc.valueParameters[1]), property) + + // inlineEncoder.encodeInt/String/SerializableValue + val elementCall = formEncodeDecodePropertyCall(irGet(inlineEncoder), saveFunc.dispatchReceiverParameter!!, property, {innerSerial, sti -> + val f = + encoderClass.referenceMethod("${CallingConventions.encode}${sti.elementMethodPrefix}SerializableValue") + f to listOf( + innerSerial, + value + ) + }, { + val f = + encoderClass.referenceMethod("${CallingConventions.encode}${it.elementMethodPrefix}") + val args = if (it.elementMethodPrefix != "Unit") listOf(value) else emptyList() + f to args + }) + + val actualEncodeCall = irIfNull(compilerContext.irBuiltIns.unitType, irGet(inlineEncoder), irNull(), elementCall) + +actualEncodeCall + } + + override fun generateLoad(function: FunctionDescriptor) = irClass.contributeFunction(function) { loadFunc -> + fun irThis(): IrExpression = + IrGetValueImpl(startOffset, endOffset, loadFunc.dispatchReceiverParameter!!.symbol) + + val decoderClass = serializerDescriptor.getClassFromSerializationPackage(SerialEntityNames.DECODER_CLASS) + val descriptorGetterSymbol = irAnySerialDescProperty?.owner?.getter!!.symbol + val decodeInline = decoderClass.referenceMethod(CallingConventions.decodeInline) + val serialDescGetter = irGet(descriptorGetterSymbol.owner.returnType, irThis(), descriptorGetterSymbol) + + // val inlineDecoder = decoder.decodeInline() + val inlineDecoder: IrExpression = irInvoke(irGet(loadFunc.valueParameters[0]), decodeInline, serialDescGetter) + + val property = serializableProperties.first() + val inlinedType = property.type.toIrType() + val actualCall = formEncodeDecodePropertyCall(inlineDecoder, loadFunc.dispatchReceiverParameter!!, property, { innerSerial, sti -> + decoderClass.referenceMethod( "${CallingConventions.decode}${sti.elementMethodPrefix}SerializableValue") to listOf(innerSerial) + }, { + decoderClass.referenceMethod("${CallingConventions.decode}${it.elementMethodPrefix}") to listOf() + }, returnTypeHint = inlinedType) + val value = coerceToBox(actualCall, inlinedType, loadFunc.returnType) + +irReturn(value) + } + + override val serialDescImplClass: ClassDescriptor = serializerDescriptor + .getClassFromInternalSerializationPackage(SerialEntityNames.SERIAL_DESCRIPTOR_FOR_INLINE) + + override fun IrBlockBodyBuilder.instantiateNewDescriptor( + serialDescImplClass: ClassDescriptor, + correctThis: IrExpression + ): IrExpression { + val ctor = compilerContext.referenceConstructors(serialDescImplClass.fqNameSafe).single { it.owner.isPrimary } + return irInvoke( + null, ctor, + irString(serialName), + correctThis + ) + } + + + // Compiler will elide these in corresponding inline class lowerings (when serialize/deserialize functions will be split in two) + + fun IrBlockBodyBuilder.coerceToBox(expression: IrExpression, propertyType: IrType, inlineClassBoxType: IrType): IrExpression { + return irInvoke(null, serializableIrClass.constructors.single { it.isPrimary }.symbol, (inlineClassBoxType as IrSimpleType).arguments.map { it.typeOrNull }, listOf(expression)) + } + + fun IrBlockBodyBuilder.getFromBox(expression: IrExpression, serializableProperty: SerializableProperty): IrExpression { + return getProperty(expression, serializableProperty.irProp) + } +} \ No newline at end of file diff --git a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializerIrGenerator.kt b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializerIrGenerator.kt index fc2efe10b0d..8f47bfc6ef5 100644 --- a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializerIrGenerator.kt +++ b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializerIrGenerator.kt @@ -25,8 +25,11 @@ import org.jetbrains.kotlin.platform.jvm.isJvm import org.jetbrains.kotlin.resolve.BindingContext import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe import org.jetbrains.kotlin.util.OperatorNameConventions +import org.jetbrains.kotlinx.serialization.compiler.backend.common.SerialTypeInfo import org.jetbrains.kotlinx.serialization.compiler.backend.common.SerializerCodegen import org.jetbrains.kotlinx.serialization.compiler.backend.common.getSerialTypeInfo +import org.jetbrains.kotlinx.serialization.compiler.backend.jvm.SerializerCodegenImpl +import org.jetbrains.kotlinx.serialization.compiler.backend.jvm.SerializerForEnumsCodegen import org.jetbrains.kotlinx.serialization.compiler.extensions.SerializationDescriptorSerializerPlugin import org.jetbrains.kotlinx.serialization.compiler.extensions.SerializationPluginContext import org.jetbrains.kotlinx.serialization.compiler.resolve.* @@ -39,6 +42,8 @@ import org.jetbrains.kotlinx.serialization.compiler.resolve.SerialEntityNames.UN object SERIALIZABLE_PLUGIN_ORIGIN : IrDeclarationOriginImpl("SERIALIZER", true) +internal typealias FunctionWithArgs = Pair> + open class SerializerIrGenerator( val irClass: IrClass, final override val compilerContext: SerializationPluginContext, @@ -286,22 +291,7 @@ open class SerializerIrGenerator( // internal serialization via virtual calls? for ((index, property) in serializableProperties.filter { !it.transient }.withIndex()) { // output.writeXxxElementValue(classDesc, index, value) - val sti = getSerialTypeInfo(property) - val innerSerial = serializerInstance( - this@SerializerIrGenerator, - saveFunc.dispatchReceiverParameter!!, - sti.serializer, - property.module, - property.type, - genericIndex = property.genericIndex - ) - val (writeFunc, args: List) = if (innerSerial == null) { - val f = - kOutputClass.referenceMethod("${CallingConventions.encode}${sti.elementMethodPrefix}${CallingConventions.elementPostfix}") - val args: MutableList = mutableListOf(irGet(localSerialDesc), irInt(index)) - if (sti.elementMethodPrefix != "Unit") args.add(property.irGet()) - f to args - } else { + val elementCall = formEncodeDecodePropertyCall(irGet(localOutput), saveFunc.dispatchReceiverParameter!!, property, {innerSerial, sti -> val f = kOutputClass.referenceMethod("${CallingConventions.encode}${sti.elementMethodPrefix}Serializable${CallingConventions.elementPostfix}") f to listOf( @@ -310,9 +300,13 @@ open class SerializerIrGenerator( innerSerial, property.irGet() ) - } - val typeArgs = if (writeFunc.descriptor.typeParameters.isNotEmpty()) listOf(property.type.toIrType()) else listOf() - val elementCall = irInvoke(irGet(localOutput), writeFunc, typeArguments = typeArgs, valueArguments = args) + }, { + val f = + kOutputClass.referenceMethod("${CallingConventions.encode}${it.elementMethodPrefix}${CallingConventions.elementPostfix}") + val args: MutableList = mutableListOf(irGet(localSerialDesc), irInt(index)) + if (it.elementMethodPrefix != "Unit") args.add(property.irGet()) + f to args + }) // check for call to .shouldEncodeElementDefault if (!property.optional || index < ignoreIndexTo) { @@ -337,6 +331,28 @@ open class SerializerIrGenerator( +irInvoke(irGet(localOutput), wEndFunc, irGet(localSerialDesc)) } + protected inline fun IrBlockBodyBuilder.formEncodeDecodePropertyCall( + encoder: IrExpression, + dispatchReceiver: IrValueParameter, + property: SerializableProperty, + whenHaveSerializer: (serializer: IrExpression, sti: SerialTypeInfo) -> FunctionWithArgs, + whenDoNot: (sti: SerialTypeInfo) -> FunctionWithArgs, + returnTypeHint: IrType? = null + ): IrExpression { + val sti = getSerialTypeInfo(property) + val innerSerial = serializerInstance( + this@SerializerIrGenerator, + dispatchReceiver, + sti.serializer, + property.module, + property.type, + genericIndex = property.genericIndex + ) + val (functionToCall, args: List) = if (innerSerial != null) whenHaveSerializer(innerSerial, sti) else whenDoNot(sti) + val typeArgs = if (functionToCall.descriptor.typeParameters.isNotEmpty()) listOf(property.type.toIrType()) else listOf() + return irInvoke(encoder, functionToCall, typeArguments = typeArgs, valueArguments = args, returnTypeHint = returnTypeHint) + } + // returns null: Any? for boxed types and 0: for primitives private fun IrBuilderWithScope.defaultValueAndType(prop: SerializableProperty): Pair { val kType = prop.descriptor.returnType!! @@ -403,33 +419,23 @@ open class SerializerIrGenerator( val decoderCalls: List> = serializableProperties.mapIndexed { index, property -> val body = irBlock { - val sti = getSerialTypeInfo(property) - val innerSerial = serializerInstance( - this@SerializerIrGenerator, - loadFunc.dispatchReceiverParameter!!, - sti.serializer, - property.module, - property.type, - genericIndex = property.genericIndex - ) - val isSerializable = innerSerial != null - val decodeFuncToCall = - (if (isSerializable) "${CallingConventions.decode}${sti.elementMethodPrefix}Serializable${CallingConventions.elementPostfix}" - else "${CallingConventions.decode}${sti.elementMethodPrefix}${CallingConventions.elementPostfix}") - .let { - inputClass.referenceMethod(it) { it.valueParameters.size == if (isSerializable) 4 else 2 } - } - val typeArgs = - if (decodeFuncToCall.descriptor.typeParameters.isNotEmpty()) listOf(property.type.toIrType()) else listOf() - val args = mutableListOf(localSerialDesc.get(), irInt(index)) - if (isSerializable) { - args.add(innerSerial!!) - args.add(localProps[index].get()) - } + val decodeFuncToCall = formEncodeDecodePropertyCall(localInput.get(), loadFunc.dispatchReceiverParameter!!, property, {innerSerial, sti -> + inputClass.referenceMethod( + "${CallingConventions.decode}${sti.elementMethodPrefix}Serializable${CallingConventions.elementPostfix}", {it.valueParameters.size == 4} + ) to listOf( + localSerialDesc.get(), irInt(index), innerSerial, localProps[index].get() + ) + }, { + inputClass.referenceMethod( + "${CallingConventions.decode}${it.elementMethodPrefix}${CallingConventions.elementPostfix}", {it.valueParameters.size == 2} + ) to listOf( + localSerialDesc.get(), irInt(index) + ) + }, returnTypeHint = property.type.toIrType()) // local$i = localInput.decode...(...) +irSet( localProps[index].symbol, - irInvoke(localInput.get(), decodeFuncToCall, typeArgs, args, returnTypeHint = property.type.toIrType()) + decodeFuncToCall ) // bitMask[i] |= 1 << x val bitPos = 1 shl (index % 32) @@ -507,11 +513,12 @@ open class SerializerIrGenerator( serialInfoJvmGenerator: SerialInfoImplJvmIrGenerator, ) { val serializableDesc = getSerializableClassDescriptorBySerializer(irClass.symbol.descriptor) ?: return - if (serializableDesc.isSerializableEnum()) { - SerializerForEnumsGenerator(irClass, context, bindingContext, serialInfoJvmGenerator).generate() - } else { - SerializerIrGenerator(irClass, context, bindingContext, metadataPlugin, serialInfoJvmGenerator).generate() + val generator = when { + serializableDesc.isSerializableEnum() -> SerializerForEnumsGenerator(irClass, context, bindingContext, serialInfoJvmGenerator) + serializableDesc.isInline -> SerializerForInlineClassGenerator(irClass, context, bindingContext, serialInfoJvmGenerator) + else -> SerializerIrGenerator(irClass, context, bindingContext, metadataPlugin, serialInfoJvmGenerator) } + generator.generate() irClass.patchDeclarationParents(irClass.parent) } } diff --git a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/diagnostic/SerializationPluginDeclarationChecker.kt b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/diagnostic/SerializationPluginDeclarationChecker.kt index 378d047e290..6c45e5a74fd 100644 --- a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/diagnostic/SerializationPluginDeclarationChecker.kt +++ b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/diagnostic/SerializationPluginDeclarationChecker.kt @@ -123,10 +123,10 @@ open class SerializationPluginDeclarationChecker : DeclarationChecker { return false } - if (descriptor.isInlineClass()) { - trace.reportOnSerializableAnnotation(descriptor, SerializationErrors.INLINE_CLASSES_NOT_SUPPORTED) - return false - } +// if (descriptor.isInlineClass()) { +// trace.reportOnSerializableAnnotation(descriptor, SerializationErrors.INLINE_CLASSES_NOT_SUPPORTED) +// return false +// } if (!descriptor.hasSerializableAnnotationWithoutArgs) return false if (descriptor.serializableAnnotationIsUseless) { @@ -258,9 +258,9 @@ open class SerializationPluginDeclarationChecker : DeclarationChecker { ) { if (type.genericIndex != null) return // type arguments always have serializer stored in class' field val element = ktType?.typeElement - if (type.isUnsupportedInlineType()) { - trace.report(SerializationErrors.INLINE_CLASSES_NOT_SUPPORTED.on(element ?: fallbackElement)) - } +// if (type.isUnsupportedInlineType()) { +// trace.report(SerializationErrors.INLINE_CLASSES_NOT_SUPPORTED.on(element ?: fallbackElement)) +// } val serializer = findTypeSerializerOrContextUnchecked(module, type) if (serializer != null) { checkCustomSerializerMatch(module, type, type, element, trace, fallbackElement) diff --git a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/extensions/SerializationResolveExtension.kt b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/extensions/SerializationResolveExtension.kt index 3e56c7254d1..4a7c308eb7a 100644 --- a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/extensions/SerializationResolveExtension.kt +++ b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/extensions/SerializationResolveExtension.kt @@ -1,17 +1,6 @@ /* - * Copyright 2010-2017 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. + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ package org.jetbrains.kotlinx.serialization.compiler.extensions @@ -26,6 +15,7 @@ import org.jetbrains.kotlin.platform.jvm.isJvm import org.jetbrains.kotlin.resolve.BindingContext import org.jetbrains.kotlin.resolve.descriptorUtil.platform import org.jetbrains.kotlin.resolve.extensions.SyntheticResolveExtension +import org.jetbrains.kotlin.resolve.isInlineClass import org.jetbrains.kotlin.resolve.lazy.LazyClassContext import org.jetbrains.kotlin.resolve.lazy.declarations.ClassMemberDeclarationProvider import org.jetbrains.kotlin.types.KotlinType @@ -87,6 +77,7 @@ open class SerializationResolveExtension @JvmOverloads constructor(val metadataP if (thisDescriptor.isInternalSerializable) { // do not add synthetic deserialization constructor if .deserialize method is customized if (thisDescriptor.hasCompanionObjectAsSerializer && SerializerCodegen.getSyntheticLoadMember(thisDescriptor.companionObjectDescriptor!!) == null) return + if (thisDescriptor.isInline) return result.add(KSerializerDescriptorResolver.createLoadConstructorDescriptor(thisDescriptor, bindingContext, metadataPlugin)) } } diff --git a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/resolve/NamingConventions.kt b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/resolve/NamingConventions.kt index 2d99e69c211..67c02566f98 100644 --- a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/resolve/NamingConventions.kt +++ b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/resolve/NamingConventions.kt @@ -69,6 +69,7 @@ object SerialEntityNames { const val SERIAL_DESCRIPTOR_CLASS = "SerialDescriptor" const val SERIAL_DESCRIPTOR_CLASS_IMPL = "PluginGeneratedSerialDescriptor" const val SERIAL_DESCRIPTOR_FOR_ENUM = "EnumDescriptor" + const val SERIAL_DESCRIPTOR_FOR_INLINE = "InlineClassDescriptor" const val PLUGIN_EXCEPTIONS_FILE = "PluginExceptions" @@ -114,6 +115,8 @@ object CallingConventions { const val encode = "encode" const val encodeEnum = "encodeEnum" const val decodeEnum = "decodeEnum" + const val encodeInline = "encodeInline" + const val decodeInline = "decodeInline" const val decodeElementIndex = "decodeElementIndex" const val decodeSequentially = "decodeSequentially" const val elementPostfix = "Element" diff --git a/plugins/kotlin-serialization/kotlin-serialization-ide/src/org/jetbrains/kotlinx/serialization/compiler/extensions/SerializationIDECodegenExtensions.kt b/plugins/kotlin-serialization/kotlin-serialization-ide/src/org/jetbrains/kotlinx/serialization/compiler/extensions/SerializationIDECodegenExtensions.kt index 8467edf5a4d..45f91aa6dc9 100644 --- a/plugins/kotlin-serialization/kotlin-serialization-ide/src/org/jetbrains/kotlinx/serialization/compiler/extensions/SerializationIDECodegenExtensions.kt +++ b/plugins/kotlin-serialization/kotlin-serialization-ide/src/org/jetbrains/kotlinx/serialization/compiler/extensions/SerializationIDECodegenExtensions.kt @@ -1,5 +1,5 @@ /* - * Copyright 2010-2018 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ @@ -8,10 +8,12 @@ package org.jetbrains.kotlinx.serialization.compiler.extensions import org.jetbrains.kotlin.backend.common.extensions.IrPluginContext import org.jetbrains.kotlin.codegen.ImplementationBodyCodegen import org.jetbrains.kotlin.descriptors.ClassDescriptor +import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI import org.jetbrains.kotlin.ir.declarations.IrModuleFragment import org.jetbrains.kotlin.js.translate.context.TranslationContext import org.jetbrains.kotlin.js.translate.declaration.DeclarationBodyVisitor import org.jetbrains.kotlin.psi.KtPureClassOrObject +import org.jetbrains.kotlinx.serialization.idea.runIfEnabledIn import org.jetbrains.kotlinx.serialization.idea.runIfEnabledOn class SerializationIDECodegenExtension : SerializationCodegenExtension() { @@ -31,7 +33,10 @@ class SerializationIDEJsExtension : SerializationJsExtension() { } class SerializationIDEIrExtension : SerializationLoweringExtension() { + @OptIn(ObsoleteDescriptorBasedAPI::class) override fun generate(moduleFragment: IrModuleFragment, pluginContext: IrPluginContext) { - /* No-op – don't enable IR extensions in IDE */ + runIfEnabledIn(pluginContext.moduleDescriptor) { + super.generate(moduleFragment, pluginContext) + } } } \ No newline at end of file diff --git a/plugins/kotlin-serialization/kotlin-serialization-ide/src/org/jetbrains/kotlinx/serialization/idea/SerializationSwitchUtils.kt b/plugins/kotlin-serialization/kotlin-serialization-ide/src/org/jetbrains/kotlinx/serialization/idea/SerializationSwitchUtils.kt index 38dc51c1613..26acdeaa31f 100644 --- a/plugins/kotlin-serialization/kotlin-serialization-ide/src/org/jetbrains/kotlinx/serialization/idea/SerializationSwitchUtils.kt +++ b/plugins/kotlin-serialization/kotlin-serialization-ide/src/org/jetbrains/kotlinx/serialization/idea/SerializationSwitchUtils.kt @@ -1,5 +1,5 @@ /* - * Copyright 2010-2018 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. */ @@ -7,16 +7,23 @@ package org.jetbrains.kotlinx.serialization.idea import org.jetbrains.kotlin.analyzer.ModuleInfo import org.jetbrains.kotlin.descriptors.ClassDescriptor +import org.jetbrains.kotlin.descriptors.ModuleDescriptor import org.jetbrains.kotlin.idea.core.unwrapModuleSourceInfo import org.jetbrains.kotlin.idea.facet.KotlinFacet import org.jetbrains.kotlin.resolve.descriptorUtil.module -fun getIfEnabledOn(clazz: ClassDescriptor, body: () -> T): T? { - val module = clazz.module.getCapability(ModuleInfo.Capability)?.unwrapModuleSourceInfo()?.module ?: return null - val facet = KotlinFacet.get(module) ?: return null - val pluginClasspath = facet.configuration.settings.compilerArguments?.pluginClasspaths ?: return null - if (pluginClasspath.none(KotlinSerializationImportHandler::isPluginJarPath)) return null - return body() +private fun isEnabledIn(moduleDescriptor: ModuleDescriptor): Boolean { + val module = moduleDescriptor.getCapability(ModuleInfo.Capability)?.unwrapModuleSourceInfo()?.module ?: return false + val facet = KotlinFacet.get(module) ?: return false + val pluginClasspath = facet.configuration.settings.compilerArguments?.pluginClasspaths ?: return false + if (pluginClasspath.none(KotlinSerializationImportHandler::isPluginJarPath)) return false + return true } -fun runIfEnabledOn(clazz: ClassDescriptor, body: () -> Unit) { getIfEnabledOn(clazz, body) } \ No newline at end of file +fun getIfEnabledOn(clazz: ClassDescriptor, body: () -> T): T? { + return if (isEnabledIn(clazz.module)) body() else null +} + +fun runIfEnabledOn(clazz: ClassDescriptor, body: () -> Unit) { getIfEnabledOn(clazz, body) } + +fun runIfEnabledIn(moduleDescriptor: ModuleDescriptor, block: () -> Unit) { if (isEnabledIn(moduleDescriptor)) block() } \ No newline at end of file From a5ddb1fdf13bfde6d973f6246cce1771623cad6e Mon Sep 17 00:00:00 2001 From: Leonid Startsev Date: Thu, 10 Dec 2020 02:26:19 +0300 Subject: [PATCH 175/196] Update error about unsupported inline classes Remove unused declarations --- .../ir/SerializerForInlineClassGenerator.kt | 46 ++++--------------- .../diagnostic/SerializationErrors.java | 2 +- .../SerializationPluginDeclarationChecker.kt | 31 ++++++++++--- .../SerializationPluginErrorsRendering.kt | 4 +- .../compiler/diagnostic/VersionReader.kt | 9 ++++ 5 files changed, 46 insertions(+), 46 deletions(-) diff --git a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializerForInlineClassGenerator.kt b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializerForInlineClassGenerator.kt index 9e3785d6f5e..6ad6cce9d9c 100644 --- a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializerForInlineClassGenerator.kt +++ b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/backend/ir/SerializerForInlineClassGenerator.kt @@ -7,49 +7,19 @@ package org.jetbrains.kotlinx.serialization.compiler.backend.ir import org.jetbrains.kotlin.descriptors.ClassDescriptor import org.jetbrains.kotlin.descriptors.FunctionDescriptor -import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET import org.jetbrains.kotlin.ir.builders.* -import org.jetbrains.kotlin.ir.builders.declarations.addTypeParameter -import org.jetbrains.kotlin.ir.builders.declarations.addValueParameter -import org.jetbrains.kotlin.ir.builders.declarations.buildFun import org.jetbrains.kotlin.ir.declarations.IrClass -import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin -import org.jetbrains.kotlin.ir.declarations.impl.IrExternalPackageFragmentImpl import org.jetbrains.kotlin.ir.expressions.IrExpression -import org.jetbrains.kotlin.ir.expressions.impl.IrCallImpl import org.jetbrains.kotlin.ir.expressions.impl.IrGetValueImpl import org.jetbrains.kotlin.ir.types.IrSimpleType import org.jetbrains.kotlin.ir.types.IrType -import org.jetbrains.kotlin.ir.types.defaultType import org.jetbrains.kotlin.ir.types.typeOrNull import org.jetbrains.kotlin.ir.util.constructors -import org.jetbrains.kotlin.name.FqName -import org.jetbrains.kotlin.name.Name -import org.jetbrains.kotlin.platform.jvm.isJvm import org.jetbrains.kotlin.resolve.BindingContext import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe import org.jetbrains.kotlinx.serialization.compiler.extensions.SerializationPluginContext import org.jetbrains.kotlinx.serialization.compiler.resolve.* -private fun SerializationPluginContext.coerceInlineClasses(argument: IrExpression, from: IrType, to: IrType): IrExpression { - if (this.platform?.isJvm() != true) return argument.apply { type = to } - val unsafeCoerce = irFactory.buildFun { - name = Name.special("") - origin = IrDeclarationOrigin.IR_BUILTINS_STUB - }.apply { - parent = IrExternalPackageFragmentImpl.createEmptyExternalPackageFragment(moduleDescriptor, FqName("kotlin.jvm.internal")) - val src = addTypeParameter("T", irBuiltIns.anyNType) - val dst = addTypeParameter("R", irBuiltIns.anyNType) - addValueParameter("v", src.defaultType) - returnType = dst.defaultType - }.symbol - return IrCallImpl.fromSymbolOwner(UNDEFINED_OFFSET, UNDEFINED_OFFSET, to, unsafeCoerce).apply { - putTypeArgument(0, from) - putTypeArgument(1, to) - putValueArgument(0, argument) - } -} - class SerializerForInlineClassGenerator( irClass: IrClass, compilerContext: SerializationPluginContext, @@ -129,14 +99,16 @@ class SerializerForInlineClassGenerator( ) } - // Compiler will elide these in corresponding inline class lowerings (when serialize/deserialize functions will be split in two) - fun IrBlockBodyBuilder.coerceToBox(expression: IrExpression, propertyType: IrType, inlineClassBoxType: IrType): IrExpression { - return irInvoke(null, serializableIrClass.constructors.single { it.isPrimary }.symbol, (inlineClassBoxType as IrSimpleType).arguments.map { it.typeOrNull }, listOf(expression)) - } + private fun IrBlockBodyBuilder.coerceToBox(expression: IrExpression, propertyType: IrType, inlineClassBoxType: IrType): IrExpression = + irInvoke( + null, + serializableIrClass.constructors.single { it.isPrimary }.symbol, + (inlineClassBoxType as IrSimpleType).arguments.map { it.typeOrNull }, + listOf(expression) + ) - fun IrBlockBodyBuilder.getFromBox(expression: IrExpression, serializableProperty: SerializableProperty): IrExpression { - return getProperty(expression, serializableProperty.irProp) - } + private fun IrBlockBodyBuilder.getFromBox(expression: IrExpression, serializableProperty: SerializableProperty): IrExpression = + getProperty(expression, serializableProperty.getIrPropertyFrom(serializableIrClass)) } \ No newline at end of file diff --git a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/diagnostic/SerializationErrors.java b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/diagnostic/SerializationErrors.java index 54af6738761..abfe1313713 100644 --- a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/diagnostic/SerializationErrors.java +++ b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/diagnostic/SerializationErrors.java @@ -14,7 +14,7 @@ import static org.jetbrains.kotlin.diagnostics.Severity.ERROR; import static org.jetbrains.kotlin.diagnostics.Severity.WARNING; public interface SerializationErrors { - DiagnosticFactory0 INLINE_CLASSES_NOT_SUPPORTED = DiagnosticFactory0.create(ERROR); + DiagnosticFactory2 INLINE_CLASSES_NOT_SUPPORTED = DiagnosticFactory2.create(ERROR); DiagnosticFactory0 PLUGIN_IS_NOT_ENABLED = DiagnosticFactory0.create(WARNING); DiagnosticFactory0 EXPLICIT_SERIALIZABLE_IS_REQUIRED = DiagnosticFactory0.create(WARNING); diff --git a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/diagnostic/SerializationPluginDeclarationChecker.kt b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/diagnostic/SerializationPluginDeclarationChecker.kt index 6c45e5a74fd..9d9458fd1f0 100644 --- a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/diagnostic/SerializationPluginDeclarationChecker.kt +++ b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/diagnostic/SerializationPluginDeclarationChecker.kt @@ -123,10 +123,18 @@ open class SerializationPluginDeclarationChecker : DeclarationChecker { return false } -// if (descriptor.isInlineClass()) { -// trace.reportOnSerializableAnnotation(descriptor, SerializationErrors.INLINE_CLASSES_NOT_SUPPORTED) -// return false -// } + if (descriptor.isInlineClass() && !canSupportInlineClasses(descriptor.module, trace)) { + descriptor.onSerializableAnnotation { + trace.report( + SerializationErrors.INLINE_CLASSES_NOT_SUPPORTED.on( + it, + VersionReader.minVersionForInlineClasses.toString(), + VersionReader.getVersionsForCurrentModuleFromTrace(descriptor.module, trace)?.implementationVersion.toString() + ) + ) + } + return false + } if (!descriptor.hasSerializableAnnotationWithoutArgs) return false if (descriptor.serializableAnnotationIsUseless) { @@ -249,6 +257,11 @@ open class SerializationPluginDeclarationChecker : DeclarationChecker { private fun KotlinType.isUnsupportedInlineType() = isInlineClassType() && !KotlinBuiltIns.isPrimitiveTypeOrNullablePrimitiveType(this) + private fun canSupportInlineClasses(module: ModuleDescriptor, trace: BindingTrace): Boolean { + if (isIde) return true // do not get version from jar manifest in ide + return VersionReader.canSupportInlineClasses(module, trace) + } + private fun AbstractSerialGenerator.checkType( module: ModuleDescriptor, type: KotlinType, @@ -258,9 +271,13 @@ open class SerializationPluginDeclarationChecker : DeclarationChecker { ) { if (type.genericIndex != null) return // type arguments always have serializer stored in class' field val element = ktType?.typeElement -// if (type.isUnsupportedInlineType()) { -// trace.report(SerializationErrors.INLINE_CLASSES_NOT_SUPPORTED.on(element ?: fallbackElement)) -// } + if (type.isUnsupportedInlineType() && !canSupportInlineClasses(module, trace)) { + trace.report(SerializationErrors.INLINE_CLASSES_NOT_SUPPORTED.on( + element ?: fallbackElement, + VersionReader.minVersionForInlineClasses.toString(), + VersionReader.getVersionsForCurrentModuleFromTrace(module, trace)?.implementationVersion.toString() + )) + } val serializer = findTypeSerializerOrContextUnchecked(module, type) if (serializer != null) { checkCustomSerializerMatch(module, type, type, element, trace, fallbackElement) diff --git a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/diagnostic/SerializationPluginErrorsRendering.kt b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/diagnostic/SerializationPluginErrorsRendering.kt index 185a9e8ff24..f561aba2015 100644 --- a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/diagnostic/SerializationPluginErrorsRendering.kt +++ b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/diagnostic/SerializationPluginErrorsRendering.kt @@ -16,7 +16,9 @@ object SerializationPluginErrorsRendering : DefaultErrorMessages.Extension { init { MAP.put( SerializationErrors.INLINE_CLASSES_NOT_SUPPORTED, - "Inline classes are not supported by kotlinx.serialization yet" + "Inline classes require runtime serialization library version at least {0}, while your classpath has {1}.", + Renderers.STRING, + Renderers.STRING, ) MAP.put( SerializationErrors.PLUGIN_IS_NOT_ENABLED, diff --git a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/diagnostic/VersionReader.kt b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/diagnostic/VersionReader.kt index 22137b76b2f..529952317c3 100644 --- a/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/diagnostic/VersionReader.kt +++ b/plugins/kotlin-serialization/kotlin-serialization-compiler/src/org/jetbrains/kotlinx/serialization/compiler/diagnostic/VersionReader.kt @@ -65,4 +65,13 @@ object VersionReader { if (!file.exists()) return null return getVersionsFromManifest(file) } + + internal val minVersionForInlineClasses = ApiVersion.parse("1.1-M1-SNAPSHOT")!! + + fun canSupportInlineClasses(module: ModuleDescriptor, trace: BindingTrace): Boolean { + // Klibs do not have manifest file, unfortunately, so we hope for the better + val currentVersion = getVersionsForCurrentModuleFromTrace(module, trace) ?: return true + val implVersion = currentVersion.implementationVersion ?: return false + return implVersion >= minVersionForInlineClasses + } } From 92f8eff958194de6e6dbaf4ebf9924bb8e31e38d Mon Sep 17 00:00:00 2001 From: Alexander Shabalin Date: Tue, 15 Dec 2020 10:30:15 +0300 Subject: [PATCH 176/196] Cleanup Stubs.cpp (#4593) --- .../runtime/src/legacymm/cpp/Memory.cpp | 38 ++++--- kotlin-native/runtime/src/main/cpp/KAssert.h | 18 +++ .../runtime/src/main/cpp/KAssertTest.cpp | 20 ++++ kotlin-native/runtime/src/main/cpp/Memory.h | 9 +- .../runtime/src/main/cpp/Runtime.cpp | 2 +- .../src/main/kotlin/kotlin/native/Platform.kt | 4 +- kotlin-native/runtime/src/mm/cpp/Memory.cpp | 55 ++++++++- kotlin-native/runtime/src/mm/cpp/Stubs.cpp | 106 ++++++------------ .../runtime/src/relaxed/cpp/MemoryImpl.cpp | 2 +- .../runtime/src/strict/cpp/MemoryImpl.cpp | 2 +- 10 files changed, 161 insertions(+), 95 deletions(-) create mode 100644 kotlin-native/runtime/src/main/cpp/KAssertTest.cpp diff --git a/kotlin-native/runtime/src/legacymm/cpp/Memory.cpp b/kotlin-native/runtime/src/legacymm/cpp/Memory.cpp index e46ef5aad73..54e7f287e7e 100644 --- a/kotlin-native/runtime/src/legacymm/cpp/Memory.cpp +++ b/kotlin-native/runtime/src/legacymm/cpp/Memory.cpp @@ -73,6 +73,10 @@ namespace { +ALWAYS_INLINE bool IsStrictMemoryModel() noexcept { + return CurrentMemoryModel == MemoryModel::kStrict; +} + typedef uint32_t container_size_t; // Granularity of arena container chunks. @@ -1026,7 +1030,7 @@ inline void unlock(KInt* spinlock) { } inline bool canFreeze(ContainerHeader* container) { - if (IsStrictMemoryModel) + if (IsStrictMemoryModel()) // In strict memory model we ignore permanent, frozen and shared object when recursively freezing. return container != nullptr && !container->shareable(); else @@ -1393,14 +1397,14 @@ inline void decrementRC(ContainerHeader* container) { inline void decrementRC(ContainerHeader* container) { auto* state = memoryState; - RuntimeAssert(!IsStrictMemoryModel || state->gcInProgress, "Must only be called during GC"); + RuntimeAssert(!IsStrictMemoryModel() || state->gcInProgress, "Must only be called during GC"); // TODO: enable me, once account for inner references in frozen objects correctly. // RuntimeAssert(container->refCount() > 0, "Must be positive"); bool useCycleCollector = container->local(); if (container->decRefCount() == 0) { freeContainer(container); } else if (useCycleCollector && state->toFree != nullptr) { - RuntimeAssert(IsStrictMemoryModel, "No cycle collector in relaxed mode yet"); + RuntimeAssert(IsStrictMemoryModel(), "No cycle collector in relaxed mode yet"); RuntimeAssert(container->refCount() > 0, "Must be positive"); RuntimeAssert(!container->shareable(), "Cycle collector shalln't be used with shared objects yet"); RuntimeAssert(container->objectCount() == 1, "cycle collector shall only work with single object containers"); @@ -1819,7 +1823,7 @@ void incrementStack(MemoryState* state) { } void processDecrements(MemoryState* state) { - RuntimeAssert(IsStrictMemoryModel, "Only works in strict model now"); + RuntimeAssert(IsStrictMemoryModel(), "Only works in strict model now"); auto* toRelease = state->toRelease; state->gcSuspendCount++; while (toRelease->size() > 0) { @@ -1840,7 +1844,7 @@ void processDecrements(MemoryState* state) { } void decrementStack(MemoryState* state) { - RuntimeAssert(IsStrictMemoryModel, "Only works in strict model now"); + RuntimeAssert(IsStrictMemoryModel(), "Only works in strict model now"); state->gcSuspendCount++; FrameOverlay* frame = currentFrame; while (frame != nullptr) { @@ -1868,7 +1872,7 @@ void garbageCollect(MemoryState* state, bool force) { #endif // TRACE_GC state->allocSinceLastGc = 0; - if (!IsStrictMemoryModel) { + if (!IsStrictMemoryModel()) { // In relaxed model we just process finalizer queue and be done with it. processFinalizerQueue(state); return; @@ -1988,7 +1992,7 @@ void garbageCollect() { #endif // USE_GC ForeignRefManager* initLocalForeignRef(ObjHeader* object) { - if (!IsStrictMemoryModel) return nullptr; + if (!IsStrictMemoryModel()) return nullptr; return memoryState->foreignRefManager; } @@ -1996,7 +2000,7 @@ ForeignRefManager* initLocalForeignRef(ObjHeader* object) { ForeignRefManager* initForeignRef(ObjHeader* object) { addHeapRef(object); - if (!IsStrictMemoryModel) return nullptr; + if (!IsStrictMemoryModel()) return nullptr; // Note: it is possible to return nullptr for shared object as an optimization, // but this will force the implementation to release objects on uninitialized threads @@ -2007,7 +2011,7 @@ ForeignRefManager* initForeignRef(ObjHeader* object) { } bool isForeignRefAccessible(ObjHeader* object, ForeignRefManager* manager) { - if (!IsStrictMemoryModel) return true; + if (!IsStrictMemoryModel()) return true; if (manager == memoryState->foreignRefManager) { // Note: it is important that this code neither crashes nor returns false-negative result @@ -2021,7 +2025,7 @@ bool isForeignRefAccessible(ObjHeader* object, ForeignRefManager* manager) { } void deinitForeignRef(ObjHeader* object, ForeignRefManager* manager) { - if (IsStrictMemoryModel) { + if (IsStrictMemoryModel()) { if (memoryState != nullptr && isForeignRefAccessible(object, manager)) { releaseHeapRef(object); } else { @@ -2127,13 +2131,13 @@ void deinitMemory(MemoryState* memoryState, bool destroyRuntime) { atomicAdd(&pendingDeinit, -1); #if TRACE_MEMORY - if (IsStrictMemoryModel && destroyRuntime && allocCount > 0) { + if (IsStrictMemoryModel() && destroyRuntime && allocCount > 0) { MEMORY_LOG("*** Memory leaks, leaked %d containers ***\n", allocCount); dumpReachable("", memoryState->containers); } #else #if USE_GC - if (IsStrictMemoryModel && allocCount > 0 && checkLeaks) { + if (IsStrictMemoryModel() && allocCount > 0 && checkLeaks) { konan::consoleErrorf( "Memory leaks detected, %d objects leaked!\n" "Use `Platform.isMemoryLeakCheckerActive = false` to avoid this check.\n", allocCount); @@ -2441,7 +2445,7 @@ OBJ_GETTER(swapHeapRefLocked, lock(spinlock); ObjHeader* oldValue = *location; bool shallRemember = false; - if (IsStrictMemoryModel) { + if (IsStrictMemoryModel()) { auto realCookie = computeCookie(); shallRemember = *cookie != realCookie; if (shallRemember) *cookie = realCookie; @@ -2455,7 +2459,7 @@ OBJ_GETTER(swapHeapRefLocked, } UpdateReturnRef(OBJ_RESULT, oldValue); - if (IsStrictMemoryModel && shallRemember && oldValue != nullptr && oldValue != expectedValue) { + if (IsStrictMemoryModel() && shallRemember && oldValue != nullptr && oldValue != expectedValue) { // Only remember container if it is not known to this thread (i.e. != expectedValue). rememberNewContainer(containerFor(oldValue)); } @@ -2491,7 +2495,7 @@ OBJ_GETTER(readHeapRefLocked, ObjHeader** location, int32_t* spinlock, int32_t* if (shallRemember) *cookie = realCookie; UpdateReturnRef(OBJ_RESULT, value); #if USE_GC - if (IsStrictMemoryModel && shallRemember && value != nullptr) { + if (IsStrictMemoryModel() && shallRemember && value != nullptr) { auto* container = containerFor(value); rememberNewContainer(container); } @@ -2506,7 +2510,7 @@ OBJ_GETTER(readHeapRefNoLock, ObjHeader* object, KInt index) { reinterpret_cast(object) + object->type_info()->objOffsets_[index]); ObjHeader* value = *location; #if USE_GC - if (IsStrictMemoryModel && (value != nullptr)) { + if (IsStrictMemoryModel() && (value != nullptr)) { // Maybe not so good to do that under lock. rememberNewContainer(containerFor(value)); } @@ -3300,7 +3304,7 @@ bool IsForeignRefAccessible(ObjHeader* object, ForeignRefContext context) { void AdoptReferenceFromSharedVariable(ObjHeader* object) { #if USE_GC - if (IsStrictMemoryModel && object != nullptr && isShareable(containerFor(object))) + if (IsStrictMemoryModel() && object != nullptr && isShareable(containerFor(object))) rememberNewContainer(containerFor(object)); #endif // USE_GC } diff --git a/kotlin-native/runtime/src/main/cpp/KAssert.h b/kotlin-native/runtime/src/main/cpp/KAssert.h index c111c1783fa..aa8edac245b 100644 --- a/kotlin-native/runtime/src/main/cpp/KAssert.h +++ b/kotlin-native/runtime/src/main/cpp/KAssert.h @@ -27,6 +27,19 @@ RUNTIME_NORETURN void RuntimeAssertFailed(const char* location, const char* message); +namespace internal { + +inline RUNTIME_NORETURN void TODOImpl(const char* location) { + RuntimeAssertFailed(location, "Unimplemented"); +} + +// TODO: Support format string when `RuntimeAssertFailed` supports it. +inline RUNTIME_NORETURN void TODOImpl(const char* location, const char* message) { + RuntimeAssertFailed(location, message); +} + +} // namespace internal + // During codegeneration we set this constant to 1 or 0 to allow bitcode optimizer // to get rid of code behind condition. extern "C" const int KonanNeedDebugInfo; @@ -48,4 +61,9 @@ if (KonanNeedDebugInfo && (!(condition))) { \ RuntimeAssertFailed(nullptr, message); \ } +#define TODO(...) \ + do { \ + ::internal::TODOImpl(__FILE__ ":" TOSTRING(__LINE__), ##__VA_ARGS__); \ + } while (false) + #endif // RUNTIME_ASSERT_H diff --git a/kotlin-native/runtime/src/main/cpp/KAssertTest.cpp b/kotlin-native/runtime/src/main/cpp/KAssertTest.cpp new file mode 100644 index 00000000000..4460db8515a --- /dev/null +++ b/kotlin-native/runtime/src/main/cpp/KAssertTest.cpp @@ -0,0 +1,20 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license + * that can be found in the LICENSE file. + */ + +#include "KAssert.h" + +#include "gtest/gtest.h" + +TEST(TODODeathTest, EmptyTODO) { + EXPECT_DEATH({ + TODO(); + }, "KAssertTest.cpp:12: runtime assert: Unimplemented"); +} + +TEST(TODODeathTest, TODOWithMessage) { + EXPECT_DEATH({ + TODO("Nope"); + }, "KAssertTest.cpp:18: runtime assert: Nope"); +} diff --git a/kotlin-native/runtime/src/main/cpp/Memory.h b/kotlin-native/runtime/src/main/cpp/Memory.h index 82c58fde4b6..94b7a94b85d 100644 --- a/kotlin-native/runtime/src/main/cpp/Memory.h +++ b/kotlin-native/runtime/src/main/cpp/Memory.h @@ -173,8 +173,15 @@ void InitAndRegisterGlobal(ObjHeader** location, const ObjHeader* initialValue) // in intermediate frames when throwing // +// NOTE: Must match `MemoryModel` in `Platform.kt` +enum class MemoryModel { + kStrict = 0, + kRelaxed = 1, + kExperimental = 2, +}; + // Controls the current memory model, is compile-time constant. -extern const bool IsStrictMemoryModel; +extern const MemoryModel CurrentMemoryModel; // Sets stack location. void SetStackRef(ObjHeader** location, const ObjHeader* object) RUNTIME_NOTHROW; diff --git a/kotlin-native/runtime/src/main/cpp/Runtime.cpp b/kotlin-native/runtime/src/main/cpp/Runtime.cpp index faa29a629de..88ebcdf8e60 100644 --- a/kotlin-native/runtime/src/main/cpp/Runtime.cpp +++ b/kotlin-native/runtime/src/main/cpp/Runtime.cpp @@ -314,7 +314,7 @@ KInt Konan_Platform_getCpuArchitecture() { } KInt Konan_Platform_getMemoryModel() { - return IsStrictMemoryModel ? 0 : 1; + return static_cast(CurrentMemoryModel); } KBoolean Konan_Platform_isDebugBinary() { diff --git a/kotlin-native/runtime/src/main/kotlin/kotlin/native/Platform.kt b/kotlin-native/runtime/src/main/kotlin/kotlin/native/Platform.kt index 6ca425e88fa..39da7b97961 100644 --- a/kotlin-native/runtime/src/main/kotlin/kotlin/native/Platform.kt +++ b/kotlin-native/runtime/src/main/kotlin/kotlin/native/Platform.kt @@ -36,9 +36,11 @@ public enum class CpuArchitecture(val bitness: Int) { /** * Memory model. */ +// NOTE: Must match `MemoryModel` in `Memory.h` public enum class MemoryModel { STRICT, - RELAXED + RELAXED, + EXPERIMENTAL, } /** diff --git a/kotlin-native/runtime/src/mm/cpp/Memory.cpp b/kotlin-native/runtime/src/mm/cpp/Memory.cpp index ba9ab725eeb..184736dc66d 100644 --- a/kotlin-native/runtime/src/mm/cpp/Memory.cpp +++ b/kotlin-native/runtime/src/mm/cpp/Memory.cpp @@ -6,6 +6,8 @@ #include "Memory.h" #include "GlobalsRegistry.hpp" +#include "KAssert.h" +#include "Porting.h" #include "StableRefRegistry.hpp" #include "ThreadData.hpp" #include "ThreadRegistry.hpp" @@ -55,6 +57,11 @@ ALWAYS_INLINE mm::ThreadData* GetThreadData(MemoryState* state) { } // namespace +ALWAYS_INLINE bool isShareable(const ObjHeader* obj) { + // TODO: Remove when legacy MM is gone. + return true; +} + extern "C" MemoryState* InitMemory(bool firstRuntime) { return ToMemoryState(mm::ThreadRegistry::Instance().RegisterCurrentThread()); } @@ -63,21 +70,27 @@ extern "C" void DeinitMemory(MemoryState* state, bool destroyRuntime) { mm::ThreadRegistry::Instance().Unregister(FromMemoryState(state)); } +extern "C" void RestoreMemory(MemoryState*) { + // TODO: Remove when legacy MM is gone. +} + extern "C" OBJ_GETTER(InitSingleton, ObjHeader** location, const TypeInfo* typeInfo, void (*ctor)(ObjHeader*)) { auto* threadData = mm::ThreadRegistry::Instance().CurrentThreadData(); // TODO: This should only be called if singleton is actually created here. It's possible that the // singleton will be created on a different thread and here we should check that, instead of creating // another one (and registering `location` twice). mm::GlobalsRegistry::Instance().RegisterStorageForGlobal(threadData, location); - RuntimeCheck(false, "Unimplemented"); + TODO(); } extern "C" RUNTIME_NOTHROW void InitAndRegisterGlobal(ObjHeader** location, const ObjHeader* initialValue) { auto* threadData = mm::ThreadRegistry::Instance().CurrentThreadData(); mm::GlobalsRegistry::Instance().RegisterStorageForGlobal(threadData, location); - RuntimeCheck(false, "Unimplemented"); + TODO(); } +extern "C" const MemoryModel CurrentMemoryModel = MemoryModel::kExperimental; + extern "C" RUNTIME_NOTHROW void AddTLSRecord(MemoryState* memory, void** key, int size) { GetThreadData(memory)->tls().AddRecord(key, size); } @@ -94,6 +107,31 @@ extern "C" RUNTIME_NOTHROW ObjHeader** LookupTLS(void** key, int index) { return mm::ThreadRegistry::Instance().CurrentThreadData()->tls().Lookup(key, index); } +extern "C" RUNTIME_NOTHROW void GC_RegisterWorker(void* worker) { + // TODO: Remove when legacy MM is gone. + // Nothing to do +} + +extern "C" RUNTIME_NOTHROW void GC_UnregisterWorker(void* worker) { + // TODO: Remove when legacy MM is gone. + // Nothing to do +} + +extern "C" RUNTIME_NOTHROW void GC_CollectorCallback(void* worker) { + // TODO: Remove when legacy MM is gone. + // Nothing to do +} + +extern "C" bool Kotlin_Any_isShareable(ObjHeader* thiz) { + // TODO: Remove when legacy MM is gone. + return true; +} + +extern "C" RUNTIME_NOTHROW bool ClearSubgraphReferences(ObjHeader* root, bool checked) { + // TODO: Remove when legacy MM is gone. + return true; +} + extern "C" RUNTIME_NOTHROW void* CreateStablePointer(ObjHeader* object) { auto* threadData = mm::ThreadRegistry::Instance().CurrentThreadData(); return mm::StableRefRegistry::Instance().RegisterStableRef(threadData, object); @@ -120,6 +158,14 @@ extern "C" RUNTIME_NOTHROW OBJ_GETTER(AdoptStablePointer, void* pointer) { return object; } +extern "C" RUNTIME_NOTHROW void CheckLifetimesConstraint(ObjHeader* obj, ObjHeader* pointee) { + if (!obj->local() && pointee != nullptr && pointee->local()) { + konan::consolePrintf("Attempt to store a stack object %p into a heap object %p\n", pointee, obj); + konan::consolePrintf("This is a compiler bug, please report it to https://kotl.in/issue\n"); + konan::abort(); + } +} + extern "C" ForeignRefContext InitForeignRef(ObjHeader* object) { auto* threadData = mm::ThreadRegistry::Instance().CurrentThreadData(); auto* node = mm::StableRefRegistry::Instance().RegisterStableRef(threadData, object); @@ -142,3 +188,8 @@ extern "C" void AdoptReferenceFromSharedVariable(ObjHeader* object) { // TODO: Remove when legacy MM is gone. // Nothing to do. } + +void CheckGlobalsAccessible() { + // TODO: Remove when legacy MM is gone. + // Always accessible +} diff --git a/kotlin-native/runtime/src/mm/cpp/Stubs.cpp b/kotlin-native/runtime/src/mm/cpp/Stubs.cpp index 5b67ff9f063..bc79217b2cd 100644 --- a/kotlin-native/runtime/src/mm/cpp/Stubs.cpp +++ b/kotlin-native/runtime/src/mm/cpp/Stubs.cpp @@ -5,181 +5,145 @@ #include "Memory.h" +#include "KAssert.h" + ALWAYS_INLINE bool isFrozen(const ObjHeader* obj) { - RuntimeCheck(false, "Unimplemented"); + TODO(); } ALWAYS_INLINE bool isPermanentOrFrozen(const ObjHeader* obj) { - RuntimeCheck(false, "Unimplemented"); -} - -ALWAYS_INLINE bool isShareable(const ObjHeader* obj) { - RuntimeCheck(false, "Unimplemented"); + TODO(); } ObjHeader** ObjHeader::GetWeakCounterLocation() { - RuntimeCheck(false, "Unimplemented"); + TODO(); } #ifdef KONAN_OBJC_INTEROP void* ObjHeader::GetAssociatedObject() { - RuntimeCheck(false, "Unimplemented"); + TODO(); } void** ObjHeader::GetAssociatedObjectLocation() { - RuntimeCheck(false, "Unimplemented"); + TODO(); } void ObjHeader::SetAssociatedObject(void* obj) { - RuntimeCheck(false, "Unimplemented"); + TODO(); } #endif // KONAN_OBJC_INTEROP static MetaObjHeader* createMetaObject(TypeInfo** location) { - RuntimeCheck(false, "Unimplemented"); + TODO(); } static void destroyMetaObject(TypeInfo** location) { - RuntimeCheck(false, "Unimplemented"); + TODO(); } extern "C" { -void RestoreMemory(MemoryState*) { - // TODO: Remove this function when legacy MM is gone. -} - RUNTIME_NOTHROW OBJ_GETTER(AllocInstance, const TypeInfo* type_info) { - RuntimeCheck(false, "Unimplemented"); + TODO(); } OBJ_GETTER(AllocArrayInstance, const TypeInfo* type_info, int32_t elements) { - RuntimeCheck(false, "Unimplemented"); + TODO(); } OBJ_GETTER(InitThreadLocalSingleton, ObjHeader** location, const TypeInfo* typeInfo, void (*ctor)(ObjHeader*)) { - RuntimeCheck(false, "Unimplemented"); + TODO(); } -extern const bool IsStrictMemoryModel = true; - RUNTIME_NOTHROW void SetStackRef(ObjHeader** location, const ObjHeader* object) { - RuntimeCheck(false, "Unimplemented"); + TODO(); } RUNTIME_NOTHROW void SetHeapRef(ObjHeader** location, const ObjHeader* object) { - RuntimeCheck(false, "Unimplemented"); + TODO(); } RUNTIME_NOTHROW void ZeroHeapRef(ObjHeader** location) { - RuntimeCheck(false, "Unimplemented"); + TODO(); } RUNTIME_NOTHROW void ZeroArrayRefs(ArrayHeader* array) { - RuntimeCheck(false, "Unimplemented"); + TODO(); } RUNTIME_NOTHROW void ZeroStackRef(ObjHeader** location) { - RuntimeCheck(false, "Unimplemented"); + TODO(); } RUNTIME_NOTHROW void UpdateStackRef(ObjHeader** location, const ObjHeader* object) { - RuntimeCheck(false, "Unimplemented"); + TODO(); } RUNTIME_NOTHROW void UpdateHeapRef(ObjHeader** location, const ObjHeader* object) { - RuntimeCheck(false, "Unimplemented"); + TODO(); } RUNTIME_NOTHROW void UpdateHeapRefIfNull(ObjHeader** location, const ObjHeader* object) { - RuntimeCheck(false, "Unimplemented"); + TODO(); } RUNTIME_NOTHROW void UpdateReturnRef(ObjHeader** returnSlot, const ObjHeader* object) { - RuntimeCheck(false, "Unimplemented"); + TODO(); } RUNTIME_NOTHROW OBJ_GETTER( SwapHeapRefLocked, ObjHeader** location, ObjHeader* expectedValue, ObjHeader* newValue, int32_t* spinlock, int32_t* cookie) { - RuntimeCheck(false, "Unimplemented"); + TODO(); } RUNTIME_NOTHROW void SetHeapRefLocked(ObjHeader** location, ObjHeader* newValue, int32_t* spinlock, int32_t* cookie) { - RuntimeCheck(false, "Unimplemented"); + TODO(); } RUNTIME_NOTHROW OBJ_GETTER(ReadHeapRefLocked, ObjHeader** location, int32_t* spinlock, int32_t* cookie) { - RuntimeCheck(false, "Unimplemented"); + TODO(); } RUNTIME_NOTHROW void EnterFrame(ObjHeader** start, int parameters, int count) { - RuntimeCheck(false, "Unimplemented"); + TODO(); } RUNTIME_NOTHROW void LeaveFrame(ObjHeader** start, int parameters, int count) { - RuntimeCheck(false, "Unimplemented"); -} - -RUNTIME_NOTHROW bool ClearSubgraphReferences(ObjHeader* root, bool checked) { - RuntimeCheck(false, "Unimplemented"); + TODO(); } void MutationCheck(ObjHeader* obj) { - RuntimeCheck(false, "Unimplemented"); -} - -RUNTIME_NOTHROW void CheckLifetimesConstraint(ObjHeader* obj, ObjHeader* pointee) { - RuntimeCheck(false, "Unimplemented"); + TODO(); } void FreezeSubgraph(ObjHeader* obj) { - RuntimeCheck(false, "Unimplemented"); + TODO(); } void EnsureNeverFrozen(ObjHeader* obj) { - RuntimeCheck(false, "Unimplemented"); -} - -RUNTIME_NOTHROW void GC_RegisterWorker(void* worker) { - RuntimeCheck(false, "Unimplemented"); -} - -RUNTIME_NOTHROW void GC_UnregisterWorker(void* worker) { - RuntimeCheck(false, "Unimplemented"); -} - -RUNTIME_NOTHROW void GC_CollectorCallback(void* worker) { - RuntimeCheck(false, "Unimplemented"); -} - -bool Kotlin_Any_isShareable(ObjHeader* thiz) { - RuntimeCheck(false, "Unimplemented"); + TODO(); } RUNTIME_NOTHROW void PerformFullGC(MemoryState* memory) { - RuntimeCheck(false, "Unimplemented"); + TODO(); } bool TryAddHeapRef(const ObjHeader* object) { - RuntimeCheck(false, "Unimplemented"); + TODO(); } RUNTIME_NOTHROW void ReleaseHeapRef(const ObjHeader* object) { - RuntimeCheck(false, "Unimplemented"); + TODO(); } RUNTIME_NOTHROW void ReleaseHeapRefNoCollect(const ObjHeader* object) { - RuntimeCheck(false, "Unimplemented"); + TODO(); } ForeignRefContext InitLocalForeignRef(ObjHeader* object) { - RuntimeCheck(false, "Unimplemented"); -} - -void CheckGlobalsAccessible() { - // Globals are always accessible. + TODO(); } } // extern "C" diff --git a/kotlin-native/runtime/src/relaxed/cpp/MemoryImpl.cpp b/kotlin-native/runtime/src/relaxed/cpp/MemoryImpl.cpp index 4bc24d38c6c..458d2177ae1 100644 --- a/kotlin-native/runtime/src/relaxed/cpp/MemoryImpl.cpp +++ b/kotlin-native/runtime/src/relaxed/cpp/MemoryImpl.cpp @@ -9,7 +9,7 @@ extern "C" { -const bool IsStrictMemoryModel = false; +const MemoryModel CurrentMemoryModel = MemoryModel::kRelaxed; OBJ_GETTER(AllocInstance, const TypeInfo* typeInfo) { RETURN_RESULT_OF(AllocInstanceRelaxed, typeInfo); diff --git a/kotlin-native/runtime/src/strict/cpp/MemoryImpl.cpp b/kotlin-native/runtime/src/strict/cpp/MemoryImpl.cpp index 413b802258d..8c0b65891d3 100644 --- a/kotlin-native/runtime/src/strict/cpp/MemoryImpl.cpp +++ b/kotlin-native/runtime/src/strict/cpp/MemoryImpl.cpp @@ -9,7 +9,7 @@ extern "C" { -const bool IsStrictMemoryModel = true; +const MemoryModel CurrentMemoryModel = MemoryModel::kStrict; OBJ_GETTER(AllocInstance, const TypeInfo* typeInfo) { RETURN_RESULT_OF(AllocInstanceStrict, typeInfo); From 9b84d72a44ad7325e3d18d34451087e73b17da85 Mon Sep 17 00:00:00 2001 From: Igor Chevdar Date: Wed, 9 Dec 2020 20:13:16 +0500 Subject: [PATCH 177/196] [objc][codegen] Fixed bug with calling fake override interface methods --- .../konan/descriptors/ClassLayoutBuilder.kt | 6 +-- .../objcexport/ObjCExportCodeGenerator.kt | 1 + .../tests/objcexport/expectedLazy.h | 12 ++++++ .../backend.native/tests/objcexport/values.kt | 9 +++++ .../tests/objcexport/values.swift | 9 +++++ .../runtime/src/main/cpp/ObjCExport.mm | 37 ++++++++++++------- 6 files changed, 57 insertions(+), 17 deletions(-) diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/descriptors/ClassLayoutBuilder.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/descriptors/ClassLayoutBuilder.kt index 7431e56aae7..75e9ace5c2f 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/descriptors/ClassLayoutBuilder.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/descriptors/ClassLayoutBuilder.kt @@ -363,9 +363,9 @@ internal class ClassLayoutBuilder(val irClass: IrClass, val context: Context, va .toList() } - data class InterfaceTablePlace(val interfaceId: Int, val methodIndex: Int) { + data class InterfaceTablePlace(val interfaceId: Int, val itableSize: Int, val methodIndex: Int) { companion object { - val INVALID = InterfaceTablePlace(0, -1) + val INVALID = InterfaceTablePlace(0, -1, -1) } } @@ -374,7 +374,7 @@ internal class ClassLayoutBuilder(val irClass: IrClass, val context: Context, va val itable = interfaceTableEntries val index = itable.indexOf(function) if (index >= 0) - return InterfaceTablePlace(hierarchyInfo.interfaceId, index) + return InterfaceTablePlace(hierarchyInfo.interfaceId, itable.size, index) val superFunction = function.overriddenSymbols.first().owner return context.getLayoutBuilder(superFunction.parentAsClass).itablePlace(superFunction) } diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/objcexport/ObjCExportCodeGenerator.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/objcexport/ObjCExportCodeGenerator.kt index 48fc3c761bb..b1a25250c97 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/objcexport/ObjCExportCodeGenerator.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/objcexport/ObjCExportCodeGenerator.kt @@ -405,6 +405,7 @@ internal class ObjCExportCodeGenerator( staticData.cStringLiteral(selector), Int64(nameSignature), Int32(itablePlace.interfaceId), + Int32(itablePlace.itableSize), Int32(itablePlace.methodIndex), Int32(vtableIndex), kotlinImpl diff --git a/kotlin-native/backend.native/tests/objcexport/expectedLazy.h b/kotlin-native/backend.native/tests/objcexport/expectedLazy.h index 0bbb1375263..39dcf92fc9a 100644 --- a/kotlin-native/backend.native/tests/objcexport/expectedLazy.h +++ b/kotlin-native/backend.native/tests/objcexport/expectedLazy.h @@ -1937,6 +1937,17 @@ __attribute__((swift_name("GH3825KotlinImpl"))) - (BOOL)call2Callback:(void (^)(void))callback doThrow:(BOOL)doThrow error:(NSError * _Nullable * _Nullable)error __attribute__((swift_name("call2(callback:doThrow:)"))); @end; +__attribute__((swift_name("Foo_FakeOverrideInInterface"))) +@protocol KtFoo_FakeOverrideInInterface +@required +- (void)fooT:(id _Nullable)t __attribute__((swift_name("foo(t:)"))); +@end; + +__attribute__((swift_name("Bar_FakeOverrideInInterface"))) +@protocol KtBar_FakeOverrideInInterface +@required +@end; + @interface KtEnumeration (ValuesKt) - (KtEnumeration *)getAnswer __attribute__((swift_name("getAnswer()"))); @end; @@ -2088,6 +2099,7 @@ __attribute__((swift_name("ValuesKt"))) + (KtMutableDictionary *)mutULong2Long __attribute__((swift_name("mutULong2Long()"))); + (KtMutableDictionary *)mutFloat2Float __attribute__((swift_name("mutFloat2Float()"))); + (KtMutableDictionary *)mutDouble2String __attribute__((swift_name("mutDouble2String()"))); ++ (void)callFoo_FakeOverrideInInterfaceObj:(id)obj __attribute__((swift_name("callFoo_FakeOverrideInInterface(obj:)"))); @property (class, readonly) double dbl __attribute__((swift_name("dbl"))); @property (class, readonly) float flt __attribute__((swift_name("flt"))); @property (class, readonly) int32_t integer __attribute__((swift_name("integer"))); diff --git a/kotlin-native/backend.native/tests/objcexport/values.kt b/kotlin-native/backend.native/tests/objcexport/values.kt index 01753e1c599..6f6d224360c 100644 --- a/kotlin-native/backend.native/tests/objcexport/values.kt +++ b/kotlin-native/backend.native/tests/objcexport/values.kt @@ -1012,3 +1012,12 @@ fun mutULong2Long(): MutableMap = mutableMapOf(Pair(0x8000_0000_000 fun mutFloat2Float(): MutableMap = mutableMapOf(Pair(3.14f, 100f)) fun mutDouble2String(): MutableMap = mutableMapOf(Pair(2.718281828459045, "2.718281828459045")) +interface Foo_FakeOverrideInInterface { + fun foo(t: T?) +} + +interface Bar_FakeOverrideInInterface : Foo_FakeOverrideInInterface + +fun callFoo_FakeOverrideInInterface(obj: Bar_FakeOverrideInInterface) { + obj.foo(null) +} \ No newline at end of file diff --git a/kotlin-native/backend.native/tests/objcexport/values.swift b/kotlin-native/backend.native/tests/objcexport/values.swift index 8ae7fe998ed..2605878cd58 100644 --- a/kotlin-native/backend.native/tests/objcexport/values.swift +++ b/kotlin-native/backend.native/tests/objcexport/values.swift @@ -1318,6 +1318,14 @@ func testMapsExport() throws { try assertEquals(actual: (ValuesKt.mutDouble2String() as! [Double: String])[2.718281828459045], expected: "2.718281828459045") } +class Baz_FakeOverrideInInterface : Bar_FakeOverrideInInterface { + func foo(t: Any?) {} +} + +func testFakeOverrideInInterface() throws { + ValuesKt.callFoo_FakeOverrideInInterface(obj: Baz_FakeOverrideInInterface()) +} + // -------- Execution of the test -------- class ValuesTests : SimpleTestProvider { @@ -1374,6 +1382,7 @@ class ValuesTests : SimpleTestProvider { test("TestStringConversion", testStringConversion) test("TestGH3825", testGH3825) test("TestMapsExport", testMapsExport) + test("TestFakeOverrideInInterface", testFakeOverrideInInterface) // Stress test, must remain the last one: test("TestGH2931", testGH2931) diff --git a/kotlin-native/runtime/src/main/cpp/ObjCExport.mm b/kotlin-native/runtime/src/main/cpp/ObjCExport.mm index e615ef07ea2..ae9ead6feee 100644 --- a/kotlin-native/runtime/src/main/cpp/ObjCExport.mm +++ b/kotlin-native/runtime/src/main/cpp/ObjCExport.mm @@ -54,6 +54,7 @@ struct KotlinToObjCMethodAdapter { const char* selector; MethodNameHash nameSignature; ClassId interfaceId; + int itableSize; int itableIndex; int vtableIndex; const void* kotlinImpl; @@ -889,6 +890,8 @@ static const TypeInfo* createTypeInfo(Class clazz, const TypeInfo* superType, co supers.push_back(t); } + bool itableEqualsSuper = true; + auto addToITable = [&interfaceVTables](ClassId interfaceId, int methodIndex, VTableElement entry) { RuntimeAssert(interfaceId != kInvalidInterfaceId, ""); auto interfaceVTableIt = interfaceVTables.find(interfaceId); @@ -898,7 +901,18 @@ static const TypeInfo* createTypeInfo(Class clazz, const TypeInfo* superType, co interfaceVTable[methodIndex] = entry; }; - bool itableEqualsSuper = true; + auto addITable = [&interfaceVTables, &itableEqualsSuper](ClassId interfaceId, int itableSize) { + RuntimeAssert(itableSize >= 0, ""); + auto interfaceVTablesIt = interfaceVTables.find(interfaceId); + if (interfaceVTablesIt == interfaceVTables.end()) { + itableEqualsSuper = false; + interfaceVTables.emplace(interfaceId, KStdVector(itableSize)); + } else { + auto const& interfaceVTable = interfaceVTablesIt->second; + RuntimeAssert(interfaceVTable.size() == static_cast(itableSize), ""); + } + }; + for (const TypeInfo* t : supers) { const ObjCTypeAdapter* typeAdapter = getTypeAdapter(t); if (typeAdapter == nullptr) continue; @@ -924,17 +938,8 @@ static const TypeInfo* createTypeInfo(Class clazz, const TypeInfo* superType, co if (typeAdapter == nullptr) continue; if (superITable != nullptr) { - auto interfaceId = typeInfo->classId_; - int interfaceVTableSize = typeAdapter->kotlinItableSize; - RuntimeAssert(interfaceVTableSize >= 0, ""); - auto interfaceVTablesIt = interfaceVTables.find(interfaceId); - if (interfaceVTablesIt == interfaceVTables.end()) { - itableEqualsSuper = false; - interfaceVTables.emplace(interfaceId, KStdVector(interfaceVTableSize)); - } else { - auto const& interfaceVTable = interfaceVTablesIt->second; - RuntimeAssert(interfaceVTable.size() == static_cast(interfaceVTableSize), ""); - } + // The interface vtable has to be created always in order for type checks to work. + addITable(typeInfo->classId_, typeAdapter->kotlinItableSize); } for (int i = 0; i < typeAdapter->reverseAdapterNum; ++i) { @@ -945,8 +950,12 @@ static const TypeInfo* createTypeInfo(Class clazz, const TypeInfo* superType, co insertOrReplace(methodTable, adapter->nameSignature, const_cast(adapter->kotlinImpl)); RuntimeAssert(adapter->vtableIndex == -1, ""); - if (adapter->itableIndex != -1 && superITable != nullptr) - addToITable(adapter->interfaceId, adapter->itableIndex, adapter->kotlinImpl); + if (adapter->itableIndex != -1 && superITable != nullptr) { + // In general, [adapter->interfaceId] might not be equal to [typeInfo->classId_]. + auto interfaceId = adapter->interfaceId; + addITable(interfaceId, adapter->itableSize); + addToITable(interfaceId, adapter->itableIndex, adapter->kotlinImpl); + } } } From ceae6c5a3ee0be61953f3544a0ee25afd3d834d0 Mon Sep 17 00:00:00 2001 From: Ilya Matveev Date: Mon, 7 Dec 2020 18:56:48 +0700 Subject: [PATCH 178/196] [runtime] Add runtime/.idea generated by CLion to gitignore --- kotlin-native/.gitignore | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/kotlin-native/.gitignore b/kotlin-native/.gitignore index 94a9f214684..38732eb4eed 100644 --- a/kotlin-native/.gitignore +++ b/kotlin-native/.gitignore @@ -74,4 +74,7 @@ compile_commands.json runtime/googletest/ # Toolchain builder artifacts -tools/toolchain_builder/artifacts \ No newline at end of file +tools/toolchain_builder/artifacts + +# ignore the project model created by CLion (for now). +runtime/.idea From 6fb5e43f6253778de81d3596d3d0e731cea430d9 Mon Sep 17 00:00:00 2001 From: Ilya Matveev Date: Mon, 7 Dec 2020 19:15:19 +0700 Subject: [PATCH 179/196] [runtime] Introduce thread states --- .../runtime/src/legacymm/cpp/Memory.cpp | 8 ++ .../runtime/src/main/cpp/CompilerExport.cpp | 2 + kotlin-native/runtime/src/main/cpp/Memory.h | 5 ++ .../runtime/src/mm/cpp/ThreadData.hpp | 12 ++- .../runtime/src/mm/cpp/ThreadState.cpp | 67 +++++++++++++++++ .../runtime/src/mm/cpp/ThreadState.hpp | 36 +++++++++ .../runtime/src/mm/cpp/ThreadStateTest.cpp | 75 +++++++++++++++++++ .../src/test_support/cpp/TestLauncher.cpp | 3 + 8 files changed, 207 insertions(+), 1 deletion(-) create mode 100644 kotlin-native/runtime/src/mm/cpp/ThreadState.cpp create mode 100644 kotlin-native/runtime/src/mm/cpp/ThreadState.hpp create mode 100644 kotlin-native/runtime/src/mm/cpp/ThreadStateTest.cpp diff --git a/kotlin-native/runtime/src/legacymm/cpp/Memory.cpp b/kotlin-native/runtime/src/legacymm/cpp/Memory.cpp index 54e7f287e7e..d826cd0218c 100644 --- a/kotlin-native/runtime/src/legacymm/cpp/Memory.cpp +++ b/kotlin-native/runtime/src/legacymm/cpp/Memory.cpp @@ -3670,4 +3670,12 @@ void CheckGlobalsAccessible() { ThrowIncorrectDereferenceException(); } +ALWAYS_INLINE RUNTIME_NOTHROW void Kotlin_mm_switchThreadStateNative() { + // no-op, used by the new MM only. +} + +ALWAYS_INLINE RUNTIME_NOTHROW void Kotlin_mm_switchThreadStateRunnable() { + // no-op, used by the new MM only. +} + } // extern "C" diff --git a/kotlin-native/runtime/src/main/cpp/CompilerExport.cpp b/kotlin-native/runtime/src/main/cpp/CompilerExport.cpp index 8f9ce315cc5..10a5ba0b53b 100644 --- a/kotlin-native/runtime/src/main/cpp/CompilerExport.cpp +++ b/kotlin-native/runtime/src/main/cpp/CompilerExport.cpp @@ -42,4 +42,6 @@ void EnsureDeclarationsEmitted() { ensureUsed(FreezeSubgraph); ensureUsed(FreezeSubgraph); ensureUsed(CheckGlobalsAccessible); + ensureUsed(Kotlin_mm_switchThreadStateNative); + ensureUsed(Kotlin_mm_switchThreadStateRunnable); } diff --git a/kotlin-native/runtime/src/main/cpp/Memory.h b/kotlin-native/runtime/src/main/cpp/Memory.h index 94b7a94b85d..5f0b0e1eb85 100644 --- a/kotlin-native/runtime/src/main/cpp/Memory.h +++ b/kotlin-native/runtime/src/main/cpp/Memory.h @@ -268,6 +268,11 @@ void AdoptReferenceFromSharedVariable(ObjHeader* object); void CheckGlobalsAccessible(); +// Sets state of the current thread to NATIVE (used by the new MM). +ALWAYS_INLINE RUNTIME_NOTHROW void Kotlin_mm_switchThreadStateNative(); +// Sets state of the current thread to RUNNABLE (used by the new MM). +ALWAYS_INLINE RUNTIME_NOTHROW void Kotlin_mm_switchThreadStateRunnable(); + #ifdef __cplusplus } #endif diff --git a/kotlin-native/runtime/src/mm/cpp/ThreadData.hpp b/kotlin-native/runtime/src/mm/cpp/ThreadData.hpp index e7a788e5099..b5f18dc1853 100644 --- a/kotlin-native/runtime/src/mm/cpp/ThreadData.hpp +++ b/kotlin-native/runtime/src/mm/cpp/ThreadData.hpp @@ -6,12 +6,14 @@ #ifndef RUNTIME_MM_THREAD_DATA_H #define RUNTIME_MM_THREAD_DATA_H +#include #include #include "GlobalsRegistry.hpp" #include "StableRefRegistry.hpp" #include "ThreadLocalStorage.hpp" #include "Utils.hpp" +#include "ThreadState.hpp" namespace kotlin { namespace mm { @@ -21,7 +23,10 @@ namespace mm { class ThreadData final : private Pinned { public: ThreadData(pthread_t threadId) noexcept : - threadId_(threadId), globalsThreadQueue_(GlobalsRegistry::Instance()), stableRefThreadQueue_(StableRefRegistry::Instance()) {} + threadId_(threadId), + globalsThreadQueue_(GlobalsRegistry::Instance()), + stableRefThreadQueue_(StableRefRegistry::Instance()), + state_(ThreadState::kRunnable) {} ~ThreadData() = default; @@ -33,11 +38,16 @@ public: StableRefRegistry::ThreadQueue& stableRefThreadQueue() noexcept { return stableRefThreadQueue_; } + ThreadState state() noexcept { return state_; } + + ThreadState setState(ThreadState state) noexcept { return state_.exchange(state); } + private: const pthread_t threadId_; GlobalsRegistry::ThreadQueue globalsThreadQueue_; ThreadLocalStorage tls_; StableRefRegistry::ThreadQueue stableRefThreadQueue_; + std::atomic state_; }; } // namespace mm diff --git a/kotlin-native/runtime/src/mm/cpp/ThreadState.cpp b/kotlin-native/runtime/src/mm/cpp/ThreadState.cpp new file mode 100644 index 00000000000..57b7c2410dc --- /dev/null +++ b/kotlin-native/runtime/src/mm/cpp/ThreadState.cpp @@ -0,0 +1,67 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license + * that can be found in the LICENSE file. + */ + +#include "ThreadData.hpp" +#include "ThreadState.hpp" + +using namespace kotlin; + +namespace { + +ALWAYS_INLINE bool isStateSwitchAllowed(mm::ThreadState oldState, mm::ThreadState newState) noexcept { + return oldState != newState; +} + +const char* stateToString(mm::ThreadState state) noexcept { + switch (state) { + case mm::ThreadState::kRunnable: + return "RUNNABLE"; + case mm::ThreadState::kNative: + return "NATIVE"; + } +} + +std::string unexpectedStateMessage(mm::ThreadState expected, mm::ThreadState actual) noexcept { + return std::string("Unexpected thread state. Expected: ") + stateToString(expected) + + ". Actual: " + stateToString(actual); +} + +std::string illegalStateSwitchMessage(mm::ThreadState oldState, mm::ThreadState newState) noexcept { + return std::string("Illegal thread state switch. Old state: ") + stateToString(oldState) + + ". New state: " + stateToString(newState); +} + +} // namespace + +// Switches the state of the current thread to `newState` and returns the previous state. +ALWAYS_INLINE mm::ThreadState mm::SwitchThreadState(ThreadData* threadData, ThreadState newState) noexcept { + auto oldState = threadData->setState(newState); + // TODO(perf): Mesaure the impact of this assert in debug and opt modes. + RuntimeAssert(isStateSwitchAllowed(oldState, newState), + illegalStateSwitchMessage(oldState, newState).c_str()); + return oldState; +} + +ALWAYS_INLINE void mm::AssertThreadState(ThreadData* threadData, ThreadState expected) noexcept { + auto actual = threadData->state(); + RuntimeAssert(actual == expected, unexpectedStateMessage(expected, actual).c_str()); +} + +mm::ThreadStateGuard::ThreadStateGuard(ThreadData* threadData, ThreadState state) noexcept : threadData_(threadData) { + oldState_ = SwitchThreadState(threadData, state); +} + +mm::ThreadStateGuard::~ThreadStateGuard() noexcept { + SwitchThreadState(threadData_, oldState_); +} + +extern "C" ALWAYS_INLINE RUNTIME_NOTHROW void Kotlin_mm_switchThreadStateNative() { + mm::SwitchThreadState(mm::ThreadRegistry::Instance().CurrentThreadData(), mm::ThreadState::kNative); +} + +extern "C" ALWAYS_INLINE RUNTIME_NOTHROW void Kotlin_mm_switchThreadStateRunnable() { + mm::SwitchThreadState(mm::ThreadRegistry::Instance().CurrentThreadData(), mm::ThreadState::kRunnable); +} + diff --git a/kotlin-native/runtime/src/mm/cpp/ThreadState.hpp b/kotlin-native/runtime/src/mm/cpp/ThreadState.hpp new file mode 100644 index 00000000000..65442a6db48 --- /dev/null +++ b/kotlin-native/runtime/src/mm/cpp/ThreadState.hpp @@ -0,0 +1,36 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license + * that can be found in the LICENSE file. + */ + +#ifndef RUNTIME_MM_THREAD_STATE_H +#define RUNTIME_MM_THREAD_STATE_H + +#include +#include + +namespace kotlin { +namespace mm { + +enum class ThreadState { + kRunnable, kNative +}; + +// Switches the state of the current thread to `newState` and returns the previous thread state. +ALWAYS_INLINE ThreadState SwitchThreadState(ThreadData* threadData, ThreadState newState) noexcept; + +ALWAYS_INLINE void AssertThreadState(ThreadData* threadData, ThreadState expected) noexcept; + +class ThreadStateGuard final : private Pinned { +public: + explicit ThreadStateGuard(ThreadData* threadData, ThreadState state) noexcept; + ~ThreadStateGuard() noexcept; +private: + ThreadData* threadData_; + ThreadState oldState_; +}; + +} // namespace mm +} // namespace kotlin + +#endif // RUNTIME_MM_THREAD_STATE_H \ No newline at end of file diff --git a/kotlin-native/runtime/src/mm/cpp/ThreadStateTest.cpp b/kotlin-native/runtime/src/mm/cpp/ThreadStateTest.cpp new file mode 100644 index 00000000000..75f0ef5ed69 --- /dev/null +++ b/kotlin-native/runtime/src/mm/cpp/ThreadStateTest.cpp @@ -0,0 +1,75 @@ +/* + * Copyright 2010-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license + * that can be found in the LICENSE file. + */ + +#include + +#include "gtest/gtest.h" + +#include "ThreadData.hpp" +#include "ThreadRegistry.hpp" +#include "ThreadState.hpp" + +using namespace kotlin; + +TEST(ThreadStateTest, StateSwitch) { + std::thread t([]() { + mm::ThreadRegistry::Instance().RegisterCurrentThread(); + + auto* threadData = mm::ThreadRegistry::Instance().CurrentThreadData(); + auto initialState = threadData->state(); + EXPECT_EQ(mm::ThreadState::kRunnable, initialState); + + mm::ThreadState oldState = mm::SwitchThreadState(threadData, mm::ThreadState::kNative); + EXPECT_EQ(initialState, oldState); + EXPECT_EQ(mm::ThreadState::kNative, threadData->state()); + + // Check functions exported for the compiler too. + Kotlin_mm_switchThreadStateRunnable(); + EXPECT_EQ(mm::ThreadState::kRunnable, threadData->state()); + + Kotlin_mm_switchThreadStateNative(); + EXPECT_EQ(mm::ThreadState::kNative, threadData->state()); + }); + t.join(); +} + +TEST(ThreadStateTest, StateGuard) { + std::thread t([]() { + mm::ThreadRegistry::Instance().RegisterCurrentThread(); + auto* threadData = mm::ThreadRegistry::Instance().CurrentThreadData(); + auto initialState = threadData->state(); + EXPECT_EQ(mm::ThreadState::kRunnable, initialState); + { + mm::ThreadStateGuard guard(threadData, mm::ThreadState::kNative); + EXPECT_EQ(mm::ThreadState::kNative, threadData->state()); + } + EXPECT_EQ(initialState, threadData->state()); + }); + t.join(); +} + +TEST(ThreadStateDeathTest, StateAsserts) { + std::thread t([]() { + auto* threadData = mm::ThreadRegistry::Instance().RegisterCurrentThread()->Get(); + EXPECT_DEATH(mm::AssertThreadState(threadData, mm::ThreadState::kNative), + "runtime assert: Unexpected thread state. Expected: NATIVE. Actual: RUNNABLE"); + }); + t.join(); +} + +TEST(ThreadStateDeathTest, IncorrectStateSwitch) { + std::thread t([]() { + auto* threadData = mm::ThreadRegistry::Instance().RegisterCurrentThread()->Get(); + EXPECT_DEATH(mm::SwitchThreadState(threadData, kotlin::mm::ThreadState::kRunnable), + "runtime assert: Illegal thread state switch. Old state: RUNNABLE. New state: RUNNABLE"); + EXPECT_DEATH(Kotlin_mm_switchThreadStateRunnable(), + "runtime assert: Illegal thread state switch. Old state: RUNNABLE. New state: RUNNABLE"); + + mm::SwitchThreadState(threadData, kotlin::mm::ThreadState::kNative); + EXPECT_DEATH(Kotlin_mm_switchThreadStateNative(), + "runtime assert: Illegal thread state switch. Old state: NATIVE. New state: NATIVE"); + }); + t.join(); +} diff --git a/kotlin-native/runtime/src/test_support/cpp/TestLauncher.cpp b/kotlin-native/runtime/src/test_support/cpp/TestLauncher.cpp index fa2c38e9536..0981e3e6e71 100644 --- a/kotlin-native/runtime/src/test_support/cpp/TestLauncher.cpp +++ b/kotlin-native/runtime/src/test_support/cpp/TestLauncher.cpp @@ -8,5 +8,8 @@ int main(int argc, char** argv) { testing::InitGoogleMock(&argc, argv); + // Use the `threadsafe` style to mitigate possible issues with multithreaded death tests. + // See more about death test styles: https://github.com/google/googletest/blob/master/googletest/docs/advanced.md#how-it-works + testing::FLAGS_gtest_death_test_style="threadsafe"; return RUN_ALL_TESTS(); } From e3bc247557b3498abf1951bb70f0df9b943f6b67 Mon Sep 17 00:00:00 2001 From: Ilya Matveev Date: Thu, 10 Dec 2020 19:52:41 +0700 Subject: [PATCH 180/196] [runtime] Support formatted output in the runtime assertions --- .../runtime/src/main/cpp/KAssert.cpp | 49 ++++++++++--------- kotlin-native/runtime/src/main/cpp/KAssert.h | 14 +++--- .../runtime/src/main/cpp/Porting.cpp | 6 ++- kotlin-native/runtime/src/main/cpp/Porting.h | 2 + .../runtime/src/mm/cpp/ThreadState.cpp | 17 ++----- 5 files changed, 45 insertions(+), 43 deletions(-) diff --git a/kotlin-native/runtime/src/main/cpp/KAssert.cpp b/kotlin-native/runtime/src/main/cpp/KAssert.cpp index ee3ab1fdeaa..224f6cd7336 100644 --- a/kotlin-native/runtime/src/main/cpp/KAssert.cpp +++ b/kotlin-native/runtime/src/main/cpp/KAssert.cpp @@ -1,29 +1,32 @@ /* - * Copyright 2010-2017 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. + * Copyright 2010-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license + * that can be found in the LICENSE file. */ -#include "KAssert.h" +#include #include "Porting.h" -void RuntimeAssertFailed(const char* location, const char* message) { - // TODO: produce stacktrace and such. - char buf[1024]; - if (location != nullptr) - konan::snprintf(buf, sizeof(buf), "%s: runtime assert: %s\n", location, message); - else - konan::snprintf(buf, sizeof(buf), "runtime assert: %s\n", message); - konan::consoleErrorUtf8(buf, konan::strnlen(buf, sizeof(buf))); - konan::abort(); +RUNTIME_NORETURN void RuntimeAssertFailed(const char* location, const char* format, ...) { + char buf[1024]; + int written = -1; + + // Write the title with a source location. + if (location != nullptr) { + written = konan::snprintf(buf, sizeof(buf), "%s: runtime assert: ", location); + } else { + written = konan::snprintf(buf, sizeof(buf), "runtime assert: "); + } + + // Write the message. + if (written >= 0 && static_cast(written) < sizeof(buf)) { + std::va_list args; + va_start(args, format); + konan::vsnprintf(buf + written, sizeof(buf) - written, format, args); + va_end(args); + } + + konan::consoleErrorUtf8(buf, konan::strnlen(buf, sizeof(buf))); + konan::consoleErrorf("\n"); + // TODO: Write the stacktrace. + konan::abort(); } diff --git a/kotlin-native/runtime/src/main/cpp/KAssert.h b/kotlin-native/runtime/src/main/cpp/KAssert.h index aa8edac245b..0f43d854513 100644 --- a/kotlin-native/runtime/src/main/cpp/KAssert.h +++ b/kotlin-native/runtime/src/main/cpp/KAssert.h @@ -25,7 +25,7 @@ #define STRINGIFY(x) #x #define TOSTRING(x) STRINGIFY(x) -RUNTIME_NORETURN void RuntimeAssertFailed(const char* location, const char* message); +RUNTIME_NORETURN void RuntimeAssertFailed(const char* location, const char* message, ...); namespace internal { @@ -46,9 +46,9 @@ extern "C" const int KonanNeedDebugInfo; #if KONAN_ENABLE_ASSERT // Use RuntimeAssert() in internal state checks, which could be ignored in production. -#define RuntimeAssert(condition, message) \ -if (KonanNeedDebugInfo && (!(condition))) { \ - RuntimeAssertFailed( __FILE__ ":" TOSTRING(__LINE__), message); \ +#define RuntimeAssert(condition, format, ...) \ +if (KonanNeedDebugInfo && (!(condition))) { \ + RuntimeAssertFailed( __FILE__ ":" TOSTRING(__LINE__), format, ##__VA_ARGS__); \ } #else #define RuntimeAssert(condition, message) @@ -56,9 +56,9 @@ if (KonanNeedDebugInfo && (!(condition))) { \ // Use RuntimeCheck() in runtime checks that could fail due to external condition and shall lead // to program termination. Never compiled out. -#define RuntimeCheck(condition, message) \ - if (!(condition)) { \ - RuntimeAssertFailed(nullptr, message); \ +#define RuntimeCheck(condition, format, ...) \ + if (!(condition)) { \ + RuntimeAssertFailed(nullptr, format, ##__VA_ARGS__); \ } #define TODO(...) \ diff --git a/kotlin-native/runtime/src/main/cpp/Porting.cpp b/kotlin-native/runtime/src/main/cpp/Porting.cpp index 953c16cecdd..b2be18cc11c 100644 --- a/kotlin-native/runtime/src/main/cpp/Porting.cpp +++ b/kotlin-native/runtime/src/main/cpp/Porting.cpp @@ -273,11 +273,15 @@ void* memmem(const void *big, size_t bigLen, const void *little, size_t littleLe int snprintf(char* buffer, size_t size, const char* format, ...) { va_list args; va_start(args, format); - int rv = vsnprintf_impl(buffer, size, format, args); + int rv = vsnprintf(buffer, size, format, args); va_end(args); return rv; } +int vsnprintf(char* buffer, size_t size, const char* format, va_list args) { + return vsnprintf_impl(buffer, size, format, args); +} + size_t strnlen(const char* buffer, size_t maxSize) { return ::strnlen(buffer, maxSize); } diff --git a/kotlin-native/runtime/src/main/cpp/Porting.h b/kotlin-native/runtime/src/main/cpp/Porting.h index 59693a538c6..1085e1fb789 100644 --- a/kotlin-native/runtime/src/main/cpp/Porting.h +++ b/kotlin-native/runtime/src/main/cpp/Porting.h @@ -17,6 +17,7 @@ #ifndef RUNTIME_PORTING_H #define RUNTIME_PORTING_H +#include #include #include @@ -46,6 +47,7 @@ void onThreadExit(void (*destructor)(void*), void* destructorParameter); // by C compiler. void* memmem(const void *big, size_t bigLen, const void *little, size_t littleLen); int snprintf(char* buffer, size_t size, const char* format, ...); +int vsnprintf(char* buffer, size_t size, const char* format, va_list args); size_t strnlen(const char* buffer, size_t maxSize); diff --git a/kotlin-native/runtime/src/mm/cpp/ThreadState.cpp b/kotlin-native/runtime/src/mm/cpp/ThreadState.cpp index 57b7c2410dc..c22fcf361c0 100644 --- a/kotlin-native/runtime/src/mm/cpp/ThreadState.cpp +++ b/kotlin-native/runtime/src/mm/cpp/ThreadState.cpp @@ -23,16 +23,6 @@ const char* stateToString(mm::ThreadState state) noexcept { } } -std::string unexpectedStateMessage(mm::ThreadState expected, mm::ThreadState actual) noexcept { - return std::string("Unexpected thread state. Expected: ") + stateToString(expected) - + ". Actual: " + stateToString(actual); -} - -std::string illegalStateSwitchMessage(mm::ThreadState oldState, mm::ThreadState newState) noexcept { - return std::string("Illegal thread state switch. Old state: ") + stateToString(oldState) - + ". New state: " + stateToString(newState); -} - } // namespace // Switches the state of the current thread to `newState` and returns the previous state. @@ -40,13 +30,16 @@ ALWAYS_INLINE mm::ThreadState mm::SwitchThreadState(ThreadData* threadData, Thre auto oldState = threadData->setState(newState); // TODO(perf): Mesaure the impact of this assert in debug and opt modes. RuntimeAssert(isStateSwitchAllowed(oldState, newState), - illegalStateSwitchMessage(oldState, newState).c_str()); + "Illegal thread state switch. Old state: %s. New state: %s.", + stateToString(oldState), stateToString(newState)); return oldState; } ALWAYS_INLINE void mm::AssertThreadState(ThreadData* threadData, ThreadState expected) noexcept { auto actual = threadData->state(); - RuntimeAssert(actual == expected, unexpectedStateMessage(expected, actual).c_str()); + RuntimeAssert(actual == expected, + "Unexpected thread state. Expected: %s. Actual: %s.", + stateToString(expected), stateToString(actual)); } mm::ThreadStateGuard::ThreadStateGuard(ThreadData* threadData, ThreadState state) noexcept : threadData_(threadData) { From f22d84c07bf1dbd5f8932be1aeea97f209964d34 Mon Sep 17 00:00:00 2001 From: Pavel Punegov Date: Tue, 15 Dec 2020 11:44:17 +0300 Subject: [PATCH 181/196] Use kotlinCompilerRepo for calculator sample --- kotlin-native/samples/calculator/build.gradle | 6 ++++++ kotlin-native/samples/calculator/gradle.properties | 3 +++ 2 files changed, 9 insertions(+) diff --git a/kotlin-native/samples/calculator/build.gradle b/kotlin-native/samples/calculator/build.gradle index 9b4f0c9f682..2364b5baedb 100644 --- a/kotlin-native/samples/calculator/build.gradle +++ b/kotlin-native/samples/calculator/build.gradle @@ -5,6 +5,9 @@ buildscript { mavenCentral() maven { url 'https://dl.bintray.com/kotlin/kotlin-dev' } maven { url 'https://dl.bintray.com/kotlin/kotlin-eap' } + if (project.hasProperty("kotlinCompilerRepo")) { + maven { setUrl(project.property("kotlinCompilerRepo")) } + } } dependencies { @@ -20,5 +23,8 @@ allprojects { mavenCentral() maven { url 'https://dl.bintray.com/kotlin/kotlin-dev' } maven { url 'https://dl.bintray.com/kotlin/kotlin-eap' } + if (project.hasProperty("kotlinCompilerRepo")) { + maven { setUrl(project.property("kotlinCompilerRepo")) } + } } } diff --git a/kotlin-native/samples/calculator/gradle.properties b/kotlin-native/samples/calculator/gradle.properties index 146d025d3e9..341c76ecd5c 100644 --- a/kotlin-native/samples/calculator/gradle.properties +++ b/kotlin-native/samples/calculator/gradle.properties @@ -8,6 +8,9 @@ org.gradle.workers.max=4 # CHANGE_VERSION_WITH_RELEASE kotlin_version=1.4.10 +# Sets maven path for the kotlin version other than release +#kotlinCompilerRepo= + # Use custom Kotlin/Native home: kotlin.native.home=../../../dist From 56683ef40303170c8ead8ecb95ae64dd46c5b584 Mon Sep 17 00:00:00 2001 From: Sergey Bogolepov Date: Fri, 6 Nov 2020 19:09:03 +0700 Subject: [PATCH 182/196] [IR] Rename .symbolName and similar extension properties Convert these extensions to functions with `compute` prefix to make it obvious that they are not cheap. --- .../src/org/jetbrains/kotlin/backend/konan/Context.kt | 2 +- .../backend/konan/descriptors/ClassLayoutBuilder.kt | 4 ++-- .../kotlin/backend/konan/llvm/BinaryInterface.kt | 11 ++++++----- .../kotlin/backend/konan/llvm/CodeGenerator.kt | 2 +- .../kotlin/backend/konan/llvm/ContextUtils.kt | 5 ++--- .../kotlin/backend/konan/llvm/IrToBitcode.kt | 2 +- .../kotlin/backend/konan/llvm/LlvmDeclarations.kt | 6 +++--- .../kotlin/backend/konan/llvm/RTTIGenerator.kt | 6 ++---- .../konan/llvm/coverage/CoverageInformation.kt | 4 ++-- .../backend/konan/llvm/coverage/LLVMCoverageWriter.kt | 2 -- .../konan/llvm/objcexport/ObjCExportCodeGenerator.kt | 4 ++-- .../backend/konan/lower/FunctionReferenceLowering.kt | 4 ++-- .../kotlin/backend/konan/lower/ReflectionSupport.kt | 4 ++-- .../kotlin/backend/konan/optimizations/DFGBuilder.kt | 4 ++-- .../kotlin/backend/konan/optimizations/DataFlowIR.kt | 11 +++++------ 15 files changed, 33 insertions(+), 38 deletions(-) diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/Context.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/Context.kt index 7c32df1e0f3..ccffa7eeb73 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/Context.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/Context.kt @@ -152,7 +152,7 @@ internal class SpecialDeclarationsFactory(val context: Context) { startOffset, endOffset, DECLARATION_ORIGIN_BRIDGE_METHOD(function), IrSimpleFunctionSymbolImpl(descriptor), - "${function.functionName}".synthesizedName, + "${function.computeFunctionName()}".synthesizedName, function.visibility, function.modality, isInline = false, diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/descriptors/ClassLayoutBuilder.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/descriptors/ClassLayoutBuilder.kt index 75e9ace5c2f..4dae07c4451 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/descriptors/ClassLayoutBuilder.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/descriptors/ClassLayoutBuilder.kt @@ -9,7 +9,7 @@ import llvm.LLVMStoreSizeOfType import org.jetbrains.kotlin.backend.common.ir.simpleFunctions import org.jetbrains.kotlin.backend.konan.* import org.jetbrains.kotlin.backend.konan.ir.* -import org.jetbrains.kotlin.backend.konan.llvm.functionName +import org.jetbrains.kotlin.backend.konan.llvm.computeFunctionName import org.jetbrains.kotlin.backend.konan.llvm.llvmType import org.jetbrains.kotlin.backend.konan.llvm.localHash import org.jetbrains.kotlin.backend.konan.lower.InnerClassLowering @@ -462,5 +462,5 @@ internal class ClassLayoutBuilder(val irClass: IrClass, val context: Context, va private val functionIds = mutableMapOf() - private val IrFunction.uniqueId get() = functionIds.getOrPut(this) { functionName.localHash.value } + private val IrFunction.uniqueId get() = functionIds.getOrPut(this) { computeFunctionName().localHash.value } } diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/BinaryInterface.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/BinaryInterface.kt index 3cc6ea68d6f..b68ffe1be4e 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/BinaryInterface.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/BinaryInterface.kt @@ -112,14 +112,15 @@ internal val IrClass.kotlinObjCClassInfoSymbolName: String return "kobjcclassinfo:$fqNameForIrSerialization" } -val IrFunction.functionName get() = with(KonanBinaryInterface) { functionName } -val IrFunction.fullName get() = parent.fqNameForIrSerialization.child(Name.identifier(functionName)).asString() +fun IrFunction.computeFunctionName() = with(KonanBinaryInterface) { functionName } -val IrFunction.symbolName get() = with(KonanBinaryInterface) { symbolName } +fun IrFunction.computeFullName() = parent.fqNameForIrSerialization.child(Name.identifier(computeFunctionName())).asString() -val IrField.symbolName get() = with(KonanBinaryInterface) { symbolName } +fun IrFunction.computeSymbolName() = with(KonanBinaryInterface) { symbolName } -val IrClass.typeInfoSymbolName get() = with(KonanBinaryInterface) { typeInfoSymbolName } +fun IrField.computeSymbolName() = with(KonanBinaryInterface) { symbolName } + +fun IrClass.computeTypeInfoSymbolName() = with(KonanBinaryInterface) { typeInfoSymbolName } fun IrDeclaration.isExported() = KonanBinaryInterface.isExported(this) diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/CodeGenerator.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/CodeGenerator.kt index 54fba7661ec..932fbbe8866 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/CodeGenerator.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/CodeGenerator.kt @@ -63,7 +63,7 @@ internal class CodeGenerator(override val context: Context) : ContextUtils { private fun countParams(fn: IrFunction) = LLVMCountParams(fn.llvmFunction) fun functionEntryPointAddress(function: IrFunction) = function.entryPointAddress.llvm - fun functionHash(function: IrFunction): LLVMValueRef = function.functionName.localHash.llvm + fun functionHash(function: IrFunction): LLVMValueRef = function.computeFunctionName().localHash.llvm fun typeInfoForAllocation(constructedClass: IrClass): LLVMValueRef { assert(!constructedClass.isObjCClass()) diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/ContextUtils.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/ContextUtils.kt index 05ecc700e61..42fe7820d25 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/ContextUtils.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/ContextUtils.kt @@ -26,7 +26,6 @@ import org.jetbrains.kotlin.ir.util.isReal import org.jetbrains.kotlin.konan.library.KonanLibrary import org.jetbrains.kotlin.konan.target.KonanTarget import org.jetbrains.kotlin.library.KotlinLibrary -import org.jetbrains.kotlin.library.resolver.TopologicalLibraryOrder import org.jetbrains.kotlin.library.uniqueName import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name @@ -181,7 +180,7 @@ internal interface ContextUtils : RuntimeAware { get() { assert(this.isReal) return if (isExternal(this)) { - runtime.addedLLVMExternalFunctions.getOrPut(this) { context.llvm.externalFunction(this.symbolName, getLlvmFunctionType(this), + runtime.addedLLVMExternalFunctions.getOrPut(this) { context.llvm.externalFunction(this.computeSymbolName(), getLlvmFunctionType(this), origin = this.llvmSymbolOrigin) } } else { @@ -201,7 +200,7 @@ internal interface ContextUtils : RuntimeAware { val IrClass.typeInfoPtr: ConstPointer get() { return if (isExternal(this)) { - constPointer(importGlobal(this.typeInfoSymbolName, runtime.typeInfoType, + constPointer(importGlobal(this.computeTypeInfoSymbolName(), runtime.typeInfoType, origin = this.llvmSymbolOrigin)) } else { context.llvmDeclarations.forClass(this).typeInfo diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IrToBitcode.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IrToBitcode.kt index 6897fe8715f..d4cd2c4626c 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IrToBitcode.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IrToBitcode.kt @@ -1934,7 +1934,7 @@ internal class CodeGeneratorVisitor(val context: Context, val lifetimes: Map { val functionNames = mutableMapOf() return context.getLayoutBuilder(irClass).methodTableEntries.map { - val functionName = it.overriddenFunction.functionName + val functionName = it.overriddenFunction.computeFunctionName() val nameSignature = functionName.localHash val previous = functionNames.putIfAbsent(nameSignature.value, it) if (previous != null) @@ -542,7 +540,7 @@ internal class RTTIGenerator(override val context: Context) : ContextUtils { val methods = (methodTableRecords(superClass) + methodImpls.map { (method, impl) -> assert(method.parent == irClass) - MethodTableRecord(method.functionName.localHash, impl.bitcast(int8TypePtr)) + MethodTableRecord(method.computeFunctionName().localHash, impl.bitcast(int8TypePtr)) }).sortedBy { it.nameSignature.value }.also { assert(it.distinctBy { it.nameSignature.value } == it) } diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/coverage/CoverageInformation.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/coverage/CoverageInformation.kt index c318cdebaaa..07ecae2fbe9 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/coverage/CoverageInformation.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/coverage/CoverageInformation.kt @@ -7,7 +7,7 @@ package org.jetbrains.kotlin.backend.konan.llvm.coverage import org.jetbrains.kotlin.backend.common.ir.ir2string import org.jetbrains.kotlin.backend.konan.llvm.column import org.jetbrains.kotlin.backend.konan.llvm.line -import org.jetbrains.kotlin.backend.konan.llvm.symbolName +import org.jetbrains.kotlin.backend.konan.llvm.computeSymbolName import org.jetbrains.kotlin.ir.IrElement import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET import org.jetbrains.kotlin.ir.declarations.IrFile @@ -87,7 +87,7 @@ class FunctionRegions( val structuralHash: Long = 0 override fun toString(): String = buildString { - appendLine("${function.symbolName} regions:") + appendLine("${function.computeSymbolName()} regions:") regions.forEach { (irElem, region) -> appendLine("${ir2string(irElem)} -> ($region)") } } } diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/coverage/LLVMCoverageWriter.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/coverage/LLVMCoverageWriter.kt index 4e28b9f5fea..886754ed2b8 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/coverage/LLVMCoverageWriter.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/coverage/LLVMCoverageWriter.kt @@ -8,9 +8,7 @@ import kotlinx.cinterop.* import llvm.* import org.jetbrains.kotlin.backend.konan.Context import org.jetbrains.kotlin.backend.konan.llvm.name -import org.jetbrains.kotlin.backend.konan.llvm.symbolName import org.jetbrains.kotlin.ir.declarations.IrFile -import org.jetbrains.kotlin.ir.declarations.name import org.jetbrains.kotlin.ir.declarations.path import org.jetbrains.kotlin.konan.file.File diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/objcexport/ObjCExportCodeGenerator.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/objcexport/ObjCExportCodeGenerator.kt index b1a25250c97..322f1926e60 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/objcexport/ObjCExportCodeGenerator.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/objcexport/ObjCExportCodeGenerator.kt @@ -1342,13 +1342,13 @@ private fun ObjCExportCodeGenerator.createReverseAdapters( inherited.forEach { presentVtableBridges += vtableIndex(it) - presentMethodTableBridges += it.functionName + presentMethodTableBridges += it.computeFunctionName() presentItableBridges += itablePlace(it) } uninherited.forEach { val vtableIndex = vtableIndex(it) - val functionName = it.functionName + val functionName = it.computeFunctionName() val itablePlace = itablePlace(it) if (vtableIndex !in presentVtableBridges || functionName !in presentMethodTableBridges diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/FunctionReferenceLowering.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/FunctionReferenceLowering.kt index 51ec2a03f98..f6d39c27c8a 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/FunctionReferenceLowering.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/FunctionReferenceLowering.kt @@ -13,7 +13,7 @@ import org.jetbrains.kotlin.backend.common.pop import org.jetbrains.kotlin.backend.common.push import org.jetbrains.kotlin.backend.konan.Context import org.jetbrains.kotlin.backend.konan.descriptors.synthesizedName -import org.jetbrains.kotlin.backend.konan.llvm.fullName +import org.jetbrains.kotlin.backend.konan.llvm.computeFullName import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor @@ -374,7 +374,7 @@ internal class FunctionReferenceLowering(val context: Context): FileLoweringPass val receiver = if (needReceiver) irGet(valueParameters.single()) else irNull() val arity = unboundFunctionParameters.size + if (functionReferenceTarget.isSuspend) 1 else 0 putValueArgument(0, irString(name.asString())) - putValueArgument(1, irString(functionReferenceTarget.fullName)) + putValueArgument(1, irString(functionReferenceTarget.computeFullName())) putValueArgument(2, receiver) putValueArgument(3, irInt(arity)) putValueArgument(4, irInt(getFlags())) diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/ReflectionSupport.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/ReflectionSupport.kt index 088766b8151..8364b0eb0e7 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/ReflectionSupport.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/ReflectionSupport.kt @@ -10,7 +10,7 @@ import org.jetbrains.kotlin.backend.konan.KonanBackendContext import org.jetbrains.kotlin.backend.konan.ir.typeWithStarProjections import org.jetbrains.kotlin.backend.konan.ir.typeWithoutArguments import org.jetbrains.kotlin.backend.konan.isObjCClass -import org.jetbrains.kotlin.backend.konan.llvm.fullName +import org.jetbrains.kotlin.backend.konan.llvm.computeFullName import org.jetbrains.kotlin.backend.konan.reportCompilationError import org.jetbrains.kotlin.descriptors.ClassDescriptor import org.jetbrains.kotlin.ir.IrElement @@ -122,7 +122,7 @@ internal class KTypeGenerator( } private val IrTypeParameter.parentUniqueName get() = when (val parent = parent) { - is IrFunction -> parent.fullName + is IrFunction -> parent.computeFullName() else -> parent.fqNameForIrSerialization.asString() } diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/optimizations/DFGBuilder.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/optimizations/DFGBuilder.kt index b906b3ec31a..abe1a7f1f58 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/optimizations/DFGBuilder.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/optimizations/DFGBuilder.kt @@ -15,7 +15,7 @@ import org.jetbrains.kotlin.backend.common.push import org.jetbrains.kotlin.backend.konan.* import org.jetbrains.kotlin.backend.konan.descriptors.allOverriddenFunctions import org.jetbrains.kotlin.backend.konan.ir.* -import org.jetbrains.kotlin.backend.konan.llvm.functionName +import org.jetbrains.kotlin.backend.konan.llvm.computeFunctionName import org.jetbrains.kotlin.backend.konan.llvm.localHash import org.jetbrains.kotlin.ir.IrElement import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET @@ -786,7 +786,7 @@ internal class ModuleDFGBuilder(val context: Context, val irModule: IrModuleFrag } } if (owner.isInterface) { - val calleeHash = callee.functionName.localHash.value + val calleeHash = callee.computeFunctionName().localHash.value DataFlowIR.Node.ItableCall( symbolTable.mapFunction(callee.target), receiverType, diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/optimizations/DataFlowIR.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/optimizations/DataFlowIR.kt index 30644c322b5..ac6f9c5b9cb 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/optimizations/DataFlowIR.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/optimizations/DataFlowIR.kt @@ -10,13 +10,12 @@ import org.jetbrains.kotlin.backend.konan.descriptors.isAbstract import org.jetbrains.kotlin.backend.konan.descriptors.isBuiltInOperator import org.jetbrains.kotlin.backend.common.ir.allParameters import org.jetbrains.kotlin.backend.konan.ir.isOverridableOrOverrides -import org.jetbrains.kotlin.backend.konan.llvm.functionName +import org.jetbrains.kotlin.backend.konan.llvm.computeFunctionName +import org.jetbrains.kotlin.backend.konan.llvm.computeSymbolName import org.jetbrains.kotlin.backend.konan.llvm.isExported import org.jetbrains.kotlin.backend.konan.llvm.localHash -import org.jetbrains.kotlin.backend.konan.llvm.symbolName import org.jetbrains.kotlin.backend.konan.lower.DECLARATION_ORIGIN_BRIDGE_METHOD import org.jetbrains.kotlin.backend.konan.lower.bridgeTarget -import org.jetbrains.kotlin.backend.konan.optimizations.DataFlowIR.Function.Companion.appendCastTo import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.descriptors.ModuleDescriptor import org.jetbrains.kotlin.ir.IrElement @@ -507,7 +506,7 @@ internal object DataFlowIR { mapFunction(it.getImplementation(context)!!) } layoutBuilder.methodTableEntries.forEach { - type.itable[it.overriddenFunction.functionName.localHash.value] = mapFunction(it.getImplementation(context)!!) + type.itable[it.overriddenFunction.computeFunctionName().localHash.value] = mapFunction(it.getImplementation(context)!!) } } else if (irClass.isInterface) { // Warmup interface table so it is computed before DCE. @@ -565,7 +564,7 @@ internal object DataFlowIR { val containingDeclarationPart = parent.fqNameForIrSerialization.let { if (it.isRoot) "" else "$it." } - val name = "kfun:$containingDeclarationPart${it.functionName}" + val name = "kfun:$containingDeclarationPart${it.computeFunctionName()}" val returnsUnit = it is IrConstructor || (!it.isSuspend && it.returnType.isUnit()) val returnsNothing = !it.isSuspend && it.returnType.isNothing() @@ -639,7 +638,7 @@ internal object DataFlowIR { assert(irField.parent !is IrClass) { "All local properties initializers should've been lowered" } val attributes = FunctionAttributes.IS_GLOBAL_INITIALIZER or FunctionAttributes.RETURNS_UNIT - val symbol = FunctionSymbol.Private(privateFunIndex++, module, -1, attributes, null, null, takeName { "${irField.symbolName}_init" }) + val symbol = FunctionSymbol.Private(privateFunIndex++, module, -1, attributes, null, null, takeName { "${irField.computeSymbolName()}_init" }) functionMap[irField] = symbol From 54f70a68a2be117d428bf5e136fafedd06dfd794 Mon Sep 17 00:00:00 2001 From: Sergey Bogolepov Date: Wed, 16 Dec 2020 14:32:13 +0700 Subject: [PATCH 183/196] Replace '@' with '_' in binary symbol names. '@' symbol is used for symbol versioning in GCC which leads to compilation errors in case of compiler caches usage. --- .../kotlin/backend/konan/llvm/BinaryInterface.kt | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/BinaryInterface.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/BinaryInterface.kt index b68ffe1be4e..af85951e56e 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/BinaryInterface.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/BinaryInterface.kt @@ -116,11 +116,15 @@ fun IrFunction.computeFunctionName() = with(KonanBinaryInterface) { functionName fun IrFunction.computeFullName() = parent.fqNameForIrSerialization.child(Name.identifier(computeFunctionName())).asString() -fun IrFunction.computeSymbolName() = with(KonanBinaryInterface) { symbolName } +fun IrFunction.computeSymbolName() = with(KonanBinaryInterface) { symbolName }.replaceSpecialSymbols() -fun IrField.computeSymbolName() = with(KonanBinaryInterface) { symbolName } +fun IrField.computeSymbolName() = with(KonanBinaryInterface) { symbolName }.replaceSpecialSymbols() -fun IrClass.computeTypeInfoSymbolName() = with(KonanBinaryInterface) { typeInfoSymbolName } +fun IrClass.computeTypeInfoSymbolName() = with(KonanBinaryInterface) { typeInfoSymbolName }.replaceSpecialSymbols() + +private fun String.replaceSpecialSymbols() = + // '@' is used for symbol versioning in GCC: https://gcc.gnu.org/wiki/SymbolVersioning. + this.replace("@", "__at__") fun IrDeclaration.isExported() = KonanBinaryInterface.isExported(this) From 3068c230f997e5d6a9bf11944595914bdb709eae Mon Sep 17 00:00:00 2001 From: Sergey Bogolepov Date: Fri, 11 Dec 2020 15:41:14 +0700 Subject: [PATCH 184/196] Enable caches for linux_x64 --- kotlin-native/konan/konan.properties | 12 +++++++----- kotlin-native/runtime/src/main/cpp/StdCppStubs.cpp | 2 +- 2 files changed, 8 insertions(+), 6 deletions(-) diff --git a/kotlin-native/konan/konan.properties b/kotlin-native/konan/konan.properties index c1fb19308be..7ec7e13854c 100644 --- a/kotlin-native/konan/konan.properties +++ b/kotlin-native/konan/konan.properties @@ -68,7 +68,8 @@ cacheableTargets.macos_x64 = \ ios_x64 \ ios_arm64 -cacheableTargets.linux_x64 = +cacheableTargets.linux_x64 = \ + linux_x64 cacheableTargets.mingw_x64 = @@ -400,14 +401,15 @@ targetSysRoot.linux_x64 = $gccToolchain.linux_x64/x86_64-unknown-linux-gnu/sysro # targetSysroot-relative. libGcc.linux_x64 = ../../lib/gcc/x86_64-unknown-linux-gnu/8.3.0 targetCpu.linux_x64 = x86-64 -clangFlags.linux_x64 = -cc1 -target-cpu $targetCpu.linux_x64 -emit-obj -disable-llvm-optzns -x ir +clangFlags.linux_x64 = -cc1 -target-cpu $targetCpu.linux_x64 -emit-obj -disable-llvm-optzns -x ir \ + -ffunction-sections -fdata-sections clangNooptFlags.linux_x64 = -O1 -clangOptFlags.linux_x64 = -O3 -ffunction-sections +clangOptFlags.linux_x64 = -O3 clangDebugFlags.linux_x64 = -O0 clangDynamicFlags.linux_x64 = -mrelocation-model pic linkerKonanFlags.linux_x64 = -Bstatic -lstdc++ -Bdynamic -ldl -lm -lpthread \ - --defsym __cxa_demangle=Konan_cxa_demangle -linkerOptimizationFlags.linux_x64 = --gc-sections + --defsym __cxa_demangle=Konan_cxa_demangle --gc-sections +linkerOptimizationFlags.linux_x64 = linkerNoDebugFlags.linux_x64 = -S linkerDynamicFlags.linux_x64 = -shared dynamicLinker.linux_x64 = /lib64/ld-linux-x86-64.so.2 diff --git a/kotlin-native/runtime/src/main/cpp/StdCppStubs.cpp b/kotlin-native/runtime/src/main/cpp/StdCppStubs.cpp index 09fd4e6a64c..1269305dcd8 100644 --- a/kotlin-native/runtime/src/main/cpp/StdCppStubs.cpp +++ b/kotlin-native/runtime/src/main/cpp/StdCppStubs.cpp @@ -31,7 +31,7 @@ RUNTIME_USED RUNTIME_WEAK extern "C" char* Konan_cxa_demangle( } namespace std { -void __throw_length_error(const char* __s __attribute__((unused))) { +RUNTIME_WEAK void __throw_length_error(const char* __s __attribute__((unused))) { RuntimeAssert(false, __s); } From e8e705bf68f6c24914f338ee1de03dcff062acde Mon Sep 17 00:00:00 2001 From: Sergey Bogolepov Date: Fri, 11 Dec 2020 17:20:57 +0700 Subject: [PATCH 185/196] Introduce property for relocation mode --- .../kotlin/backend/konan/BitcodeCompiler.kt | 10 +++++--- .../backend/konan/OptimizationPipeline.kt | 21 ++++++++++++---- kotlin-native/konan/konan.properties | 25 ++++++++----------- .../kotlin/konan/target/Configurables.kt | 24 +++++++++++++++--- 4 files changed, 54 insertions(+), 26 deletions(-) diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/BitcodeCompiler.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/BitcodeCompiler.kt index eb6a75dfe22..d8701e68719 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/BitcodeCompiler.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/BitcodeCompiler.kt @@ -74,9 +74,7 @@ internal class BitcodeCompiler(val context: Context) { else -> configurables.clangNooptFlags }) addNonEmpty(BitcodeEmbedding.getClangOptions(context.config)) - if (determineLinkerOutput(context) == LinkerOutputKind.DYNAMIC_LIBRARY) { - addNonEmpty(configurables.clangDynamicFlags) - } + addNonEmpty(configurables.currentRelocationMode(context).translateToClangCc1Flag()) addNonEmpty(profilingFlags) } if (configurables is AppleConfigurables) { @@ -87,6 +85,12 @@ internal class BitcodeCompiler(val context: Context) { return objectFile } + private fun RelocationModeFlags.Mode.translateToClangCc1Flag() = when (this) { + RelocationModeFlags.Mode.PIC -> listOf("-mrelocation-model", "pic") + RelocationModeFlags.Mode.STATIC -> listOf("-mrelocation-model", "static") + RelocationModeFlags.Mode.DEFAULT -> emptyList() + } + private fun llvmProfilingFlags(): List { val flags = mutableListOf() if (context.shouldProfilePhases()) { diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/OptimizationPipeline.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/OptimizationPipeline.kt index 9e236b03c97..58fa1349f13 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/OptimizationPipeline.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/OptimizationPipeline.kt @@ -6,9 +6,7 @@ import kotlinx.cinterop.ptr import kotlinx.cinterop.value import llvm.* import org.jetbrains.kotlin.backend.konan.llvm.makeVisibilityHiddenLikeLlvmInternalizePass -import org.jetbrains.kotlin.konan.target.CompilerOutputKind -import org.jetbrains.kotlin.konan.target.Configurables -import org.jetbrains.kotlin.konan.target.KonanTarget +import org.jetbrains.kotlin.konan.target.* private fun initializeLlvmGlobalPassRegistry() { val passRegistry = LLVMGetGlobalPassRegistry() @@ -90,7 +88,13 @@ private class LlvmPipelineConfiguration(context: Context) { else -> LLVMCodeGenOptLevel.LLVMCodeGenLevelDefault } - val relocMode: LLVMRelocMode = LLVMRelocMode.LLVMRelocDefault + val relocMode: LLVMRelocMode = configurables.currentRelocationMode(context).translateToLlvmRelocMode() + + private fun RelocationModeFlags.Mode.translateToLlvmRelocMode() = when (this) { + RelocationModeFlags.Mode.PIC -> LLVMRelocMode.LLVMRelocPIC + RelocationModeFlags.Mode.STATIC -> LLVMRelocMode.LLVMRelocStatic + RelocationModeFlags.Mode.DEFAULT -> LLVMRelocMode.LLVMRelocDefault + } val codeModel: LLVMCodeModel = LLVMCodeModel.LLVMCodeModelDefault @@ -175,4 +179,11 @@ internal fun runLlvmOptimizationPipeline(context: Context) { if (shouldRunLateBitcodePasses(context)) { runLateBitcodePasses(context, llvmModule) } -} \ No newline at end of file +} + +internal fun RelocationModeFlags.currentRelocationMode(context: Context): RelocationModeFlags.Mode = + when (determineLinkerOutput(context)) { + LinkerOutputKind.DYNAMIC_LIBRARY -> dynamicLibraryRelocationMode + LinkerOutputKind.STATIC_LIBRARY -> staticLibraryRelocationMode + LinkerOutputKind.EXECUTABLE -> executableRelocationMode + } \ No newline at end of file diff --git a/kotlin-native/konan/konan.properties b/kotlin-native/konan/konan.properties index 7ec7e13854c..8301cd27cea 100644 --- a/kotlin-native/konan/konan.properties +++ b/kotlin-native/konan/konan.properties @@ -87,7 +87,6 @@ clangFlags.macos_x64 = -cc1 -emit-obj -disable-llvm-passes -x ir clangNooptFlags.macos_x64 = -O1 clangOptFlags.macos_x64 = -O3 clangDebugFlags.macos_x64 = -O0 -clangDynamicFlags.macos_x64 = linkerKonanFlags.macos_x64 = -lSystem -lc++ -lobjc -framework Foundation -sdk_version 10.15.6 linkerOptimizationFlags.macos_x64 = -dead_strip @@ -129,7 +128,6 @@ clangFlags.ios_arm32 = -cc1 -emit-obj -disable-llvm-optzns -x ir clangNooptFlags.ios_arm32 = -O1 clangOptFlags.ios_arm32 = -O3 clangDebugFlags.ios_arm32 = -O0 -clangDynamicFlags.ios_arm32 = linkerNoDebugFlags.ios_arm32 = -S linkerDynamicFlags.ios_arm32 = -dylib linkerKonanFlags.ios_arm32 = -lSystem -lc++ -lobjc -framework Foundation -sdk_version 14.0 @@ -164,7 +162,6 @@ clangOptFlags.ios_arm64 = -O3 # Related: # https://github.com/JetBrains/kotlin-native/issues/3290 clangDebugFlags.ios_arm64 = -O0 -mllvm -fast-isel=false -mllvm -global-isel=false -clangDynamicFlags.ios_arm64 = linkerNoDebugFlags.ios_arm64 = -S linkerDynamicFlags.ios_arm64 = -dylib @@ -192,7 +189,6 @@ clangFlags.ios_x64 = -cc1 -emit-obj -disable-llvm-passes -x ir clangNooptFlags.ios_x64 = -O1 clangOptFlags.ios_x64 = -O3 clangDebugFlags.ios_x64 = -O0 -clangDynamicFlags.ios_x64 = linkerKonanFlags.ios_x64 = -lSystem -lc++ -lobjc -framework Foundation -sdk_version 14.0 linkerOptimizationFlags.ios_x64 = -dead_strip @@ -219,7 +215,6 @@ clangFlags.tvos_x64 = -cc1 -emit-obj -disable-llvm-passes -x ir clangNooptFlags.tvos_x64 = -O1 clangOptFlags.tvos_x64 = -O3 clangDebugFlags.tvos_x64 = -O0 -clangDynamicFlags.tvos_x64 = linkerKonanFlags.tvos_x64 = -lSystem -lc++ -lobjc -framework Foundation -sdk_version 14.0 linkerOptimizationFlags.tvos_x64 = -dead_strip @@ -246,7 +241,6 @@ clangFlags.tvos_arm64 = -cc1 -emit-obj -disable-llvm-passes -x ir clangNooptFlags.tvos_arm64 = -O1 clangOptFlags.tvos_arm64 = -O3 clangDebugFlags.tvos_arm64 = -O0 -mllvm -fast-isel=false -mllvm -global-isel=false -clangDynamicFlags.tvos_arm64 = linkerNoDebugFlags.tvos_arm64 = -S linkerDynamicFlags.tvos_arm64 = -dylib @@ -273,7 +267,6 @@ clangFlags.watchos_arm32 = -cc1 -emit-obj -disable-llvm-passes -x ir clangNooptFlags.watchos_arm32 = -O1 clangOptFlags.watchos_arm32 = -O3 clangDebugFlags.watchos_arm32 = -O0 -clangDynamicFlags.watchos_arm32 = linkerKonanFlags.watchos_arm32 = -lSystem -lc++ -lobjc -framework Foundation -sdk_version 7.0 linkerOptimizationFlags.watchos_arm32 = -dead_strip @@ -303,7 +296,6 @@ clangFlags.watchos_arm64 = -cc1 -emit-obj -disable-llvm-passes -x ir -mllvm -aar clangNooptFlags.watchos_arm64 = -O1 clangOptFlags.watchos_arm64 = -O3 clangDebugFlags.watchos_arm64 = -O0 -clangDynamicFlags.watchos_arm64 = linkerKonanFlags.watchos_arm64 = -lSystem -lc++ -lobjc -framework Foundation -sdk_version 7.0 linkerOptimizationFlags.watchos_arm64 = -dead_strip @@ -336,7 +328,6 @@ clangFlags.watchos_x86 = -cc1 -emit-obj -disable-llvm-passes -x ir -target-cpu $ clangNooptFlags.watchos_x86 = -O1 clangOptFlags.watchos_x86 = -O3 clangDebugFlags.watchos_x86 = -O0 -clangDynamicFlags.watchos_x86 = linkerKonanFlags.watchos_x86 = -lSystem -lc++ -lobjc -framework Foundation -sdk_version 7.0 linkerOptimizationFlags.watchos_x86 = -dead_strip @@ -363,7 +354,6 @@ clangFlags.watchos_x64 = -cc1 -emit-obj -disable-llvm-passes -x ir -target-cpu $ clangNooptFlags.watchos_x64 = -O1 clangOptFlags.watchos_x64 = -O3 clangDebugFlags.watchos_x64 = -O0 -clangDynamicFlags.watchos_x64 = linkerKonanFlags.watchos_x64 = -lSystem -lc++ -lobjc -framework Foundation -sdk_version 7.0 linkerOptimizationFlags.watchos_x64 = -dead_strip @@ -406,7 +396,8 @@ clangFlags.linux_x64 = -cc1 -target-cpu $targetCpu.linux_x64 -emit-obj -disable- clangNooptFlags.linux_x64 = -O1 clangOptFlags.linux_x64 = -O3 clangDebugFlags.linux_x64 = -O0 -clangDynamicFlags.linux_x64 = -mrelocation-model pic +dynamicLibraryRelocationMode.linux_x64 = pic +staticLibraryRelocationMode.linux_x64 = pic linkerKonanFlags.linux_x64 = -Bstatic -lstdc++ -Bdynamic -ldl -lm -lpthread \ --defsym __cxa_demangle=Konan_cxa_demangle --gc-sections linkerOptimizationFlags.linux_x64 = @@ -457,7 +448,8 @@ clangFlags.linux_arm32_hfp = -cc1 -target-cpu $targetCpu.linux_arm32_hfp -mfloat clangNooptFlags.linux_arm32_hfp = -O1 clangOptFlags.linux_arm32_hfp = -O3 -ffunction-sections clangDebugFlags.linux_arm32_hfp = -O0 -clangDynamicFlags.linux_arm32_hfp = -mrelocation-model pic +dynamicLibraryRelocationMode.linux_arm32_hfp = pic +staticLibraryRelocationMode.linux_arm32_hfp = pic dynamicLinker.linux_arm32_hfp = /lib/ld-linux-armhf.so.3 # targetSysRoot relative abiSpecificLibraries.linux_arm32_hfp = lib usr/lib @@ -501,7 +493,8 @@ clangFlags.linux_arm64 = -cc1 -target-cpu cortex-a57 -emit-obj -disable-llvm-opt clangNooptFlags.linux_arm64 = -O1 clangOptFlags.linux_arm64 = -O3 -ffunction-sections clangDebugFlags.linux_arm64 = -O0 -clangDynamicFlags.linux_arm64 = -mrelocation-model pic +dynamicLibraryRelocationMode.linux_arm64 = pic +staticLibraryRelocationMode.linux_arm64 = pic dynamicLinker.linux_arm64 = /lib/ld-linux-aarch64.so.1 # targetSysRoot relative abiSpecificLibraries.linux_arm64 = lib usr/lib @@ -535,7 +528,8 @@ clangFlags.linux_mips32 = -cc1 -emit-obj -disable-llvm-optzns -x ir -target-cpu clangNooptFlags.linux_mips32 = -O1 clangOptFlags.linux_mips32 = -O3 -ffunction-sections clangDebugFlags.linux_mips32 = -O0 -clangDynamicFlags.linux_mips32 = -mrelocation-model pic +dynamicLibraryRelocationMode.linux_mips32 = pic +staticLibraryRelocationMode.linux_mips32 = pic dynamicLinker.linux_mips32 = /lib/ld.so.1 # targetSysRoot relative abiSpecificLibraries.linux_mips32 = lib usr/lib @@ -570,7 +564,8 @@ clangFlags.linux_mipsel32 = -cc1 -emit-obj -disable-llvm-optzns -x ir -target-cp clangNooptFlags.linux_mipsel32 = -O1 clangOptFlags.linux_mipsel32 = -O3 -ffunction-sections clangDebugFlags.linux_mipsel32 = -O0 -clangDynamicFlags.linux_mipsel32 = -mrelocation-model pic +dynamicLibraryRelocationMode.linux_mipsel32 = pic +staticLibraryRelocationMode.linux_mipsel32 = pic dynamicLinker.linux_mipsel32 = /lib/ld.so.1 # targetSysRoot relative abiSpecificLibraries.linux_mipsel32 = lib usr/lib diff --git a/kotlin-native/shared/src/main/kotlin/org/jetbrains/kotlin/konan/target/Configurables.kt b/kotlin-native/shared/src/main/kotlin/org/jetbrains/kotlin/konan/target/Configurables.kt index b20952cf2db..eef571d2670 100644 --- a/kotlin-native/shared/src/main/kotlin/org/jetbrains/kotlin/konan/target/Configurables.kt +++ b/kotlin-native/shared/src/main/kotlin/org/jetbrains/kotlin/konan/target/Configurables.kt @@ -18,19 +18,37 @@ package org.jetbrains.kotlin.konan.target import org.jetbrains.kotlin.konan.properties.* -interface ClangFlags : TargetableExternalStorage { +interface RelocationModeFlags : TargetableExternalStorage { + val dynamicLibraryRelocationMode get() = targetString("dynamicLibraryRelocationMode").mode() + val staticLibraryRelocationMode get() = targetString("staticLibraryRelocationMode").mode() + val executableRelocationMode get() = targetString("executableRelocationMode").mode() + + private fun String?.mode(): Mode = when (this?.toLowerCase()) { + null -> Mode.DEFAULT + "pic" -> Mode.PIC + "static" -> Mode.STATIC + else -> error("Unknown relocation mode: $this") + } + + enum class Mode { + PIC, + STATIC, + DEFAULT + } +} + +interface ClangFlags : TargetableExternalStorage, RelocationModeFlags { val clangFlags get() = targetList("clangFlags") val clangNooptFlags get() = targetList("clangNooptFlags") val clangOptFlags get() = targetList("clangOptFlags") val clangDebugFlags get() = targetList("clangDebugFlags") - val clangDynamicFlags get() = targetList("clangDynamicFlags") } interface LldFlags : TargetableExternalStorage { val lldFlags get() = targetList("lld") } -interface Configurables : TargetableExternalStorage { +interface Configurables : TargetableExternalStorage, RelocationModeFlags { val target: KonanTarget From 0f733b6baf2c507d89e70bdde95fa20bb3bc22a4 Mon Sep 17 00:00:00 2001 From: Sergey Bogolepov Date: Mon, 14 Dec 2020 12:29:16 +0700 Subject: [PATCH 186/196] Move linker selection to konan.properties --- kotlin-native/konan/konan.properties | 28 +++++++++++++++++++ .../kotlin/konan/target/Configurables.kt | 5 ++++ .../jetbrains/kotlin/konan/target/Linker.kt | 10 ++----- 3 files changed, 35 insertions(+), 8 deletions(-) diff --git a/kotlin-native/konan/konan.properties b/kotlin-native/konan/konan.properties index 8301cd27cea..0764ea29882 100644 --- a/kotlin-native/konan/konan.properties +++ b/kotlin-native/konan/konan.properties @@ -403,6 +403,14 @@ linkerKonanFlags.linux_x64 = -Bstatic -lstdc++ -Bdynamic -ldl -lm -lpthread \ linkerOptimizationFlags.linux_x64 = linkerNoDebugFlags.linux_x64 = -S linkerDynamicFlags.linux_x64 = -shared + +linker.linux_x64 = $targetToolchain.linux_x64/bin/ld.gold +linkerHostSpecificFlags.linux_x64-linux_x64 = +linker.mingw_x64-linux_x64 = $targetToolchain.mingw_x64-linux_x64/bin/ld.gold +linkerHostSpecificFlags.mingw_x64-linux_x64 = +linker.macos_x64-linux_x64 = $targetToolchain.macos_x64-linux_x64/bin/ld.lld +linkerHostSpecificFlags.macos_x64-linux_x64 = --no-threads + dynamicLinker.linux_x64 = /lib64/ld-linux-x86-64.so.2 # targetSysRoot relative abiSpecificLibraries.linux_x64 = lib usr/lib ../lib64 lib64 usr/lib64 @@ -450,6 +458,13 @@ clangOptFlags.linux_arm32_hfp = -O3 -ffunction-sections clangDebugFlags.linux_arm32_hfp = -O0 dynamicLibraryRelocationMode.linux_arm32_hfp = pic staticLibraryRelocationMode.linux_arm32_hfp = pic + +linker.linux_x64-linux_arm32_hfp = $targetToolchain.linux_x64-linux_arm32_hfp/bin/ld +linkerHostSpecificFlags.linux_x64-linux_arm32_hfp = +linker.mingw_x64-linux_arm32_hfp = $targetToolchain.mingw_x64-linux_arm32_hfp/bin/ld +linkerHostSpecificFlags.mingw_x64-linux_arm32_hfp = +linker.macos_x64-linux_arm32_hfp = $targetToolchain.macos_x64-linux_arm32_hfp/bin/ld.lld +linkerHostSpecificFlags.macos_x64-linux_arm32_hfp = --no-threads dynamicLinker.linux_arm32_hfp = /lib/ld-linux-armhf.so.3 # targetSysRoot relative abiSpecificLibraries.linux_arm32_hfp = lib usr/lib @@ -495,6 +510,13 @@ clangOptFlags.linux_arm64 = -O3 -ffunction-sections clangDebugFlags.linux_arm64 = -O0 dynamicLibraryRelocationMode.linux_arm64 = pic staticLibraryRelocationMode.linux_arm64 = pic + +linker.linux_x64-linux_arm64 = $targetToolchain.linux_x64-linux_arm64/bin/ld.gold +linkerHostSpecificFlags.linux_x64-linux_arm64 = +linker.mingw_x64-linux_arm64 = $targetToolchain.mingw_x64-linux_arm64/bin/ld.gold +linkerHostSpecificFlags.mingw_x64-linux_arm64 = +linker.macos_x64-linux_arm64 = $targetToolchain.macos_x64-linux_arm64/bin/ld.lld +linkerHostSpecificFlags.macos_x64-linux_arm64 = --no-threads dynamicLinker.linux_arm64 = /lib/ld-linux-aarch64.so.1 # targetSysRoot relative abiSpecificLibraries.linux_arm64 = lib usr/lib @@ -530,6 +552,9 @@ clangOptFlags.linux_mips32 = -O3 -ffunction-sections clangDebugFlags.linux_mips32 = -O0 dynamicLibraryRelocationMode.linux_mips32 = pic staticLibraryRelocationMode.linux_mips32 = pic + +linker.linux_x64-linux_mips32 = $targetToolchain.linux_x64-linux_mips32/bin/ld +linkerHostSpecificFlags.linux_x64-linux_mips32 = dynamicLinker.linux_mips32 = /lib/ld.so.1 # targetSysRoot relative abiSpecificLibraries.linux_mips32 = lib usr/lib @@ -566,6 +591,9 @@ clangOptFlags.linux_mipsel32 = -O3 -ffunction-sections clangDebugFlags.linux_mipsel32 = -O0 dynamicLibraryRelocationMode.linux_mipsel32 = pic staticLibraryRelocationMode.linux_mipsel32 = pic + +linker.linux_x64-linux_mipsel32 = $targetToolchain.linux_x64-linux_mipsel32/bin/ld +linkerHostSpecificFlags.linux_x64-linux_mipsel32 = dynamicLinker.linux_mipsel32 = /lib/ld.so.1 # targetSysRoot relative abiSpecificLibraries.linux_mipsel32 = lib usr/lib diff --git a/kotlin-native/shared/src/main/kotlin/org/jetbrains/kotlin/konan/target/Configurables.kt b/kotlin-native/shared/src/main/kotlin/org/jetbrains/kotlin/konan/target/Configurables.kt index eef571d2670..e09b05d8c2f 100644 --- a/kotlin-native/shared/src/main/kotlin/org/jetbrains/kotlin/konan/target/Configurables.kt +++ b/kotlin-native/shared/src/main/kotlin/org/jetbrains/kotlin/konan/target/Configurables.kt @@ -112,6 +112,11 @@ interface GccConfigurables : TargetableConfigurables, ClangFlags { val dynamicLinker get() = targetString("dynamicLinker")!! val abiSpecificLibraries get() = targetList("abiSpecificLibraries") val crtFilesLocation get() = targetString("crtFilesLocation")!! + + val linker get() = hostTargetString("linker") + val linkerHostSpecificFlags get() = hostTargetList("linkerHostSpecificFlags") + val absoluteLinker get() = absolute(linker) + val linkerGccFlags get() = targetList("linkerGccFlags") } diff --git a/kotlin-native/shared/src/main/kotlin/org/jetbrains/kotlin/konan/target/Linker.kt b/kotlin-native/shared/src/main/kotlin/org/jetbrains/kotlin/konan/target/Linker.kt index 8c49a4c4316..dcce518d8c8 100644 --- a/kotlin-native/shared/src/main/kotlin/org/jetbrains/kotlin/konan/target/Linker.kt +++ b/kotlin-native/shared/src/main/kotlin/org/jetbrains/kotlin/konan/target/Linker.kt @@ -337,17 +337,11 @@ class GccBasedLinker(targetProperties: GccConfigurables) needsProfileLibrary: Boolean, mimallocEnabled: Boolean): List { if (kind == LinkerOutputKind.STATIC_LIBRARY) return staticGnuArCommands(ar, executable, objectFiles, libraries) - // TODO: Control via properties. - val (linker, linkerSpecificFlags) = when { - HostManager.hostIsMac -> "$absoluteLlvmHome/bin/ld.lld" to listOf("--no-threads") - else -> "$absoluteTargetToolchain/bin/ld.gold" to emptyList() - } - val isMips = target == KonanTarget.LINUX_MIPS32 || target == KonanTarget.LINUX_MIPSEL32 val dynamic = kind == LinkerOutputKind.DYNAMIC_LIBRARY val crtPrefix = "$absoluteTargetSysRoot/$crtFilesLocation" // TODO: Can we extract more to the konan.configurables? - return listOf(Command(linker).apply { + return listOf(Command(absoluteLinker).apply { +"--sysroot=${absoluteTargetSysRoot}" +"-export-dynamic" +"-z" @@ -355,8 +349,8 @@ class GccBasedLinker(targetProperties: GccConfigurables) +"--build-id" +"--eh-frame-hdr" +"-dynamic-linker" - linkerSpecificFlags.forEach { +it } +dynamicLinker + linkerHostSpecificFlags.forEach { +it } +"-o" +executable if (!dynamic) +"$crtPrefix/crt1.o" From 3c3407b3804f3355c0ac59bfd8aa96336b0a0076 Mon Sep 17 00:00:00 2001 From: Sergey Bogolepov Date: Mon, 14 Dec 2020 16:33:28 +0700 Subject: [PATCH 187/196] Fix running tests on remote Raspberry Pi. --- .../main/kotlin/org/jetbrains/kotlin/ExecutorService.kt | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/kotlin-native/build-tools/src/main/kotlin/org/jetbrains/kotlin/ExecutorService.kt b/kotlin-native/build-tools/src/main/kotlin/org/jetbrains/kotlin/ExecutorService.kt index 871d6c6c2e2..75252ea60cc 100644 --- a/kotlin-native/build-tools/src/main/kotlin/org/jetbrains/kotlin/ExecutorService.kt +++ b/kotlin-native/build-tools/src/main/kotlin/org/jetbrains/kotlin/ExecutorService.kt @@ -54,7 +54,9 @@ fun create(project: Project): ExecutorService { val platform = platformManager.platform(testTarget) val absoluteTargetToolchain = platform.absoluteTargetToolchain - return when (testTarget) { + return if (project.hasProperty("remote")) { + sshExecutor(project) + } else when (testTarget) { KonanTarget.WASM32 -> object : ExecutorService { override fun execute(action: Action): ExecResult? = project.exec { execSpec -> action.execute(execSpec) @@ -81,10 +83,7 @@ fun create(project: Project): ExecutorService { KonanTarget.IOS_ARM32, KonanTarget.IOS_ARM64 -> deviceLauncher(project) - else -> { - if (project.hasProperty("remote")) sshExecutor(project) - else localExecutorService(project) - } + else -> localExecutorService(project) } } From b2070c524380ada14f538a8d75fb929f0088d13c Mon Sep 17 00:00:00 2001 From: Sergey Bogolepov Date: Tue, 15 Dec 2020 13:06:53 +0700 Subject: [PATCH 188/196] Fix tests on qemu-arm and qemu-aarch64 --- kotlin-native/backend.native/tests/build.gradle | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/kotlin-native/backend.native/tests/build.gradle b/kotlin-native/backend.native/tests/build.gradle index c0d59b55731..87ee21d2406 100644 --- a/kotlin-native/backend.native/tests/build.gradle +++ b/kotlin-native/backend.native/tests/build.gradle @@ -3872,7 +3872,9 @@ standaloneTest("interop_objc_allocException") { interopTest("interop0") { disabled = (project.testTarget == 'wasm32') || // No interop for wasm yet. (project.testTarget == 'linux_mips32') || // st_uid of '/' is not equal to 0 when using qemu - (project.testTarget == 'linux_mipsel32') + (project.testTarget == 'linux_mipsel32') || + (project.testTarget == 'linux_arm32_hfp') || + (project.testTarget == 'linux_arm64') goldValue = "0\n0\n" source = "interop/basics/0.kt" interop = 'sysstat' From 2df2c2f05583de49fbd699600e9dedce7ae9e6ed Mon Sep 17 00:00:00 2001 From: Sergey Bogolepov Date: Wed, 16 Dec 2020 18:22:45 +0700 Subject: [PATCH 189/196] Fix compilation of executable for linux_mips32 --- kotlin-native/konan/konan.properties | 1 + 1 file changed, 1 insertion(+) diff --git a/kotlin-native/konan/konan.properties b/kotlin-native/konan/konan.properties index 0764ea29882..a796c4aabd8 100644 --- a/kotlin-native/konan/konan.properties +++ b/kotlin-native/konan/konan.properties @@ -552,6 +552,7 @@ clangOptFlags.linux_mips32 = -O3 -ffunction-sections clangDebugFlags.linux_mips32 = -O0 dynamicLibraryRelocationMode.linux_mips32 = pic staticLibraryRelocationMode.linux_mips32 = pic +executableRelocationMode.linux_mips32 = static linker.linux_x64-linux_mips32 = $targetToolchain.linux_x64-linux_mips32/bin/ld linkerHostSpecificFlags.linux_x64-linux_mips32 = From 43fe8c493143d3c44894c98b2fcebe4b3538f732 Mon Sep 17 00:00:00 2001 From: Igor Chevdar Date: Thu, 17 Dec 2020 18:19:01 +0500 Subject: [PATCH 190/196] [IR] Added printing more info in a error message Print all captured values for bound function references when they're prohibited --- .../lower/SpecialBackendChecksTraversal.kt | 88 +++++++++++++++---- 1 file changed, 72 insertions(+), 16 deletions(-) diff --git a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/SpecialBackendChecksTraversal.kt b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/SpecialBackendChecksTraversal.kt index e17c5790fd4..855cf466a0c 100644 --- a/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/SpecialBackendChecksTraversal.kt +++ b/kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/SpecialBackendChecksTraversal.kt @@ -5,16 +5,20 @@ package org.jetbrains.kotlin.backend.konan.lower -import org.jetbrains.kotlin.backend.common.* +import org.jetbrains.kotlin.backend.common.FileLoweringPass import org.jetbrains.kotlin.backend.common.ir.Symbols import org.jetbrains.kotlin.backend.common.ir.allParameters import org.jetbrains.kotlin.backend.common.lower.Closure import org.jetbrains.kotlin.backend.common.lower.ClosureAnnotator +import org.jetbrains.kotlin.backend.common.peek +import org.jetbrains.kotlin.backend.common.pop +import org.jetbrains.kotlin.backend.common.push import org.jetbrains.kotlin.backend.konan.* import org.jetbrains.kotlin.backend.konan.cgen.* import org.jetbrains.kotlin.backend.konan.descriptors.allOverriddenFunctions -import org.jetbrains.kotlin.backend.konan.ir.* import org.jetbrains.kotlin.backend.konan.ir.companionObject +import org.jetbrains.kotlin.backend.konan.ir.getSuperClassNotAny +import org.jetbrains.kotlin.backend.konan.ir.isReal import org.jetbrains.kotlin.backend.konan.llvm.IntrinsicType import org.jetbrains.kotlin.backend.konan.llvm.tryGetIntrinsicType import org.jetbrains.kotlin.descriptors.ClassDescriptor @@ -22,7 +26,6 @@ import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.descriptors.DescriptorVisibilities import org.jetbrains.kotlin.descriptors.isFinalClass import org.jetbrains.kotlin.ir.IrElement -import org.jetbrains.kotlin.ir.builders.* import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.expressions.* import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol @@ -34,6 +37,8 @@ import org.jetbrains.kotlin.ir.visitors.acceptChildrenVoid import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe import org.jetbrains.kotlin.types.Variance +import org.jetbrains.kotlin.utils.fileUtils.descendantRelativeTo +import java.io.File internal class SpecialBackendChecksTraversal(val context: Context) : FileLoweringPass { override fun lower(irFile: IrFile) = irFile.acceptChildrenVoid(BackendChecker(context, irFile)) @@ -57,12 +62,12 @@ private class BackendChecker(val context: Context, val irFile: IrFile) : IrEleme private val functionAnnotators = mutableMapOf>() private val functionClosures = mutableMapOf() - private fun capturesAnything(function: IrFunction): Boolean { - if (function.visibility != DescriptorVisibilities.LOCAL) return false + private fun captures(function: IrFunction): List { + if (function.visibility != DescriptorVisibilities.LOCAL) return emptyList() val closure = functionClosures.getOrPut(function) { functionAnnotators[function]!!.value.getFunctionClosure(function) } - return closure.capturedValues.isNotEmpty() + return closure.capturedValues.map { it.owner } } override fun visitElement(element: IrElement) { @@ -332,6 +337,22 @@ private class BackendChecker(val context: Context, val irFile: IrFile) : IrEleme } } + private val cwd = File(".").absoluteFile + + private fun reportBoundFunctionReferenceError(expression: IrExpression, callee: IrFunction, captures: List): Nothing { + val formattedCaptures = if (captures.isEmpty()) + "" + else ", but captures at:\n ${captures.joinToString("\n ") { + val location = it.getCompilerMessageLocation(irFile)!! + val relativePath = File(location.path).descendantRelativeTo(cwd).path + val capturedValueName = if (it is IrGetValue) ": ${it.symbol.owner.name.asString()}" else "" + "$relativePath:${location.line}:${location.column}$capturedValueName" + }}" + + reportError(expression, + "${callee.fqNameForIrSerialization} must take an unbound, non-capturing function or lambda$formattedCaptures") + } + override fun visitCall(expression: IrCall) { expression.acceptChildrenVoid(this) @@ -377,10 +398,10 @@ private class BackendChecker(val context: Context, val irFile: IrFile) : IrEleme when (val intrinsicType = tryGetIntrinsicType(expression)) { IntrinsicType.INTEROP_STATIC_C_FUNCTION -> { - val target = getUnboundReferencedFunction(expression.getValueArgument(0)!!) + val (target, captures) = getUnboundReferencedFunction(expression.getValueArgument(0)!!) if (target == null || target.symbol !is IrSimpleFunctionSymbol) - reportError(expression, "${callee.fqNameForIrSerialization} must take an unbound, non-capturing function or lambda") + reportBoundFunctionReferenceError(expression, callee, captures) val signatureTypes = target.allParameters.map { it.type } + target.returnType @@ -439,13 +460,16 @@ private class BackendChecker(val context: Context, val irFile: IrFile) : IrEleme reportError(expression, "unable to convert ${receiverType.toKotlinType()} to ${typeOperand.toKotlinType()}") } IntrinsicType.WORKER_EXECUTE -> { - getUnboundReferencedFunction(expression.getValueArgument(2)!!) - ?: reportError(expression, "${callee.fqNameForIrSerialization} must take an unbound, non-capturing function or lambda") + val (function, captures) = getUnboundReferencedFunction(expression.getValueArgument(2)!!) + if (function == null) + reportBoundFunctionReferenceError(expression, callee, captures) } else -> when { - callee.symbol == symbols.createCleaner -> - getUnboundReferencedFunction(expression.getValueArgument(1)!!) - ?: reportError(expression, "${callee.fqNameForIrSerialization} must take an unbound, non-capturing function or lambda") + callee.symbol == symbols.createCleaner -> { + val (function, captures) = getUnboundReferencedFunction(expression.getValueArgument(1)!!) + if (function == null) + reportBoundFunctionReferenceError(expression, callee, captures) + } callee.symbol == symbols.immutableBlobOf -> { val args = expression.getValueArgument(0) ?: reportError(expression, "expected at least one element") @@ -492,10 +516,42 @@ private class BackendChecker(val context: Context, val irFile: IrFile) : IrEleme } } + private data class ReferencedFunctionWithCapture(val function: IrFunction?, val captures: List) + + private fun searchForReferences(function: IrFunction, targetValues: Set): List { + if (targetValues.isEmpty()) return emptyList() + + val result = mutableListOf() + function.acceptChildrenVoid(object: IrElementVisitorVoid { + override fun visitElement(element: IrElement) { + element.acceptChildrenVoid(this) + } + + override fun visitGetValue(expression: IrGetValue) { + if (expression.symbol.owner in targetValues) + result += expression + } + }) + return result + } + private fun getUnboundReferencedFunction(expression: IrExpression) = when (expression) { - is IrFunctionReference -> expression.symbol.owner.takeIf { expression.getArguments().isEmpty() && !capturesAnything(it) } - is IrFunctionExpression -> expression.function.takeIf { !capturesAnything(it) } - else -> null + is IrFunctionReference -> { + val arguments = expression.getArguments() + val capturedVariables = captures(expression.symbol.owner) + ReferencedFunctionWithCapture( + expression.symbol.owner.takeIf { arguments.isEmpty() && capturedVariables.isEmpty() }, + arguments.map { it.second } + searchForReferences(expression.symbol.owner, capturedVariables.toSet()) + ) + } + is IrFunctionExpression -> { + val capturedVariables = captures(expression.function) + ReferencedFunctionWithCapture( + expression.function.takeIf { capturedVariables.isEmpty() }, + searchForReferences(expression.function, capturedVariables.toSet()) + ) + } + else -> ReferencedFunctionWithCapture(null, emptyList()) } private fun IrCall.getSingleTypeArgument(): IrType { From d09b0b704242c1d3c480c289368a8e89d5048be3 Mon Sep 17 00:00:00 2001 From: Pavel Punegov Date: Wed, 16 Dec 2020 15:05:49 +0300 Subject: [PATCH 191/196] Sort top-level descriptors by name --- .../org/jetbrains/kotlin/cli/klib/DeclarationPrinter.kt | 4 +++- .../org/jetbrains/kotlin/cli/klib/test/ContentsTest.kt | 6 +++--- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/kotlin-native/klib/src/main/kotlin/org/jetbrains/kotlin/cli/klib/DeclarationPrinter.kt b/kotlin-native/klib/src/main/kotlin/org/jetbrains/kotlin/cli/klib/DeclarationPrinter.kt index 2298c34926f..d420a603660 100644 --- a/kotlin-native/klib/src/main/kotlin/org/jetbrains/kotlin/cli/klib/DeclarationPrinter.kt +++ b/kotlin-native/klib/src/main/kotlin/org/jetbrains/kotlin/cli/klib/DeclarationPrinter.kt @@ -47,7 +47,9 @@ class DeclarationPrinter( } override fun visitPackageFragmentDescriptor(descriptor: PackageFragmentDescriptor, data: Unit) { - val children = descriptor.getMemberScope().getContributedDescriptors().filter { it.shouldBePrinted } + val children = descriptor.getMemberScope().getContributedDescriptors() + .filter { it.shouldBePrinted } + .sortedBy { it.name } if (children.isNotEmpty()) { printer.printWithBody(header = headerRenderer.render(descriptor)) { children.forEach { it.accept(this, data) } diff --git a/kotlin-native/klib/src/test/kotlin/org/jetbrains/kotlin/cli/klib/test/ContentsTest.kt b/kotlin-native/klib/src/test/kotlin/org/jetbrains/kotlin/cli/klib/test/ContentsTest.kt index 64ea0c3633c..9e4a6db9cc8 100644 --- a/kotlin-native/klib/src/test/kotlin/org/jetbrains/kotlin/cli/klib/test/ContentsTest.kt +++ b/kotlin-native/klib/src/test/kotlin/org/jetbrains/kotlin/cli/klib/test/ContentsTest.kt @@ -48,6 +48,7 @@ class ContentsTest { package { @A @B fun a() + fun Foo.e() fun f1(x: Foo) fun f2(x: Foo, y: Foo): Int inline fun i1(block: () -> Foo) @@ -62,7 +63,6 @@ class ContentsTest { fun t3(x: T, y: F) inline fun t4(x: T) fun t5(x: T) - fun Foo.e() } """.trimIndent() } @@ -325,9 +325,9 @@ class ContentsTest { fun topLevelPropertiesWithClassesCustomPackage() = klibContents(testLibrary("TopLevelPropertiesWithClassesCustomPackage")) { """ package custom.pkg { - typealias MyTransformer = (String) -> Int object Bar class Foo constructor() + typealias MyTransformer = (String) -> Int } package custom.pkg { @@ -343,9 +343,9 @@ class ContentsTest { fun topLevelPropertiesWithClassesRootPackage() = klibContents(testLibrary("TopLevelPropertiesWithClassesRootPackage")) { """ package { - typealias MyTransformer = (String) -> Int object Bar class Foo constructor() + typealias MyTransformer = (String) -> Int } package { From 62e7b6717001ac6f0b11b3ab8562f09d1083bb9f Mon Sep 17 00:00:00 2001 From: Sergey Bogolepov Date: Thu, 17 Dec 2020 17:00:21 +0700 Subject: [PATCH 192/196] Use caches for linux_x64 compile-only benchmarks --- .../src/main/kotlin/org/jetbrains/kotlin/MPPTools.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/kotlin-native/build-tools/src/main/kotlin/org/jetbrains/kotlin/MPPTools.kt b/kotlin-native/build-tools/src/main/kotlin/org/jetbrains/kotlin/MPPTools.kt index 2258508cfd6..d3a0bb23929 100644 --- a/kotlin-native/build-tools/src/main/kotlin/org/jetbrains/kotlin/MPPTools.kt +++ b/kotlin-native/build-tools/src/main/kotlin/org/jetbrains/kotlin/MPPTools.kt @@ -133,7 +133,7 @@ fun getCompileOnlyBenchmarksOpts(project: Project, defaultCompilerOpts: List Date: Fri, 18 Dec 2020 16:21:20 +0700 Subject: [PATCH 193/196] [Linux] Fix linker arguments order --- .../main/kotlin/org/jetbrains/kotlin/konan/target/Linker.kt | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/kotlin-native/shared/src/main/kotlin/org/jetbrains/kotlin/konan/target/Linker.kt b/kotlin-native/shared/src/main/kotlin/org/jetbrains/kotlin/konan/target/Linker.kt index dcce518d8c8..aac5339b34e 100644 --- a/kotlin-native/shared/src/main/kotlin/org/jetbrains/kotlin/konan/target/Linker.kt +++ b/kotlin-native/shared/src/main/kotlin/org/jetbrains/kotlin/konan/target/Linker.kt @@ -363,6 +363,9 @@ class GccBasedLinker(targetProperties: GccConfigurables) if (!debug) +linkerNoDebugFlags if (dynamic) +linkerDynamicFlags +objectFiles + +libraries + +linkerArgs + if (mimallocEnabled) +mimallocLinkerDependencies // See explanation about `-u__llvm_profile_runtime` here: // https://github.com/llvm/llvm-project/blob/21e270a479a24738d641e641115bce6af6ed360a/llvm/lib/Transforms/Instrumentation/InstrProfiling.cpp#L930 if (needsProfileLibrary) +listOf("-u__llvm_profile_runtime", profileLibrary!!) @@ -370,9 +373,6 @@ class GccBasedLinker(targetProperties: GccConfigurables) +linkerGccFlags +if (dynamic) "$libGcc/crtendS.o" else "$libGcc/crtend.o" +"$crtPrefix/crtn.o" - +libraries - +linkerArgs - if (mimallocEnabled) +mimallocLinkerDependencies }) } } From ce764d78ab38a72f424871cb422cba40b47cdad4 Mon Sep 17 00:00:00 2001 From: SvyatoslavScherbina Date: Mon, 21 Dec 2020 15:04:24 +0300 Subject: [PATCH 194/196] Fix WorkerBoundReference kdoc --- .../kotlin/kotlin/native/concurrent/WorkerBoundReference.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/kotlin-native/runtime/src/main/kotlin/kotlin/native/concurrent/WorkerBoundReference.kt b/kotlin-native/runtime/src/main/kotlin/kotlin/native/concurrent/WorkerBoundReference.kt index 16e6e23a982..7ac382a321f 100644 --- a/kotlin-native/runtime/src/main/kotlin/kotlin/native/concurrent/WorkerBoundReference.kt +++ b/kotlin-native/runtime/src/main/kotlin/kotlin/native/concurrent/WorkerBoundReference.kt @@ -23,7 +23,7 @@ external private fun describeWorkerBoundReference(ref: NativePtr): String * the worker [WorkerBoundReference] was created on, unless the referred object is frozen too. * * Note: Garbage collector currently cannot free any reference cycles with frozen [WorkerBoundReference] in them. - * To resolve such cycles consider using [AtomicReference] which can be explicitly + * To resolve such cycles consider using [AtomicReference]`` which can be explicitly * nulled out. */ @NoReorderFields From 6ed224fb365ec64c1311c05a8d2e12d8bb4cca05 Mon Sep 17 00:00:00 2001 From: Vasily Levchenko Date: Sun, 20 Dec 2020 20:25:47 +0100 Subject: [PATCH 195/196] [kotlin compiler][update] 1.5.0-dev-805 * a5ddb1fdf13 - (HEAD -> master, tag: build-1.5.0-dev-805, origin/master, origin/HEAD) Update error about unsupported inline classes (vor 2 Tagen) * 272273baed7 - Support serializable inline classes in IR plugin (vor 2 Tagen) * 631a72d14a8 - Support old serialization runtime versions (vor 2 Tagen) * f671c27f274 - (tag: build-1.5.0-dev-804) Adapt serialization exceptions constructor calls in legacy JS (vor 2 Tagen) * 18e7a1485c0 - Additional fix for Compose: (vor 2 Tagen) * f922ebbfc38 - (tag: build-1.5.0-dev-797) Value classes: Add JvmInlineValueClasses language feature (vor 3 Tagen) * 48d9812d9e3 - (tag: build-1.5.0-dev-795) Review fixes around type enhancement and loading type use annotations (vor 3 Tagen) * 9a52863fbda - Report warnings about type mismatches based on freshly supported nullability annotations deeply (vor 3 Tagen) * d6017420dec - Mark freshly supported annotations to use that mark for reporting corresponding warnings (vor 3 Tagen) * 9693ea19fb0 - Add tests for type enhancement uncluding with compiled java (vor 3 Tagen) * 71ca18e937b - Support diagnostic tests with Kotlin against compiled Java (vor 3 Tagen) * 6f8f531d87c - Put type enhancement improvements under the compiler flag (vor 3 Tagen) * 857cc92326c - Support preference of TYPE_USE annotations to enhance over others like METHOD, FIELD and VALUE_PARAMETER to avoid double applying them in case of arrays: @NotNull Integer [] (both to the array element and to the entire array) (vor 3 Tagen) * 69f31afecce - Exclude tests for loading type use annotations and type enhancement based on them to pass using javac and psi class files reading (vor 3 Tagen) * f389654fea3 - Support type enhancement for super classes' types (vor 3 Tagen) * 276498793f7 - Support enhancement of type parameter's bound for all nullability annotations (vor 3 Tagen) * c91301d04cb - Support type use annotations on fields (vor 3 Tagen) * b0debbe4c97 - Add forced mark "isDeprecated" as false for missing types among javac types (vor 3 Tagen) * 8777d28228d - Use new jetbrains annotations with type use target for "load java 8" tests (vor 3 Tagen) * 6f64e2c0360 - Avoid a cycle of analysing of type parameters via checking that it's a type parameter first (vor 3 Tagen) * a89329e0775 - Support reading from class files of the type use annotations on type parameters and type arguments (vor 3 Tagen) * 0833719a799 - Support annotations on array types (vor 3 Tagen) * f0ab8bc332a - Clean up some code in `compiler.resolution.common.jvm` (vor 3 Tagen) * 63aa8092800 - (tag: build-1.5.0-dev-790) [FIR IDE] Add fir type annotations test (vor 3 Tagen) * c4b708b5dcc - [FIR IDE] Fixed test data for types (vor 3 Tagen) * 9e89cfae08c - [FIR IDE] Fixed invalid leaks test (vor 3 Tagen) * fb944707415 - [FIR IDE] Fix resolve value parameter symbol (vor 3 Tagen) * 8891a337e29 - [FIR IDE] Implement type annotations for fir symbols (vor 3 Tagen) * 9670f67912e - [FIR IDE] Make annotations and extension receiver lazy (vor 3 Tagen) * 9c2d06cf703 - (tag: build-1.5.0-dev-782) FIR: strengthen resolution success check for augmented array set call (vor 3 Tagen) * 9bf2dfaa023 - (tag: build-1.5.0-dev-781) KT-40200: Fix main function detector in lazy resolve overload resolver (vor 3 Tagen) * 92adccde478 - (tag: build-1.5.0-dev-779) Probably fix issue with creating module descriptor for SDK twice (vor 3 Tagen) * 6296f6dc333 - [FE] Don't throw assertion in OverrideResolver if directOverridden is empty (vor 3 Tagen) * dea01125d69 - (tag: build-1.5.0-dev-775) FIR deserializer: keep SourceElement for more precise Fir2IrLazyClass's source (vor 3 Tagen) * fe0c25693d2 - FIR2IR: do not convert @ExtensionFunctionType twice (vor 3 Tagen) * 46084316829 - (tag: build-1.5.0-dev-771) FIR2IR: correct base symbols of fake overrides for delegated member (vor 3 Tagen) * 44c6ec2c449 - (tag: build-1.5.0-dev-767) FIR checker: make unused checker handle invoke properly (vor 3 Tagen) * d907c48d9ce - (tag: build-1.5.0-dev-764) Allow KtEnumEntry...RefExpression.referencedElement be nullable (vor 3 Tagen) * 4f96f9d6a17 - (tag: build-1.5.0-dev-762) [JS IR] Initialize enum fields before accessing them in companion object (vor 3 Tagen) * 3eb0745b58f - (tag: build-1.5.0-dev-750) KTIJ-650 [Code completion]: "sealed interface" is for 1.5+ only (vor 4 Tagen) * 27ebb6c946b - KTIJ-650 [Code completion]: test framework fix (vor 4 Tagen) * efc7ab50237 - (tag: build-1.5.0-dev-748) KTIJ-664 [SealedClassInheritorsProvider]: test fixes (vor 4 Tagen) * 88a0fe7ec19 - (tag: build-1.5.0-dev-727) Make a longer description for Kotlin Android plugin (vor 4 Tagen) * 43c04dfd086 - (tag: build-1.5.0-dev-726) [Wasm] Publish stdlib: remove separate project (vor 4 Tagen) * be688356c96 - (tag: build-1.5.0-dev-722) [IR] Fixed bug with thread unsafety (vor 4 Tagen) * 03693e3d5a7 - (tag: build-1.5.0-dev-721) [klib] Optimized away some Files.exists() (vor 4 Tagen) * f597343d822 - (tag: build-1.5.0-dev-710) [TEST] Fix testdata (vor 5 Tagen) * 8974d31bb8b - [TEST] Fix problem with line separator on windows (vor 5 Tagen) * f2fa36f9cb2 - (tag: build-1.5.0-dev-709) Split modules scan based if facedSettings can affect api/lang level of module (vor 5 Tagen) * e7c4121e678 - (tag: build-1.5.0-dev-677, tag: build-1.5.0-dev-676, tag: build-1.5.0-dev-675) [TEST] Add muting tests with .fail file for js box tests (vor 5 Tagen) * 416f17e5ece - [TEST] Drop remaining tests of experimental coroutines (vor 5 Tagen) * 019cb1485e1 - [TEST] Extract language feature regex pattern to :test-infrastructure-utils (vor 5 Tagen) * 4ed2651c1f0 - [CMI] Rename platforms to attributes in some forgotten places (vor 5 Tagen) * e1802fde296 - [TD] Update test data after previous commit (vor 5 Tagen) * 49d9b859502 - [TEST] Migrate AbstractFirDiagnosticsWithLightTreeTest to new test runners (vor 5 Tagen) * 7e9deb76022 - [FIR] Fix NPE in light tree source utils (vor 5 Tagen) * b048296dcaa - [FIR] Fix calculating offsets for light tree source elements (vor 5 Tagen) * acbc468fdde - [FIR] Add light tree mode to FirAnalyzerFacade (vor 5 Tagen) * 2aa1cb74519 - [TEST] Migrate AbstractDiagnosticsNativeTest to new test runners (vor 5 Tagen) * e7f84860784 - [TEST] Migrate AbstractDiagnosticsTestWithJvmBackend to new test runners (vor 5 Tagen) * 71ffaa2d97b - [TEST] Migrate AbstractDiagnosticsTestWithJsStdLib to new test runners (vor 5 Tagen) * 1fe5148f0d3 - [TEST] Extract compiler-specific test utils from :tests-common to new module (vor 5 Tagen) * d15c7861b27 - [TEST] Invert dependency between :test-generator and :tests-common modules (vor 5 Tagen) * bc7e18fb8a7 - [TEST] Regenerate tests after previous commit (vor 5 Tagen) * 9e2d6914254 - [TEST] Move utils for checking all files presented to KtTestUtil (vor 5 Tagen) * 64ce307f7fa - [TEST] Drop mechanism for muting tests with .mute files (vor 5 Tagen) * f8ad096abb4 - [TEST] Mute tests in IC JS Klib tests using exclude pattern instead of .mute file (vor 5 Tagen) * d9848544dc1 - [TEST] Move auto mute wrapping utils to :compiler:tests-mutes (vor 5 Tagen) * 8a5fc2ad294 - [Build] Split `:tests-mutes` package to common and TC integration parts (vor 5 Tagen) * 26d7ea6ce68 - [TEST] Migrate AbstractDiagnosticsWithModifiedMockJdkTest to new test runners (vor 5 Tagen) * b43fa94cb64 - [TEST] Migrate AbstractDiagnosticsWithUnsignedTypes to new test runners (vor 5 Tagen) * 23e704f3619 - [TEST] Migrate AbstractDiagnosticsWithExplicitApi to new test runners (vor 5 Tagen) * c0e4452cf84 - [TEST] Migrate AbstractDiagnosticsWithJdk9Test to new test runners (vor 5 Tagen) * 61302a2e081 - [TEST] Migrate duplicating javac tests to new test runners (vor 5 Tagen) * b44dc55109a - [TD] Mute some javac tests or update their testdata (vor 5 Tagen) * 8ddf419be59 - [Build] Fix gradle tests filter for JUnit 5 (vor 5 Tagen) * e6b5cb52160 - [TD] Update diagnostics test data due to new test runners (vor 5 Tagen) * 1d04fecd29d - [TD] Remove some outdated tests with unsupported EXPLICIT_FLEXIBLE directive (vor 5 Tagen) * 0b0e2c3ad23 - [TD] Create real helpers files for coroutines checkers (vor 5 Tagen) * 710c5ec8cce - [TEST] Drop old generated tests which are duplicated by new ones (vor 5 Tagen) * 6128d5e7f2d - [TEST] Generate new tests using new runners and old testdata (vor 5 Tagen) * d7224ad63e5 - [Build] Add generating and running new compiler tests to gradle (vor 5 Tagen) * 3bd3545a05e - [TEST] Add abstract test runners for some of compiler test in new infrastructure (vor 5 Tagen) * 32fda13ef9f - [TEST] Implement test generators for junit 5 based tests (vor 5 Tagen) * cb5183ab4d1 - [TEST] Add implementation of new infrastructure services for compiler tests (vor 5 Tagen) * dd402b16d92 - [TEST] Add core of new tests infrastructure (vor 5 Tagen) * 35437e6da9a - [FE] Allow explicitly specify dependent modules fin TopDownAnalyzerFacade (vor 5 Tagen) * c8f3a4802e4 - [TEST] Introduce test-infrastructure-utils module and extract common test utilities here (vor 5 Tagen) * 1c91b74ff0e - [CMI] Fix clearing code meta infos from original text (vor 5 Tagen) * 79601826740 - [CMI] Fix CodeMetaInfoParser to properly handle nested meta infos (vor 5 Tagen) * c558df5b4a1 - [CMI] Fix rendering metainfos at the end of file (vor 5 Tagen) * ceb44ddccd3 - [CMI] Improve CodeMetaInfoRenderer (vor 5 Tagen) * 98a2f29f958 - [CMI] Allow using right angle bracket symbol in MetaInfo message (vor 5 Tagen) * 09df07349c2 - [CMI] Add ability to replace render configuration of DiagnosticCodeMetaInfo (vor 5 Tagen) * d6ff83c7d8d - [CMI] Add ability to copy ParsedCodeMetaInfo (vor 5 Tagen) * 3bf60b3accf - [CMI] Rename `CodeMetaInfo.platforms` to `attributes` (vor 5 Tagen) * ced9a6fe355 - [CMI] Replace `getTag` with `tag` property in `CodeMetaInfo` (vor 5 Tagen) * 9e31b049fce - [CMI] Add additional constructor for DiagnosticCodeMetaInfo (vor 5 Tagen) * 87a6a669537 - [CMI] Parse description of meta info and save it to ParsedCodeMetaInfo (vor 5 Tagen) * 2bbab3170fe - [CMI] Replace StringBuffer with StringBuilder in CodeMetaInfoRenderer (vor 5 Tagen) * 25c011ca40b - [CMI] Extract core of CodeMetaInfo to :compiler:tests-common (vor 5 Tagen) * 4ad9f486420 - [CMI] Cleanup code of CodeMetaInfo (vor 5 Tagen) * 23c088afd64 - [TEST-GEN] Reorganize package structure in `:generators:test-generator` module (vor 5 Tagen) * 380e8a38145 - [TEST-GEN] Extract run of TestGenerator to top of test generation DSL (vor 5 Tagen) * 2a73aaba4d2 - [TEST-GEN] Move all generation data to `TestGroup.TestClass` (vor 5 Tagen) * c51ea6b1421 - [TEST-GEN] Create abstract TestGenerator and move current generator logic to TestGeneratorImpl (vor 5 Tagen) * d45fb4dfd81 - [TEST-GEN] Extract logic of generating test methods into separate abstraction MethodGenerator (vor 5 Tagen) * 2acbe96f15d - [TEST-GEN] Convert Test Generation DSL classes from java to kotlin (vor 5 Tagen) * 31bccb4fb03 - [TEST-GEN] Rename .java to .kt (vor 5 Tagen) * 580d2ed693d - [TEST-GEN] Add some comments to TestGenerationDSL (vor 5 Tagen) * 0e43eaa6629 - (tag: build-1.5.0-dev-674) Don't call possibleGetterNamesByPropertyName without a reason (vor 5 Tagen) * 44948aa9a2b - (tag: build-1.5.0-dev-669) [FE] Properly report diagnostics about type arguments of implicit invoke (vor 5 Tagen) * 329066a4f38 - [Parser] Fix parsing of unfinished dot access in string template (vor 5 Tagen) * 8999fd88b1a - (tag: build-1.5.0-dev-658, origin/rr/pdn_jvm_be_fix) JVM_IR KT-43401 KT-43518 fix ACC_STRICT and ACC_SYNCHRONIZED flags (vor 5 Tagen) * 7ed3860c705 - (tag: build-1.5.0-dev-654) JVM_IR KT-43043 fix nullability annotations for inline class members (vor 5 Tagen) * 2b3fc330ad5 - (tag: build-1.5.0-dev-653) KTIJ-664 [SealedClassInheritorsProvider]: test fixes (vor 5 Tagen) * c2bf124d862 - (tag: build-1.5.0-dev-652) [FIR IDE] File symbol scope and symbol test (vor 5 Tagen) * 2f4842b2719 - [FIR IDE] Add KtFileScope to support KtFileSymbol (vor 5 Tagen) * 2fa5ab6e313 - [FIR IDE] LC Remove difficult caching from FirLightClassBase (vor 5 Tagen) * f282b721bc5 - [FIR IDE] LC Fix test data (vor 5 Tagen) * f5d8ae0550a - [FIR IDE] LC add caching to light facades (vor 5 Tagen) * da54dbba8ef - [FIR IDE] LC Add callable declarations to KtFileSymbol (vor 5 Tagen) * fb63b74b37a - [FIR IDE] LC Add KtFileSymbol and fix facade annotations (vor 5 Tagen) * 46071c19257 - [FIR IDE] LC fix annotations with special sites and nullability (vor 5 Tagen) * 2e7866ca866 - [FIR IDE] LC Fix annotations and modifiers for class members (vor 5 Tagen) * 3019f439fbe - [FIR IDE] LC More accurate processing for JvmSynthetic and JvmHidden annotations (vor 5 Tagen) * 3895ad375c9 - [FIR IDE] LC add jvmstatic method into companion object (vor 5 Tagen) * d32d0a65f0f - (tag: build-1.5.0-dev-643) Revert "Report warning on @JvmStatic in private companion objects" (vor 5 Tagen) * 94deddef7f5 - Revert "Minor: cover negative cases with test +m" (vor 5 Tagen) * 5a9ff3471a4 - (tag: build-1.5.0-dev-633) FIR IDE: fix function targets on context element copy (vor 6 Tagen) * 67fc1bcb3dd - FIR IDE: add debug error message when not possible to find fir declarartion by psi (vor 6 Tagen) * 940ec06f5bc - FIR IDE: precalculate completion context on dependent analysis session creation (vor 6 Tagen) * 40b1a4df5a3 - FIR IDE: temp mute failing find usages test (vor 6 Tagen) * 2d5b23b650c - FIR IDE: separate KtExpressionTypeProvider into components (vor 6 Tagen) * 2101816f032 - FIR IDE: add expected type calculation for function calls (vor 6 Tagen) * 7be8d69870f - FIR IDE: add completion weighers tests for return/if/while (vor 6 Tagen) * b16ebe2dc4d - FIR IDE: consider if & while conditions expected type as boolean (vor 6 Tagen) * c2d83353e81 - FIR IDE: introduce builtin types container (vor 6 Tagen) * 835577383b5 - FIR IDE: introduce expected type provider for return expressions (vor 6 Tagen) * 299f36183cc - FIR IDE: add tests for completion weighers from old testdata (vor 6 Tagen) * 19fff2b1e73 - FIR IDE: implement expected type weigher for completion (vor 6 Tagen) * c61d4b5f9c1 - FIR IDE: introduce return statement target provider (vor 6 Tagen) * a0ed14eafe5 - FIR: use real source element for return statement (vor 6 Tagen) * 3af0257b380 - (tag: build-1.5.0-dev-627) KTIJ-664 [SealedClassInheritorsProvider]: IDE-specific implementation (vor 6 Tagen) * f02b73103b7 - KTIJ-650 [Code completion]: no "sealed" for classes with modifiers (vor 6 Tagen) * fe64b13140e - KTIJ-650 [Code completion]: support for "sealed interface" (vor 6 Tagen) * 602ed42b99b - (tag: build-1.5.0-dev-626) [Wasm] Move intrinsic generators to generators/wasm (vor 6 Tagen) * efeabac2c54 - (tag: build-1.5.0-dev-620) FIR: do not force coercion-to-Unit for nullable lambda return type (vor 6 Tagen) * 6239301f4ea - FIR: no constraint for coerced-to-Unit last expression of lambda (vor 6 Tagen) * 4ab0897d7d7 - FIR: pass the explicit expected type to block type (vor 6 Tagen) * 0ea6b32c018 - NI: allow lower bound of flexible type for coercion-to-Unit (vor 6 Tagen) * b0f6461fa9f - (tag: build-1.5.0-dev-598) JVM_IR KT-42020 special IdSignature for some fake override members (vor 6 Tagen) * 12cfba9ca96 - (tag: build-1.5.0-dev-590) FIR BB: remove stale test ignoring tags in old language versions (vor 6 Tagen) * f7ade2b0b84 - FIR2IR: introduce implicit casts for extension receivers (vor 6 Tagen) * 6e9ac6b3338 - (tag: build-1.5.0-dev-584) [Commonizer] Internal tool for tracking memory usage (vor 6 Tagen) * 010a2901322 - (tag: build-1.5.0-dev-580) [LC] Fix for light classes equivalence (vor 6 Tagen) * 45112a3c11e - (tag: build-1.5.0-dev-575) [ULC] Fix invalid positive inheritor for self checking (vor 7 Tagen) * 0f4173cdfa6 - (tag: build-1.5.0-dev-572) Fix running stdlib tests in worker on Native (vor 7 Tagen) * 8f4e4a4d404 - Specify common sources for stdlib test compilation tasks (vor 7 Tagen) * c094d77794a - Fix DeepRecursiveFunction in worker on Native (vor 7 Tagen) * b3d8c4a0fc0 - (tag: build-1.5.0-dev-571) [JS IR] Apply missing property for all tests tasks like jsIrTest and quickTest (vor 7 Tagen) * 32cc95a3b0c - (tag: build-1.5.0-dev-569) [JS IR] Skip export annotations while generating default stubs (vor 7 Tagen) * 7efc95705ab - (tag: build-1.5.0-dev-568) [Wasm] Publish stdlib klib to maven (vor 7 Tagen) * d37271bf358 - (tag: build-1.5.0-dev-559, tag: build-1.5.0-dev-550) [Wasm] Support packed integer array elements (vor 7 Tagen) * 51e8d782b0c - [Wasm] Support packed integer class fields (vor 7 Tagen) * 28168bf230a - (tag: build-1.5.0-dev-549, origin/rr/stdlib/js-map-entries-contains-fix-merge) Correctly implement specialized MutableEntrySet.contains KT-41278 (vor 7 Tagen) * 0a3f3bef51e - (tag: build-1.5.0-dev-529) [Gradle, JS]Process error output and rethrow errors and warns to console (vor 7 Tagen) * 55b0775565f - (tag: build-1.5.0-dev-528) [FE] Call SealedClassInheritorsProvider only for sealed classes (vor 7 Tagen) * 0a2269cccbe - (tag: build-1.5.0-dev-518) Fixed out-of-process compiler execution if project directy is absent (vor 8 Tagen) * 9be7221efda - Clear IC caches if they were not properly closed (vor 8 Tagen) * 7bdd7ce6b80 - Reformat DirtyClassesMap (vor 8 Tagen) * 275a02ce88e - Fix synchronization when working with IC caches (vor 8 Tagen) * af95b8d1fe8 - Add explicit path sensitivity for InspectClassesForMultiModuleIC (vor 8 Tagen) * 2e607335dbd - Add tests for incremental compilation of sealed interfaces (vor 8 Tagen) * 36f99156fd1 - IC of sealed classes (vor 8 Tagen) --- kotlin-native/gradle.properties | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/kotlin-native/gradle.properties b/kotlin-native/gradle.properties index 11fe69fbb67..c874d2edcc7 100644 --- a/kotlin-native/gradle.properties +++ b/kotlin-native/gradle.properties @@ -18,12 +18,12 @@ buildKotlinVersion=1.4.20-dev-2167 buildKotlinCompilerRepo=https://teamcity.jetbrains.com/guestAuth/app/rest/builds/buildType:(id:Kotlin_KotlinPublic_Compiler),number:1.4.20-dev-2167,branch:default:any,pinned:true/artifacts/content/maven remoteRoot=konan_tests -kotlinCompilerRepo=https://teamcity.jetbrains.com/guestAuth/app/rest/builds/buildType:(id:Kotlin_KotlinPublic_Compiler),number:1.5.0-dev-500,branch:default:any,pinned:true/artifacts/content/maven -kotlinVersion=1.5.0-dev-500 -kotlinStdlibRepo=https://teamcity.jetbrains.com/guestAuth/app/rest/builds/buildType:(id:Kotlin_KotlinPublic_Compiler),number:1.5.0-dev-500,branch:default:any,pinned:true/artifacts/content/maven -kotlinStdlibVersion=1.5.0-dev-500 -kotlinStdlibTestsVersion=1.5.0-dev-500 -testKotlinCompilerVersion=1.5.0-dev-500 +kotlinCompilerRepo=https://teamcity.jetbrains.com/guestAuth/app/rest/builds/buildType:(id:Kotlin_KotlinPublic_Compiler),number:1.5.0-dev-805,branch:default:any,pinned:true/artifacts/content/maven +kotlinVersion=1.5.0-dev-805 +kotlinStdlibRepo=https://teamcity.jetbrains.com/guestAuth/app/rest/builds/buildType:(id:Kotlin_KotlinPublic_Compiler),number:1.5.0-dev-805,branch:default:any,pinned:true/artifacts/content/maven +kotlinStdlibVersion=1.5.0-dev-805 +kotlinStdlibTestsVersion=1.5.0-dev-805 +testKotlinCompilerVersion=1.5.0-dev-805 konanVersion=1.5.0 # A version of Xcode required to build the Kotlin/Native compiler. From 828afa28bb14efef98b51182a5f04808bcc6b723 Mon Sep 17 00:00:00 2001 From: Vasily Levchenko Date: Mon, 21 Dec 2020 10:23:07 +0100 Subject: [PATCH 196/196] [performance][build] use buildKotlinVersion --- kotlin-native/build-tools/settings.gradle.kts | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/kotlin-native/build-tools/settings.gradle.kts b/kotlin-native/build-tools/settings.gradle.kts index 65d17a5790f..66d6e1eedca 100644 --- a/kotlin-native/build-tools/settings.gradle.kts +++ b/kotlin-native/build-tools/settings.gradle.kts @@ -3,11 +3,13 @@ pluginManagement { rootDir.resolve("../gradle.properties").reader().use(::load) } + val buildKotlinCompilerRepo: String by rootProperties val kotlinCompilerRepo: String by rootProperties - val kotlinVersion by rootProperties + val buildKotlinVersion by rootProperties repositories { maven(kotlinCompilerRepo) + maven(buildKotlinCompilerRepo) maven("https://cache-redirector.jetbrains.com/maven-central") mavenCentral() } @@ -15,7 +17,7 @@ pluginManagement { resolutionStrategy { eachPlugin { if (requested.id.id == "kotlin") { - useModule("org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion") + useModule("org.jetbrains.kotlin:kotlin-gradle-plugin:$buildKotlinVersion") } } }